Ideas.Service.Types

Services

data Service

Instances

Show Service

HasId Service

Typed a Service

makeService :: String -> String -> (forall a. TypedValue (Type a)) -> Service

deprecate :: Service -> Service

serviceDeprecated :: Service -> Bool

serviceFunction :: Service -> forall a. TypedValue (Type a)

Types

data TypeRep f t where

Constructors

Iso :: Isomorphism t1 t2 -> TypeRep f t1 -> TypeRep f t2

:-> :: TypeRep f t1 -> TypeRep f t2 -> TypeRep f (t1 -> t2)

Tag :: String -> TypeRep f t1 -> TypeRep f t1

List :: TypeRep f t -> TypeRep f [t]

Pair :: TypeRep f t1 -> TypeRep f t2 -> TypeRep f (t1, t2)

:|: :: TypeRep f t1 -> TypeRep f t2 -> TypeRep f (Either t1 t2)

Unit :: TypeRep f ()

Const :: f t -> TypeRep f t

Instances

Show (TypedValue f) => Show (TypedValue (TypeRep f))

ShowF f => ShowF (TypeRep f)

Equal f => Equal (TypeRep f)

ShowF f => Show (TypeRep f t)

data Const a t where

Constructors

Service :: Const a Service

Exercise :: Const a (Exercise a)

Strategy :: Const a (Strategy (Context a))

State :: Const a (State a)

Rule :: Const a (Rule (Context a))

Context :: Const a (Context a)

Id :: Const a Id

Location :: Const a Location

Script :: Const a Script

StratCfg :: Const a StrategyConfiguration

Environment :: Const a Environment

Text :: Const a Text

StdGen :: Const a StdGen

SomeExercise :: Const a (Some Exercise)

Bool :: Const a Bool

Int :: Const a Int

String :: Const a String

Instances

Show (TypedValue (Const a))

ShowF (Const a)

Equal (Const a)

Show (Const a t)

type Type a = TypeRep (Const a)

data TypedValue f where

Constructors

::: :: t -> f t -> TypedValue f

Instances

Show (TypedValue (Const a))

Show (TypedValue f) => Show (TypedValue (TypeRep f))

class Typed a t | t -> a where

Methods

typeOf :: t -> Type a t

typed :: Type a t

typedList :: Type a [t]

Instances

Typed a Text

Typed a Script

Typed a StrategyConfiguration

Typed a Service

Typed a Difficulty

Typed a StdGen

Typed a Environment

Typed a Location

Typed a Id

Typed a Char

Typed a ()

Typed a Bool

Typed a Int

Typed a DomainReasoner

Typed a Message

Typed a (Some Exercise)

Typed a t => Typed a (Tree t)

Typed a t => Typed a [t]

Typed a t => Typed a (Maybe t)

Typed a (Context a)

Typed a (Exercise a)

Typed a (State a)

Typed a (Strategy (Context a))

Typed a (Rule (Context a))

Typed a (Diagnosis a)

Typed a (Result a)

Typed a (Reply a)

(Typed a t1, Typed a t2) => Typed a (Derivation t1 t2)

(Typed a t1, Typed a t2) => Typed a (Either t1 t2)

(Typed a t1, Typed a t2) => Typed a (t1 -> t2)

(Typed a t1, Typed a t2) => Typed a (t1, t2)

(Typed a t1, Typed a t2, Typed a t3) => Typed a (t1, t2, t3)

(Typed a t1, Typed a t2, Typed a t3, Typed a t4) => Typed a (t1, t2, t3, t4)

class Equal f where

Methods

equal :: f a -> f b -> Maybe (a -> b)

Instances

Equal (Const a)

Equal f => Equal (TypeRep f)

class ShowF f where

Methods

showF :: f a -> String

Instances

ShowF (Const a)

ShowF f => ShowF (TypeRep f)

equalM :: Monad m => Type a t1 -> Type a t2 -> m (t1 -> t2)