purescript-0.4.0: PureScript Programming Language Compiler

Safe HaskellNone

Language.PureScript.TypeChecker.Monad

Description

Monads for type checking and type inference and associated data types

Synopsis

Documentation

data NameKind Source

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

data TypeDeclarationKind Source

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

data Environment Source

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

jsTypes :: Map (ModuleName, ProperName) (Kind, TypeDeclarationKind)Source

The basic types existing in the external javascript environment

initEnvironment :: EnvironmentSource

The initial environment with no values and only the default javascript types defined

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

Temporarily bind a collection of names to values

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

Temporarily bind a collection of names to types

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

Temporarily make a collection of type class dictionaries available

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

Get the currently available list of type class dictionaries

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

Temporarily bind a collection of names to local variables

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

Temporarily bind a collection of names to local type variables

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

Lookup the type of a value by name in the Environment

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

Lookup the kind of a type by name in the Environment

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

Canonicalize an identifier by resolving any aliases introduced by module imports

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

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

canonicalizeDataConstructor :: ModuleName -> Environment -> Qualified ProperName -> (ModuleName, ProperName)Source

Canonicalize a data constructor by resolving any aliases introduced by module imports

data CheckState Source

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

checkCurrentModule :: Maybe ModuleName

The current module

newtype Check a Source

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

Constructors

Check 

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

Get the current Environment

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

Modify the Environment

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

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 ()Source

Make an assertion, failing with an error message

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

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

freshDictionaryName :: Check IntSource

Generate new type class dictionary name

liftCheck :: Check a -> UnifyT t Check aSource

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

liftUnify :: Partial t => UnifyT t Check a -> Check (a, Substitution t)Source

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

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

Replace any unqualified names in a type wit their qualified versionss