Language.Futhark.TypeChecker.Monad

Main monad in which the type checker runs, as well as ancillary data definitions.

Documentation

data TypeM a

The type checker runs in this monad.

Instances

Applicative TypeM

Defined in Language.Futhark.TypeChecker.Monad

Methods

pure :: a -> TypeM a

(<*>) :: TypeM (a -> b) -> TypeM a -> TypeM b

liftA2 :: (a -> b -> c) -> TypeM a -> TypeM b -> TypeM c

(*>) :: TypeM a -> TypeM b -> TypeM b

(<*) :: TypeM a -> TypeM b -> TypeM a

Functor TypeM

Defined in Language.Futhark.TypeChecker.Monad

Methods

fmap :: (a -> b) -> TypeM a -> TypeM b

(<$) :: a -> TypeM b -> TypeM a

Monad TypeM

Defined in Language.Futhark.TypeChecker.Monad

Methods

(>>=) :: TypeM a -> (a -> TypeM b) -> TypeM b

(>>) :: TypeM a -> TypeM b -> TypeM b

return :: a -> TypeM a

MonadTypeChecker TypeM

Defined in Language.Futhark.TypeChecker.Monad

Methods

warn :: Located loc => loc -> Doc () -> TypeM ()

warnings :: Warnings -> TypeM ()

newName :: VName -> TypeM VName

newID :: Name -> TypeM VName

newTypeName :: Name -> TypeM VName

bindVal :: VName -> BoundV -> TypeM a -> TypeM a

lookupType :: QualName VName -> TypeM ([TypeParam], StructRetType, Liftedness)

typeError :: Located loc => loc -> Notes -> Doc () -> TypeM a

MonadError TypeError TypeM

Defined in Language.Futhark.TypeChecker.Monad

Methods

throwError :: TypeError -> TypeM a

catchError :: TypeM a -> (TypeError -> TypeM a) -> TypeM a

MonadState TypeState TypeM

Defined in Language.Futhark.TypeChecker.Monad

Methods

get :: TypeM TypeState

put :: TypeState -> TypeM ()

state :: (TypeState -> (a, TypeState)) -> TypeM a

runTypeM :: Env -> ImportTable -> ImportName -> VNameSource -> TypeM a -> (Warnings, Either TypeError (a, VNameSource))

Run a TypeM computation.

askEnv :: TypeM Env

Retrieve the current Env.

askImportName :: TypeM ImportName

The name of the current file/import.

atTopLevel :: TypeM Bool

Are we type-checking at the top level, or are we inside a nested module?

enteringModule :: TypeM a -> TypeM a

We are now going to type-check the body of a module.

bindSpaced :: [(Namespace, Name, SrcLoc)] -> ([VName] -> TypeM a) -> TypeM a

Map source-level names to fresh unique internal names, and evaluate a type checker context with the mapping active.

bindSpaced1 :: Namespace -> Name -> SrcLoc -> (VName -> TypeM a) -> TypeM a

Map single source-level name to fresh unique internal names, and evaluate a type checker context with the mapping active.

bindIdents :: [IdentBase NoInfo VName t] -> TypeM a -> TypeM a

Bind these identifiers in the name map and also check whether they have been used.

qualifyTypeVars :: Env -> [VName] -> [VName] -> TypeBase Size as -> TypeBase Size as

Try to prepend qualifiers to the type names such that they represent how to access the type in some scope.

lookupMTy :: SrcLoc -> QualName Name -> TypeM (QualName VName, MTy)

Look up a module type.

lookupImport :: SrcLoc -> FilePath -> TypeM (ImportName, Env)

Look up an import.

lookupMod :: SrcLoc -> QualName Name -> TypeM (QualName VName, Mod)

localEnv :: Env -> TypeM a -> TypeM a

Evaluate a TypeM computation within an extended (not replaced) environment.

data TypeError

Information about an error during type checking.

Constructors

TypeError Loc Notes (Doc ())

Instances

MonadError TypeError TypeM

Defined in Language.Futhark.TypeChecker.Monad

Methods

throwError :: TypeError -> TypeM a

catchError :: TypeM a -> (TypeError -> TypeM a) -> TypeM a

MonadError TypeError TermTypeM

Defined in Language.Futhark.TypeChecker.Terms.Monad

Methods

throwError :: TypeError -> TermTypeM a

catchError :: TermTypeM a -> (TypeError -> TermTypeM a) -> TermTypeM a

prettyTypeError :: TypeError -> Doc AnsiStyle

Prettyprint type error.

prettyTypeErrorNoLoc :: TypeError -> Doc AnsiStyle

Prettyprint type error, without location information. This can be used for cases where the location is printed in some other way.

withIndexLink :: Doc a -> Doc a -> Doc a

Attach a reference to documentation explaining the error in more detail.

unappliedFunctor :: MonadTypeChecker m => SrcLoc -> m a

An unexpected functor appeared!

unknownVariable :: MonadTypeChecker m => Namespace -> QualName Name -> SrcLoc -> m a

An unknown variable was referenced.

underscoreUse :: MonadTypeChecker m => SrcLoc -> QualName Name -> m a

A name prefixed with an underscore was used.

data Notes

A collection of extra information regarding a type error.

Instances

Monoid Notes

Defined in Language.Futhark.TypeChecker.Monad

Methods

mempty :: Notes

mappend :: Notes -> Notes -> Notes

mconcat :: [Notes] -> Notes

Semigroup Notes

Defined in Language.Futhark.TypeChecker.Monad

Methods

(<>) :: Notes -> Notes -> Notes

sconcat :: NonEmpty Notes -> Notes

stimes :: Integral b => b -> Notes -> Notes

Pretty Notes

Defined in Language.Futhark.TypeChecker.Monad

Methods

pretty :: Notes -> Doc ann

prettyList :: [Notes] -> Doc ann

aNote :: Doc () -> Notes

A single note.

class Monad m => MonadTypeChecker m where

Monads that support type checking. The reason we have this internal interface is because we use distinct monads for checking expressions and declarations.

Minimal complete definition

warn, warnings, newName, newTypeName, bindVal, lookupType, typeError

Methods

warn :: Located loc => loc -> Doc () -> m ()

warnings :: Warnings -> m ()

newName :: VName -> m VName

newID :: Name -> m VName

newTypeName :: Name -> m VName

bindVal :: VName -> BoundV -> m a -> m a

lookupType :: QualName VName -> m ([TypeParam], StructRetType, Liftedness)

typeError :: Located loc => loc -> Notes -> Doc () -> m a

Instances

MonadTypeChecker TypeM

Defined in Language.Futhark.TypeChecker.Monad

Methods

warn :: Located loc => loc -> Doc () -> TypeM ()

warnings :: Warnings -> TypeM ()

newName :: VName -> TypeM VName

newID :: Name -> TypeM VName

newTypeName :: Name -> TypeM VName

bindVal :: VName -> BoundV -> TypeM a -> TypeM a

lookupType :: QualName VName -> TypeM ([TypeParam], StructRetType, Liftedness)

typeError :: Located loc => loc -> Notes -> Doc () -> TypeM a

MonadTypeChecker TermTypeM

Defined in Language.Futhark.TypeChecker.Terms.Monad

Methods

warn :: Located loc => loc -> Doc () -> TermTypeM ()

warnings :: Warnings -> TermTypeM ()

newName :: VName -> TermTypeM VName

newID :: Name -> TermTypeM VName

newTypeName :: Name -> TermTypeM VName

bindVal :: VName -> BoundV -> TermTypeM a -> TermTypeM a

lookupType :: QualName VName -> TermTypeM ([TypeParam], StructRetType, Liftedness)

typeError :: Located loc => loc -> Notes -> Doc () -> TermTypeM a

data TypeState

Instances

MonadState TypeState TypeM

Defined in Language.Futhark.TypeChecker.Monad

Methods

get :: TypeM TypeState

put :: TypeState -> TypeM ()

state :: (TypeState -> (a, TypeState)) -> TypeM a

usedName :: VName -> TypeM ()

Indicate that this name has been used. This is usually done implicitly by other operations, but sometimes we want to make a "fake" use to avoid things like top level functions being considered unused.

checkName :: Namespace -> Name -> SrcLoc -> TypeM VName

Elaborate the given name in the given namespace at the given location, producing the corresponding unique VName.

checkAttr :: MonadTypeChecker m => AttrInfo VName -> m (AttrInfo VName)

Type-check an attribute.

checkQualName :: Namespace -> QualName Name -> SrcLoc -> TypeM (QualName VName)

Elaborate the given qualified name in the given namespace at the given location, producing the corresponding unique QualName.

checkValName :: QualName Name -> SrcLoc -> TypeM (QualName VName)

Elaborate the given qualified name in the given namespace at the given location, producing the corresponding unique QualName. Fails if the name is a module.

badOnLeft :: Either TypeError a -> TypeM a

Turn a Left TypeError into an actual error.

isKnownType :: QualName VName -> TypeM Bool

Does a type with this name already exist? This is used for warnings, so it is OK it's a little unprincipled.

module Language.Futhark.Warnings

data Env

Modules produces environment with this representation.

Constructors

Env

Fields

• envVtable :: Map VName BoundV
• envTypeTable :: Map VName TypeBinding
• envModTypeTable :: Map VName MTy
• envModTable :: Map VName Mod
• envNameMap :: NameMap

Instances

Monoid Env

Defined in Language.Futhark.Semantic

Methods

mempty :: Env

mappend :: Env -> Env -> Env

mconcat :: [Env] -> Env

Semigroup Env

Defined in Language.Futhark.Semantic

Methods

(<>) :: Env -> Env -> Env

sconcat :: NonEmpty Env -> Env

stimes :: Integral b => b -> Env -> Env

Show Env

Defined in Language.Futhark.Semantic

Methods

showsPrec :: Int -> Env -> ShowS

show :: Env -> String

showList :: [Env] -> ShowS

Pretty Env

Defined in Language.Futhark.Semantic

Methods

pretty :: Env -> Doc ann

prettyList :: [Env] -> Doc ann

type TySet = Map (QualName VName) Liftedness

A mapping of abstract types to their liftedness.

data FunModType

A parametric functor consists of a set of abstract types, the environment of its parameter, and the resulting module type.

Constructors

FunModType

Fields

• funModTypeAbs :: TySet
• funModTypeMod :: Mod
• funModTypeMty :: MTy

Instances

Show FunModType

Defined in Language.Futhark.Semantic

Methods

showsPrec :: Int -> FunModType -> ShowS

show :: FunModType -> String

showList :: [FunModType] -> ShowS

type ImportTable = Map ImportName Env

A mapping from import import names to Envs. This is used to resolve import declarations.

type NameMap = Map (Namespace, Name) (QualName VName)

A mapping from names (which always exist in some namespace) to a unique (tagged) name.

data BoundV

Type parameters, list of parameter types (optinally named), and return type. The type parameters are in scope in both parameter types and the return type. Non-functional values have only a return type.

Constructors

BoundV

Fields

• boundValTParams :: [TypeParam]
• boundValType :: StructType

Instances

Show BoundV

Defined in Language.Futhark.Semantic

Methods

showsPrec :: Int -> BoundV -> ShowS

show :: BoundV -> String

showList :: [BoundV] -> ShowS

data Mod

Representation of a module, which is either a plain environment, or a parametric module ("functor" in SML).

Constructors

ModEnv Env

ModFun FunModType

Instances

Show Mod

Defined in Language.Futhark.Semantic

Methods

showsPrec :: Int -> Mod -> ShowS

show :: Mod -> String

showList :: [Mod] -> ShowS

Pretty Mod

Defined in Language.Futhark.Semantic

Methods

pretty :: Mod -> Doc ann

prettyList :: [Mod] -> Doc ann

data TypeBinding

A binding from a name to its definition as a type. We allow a return type here to support type abbreviations that hide some inner sizes (these must necessarily be Lifted or SizeLifted).

Constructors

TypeAbbr Liftedness [TypeParam] StructRetType

Instances

Show TypeBinding

Defined in Language.Futhark.Semantic

Methods

showsPrec :: Int -> TypeBinding -> ShowS

show :: TypeBinding -> String

showList :: [TypeBinding] -> ShowS

Eq TypeBinding

Defined in Language.Futhark.Semantic

Methods

(==) :: TypeBinding -> TypeBinding -> Bool

(/=) :: TypeBinding -> TypeBinding -> Bool

data MTy

Representation of a module type.

Constructors

MTy

Fields

• mtyAbs :: TySet

  Abstract types in the module type.

• mtyMod :: Mod

Instances

Show MTy

Defined in Language.Futhark.Semantic

Methods

showsPrec :: Int -> MTy -> ShowS

show :: MTy -> String

showList :: [MTy] -> ShowS

Pretty MTy

Defined in Language.Futhark.Semantic

Methods

pretty :: MTy -> Doc ann

prettyList :: [MTy] -> Doc ann

anySignedType :: [PrimType]

All signed integer types.

anyUnsignedType :: [PrimType]

All unsigned integer types.

anyIntType :: [PrimType]

All integer types.

anyFloatType :: [PrimType]

All floating-point types.

anyNumberType :: [PrimType]

All number types.

anyPrimType :: [PrimType]

All primitive types.

data Namespace

The space inhabited by a name.

Constructors

Term

Functions and values.

Type

Signature

Instances

Enum Namespace

Defined in Language.Futhark.Semantic

Methods

succ :: Namespace -> Namespace

pred :: Namespace -> Namespace

toEnum :: Int -> Namespace

fromEnum :: Namespace -> Int

enumFrom :: Namespace -> [Namespace]

enumFromThen :: Namespace -> Namespace -> [Namespace]

enumFromTo :: Namespace -> Namespace -> [Namespace]

enumFromThenTo :: Namespace -> Namespace -> Namespace -> [Namespace]

Show Namespace

Defined in Language.Futhark.Semantic

Methods

showsPrec :: Int -> Namespace -> ShowS

show :: Namespace -> String

showList :: [Namespace] -> ShowS

Eq Namespace

Defined in Language.Futhark.Semantic

Methods

(==) :: Namespace -> Namespace -> Bool

(/=) :: Namespace -> Namespace -> Bool

Ord Namespace

Defined in Language.Futhark.Semantic

Methods

compare :: Namespace -> Namespace -> Ordering

(<) :: Namespace -> Namespace -> Bool

(<=) :: Namespace -> Namespace -> Bool

(>) :: Namespace -> Namespace -> Bool

(>=) :: Namespace -> Namespace -> Bool

max :: Namespace -> Namespace -> Namespace

min :: Namespace -> Namespace -> Namespace

Pretty Namespace

Defined in Language.Futhark.Semantic

Methods

pretty :: Namespace -> Doc ann

prettyList :: [Namespace] -> Doc ann

intrinsicsNameMap :: NameMap

The NameMap corresponding to the intrinsics module.

topLevelNameMap :: NameMap

The names that are available in the initial environment.

mkTypeVarName :: Name -> Int -> Name

Construct the name of a new type variable given a base description and a tag number (note that this is distinct from actually constructing a VName; the tag here is intended for human consumption but the machine does not care).