Language.PureScript.TypeChecker.Monad

Documentation

data NameKind

Constructors

Value

Extern

Alias ModulePath Ident

Instances

Show NameKind

data TypeDeclarationKind

Constructors

Data

ExternData

TypeSynonym

Instances

Show TypeDeclarationKind

data Environment

Constructors

Environment

Fields

names :: Map (ModulePath, Ident) (Type, NameKind)

types :: Map (ModulePath, ProperName) (Kind, TypeDeclarationKind)

dataConstructors :: Map (ModulePath, ProperName) Type

typeSynonyms :: Map (ModulePath, ProperName) ([String], Type)

members :: Map (ModulePath, Ident) String

Instances

Show Environment

emptyEnvironment :: Environment

data AnyUnifiable where

Constructors

AnyUnifiable :: forall t. Unifiable t => t -> AnyUnifiable

data CheckState

Constructors

CheckState

Fields

checkEnv :: Environment

checkNextVar :: Int

checkModulePath :: ModulePath

Instances

MonadState CheckState Check

newtype Check a

Constructors

Check

Fields

unCheck :: StateT CheckState (Either String) a

Instances

Monad Check

Functor Check

MonadPlus Check

Applicative Check

MonadState CheckState Check

MonadError String Check

getEnv :: Check Environment

putEnv :: Environment -> Check ()

modifyEnv :: (Environment -> Environment) -> Check ()

runCheck :: Check a -> Either String (a, Environment)

guardWith :: MonadError e m => e -> Bool -> m ()

rethrow :: MonadError e m => (e -> e) -> m a -> m a

withModule :: ProperName -> Check a -> Check a

newtype Substitution

Constructors

Substitution

Fields

runSubstitution :: forall t. Unifiable t => Unknown t -> t

Instances

Monoid Substitution

data SubstState

Constructors

SubstState

Fields

substSubst :: Substitution

substFutureEscapeChecks :: [AnyUnifiable]

newtype Subst m a

Constructors

Subst

Fields

unSubst :: StateT SubstState m a

Instances

MonadTrans Subst

MonadError String m => MonadError String (Subst m)

Monad m => Monad (Subst m)

Functor m => Functor (Subst m)

MonadPlus m => MonadPlus (Subst m)

(Monad m, Functor m) => Applicative (Subst m)

runSubst :: (Unifiable a, Monad m) => Subst m a -> m (a, Substitution, [AnyUnifiable])

substituteWith :: Typeable t => (Unknown t -> t) -> Substitution

substituteOne :: Unifiable t => Unknown t -> t -> Substitution

replace :: Unifiable t => Unknown t -> t -> Subst Check ()

class (Typeable t, Data t, Show t) => Unifiable t where

Methods

unknown :: Unknown t -> t

(~~) :: t -> t -> Subst Check ()

isUnknown :: t -> Maybe (Unknown t)

apply :: Substitution -> t -> t

unknowns :: t -> [Int]

Instances

Unifiable Kind

Unifiable Row

Unifiable Type

occursCheck :: Unifiable t => Unknown s -> t -> Subst Check ()

fresh' :: Subst Check Int

fresh :: Unifiable t => Subst Check t

escapeCheckLater :: Unifiable t => t -> Subst Check ()