Language.PureScript.TypeChecker.Monad

Monads for type checking and type inference and associated data types

Documentation

data NameKind

The type of a name in the Environment

Constructors

Value

A value introduced as a binding in a module

Extern ForeignImportType

A foreign import

Alias ModuleName Ident

An alias for a value in another module, introduced using an import declaration

LocalVariable

A local name introduced using a lambda abstraction, variable introduction or binder

DataConstructor

A data constructor

Instances

Show NameKind

data TypeDeclarationKind

The type of a type declaration

Constructors

Data

A data constructor

ExternData

A data type foreign import

TypeSynonym

A type synonym

DataAlias ModuleName ProperName

An alias for a type in another module, introduced using an import declaration

LocalTypeVariable

A local type name introduced using a forall quantifier

Instances

Show TypeDeclarationKind

data Environment

The Environment defines all values and types which are currently in scope:

Constructors

Environment

Fields

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

Value names currently in scope

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

Type names currently in scope

dataConstructors :: Map (ModuleName, ProperName) (Type, NameKind)

Data constructors currently in scope, along with their associated data type constructors

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

Type synonyms currently in scope

typeClassDictionaries :: [TypeClassDictionaryInScope]

Available type class dictionaries

Instances

Show Environment

emptyEnvironment :: Environment

An empty environment with no values and no types defined

bindNames :: MonadState CheckState m => Map (ModuleName, Ident) (Type, NameKind) -> m a -> m a

Temporarily bind a collection of names to values

bindTypes :: MonadState CheckState m => Map (ModuleName, ProperName) (Kind, TypeDeclarationKind) -> m a -> m a

Temporarily bind a collection of names to types

withTypeClassDictionaries :: MonadState CheckState m => [TypeClassDictionaryInScope] -> m a -> m a

Temporarily make a collection of type class dictionaries available

getTypeClassDictionaries :: (Functor m, MonadState CheckState m) => m [TypeClassDictionaryInScope]

Get the currently available list of type class dictionaries

bindLocalVariables :: (Functor m, MonadState CheckState m) => ModuleName -> [(Ident, Type)] -> m a -> m a

Temporarily bind a collection of names to local variables

bindLocalTypeVariables :: (Functor m, MonadState CheckState m) => ModuleName -> [(ProperName, Kind)] -> m a -> m a

Temporarily bind a collection of names to local type variables

lookupVariable :: (Functor m, MonadState CheckState m, MonadError String m) => ModuleName -> Qualified Ident -> m Type

Lookup the type of a value by name in the Environment

lookupTypeVariable :: (Functor m, MonadState CheckState m, MonadError String m) => ModuleName -> Qualified ProperName -> m Kind

Lookup the kind of a type by name in the Environment

canonicalize :: ModuleName -> Environment -> Qualified Ident -> (ModuleName, Ident)

Canonicalize an identifier by resolving any aliases introduced by module imports

canonicalizeType :: ModuleName -> Environment -> Qualified ProperName -> (ModuleName, ProperName)

Canonicalize a type variable by resolving any aliases introduced by module imports

data CheckState

State required for type checking:

Constructors

CheckState

Fields

checkEnv :: Environment

The current Environment

checkNextVar :: Int

The next fresh unification variable name

checkNextDictName :: Int

The next type class dictionary name

Instances

MonadState CheckState Subst

MonadState CheckState Check

newtype Check a

The type checking monad, which provides the state of the type checker, and error reporting capabilities

Constructors

Check

Fields

unCheck :: StateT CheckState (Either String) a

Instances

Monad Check

Functor Check

MonadPlus Check

Applicative Check

MonadError String Check

MonadState CheckState Check

getEnv :: (Functor m, MonadState CheckState m) => m Environment

Get the current Environment

putEnv :: MonadState CheckState m => Environment -> m ()

modifyEnv :: MonadState CheckState m => (Environment -> Environment) -> m ()

Modify the Environment

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

Run a computation in the Check monad, failing with an error, or succeeding with a return value and the final Environment.

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

Make an assertion, failing with an error message

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

Rethrow an error with a more detailed error message in the case of failure

freshDictionaryName :: Check Int

Generate new type class dictionary name

newtype Substitution

A substitution maintains a mapping from unification variables to their values, ensuring that the type of a unification variable matches the type of its value.

Constructors

Substitution

Fields

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

Instances

Monoid Substitution

data SubstState

State for the substitution monad, which contains the current substitution

Constructors

SubstState

Fields

substSubst :: Substitution

newtype SubstContext

Configuration for the substitution monad, constaining the current module

Constructors

SubstContext

Fields

substCurrentModule :: ModuleName

Instances

Show SubstContext

MonadReader SubstContext Subst

newtype Subst a

The substitution monad, which provides the means to unify values to generate a substitution, in addition to the actions supported by the type checking monad Check.

Constructors

Subst

Fields

unSubst :: ReaderT SubstContext (StateT SubstState Check) a

Instances

Monad Subst

Functor Subst

MonadPlus Subst

Applicative Subst

MonadError String Subst

MonadReader SubstContext Subst

MonadState CheckState Subst

liftCheck :: Check a -> Subst a

Lift a computation in the Check monad into the substitution monad.

getSubstState :: Subst SubstState

Get the current substitution monad state

runSubst :: SubstContext -> Subst a -> Check (a, Substitution)

Run a computation in the substitution monad, generating a return value and the final substitution.

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

Generate a substitution from a substitution function for a single type

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

Substitute a single unification variable

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

Replace a unification variable with the specified value in the current substitution

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

Identifies types which support unification

Methods

unknown :: Unknown t -> t

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

isUnknown :: t -> Maybe (Unknown t)

apply :: Substitution -> t -> t

unknowns :: t -> [Int]

Instances

Unifiable Kind

Unifiable Type

Unifiable a => Unifiable [a]

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

Perform the occurs check, to make sure a unification variable does not occur inside a value

fresh' :: Subst Int

Generate a fresh untyped unification variable

fresh :: Unifiable t => Subst t

Generate a fresh unification variable at a specific type

qualifyAllUnqualifiedNames :: Data d => ModuleName -> Environment -> d -> d

Replace any unqualified names in a type wit their qualified versionss