ddc-core-simpl- Disciplined Disciple Compiler code transformations.

Safe HaskellNone



Thread a state token through calls to given functions.

ASSUMPTIONS: * Program is a-normalized and fully named.



class Thread c where Source #

Class of things that can have a state token threaded through them.

Minimal complete definition



thread :: (Ord n, Show n, Pretty n) => Config a n -> KindEnv n -> TypeEnv n -> c (AnTEC a n) n -> c a n Source #


Thread Module Source # 


thread :: (Ord n, Show n, Pretty n) => Config a n -> KindEnv n -> TypeEnv n -> Module (AnTEC a n) n -> Module a n Source #

data Config a n Source #

Configuration for the Thread transform.




  • configCheckConfig :: Config n

    Config for the type checker. We need to reconstruct the type of the result of stateful functions when bundling them into the tuple that holds the state token.

  • configThreadMe :: n -> Type n -> Maybe (Type n)

    Function to decide which top-level bindings are stateful and need the state token threaded through them. If the binding with the given name is stateful then the function should return the new type for the binding that accepts and returns the state token.

  • configTokenType :: Type n

    Type of the state token to use.

  • configVoidType :: Type n

    Type that represents a missing value. If a stateful function returns a void then our thread transform rewrites it to return the state token, instead of a tuple that contains the token as well as a void value.

  • configWrapResultType :: Type n -> Type n

    Wrap a type with the world token. eg change Int to (World#, Int)

  • configWrapResultExp :: Exp (AnTEC a n) n -> Exp (AnTEC a n) n -> Exp a n

    Wrap a result expression with the state token. The function is given the types of the world token and result, then the expressions for the same.

  • configThreadPat :: n -> Maybe (Bind n -> [Bind n] -> Pat n)

    Make a pattern which binds the world argument from a threaded primop.

injectStateType :: Eq n => Config a n -> Type n -> Type n Source #

Inject the state token into the type of an effectful function. Eg, change ([a b : Data]. a -> b -> Int) to ([a b : Data]. a -> b -> World -> (World, Int)