Language.Futhark.TypeChecker.Types

Documentation

checkTypeExp :: MonadTypeChecker m => TypeExp Name -> m (TypeExp VName, StructType, Liftedness)

checkTypeDecl :: MonadTypeChecker m => [TypeParam] -> TypeDeclBase NoInfo Name -> m (TypeDeclBase Info VName, Liftedness)

unifyTypesU :: (Monoid als, ArrayDim dim) => (Uniqueness -> Uniqueness -> Maybe Uniqueness) -> TypeBase dim als -> TypeBase dim als -> Maybe (TypeBase dim als)

unifyTypes uf t2 t2 attempts to unify t1 and t2. If unification cannot happen, Nothing is returned, otherwise a type that combines the aliasing of t1 and t2 is returned. Uniqueness is unified with uf.

subtypeOf :: ArrayDim dim => TypeBase dim as1 -> TypeBase dim as2 -> Bool

x `subtypeOf` y is true if x is a subtype of y (or equal to y), meaning x is valid whenever y is.

subuniqueOf :: Uniqueness -> Uniqueness -> Bool

x subuniqueOf y is true if x is not less unique than y.

checkForDuplicateNames :: MonadTypeChecker m => [UncheckedPattern] -> m ()

Check for duplication of names inside a pattern group. Produces a description of all names used in the pattern group.

checkForDuplicateNamesInType :: MonadTypeChecker m => TypeExp Name -> m ()

Check whether the type contains arrow types that define the same parameter. These might also exist further down, but that's not really a problem - we mostly do this checking to help the user, since it is likely an error, but it's easy to assign a semantics to it (normal name shadowing).

checkTypeParams :: MonadTypeChecker m => [TypeParamBase Name] -> ([TypeParamBase VName] -> m a) -> m a

typeParamToArg :: TypeParam -> StructTypeArg

Construct a type argument corresponding to a type parameter.

typeExpUses :: TypeExp VName -> ([VName], [VName])

Return the shapes used in a given type expression in positive and negative position, respectively.

checkShapeParamUses :: (MonadTypeChecker m, Located a) => (a -> ([VName], [VName])) -> [TypeParam] -> [a] -> m ()

Ensure that every shape parameter is used in positive position at least once before being used in negative position.

data TypeSub

Constructors

TypeSub TypeBinding

DimSub (DimDecl VName)

Instances

Show TypeSub

Defined in Language.Futhark.TypeChecker.Types

Methods

showsPrec :: Int -> TypeSub -> ShowS

show :: TypeSub -> String

showList :: [TypeSub] -> ShowS

type TypeSubs = Map VName TypeSub

substituteTypes :: Monoid als => TypeSubs -> TypeBase (DimDecl VName) als -> TypeBase (DimDecl VName) als

data Subst t

A type substituion may be a substitution or a yet-unknown substitution (but which is certainly an overloaded primitive type!). The latter is used to remove aliases from types that are yet-unknown but that we know cannot carry aliases (see issue #682).

Constructors

Subst t

PrimSubst

Instances

Functor Subst

Defined in Language.Futhark.TypeChecker.Types

Methods

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

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

class Substitutable a where

Class of types which allow for substitution of types with no annotations for type variable names.

Methods

applySubst :: (VName -> Maybe (Subst (TypeBase () ()))) -> a -> a

Instances

Substitutable (TypeBase () ())

Defined in Language.Futhark.TypeChecker.Types

Methods

applySubst :: (VName -> Maybe (Subst (TypeBase () ()))) -> TypeBase () () -> TypeBase () ()

Substitutable (TypeBase () Aliasing)

Defined in Language.Futhark.TypeChecker.Types

Methods

applySubst :: (VName -> Maybe (Subst (TypeBase () ()))) -> TypeBase () Aliasing -> TypeBase () Aliasing

Substitutable (TypeBase (DimDecl VName) ())

Defined in Language.Futhark.TypeChecker.Types

Methods

applySubst :: (VName -> Maybe (Subst (TypeBase () ()))) -> TypeBase (DimDecl VName) () -> TypeBase (DimDecl VName) ()

Substitutable (TypeBase (DimDecl VName) Aliasing)

Defined in Language.Futhark.TypeChecker.Types

Methods

applySubst :: (VName -> Maybe (Subst (TypeBase () ()))) -> TypeBase (DimDecl VName) Aliasing -> TypeBase (DimDecl VName) Aliasing

substTypesAny :: (ArrayDim dim, Monoid as) => (VName -> Maybe (Subst (TypeBase dim as))) -> TypeBase dim as -> TypeBase dim as

Perform substitutions, from type names to types, on a type. Works regardless of what shape and uniqueness information is attached to the type.