Safe Haskell | Safe-Inferred |
---|---|
Language | Haskell2010 |
The Futhark source language AST definition. Many types, such as
ExpBase
, are parametrised by type and name representation.
E.g. in a value of type ExpBase f vn
, annotations are wrapped in
the functor f
, and all names are of type vn
. See
https://futhark.readthedocs.org for a language reference, or this
module may be a little hard to understand.
The system of primitive types is interesting in itself. See Language.Futhark.Primitive.
Synopsis
- module Language.Futhark.Core
- prettyString :: Pretty a => a -> String
- prettyText :: Pretty a => a -> Text
- data Uniqueness
- data IntType
- data FloatType
- data PrimType
- type Size = ExpBase Info VName
- newtype Shape dim = Shape {
- shapeDims :: [dim]
- shapeRank :: Shape dim -> Int
- stripDims :: Int -> Shape dim -> Maybe (Shape dim)
- data TypeBase dim u
- = Scalar (ScalarTypeBase dim u)
- | Array u (Shape dim) (ScalarTypeBase dim NoUniqueness)
- data TypeArg dim
- = TypeArgDim dim
- | TypeArgType (TypeBase dim NoUniqueness)
- data SizeExp f vn
- = SizeExp (ExpBase f vn) SrcLoc
- | SizeExpAny SrcLoc
- data TypeExp f vn
- = TEVar (QualName vn) SrcLoc
- | TEParens (TypeExp f vn) SrcLoc
- | TETuple [TypeExp f vn] SrcLoc
- | TERecord [(Name, TypeExp f vn)] SrcLoc
- | TEArray (SizeExp f vn) (TypeExp f vn) SrcLoc
- | TEUnique (TypeExp f vn) SrcLoc
- | TEApply (TypeExp f vn) (TypeArgExp f vn) SrcLoc
- | TEArrow (Maybe vn) (TypeExp f vn) (TypeExp f vn) SrcLoc
- | TESum [(Name, [TypeExp f vn])] SrcLoc
- | TEDim [vn] (TypeExp f vn) SrcLoc
- data TypeArgExp f vn
- = TypeArgExpSize (SizeExp f vn)
- | TypeArgExpType (TypeExp f vn)
- data PName
- data ScalarTypeBase dim u
- data RetTypeBase dim as = RetType {}
- type StructType = TypeBase Size NoUniqueness
- type ParamType = TypeBase Size Diet
- type ResType = TypeBase Size Uniqueness
- type StructRetType = RetTypeBase Size NoUniqueness
- type ResRetType = RetTypeBase Size Uniqueness
- type ValueType = TypeBase Int64 NoUniqueness
- data Diet
- data IntValue
- = Int8Value !Int8
- | Int16Value !Int16
- | Int32Value !Int32
- | Int64Value !Int64
- data FloatValue
- data PrimValue
- class IsPrimValue v where
- data AttrInfo vn
- data AttrAtom vn
- data BinOp
- data IdentBase f vn t = Ident {
- identName :: vn
- identType :: f t
- identSrcLoc :: SrcLoc
- data Inclusiveness a
- = DownToExclusive a
- | ToInclusive a
- | UpToExclusive a
- data DimIndexBase f vn
- type SliceBase f vn = [DimIndexBase f vn]
- data SizeBinder vn = SizeBinder {}
- data AppExpBase f vn
- = Apply (ExpBase f vn) (NonEmpty (f (Diet, Maybe VName), ExpBase f vn)) SrcLoc
- | Range (ExpBase f vn) (Maybe (ExpBase f vn)) (Inclusiveness (ExpBase f vn)) SrcLoc
- | LetPat [SizeBinder vn] (PatBase f vn StructType) (ExpBase f vn) (ExpBase f vn) SrcLoc
- | LetFun vn ([TypeParamBase vn], [PatBase f vn ParamType], Maybe (TypeExp f vn), f ResRetType, ExpBase f vn) (ExpBase f vn) SrcLoc
- | If (ExpBase f vn) (ExpBase f vn) (ExpBase f vn) SrcLoc
- | Loop [VName] (PatBase f vn ParamType) (ExpBase f vn) (LoopFormBase f vn) (ExpBase f vn) SrcLoc
- | BinOp (QualName vn, SrcLoc) (f StructType) (ExpBase f vn, f (Maybe VName)) (ExpBase f vn, f (Maybe VName)) SrcLoc
- | LetWith (IdentBase f vn StructType) (IdentBase f vn StructType) (SliceBase f vn) (ExpBase f vn) (ExpBase f vn) SrcLoc
- | Index (ExpBase f vn) (SliceBase f vn) SrcLoc
- | Match (ExpBase f vn) (NonEmpty (CaseBase f vn)) SrcLoc
- data AppRes = AppRes {
- appResType :: StructType
- appResExt :: [VName]
- data ExpBase f vn
- = Literal PrimValue SrcLoc
- | IntLit Integer (f StructType) SrcLoc
- | FloatLit Double (f StructType) SrcLoc
- | StringLit [Word8] SrcLoc
- | Hole (f StructType) SrcLoc
- | Var (QualName vn) (f StructType) SrcLoc
- | Parens (ExpBase f vn) SrcLoc
- | QualParens (QualName vn, SrcLoc) (ExpBase f vn) SrcLoc
- | TupLit [ExpBase f vn] SrcLoc
- | RecordLit [FieldBase f vn] SrcLoc
- | ArrayLit [ExpBase f vn] (f StructType) SrcLoc
- | Attr (AttrInfo vn) (ExpBase f vn) SrcLoc
- | Project Name (ExpBase f vn) (f StructType) SrcLoc
- | Negate (ExpBase f vn) SrcLoc
- | Not (ExpBase f vn) SrcLoc
- | Assert (ExpBase f vn) (ExpBase f vn) (f Text) SrcLoc
- | Constr Name [ExpBase f vn] (f StructType) SrcLoc
- | Update (ExpBase f vn) (SliceBase f vn) (ExpBase f vn) SrcLoc
- | RecordUpdate (ExpBase f vn) [Name] (ExpBase f vn) (f StructType) SrcLoc
- | Lambda [PatBase f vn ParamType] (ExpBase f vn) (Maybe (TypeExp f vn)) (f ResRetType) SrcLoc
- | OpSection (QualName vn) (f StructType) SrcLoc
- | OpSectionLeft (QualName vn) (f StructType) (ExpBase f vn) (f (PName, ParamType, Maybe VName), f (PName, ParamType)) (f ResRetType, f [VName]) SrcLoc
- | OpSectionRight (QualName vn) (f StructType) (ExpBase f vn) (f (PName, ParamType), f (PName, ParamType, Maybe VName)) (f ResRetType) SrcLoc
- | ProjectSection [Name] (f StructType) SrcLoc
- | IndexSection (SliceBase f vn) (f StructType) SrcLoc
- | Ascript (ExpBase f vn) (TypeExp f vn) SrcLoc
- | Coerce (ExpBase f vn) (TypeExp f vn) (f StructType) SrcLoc
- | AppExp (AppExpBase f vn) (f AppRes)
- data FieldBase f vn
- = RecordFieldExplicit Name (ExpBase f vn) SrcLoc
- | RecordFieldImplicit vn (f StructType) SrcLoc
- data CaseBase f vn = CasePat (PatBase f vn StructType) (ExpBase f vn) SrcLoc
- data LoopFormBase f vn
- = For (IdentBase f vn StructType) (ExpBase f vn)
- | ForIn (PatBase f vn StructType) (ExpBase f vn)
- | While (ExpBase f vn)
- data PatLit
- data PatBase f vn t
- = TuplePat [PatBase f vn t] SrcLoc
- | RecordPat [(Name, PatBase f vn t)] SrcLoc
- | PatParens (PatBase f vn t) SrcLoc
- | Id vn (f t) SrcLoc
- | Wildcard (f t) SrcLoc
- | PatAscription (PatBase f vn t) (TypeExp f vn) SrcLoc
- | PatLit PatLit (f t) SrcLoc
- | PatConstr Name (f t) [PatBase f vn t] SrcLoc
- | PatAttr (AttrInfo vn) (PatBase f vn t) SrcLoc
- newtype ImportName = ImportName FilePath
- data SpecBase f vn
- = ValSpec {
- specName :: vn
- specTypeParams :: [TypeParamBase vn]
- specTypeExp :: TypeExp f vn
- specType :: f StructType
- specDoc :: Maybe DocComment
- specLocation :: SrcLoc
- | TypeAbbrSpec (TypeBindBase f vn)
- | TypeSpec Liftedness vn [TypeParamBase vn] (Maybe DocComment) SrcLoc
- | ModSpec vn (SigExpBase f vn) (Maybe DocComment) SrcLoc
- | IncludeSpec (SigExpBase f vn) SrcLoc
- = ValSpec {
- data SigExpBase f vn
- = SigVar (QualName vn) (f (Map VName VName)) SrcLoc
- | SigParens (SigExpBase f vn) SrcLoc
- | SigSpecs [SpecBase f vn] SrcLoc
- | SigWith (SigExpBase f vn) (TypeRefBase f vn) SrcLoc
- | SigArrow (Maybe vn) (SigExpBase f vn) (SigExpBase f vn) SrcLoc
- data TypeRefBase f vn = TypeRef (QualName vn) [TypeParamBase vn] (TypeExp f vn) SrcLoc
- data SigBindBase f vn = SigBind {
- sigName :: vn
- sigExp :: SigExpBase f vn
- sigDoc :: Maybe DocComment
- sigLoc :: SrcLoc
- data ModExpBase f vn
- = ModVar (QualName vn) SrcLoc
- | ModParens (ModExpBase f vn) SrcLoc
- | ModImport FilePath (f ImportName) SrcLoc
- | ModDecs [DecBase f vn] SrcLoc
- | ModApply (ModExpBase f vn) (ModExpBase f vn) (f (Map VName VName)) (f (Map VName VName)) SrcLoc
- | ModAscript (ModExpBase f vn) (SigExpBase f vn) (f (Map VName VName)) SrcLoc
- | ModLambda (ModParamBase f vn) (Maybe (SigExpBase f vn, f (Map VName VName))) (ModExpBase f vn) SrcLoc
- data ModBindBase f vn = ModBind {
- modName :: vn
- modParams :: [ModParamBase f vn]
- modSignature :: Maybe (SigExpBase f vn, f (Map VName VName))
- modExp :: ModExpBase f vn
- modDoc :: Maybe DocComment
- modLocation :: SrcLoc
- data ModParamBase f vn = ModParam {
- modParamName :: vn
- modParamType :: SigExpBase f vn
- modParamAbs :: f [VName]
- modParamLocation :: SrcLoc
- data DocComment = DocComment Text SrcLoc
- data ValBindBase f vn = ValBind {
- valBindEntryPoint :: Maybe (f EntryPoint)
- valBindName :: vn
- valBindRetDecl :: Maybe (TypeExp f vn)
- valBindRetType :: f ResRetType
- valBindTypeParams :: [TypeParamBase vn]
- valBindParams :: [PatBase f vn ParamType]
- valBindBody :: ExpBase f vn
- valBindDoc :: Maybe DocComment
- valBindAttrs :: [AttrInfo vn]
- valBindLocation :: SrcLoc
- data EntryPoint = EntryPoint {}
- data EntryType = EntryType {}
- data EntryParam = EntryParam {}
- data Liftedness
- = Unlifted
- | SizeLifted
- | Lifted
- data TypeBindBase f vn = TypeBind {
- typeAlias :: vn
- typeLiftedness :: Liftedness
- typeParams :: [TypeParamBase vn]
- typeExp :: TypeExp f vn
- typeElab :: f StructRetType
- typeDoc :: Maybe DocComment
- typeBindLocation :: SrcLoc
- data TypeParamBase vn
- = TypeParamDim vn SrcLoc
- | TypeParamType Liftedness vn SrcLoc
- typeParamName :: TypeParamBase vn -> vn
- data ProgBase f vn = Prog {
- progDoc :: Maybe DocComment
- progDecs :: [DecBase f vn]
- data DecBase f vn
- = ValDec (ValBindBase f vn)
- | TypeDec (TypeBindBase f vn)
- | SigDec (SigBindBase f vn)
- | ModDec (ModBindBase f vn)
- | OpenDec (ModExpBase f vn) SrcLoc
- | LocalDec (DecBase f vn) SrcLoc
- | ImportDec FilePath (f ImportName) SrcLoc
- data NoInfo a = NoInfo
- newtype Info a = Info {
- unInfo :: a
- data QualName vn = QualName {}
- mkApply :: ExpBase Info vn -> [(Diet, Maybe VName, ExpBase Info vn)] -> AppRes -> ExpBase Info vn
- mkApplyUT :: ExpBase NoInfo vn -> ExpBase NoInfo vn -> ExpBase NoInfo vn
- sizeFromName :: QualName VName -> SrcLoc -> Size
- sizeFromInteger :: Integer -> SrcLoc -> Size
Documentation
module Language.Futhark.Core
prettyString :: Pretty a => a -> String Source #
Prettyprint a value to a String
, appropriately wrapped.
Types
data Uniqueness Source #
The uniqueness attribute of a type. This essentially indicates
whether or not in-place modifications are acceptable. With respect
to ordering, Unique
is greater than Nonunique
.
Instances
An integer type, ordered by size. Note that signedness is not a property of the type, but a property of the operations performed on values of these types.
Instances
Bounded IntType Source # | |
Enum IntType Source # | |
Show IntType Source # | |
Eq IntType Source # | |
Ord IntType Source # | |
Pretty IntType Source # | |
Defined in Language.Futhark.Primitive |
A floating point type.
Instances
Bounded FloatType Source # | |
Enum FloatType Source # | |
Defined in Language.Futhark.Primitive succ :: FloatType -> FloatType # pred :: FloatType -> FloatType # fromEnum :: FloatType -> Int # enumFrom :: FloatType -> [FloatType] # enumFromThen :: FloatType -> FloatType -> [FloatType] # enumFromTo :: FloatType -> FloatType -> [FloatType] # enumFromThenTo :: FloatType -> FloatType -> FloatType -> [FloatType] # | |
Show FloatType Source # | |
Eq FloatType Source # | |
Ord FloatType Source # | |
Defined in Language.Futhark.Primitive | |
Pretty FloatType Source # | |
Defined in Language.Futhark.Primitive |
Low-level primitive types.
The size of an array type is a list of its dimension sizes. If
Nothing
, that dimension is of a (statically) unknown size.
Instances
stripDims :: Int -> Shape dim -> Maybe (Shape dim) Source #
stripDims n shape
strips the outer n
dimensions from
shape
, returning Nothing
if this would result in zero or
fewer dimensions.
An expanded Futhark type is either an array, or something that can be an element of an array. When comparing types for equality, function parameter names are ignored. This representation permits some malformed types (arrays of functions), but importantly rules out arrays-of-arrays.
Scalar (ScalarTypeBase dim u) | |
Array u (Shape dim) (ScalarTypeBase dim NoUniqueness) |
Instances
An argument passed to a type constructor.
TypeArgDim dim | |
TypeArgType (TypeBase dim NoUniqueness) |
Instances
Foldable TypeArg Source # | |
Defined in Language.Futhark.Syntax fold :: Monoid m => TypeArg m -> m # foldMap :: Monoid m => (a -> m) -> TypeArg a -> m # foldMap' :: Monoid m => (a -> m) -> TypeArg a -> m # foldr :: (a -> b -> b) -> b -> TypeArg a -> b # foldr' :: (a -> b -> b) -> b -> TypeArg a -> b # foldl :: (b -> a -> b) -> b -> TypeArg a -> b # foldl' :: (b -> a -> b) -> b -> TypeArg a -> b # foldr1 :: (a -> a -> a) -> TypeArg a -> a # foldl1 :: (a -> a -> a) -> TypeArg a -> a # elem :: Eq a => a -> TypeArg a -> Bool # maximum :: Ord a => TypeArg a -> a # minimum :: Ord a => TypeArg a -> a # | |
Traversable TypeArg Source # | |
Functor TypeArg Source # | |
Show dim => Show (TypeArg dim) Source # | |
Eq dim => Eq (TypeArg dim) Source # | |
Ord dim => Ord (TypeArg dim) Source # | |
Defined in Language.Futhark.Syntax | |
Pretty (TypeArg Size) Source # | |
A dimension declaration expression for use in a TypeExp
.
Syntactically includes the brackets.
SizeExp (ExpBase f vn) SrcLoc | The size of the dimension is this expression, all of which free variables must be in scope. |
SizeExpAny SrcLoc | No dimension declaration. |
Instances
An unstructured syntactic type with type variables and possibly
shape declarations - this is what the user types in the source
program. These are used to construct TypeBase
s in the type
checker.
TEVar (QualName vn) SrcLoc | |
TEParens (TypeExp f vn) SrcLoc | |
TETuple [TypeExp f vn] SrcLoc | |
TERecord [(Name, TypeExp f vn)] SrcLoc | |
TEArray (SizeExp f vn) (TypeExp f vn) SrcLoc | |
TEUnique (TypeExp f vn) SrcLoc | |
TEApply (TypeExp f vn) (TypeArgExp f vn) SrcLoc | |
TEArrow (Maybe vn) (TypeExp f vn) (TypeExp f vn) SrcLoc | |
TESum [(Name, [TypeExp f vn])] SrcLoc | |
TEDim [vn] (TypeExp f vn) SrcLoc |
Instances
data TypeArgExp f vn Source #
A type argument expression passed to a type constructor.
TypeArgExpSize (SizeExp f vn) | |
TypeArgExpType (TypeExp f vn) |
Instances
The name (if any) of a function parameter. The Eq
and Ord
instances always compare values of this type equal.
data ScalarTypeBase dim u Source #
Types that can be elements of arrays. This representation does allow arrays of records of functions, which is nonsensical, but it convolutes the code too much if we try to statically rule it out.
Prim PrimType | |
TypeVar u (QualName VName) [TypeArg dim] | |
Record (Map Name (TypeBase dim u)) | |
Sum (Map Name [TypeBase dim u]) | |
Arrow u PName Diet (TypeBase dim NoUniqueness) (RetTypeBase dim Uniqueness) | The aliasing corresponds to the lexical closure of the function. |
Instances
data RetTypeBase dim as Source #
Types that can appear to the right of a function arrow. This just means they can be existentially quantified.
Instances
type StructType = TypeBase Size NoUniqueness Source #
A "structural" type with shape annotations and no aliasing information, used for declarations.
type ParamType = TypeBase Size Diet Source #
A type with consumption information, used for function parameters (but not in function types).
type ResType = TypeBase Size Uniqueness Source #
A type with uniqueness information, used for function return types
type StructRetType = RetTypeBase Size NoUniqueness Source #
The return type version of a ResType
.
type ResRetType = RetTypeBase Size Uniqueness Source #
The return type version of a StructType
.
type ValueType = TypeBase Int64 NoUniqueness Source #
A value type contains full, manifest size information.
Information about which parts of a parameter are consumed. This can be considered kind of an effect on the function.
Instances
Monoid Diet Source # | |
Semigroup Diet Source # | |
Show Diet Source # | |
ASTMappable ParamType Source # | |
Substitutable ParamType Source # | |
Defined in Language.Futhark.TypeChecker.Types | |
Eq Diet Source # | |
Ord Diet Source # | |
Pretty Diet Source # | |
Defined in Language.Futhark.Pretty | |
Substitutable (Pat ParamType) Source # | |
Defined in Language.Futhark.TypeChecker.Types | |
ASTMappable (PatBase Info VName ParamType) Source # | |
Values
An integer value.
data FloatValue Source #
A floating-point value.
Instances
Non-array values.
class IsPrimValue v where Source #
A class for converting ordinary Haskell values to primitive Futhark values.
Instances
Abstract syntax tree
The payload of an attribute.
Instances
Show (AttrInfo vn) Source # | |
Eq (AttrInfo vn) Source # | |
Ord (AttrInfo vn) Source # | |
Defined in Language.Futhark.Syntax | |
IsName vn => Pretty (AttrInfo vn) Source # | |
Defined in Language.Futhark.Pretty |
The value of an AttrAtom
.
Instances
Show (AttrAtom vn) Source # | |
Eq (AttrAtom vn) Source # | |
Ord (AttrAtom vn) Source # | |
Defined in Language.Futhark.Syntax | |
IsName vn => Pretty (AttrAtom vn) Source # | |
Defined in Language.Futhark.Pretty |
Default binary operators.
Backtick | A pseudo-operator standing in for any normal identifier used as an operator (they all have the same fixity). |
Bang | Not a real operator, but operator with this as a prefix may be defined by the user. |
Equ | Not a real operator, but operator with this as a prefix may be defined by the user. |
Plus | |
Minus | |
Pow | |
Times | |
Divide | |
Mod | |
Quot | |
Rem | |
ShiftR | |
ShiftL | |
Band | |
Xor | |
Bor | |
LogAnd | |
LogOr | |
Equal | |
NotEqual | |
Less | |
Leq | |
Greater | |
Geq | |
PipeRight | |> |
PipeLeft |
|
data IdentBase f vn t Source #
An identifier consists of its name and the type of the value bound to the identifier.
Ident | |
|
Instances
Show (Info t) => Show (IdentBase Info VName t) Source # | |
(Show (Info t), Show vn) => Show (IdentBase (NoInfo :: Type -> Type) vn t) Source # | |
ASTMappable (IdentBase Info VName StructType) Source # | |
Defined in Language.Futhark.Traversals | |
Eq vn => Eq (IdentBase ty vn t) Source # | |
Ord vn => Ord (IdentBase ty vn t) Source # | |
Defined in Language.Futhark.Syntax compare :: IdentBase ty vn t -> IdentBase ty vn t -> Ordering # (<) :: IdentBase ty vn t -> IdentBase ty vn t -> Bool # (<=) :: IdentBase ty vn t -> IdentBase ty vn t -> Bool # (>) :: IdentBase ty vn t -> IdentBase ty vn t -> Bool # (>=) :: IdentBase ty vn t -> IdentBase ty vn t -> Bool # max :: IdentBase ty vn t -> IdentBase ty vn t -> IdentBase ty vn t # min :: IdentBase ty vn t -> IdentBase ty vn t -> IdentBase ty vn t # | |
IsName vn => Pretty (IdentBase f vn t) Source # | |
Defined in Language.Futhark.Pretty | |
Located (IdentBase ty vn t) Source # | |
data Inclusiveness a Source #
Whether a bound for an end-point of a DimSlice
or a range
literal is inclusive or exclusive.
DownToExclusive a | |
ToInclusive a | May be "down to" if step is negative. |
UpToExclusive a |
Instances
data DimIndexBase f vn Source #
An indexing of a single dimension.
Instances
type SliceBase f vn = [DimIndexBase f vn] Source #
A slicing of an array (potentially multiple dimensions).
data SizeBinder vn Source #
A binding of a size in a pattern (essentially a size parameter in
a let
expression).
Instances
data AppExpBase f vn Source #
An "application expression" is a semantic (not syntactic)
grouping of expressions that have "funcall-like" semantics, mostly
meaning that they can return existential sizes. In our type
theory, these are all thought to be bound to names (*Administrative
Normal Form*), but as this is not practical in a real language, we
instead use an annotation (AppRes
) that stores the information we
need, so we can pretend that an application expression was really
bound to a name.
Apply (ExpBase f vn) (NonEmpty (f (Diet, Maybe VName), ExpBase f vn)) SrcLoc | Function application. Parts of the compiler expects that the
function expression is never itself an The |
Range (ExpBase f vn) (Maybe (ExpBase f vn)) (Inclusiveness (ExpBase f vn)) SrcLoc | |
LetPat [SizeBinder vn] (PatBase f vn StructType) (ExpBase f vn) (ExpBase f vn) SrcLoc | |
LetFun vn ([TypeParamBase vn], [PatBase f vn ParamType], Maybe (TypeExp f vn), f ResRetType, ExpBase f vn) (ExpBase f vn) SrcLoc | |
If (ExpBase f vn) (ExpBase f vn) (ExpBase f vn) SrcLoc | |
Loop [VName] (PatBase f vn ParamType) (ExpBase f vn) (LoopFormBase f vn) (ExpBase f vn) SrcLoc | |
BinOp (QualName vn, SrcLoc) (f StructType) (ExpBase f vn, f (Maybe VName)) (ExpBase f vn, f (Maybe VName)) SrcLoc | |
LetWith (IdentBase f vn StructType) (IdentBase f vn StructType) (SliceBase f vn) (ExpBase f vn) (ExpBase f vn) SrcLoc | |
Index (ExpBase f vn) (SliceBase f vn) SrcLoc | |
Match (ExpBase f vn) (NonEmpty (CaseBase f vn)) SrcLoc | A match expression. |
Instances
An annotation inserted by the type checker on constructs that are "function calls" (either literally or conceptually). This annotation encodes the result type, as well as any existential sizes that are generated here.
AppRes | |
|
The Futhark expression language.
This allows us to encode whether or not the expression has been
type-checked in the Haskell type of the expression. Specifically,
the parser will produce expressions of type Exp
,
and the type checker will convert these to NoInfo
Name
Exp
, in
which type information is always present and all names are unique.Info
VName
Literal PrimValue SrcLoc | |
IntLit Integer (f StructType) SrcLoc | A polymorphic integral literal. |
FloatLit Double (f StructType) SrcLoc | A polymorphic decimal literal. |
StringLit [Word8] SrcLoc | A string literal is just a fancy syntax for an array of bytes. |
Hole (f StructType) SrcLoc | |
Var (QualName vn) (f StructType) SrcLoc | |
Parens (ExpBase f vn) SrcLoc | A parenthesized expression. |
QualParens (QualName vn, SrcLoc) (ExpBase f vn) SrcLoc | |
TupLit [ExpBase f vn] SrcLoc | Tuple literals, e.g., |
RecordLit [FieldBase f vn] SrcLoc | Record literals, e.g. |
ArrayLit [ExpBase f vn] (f StructType) SrcLoc | Array literals, e.g., |
Attr (AttrInfo vn) (ExpBase f vn) SrcLoc | An attribute applied to the following expression. |
Project Name (ExpBase f vn) (f StructType) SrcLoc | |
Negate (ExpBase f vn) SrcLoc | Numeric negation (ugly special case; Haskell did it first). |
Not (ExpBase f vn) SrcLoc | Logical and bitwise negation. |
Assert (ExpBase f vn) (ExpBase f vn) (f Text) SrcLoc | Fail if the first expression does not return true, and return the value of the second expression if it does. |
Constr Name [ExpBase f vn] (f StructType) SrcLoc | An n-ary value constructor. |
Update (ExpBase f vn) (SliceBase f vn) (ExpBase f vn) SrcLoc | |
RecordUpdate (ExpBase f vn) [Name] (ExpBase f vn) (f StructType) SrcLoc | |
Lambda [PatBase f vn ParamType] (ExpBase f vn) (Maybe (TypeExp f vn)) (f ResRetType) SrcLoc | |
OpSection (QualName vn) (f StructType) SrcLoc |
|
OpSectionLeft (QualName vn) (f StructType) (ExpBase f vn) (f (PName, ParamType, Maybe VName), f (PName, ParamType)) (f ResRetType, f [VName]) SrcLoc |
|
OpSectionRight (QualName vn) (f StructType) (ExpBase f vn) (f (PName, ParamType), f (PName, ParamType, Maybe VName)) (f ResRetType) SrcLoc |
|
ProjectSection [Name] (f StructType) SrcLoc | Field projection as a section: |
IndexSection (SliceBase f vn) (f StructType) SrcLoc | Array indexing as a section: |
Ascript (ExpBase f vn) (TypeExp f vn) SrcLoc | Type ascription: |
Coerce (ExpBase f vn) (TypeExp f vn) (f StructType) SrcLoc | Size coercion: |
AppExp (AppExpBase f vn) (f AppRes) |
Instances
An entry in a record literal.
RecordFieldExplicit Name (ExpBase f vn) SrcLoc | |
RecordFieldImplicit vn (f StructType) SrcLoc |
Instances
A case in a match expression.
CasePat (PatBase f vn StructType) (ExpBase f vn) SrcLoc |
Instances
data LoopFormBase f vn Source #
Whether the loop is a for
-loop or a while
-loop.
For (IdentBase f vn StructType) (ExpBase f vn) | |
ForIn (PatBase f vn StructType) (ExpBase f vn) | |
While (ExpBase f vn) |
Instances
A literal in a pattern.
A pattern as used most places where variables are bound (function
parameters, let
expressions, etc).
TuplePat [PatBase f vn t] SrcLoc | |
RecordPat [(Name, PatBase f vn t)] SrcLoc | |
PatParens (PatBase f vn t) SrcLoc | |
Id vn (f t) SrcLoc | |
Wildcard (f t) SrcLoc | |
PatAscription (PatBase f vn t) (TypeExp f vn) SrcLoc | |
PatLit PatLit (f t) SrcLoc | |
PatConstr Name (f t) [PatBase f vn t] SrcLoc | |
PatAttr (AttrInfo vn) (PatBase f vn t) SrcLoc |
Instances
Module language
newtype ImportName Source #
Canonical reference to a Futhark code file. Does not include the
.fut
extension. This is most often a path relative to the
working directory of the compiler. In a multi-file program, a file
is known by exactly one import name, even if it is referenced
relatively by different names by files in different subdirectories.
Instances
Show ImportName Source # | |
Defined in Language.Futhark.Syntax showsPrec :: Int -> ImportName -> ShowS # show :: ImportName -> String # showList :: [ImportName] -> ShowS # | |
Eq ImportName Source # | |
Defined in Language.Futhark.Syntax (==) :: ImportName -> ImportName -> Bool # (/=) :: ImportName -> ImportName -> Bool # | |
Ord ImportName Source # | |
Defined in Language.Futhark.Syntax compare :: ImportName -> ImportName -> Ordering # (<) :: ImportName -> ImportName -> Bool # (<=) :: ImportName -> ImportName -> Bool # (>) :: ImportName -> ImportName -> Bool # (>=) :: ImportName -> ImportName -> Bool # max :: ImportName -> ImportName -> ImportName # min :: ImportName -> ImportName -> ImportName # |
A spec is a component of a module type.
ValSpec | |
| |
TypeAbbrSpec (TypeBindBase f vn) | |
TypeSpec Liftedness vn [TypeParamBase vn] (Maybe DocComment) SrcLoc | Abstract type. |
ModSpec vn (SigExpBase f vn) (Maybe DocComment) SrcLoc | |
IncludeSpec (SigExpBase f vn) SrcLoc |
data SigExpBase f vn Source #
A module type expression.
SigVar (QualName vn) (f (Map VName VName)) SrcLoc | |
SigParens (SigExpBase f vn) SrcLoc | |
SigSpecs [SpecBase f vn] SrcLoc | |
SigWith (SigExpBase f vn) (TypeRefBase f vn) SrcLoc | |
SigArrow (Maybe vn) (SigExpBase f vn) (SigExpBase f vn) SrcLoc |
Instances
Show (SigExpBase Info VName) Source # | |
Defined in Language.Futhark.Syntax | |
Show (SigExpBase (NoInfo :: Type -> Type) Name) Source # | |
Defined in Language.Futhark.Syntax | |
(Eq vn, IsName vn, Annot f) => Pretty (SigExpBase f vn) Source # | |
Defined in Language.Futhark.Pretty pretty :: SigExpBase f vn -> Doc ann # prettyList :: [SigExpBase f vn] -> Doc ann # | |
Located (SigExpBase f vn) Source # | |
Defined in Language.Futhark.Syntax locOf :: SigExpBase f vn -> Loc # locOfList :: [SigExpBase f vn] -> Loc # |
data TypeRefBase f vn Source #
A type refinement.
TypeRef (QualName vn) [TypeParamBase vn] (TypeExp f vn) SrcLoc |
Instances
Show (TypeRefBase Info VName) Source # | |
Defined in Language.Futhark.Syntax | |
Show (TypeRefBase (NoInfo :: Type -> Type) Name) Source # | |
Defined in Language.Futhark.Syntax | |
Located (TypeRefBase f vn) Source # | |
Defined in Language.Futhark.Syntax locOf :: TypeRefBase f vn -> Loc # locOfList :: [TypeRefBase f vn] -> Loc # |
data SigBindBase f vn Source #
Module type binding.
SigBind | |
|
Instances
Show (SigBindBase Info VName) Source # | |
Defined in Language.Futhark.Syntax | |
Show (SigBindBase (NoInfo :: Type -> Type) Name) Source # | |
Defined in Language.Futhark.Syntax | |
(Eq vn, IsName vn, Annot f) => Pretty (SigBindBase f vn) Source # | |
Defined in Language.Futhark.Pretty pretty :: SigBindBase f vn -> Doc ann # prettyList :: [SigBindBase f vn] -> Doc ann # | |
Located (SigBindBase f vn) Source # | |
Defined in Language.Futhark.Syntax locOf :: SigBindBase f vn -> Loc # locOfList :: [SigBindBase f vn] -> Loc # |
data ModExpBase f vn Source #
Module expression.
ModVar (QualName vn) SrcLoc | |
ModParens (ModExpBase f vn) SrcLoc | |
ModImport FilePath (f ImportName) SrcLoc | The contents of another file as a module. |
ModDecs [DecBase f vn] SrcLoc | |
ModApply (ModExpBase f vn) (ModExpBase f vn) (f (Map VName VName)) (f (Map VName VName)) SrcLoc | Functor application. The first mapping is from parameter names to argument names, while the second maps names in the constructed module to the names inside the functor. |
ModAscript (ModExpBase f vn) (SigExpBase f vn) (f (Map VName VName)) SrcLoc | |
ModLambda (ModParamBase f vn) (Maybe (SigExpBase f vn, f (Map VName VName))) (ModExpBase f vn) SrcLoc |
Instances
Show (ModExpBase Info VName) Source # | |
Defined in Language.Futhark.Syntax | |
Show (ModExpBase (NoInfo :: Type -> Type) Name) Source # | |
Defined in Language.Futhark.Syntax | |
(Eq vn, IsName vn, Annot f) => Pretty (ModExpBase f vn) Source # | |
Defined in Language.Futhark.Pretty pretty :: ModExpBase f vn -> Doc ann # prettyList :: [ModExpBase f vn] -> Doc ann # | |
Located (ModExpBase f vn) Source # | |
Defined in Language.Futhark.Syntax locOf :: ModExpBase f vn -> Loc # locOfList :: [ModExpBase f vn] -> Loc # |
data ModBindBase f vn Source #
A module binding.
ModBind | |
|
Instances
Show (ModBindBase Info VName) Source # | |
Defined in Language.Futhark.Syntax | |
Show (ModBindBase (NoInfo :: Type -> Type) Name) Source # | |
Defined in Language.Futhark.Syntax | |
(Eq vn, IsName vn, Annot f) => Pretty (ModBindBase f vn) Source # | |
Defined in Language.Futhark.Pretty pretty :: ModBindBase f vn -> Doc ann # prettyList :: [ModBindBase f vn] -> Doc ann # | |
Located (ModBindBase f vn) Source # | |
Defined in Language.Futhark.Syntax locOf :: ModBindBase f vn -> Loc # locOfList :: [ModBindBase f vn] -> Loc # |
data ModParamBase f vn Source #
A module parameter.
ModParam | |
|
Instances
Show (ModParamBase Info VName) Source # | |
Defined in Language.Futhark.Syntax | |
Show (ModParamBase (NoInfo :: Type -> Type) Name) Source # | |
Defined in Language.Futhark.Syntax | |
(Eq vn, IsName vn, Annot f) => Pretty (ModParamBase f vn) Source # | |
Defined in Language.Futhark.Pretty pretty :: ModParamBase f vn -> Doc ann # prettyList :: [ModParamBase f vn] -> Doc ann # | |
Located (ModParamBase f vn) Source # | |
Defined in Language.Futhark.Syntax locOf :: ModParamBase f vn -> Loc # locOfList :: [ModParamBase f vn] -> Loc # |
Definitions
data DocComment Source #
Documentation strings, including source location. The string may contain newline characters, but it does not contain comment prefix markers.
Instances
Show DocComment Source # | |
Defined in Language.Futhark.Syntax showsPrec :: Int -> DocComment -> ShowS # show :: DocComment -> String # showList :: [DocComment] -> ShowS # | |
Located DocComment Source # | |
Defined in Language.Futhark.Syntax locOf :: DocComment -> Loc # locOfList :: [DocComment] -> Loc # |
data ValBindBase f vn Source #
Function Declarations
ValBind | |
|
Instances
Show (ValBindBase Info VName) Source # | |
Defined in Language.Futhark.Syntax | |
Show (ValBindBase (NoInfo :: Type -> Type) Name) Source # | |
Defined in Language.Futhark.Syntax | |
(Eq vn, IsName vn, Annot f) => Pretty (ValBindBase f vn) Source # | |
Defined in Language.Futhark.Pretty pretty :: ValBindBase f vn -> Doc ann # prettyList :: [ValBindBase f vn] -> Doc ann # | |
Located (ValBindBase f vn) Source # | |
Defined in Language.Futhark.Syntax locOf :: ValBindBase f vn -> Loc # locOfList :: [ValBindBase f vn] -> Loc # |
data EntryPoint Source #
Information about the external interface exposed by an entry point. The important thing is that that we remember the original source-language types, without desugaring them at all. The annoying thing is that we do not require type annotations on entry points, so the types can be either ascribed or inferred.
Instances
Show EntryPoint Source # | |
Defined in Language.Futhark.Syntax showsPrec :: Int -> EntryPoint -> ShowS # show :: EntryPoint -> String # showList :: [EntryPoint] -> ShowS # |
Part of the type of an entry point. Has an actual type, and maybe also an ascribed type expression. Note that although size expressions in the elaborated type can contain variables, they are no longer in scope, and are considered more like equivalence classes.
data EntryParam Source #
A parameter of an entry point.
Instances
Show EntryParam Source # | |
Defined in Language.Futhark.Syntax showsPrec :: Int -> EntryParam -> ShowS # show :: EntryParam -> String # showList :: [EntryParam] -> ShowS # |
data Liftedness Source #
The liftedness of a type parameter. By the Ord
instance,
Unlifted < SizeLifted < Lifted
.
Unlifted | May only be instantiated with a zero-order type of (possibly symbolically) known size. |
SizeLifted | May only be instantiated with a zero-order type, but the size can be varying. |
Lifted | May be instantiated with a functional type. |
Instances
Show Liftedness Source # | |
Defined in Language.Futhark.Syntax showsPrec :: Int -> Liftedness -> ShowS # show :: Liftedness -> String # showList :: [Liftedness] -> ShowS # | |
Eq Liftedness Source # | |
Defined in Language.Futhark.Syntax (==) :: Liftedness -> Liftedness -> Bool # (/=) :: Liftedness -> Liftedness -> Bool # | |
Ord Liftedness Source # | |
Defined in Language.Futhark.Syntax compare :: Liftedness -> Liftedness -> Ordering # (<) :: Liftedness -> Liftedness -> Bool # (<=) :: Liftedness -> Liftedness -> Bool # (>) :: Liftedness -> Liftedness -> Bool # (>=) :: Liftedness -> Liftedness -> Bool # max :: Liftedness -> Liftedness -> Liftedness # min :: Liftedness -> Liftedness -> Liftedness # | |
Pretty Liftedness Source # | |
Defined in Language.Futhark.Pretty pretty :: Liftedness -> Doc ann # prettyList :: [Liftedness] -> Doc ann # |
data TypeBindBase f vn Source #
Type Declarations
TypeBind | |
|
Instances
Show (TypeBindBase Info VName) Source # | |
Defined in Language.Futhark.Syntax | |
Show (TypeBindBase (NoInfo :: Type -> Type) Name) Source # | |
Defined in Language.Futhark.Syntax | |
(Eq vn, IsName vn, Annot f) => Pretty (TypeBindBase f vn) Source # | |
Defined in Language.Futhark.Pretty pretty :: TypeBindBase f vn -> Doc ann # prettyList :: [TypeBindBase f vn] -> Doc ann # | |
Located (TypeBindBase f vn) Source # | |
Defined in Language.Futhark.Syntax locOf :: TypeBindBase f vn -> Loc # locOfList :: [TypeBindBase f vn] -> Loc # |
data TypeParamBase vn Source #
A type parameter.
TypeParamDim vn SrcLoc | A type parameter that must be a size. |
TypeParamType Liftedness vn SrcLoc | A type parameter that must be a type. |
Instances
typeParamName :: TypeParamBase vn -> vn Source #
The name of a type parameter.
The program described by a single Futhark file. May depend on other files.
A top-level binding.
ValDec (ValBindBase f vn) | |
TypeDec (TypeBindBase f vn) | |
SigDec (SigBindBase f vn) | |
ModDec (ModBindBase f vn) | |
OpenDec (ModExpBase f vn) SrcLoc | |
LocalDec (DecBase f vn) SrcLoc | |
ImportDec FilePath (f ImportName) SrcLoc |
Miscellaneous
No information functor. Usually used for placeholder type- or aliasing information.
Instances
Some information. The dual to NoInfo
Instances
A name qualified with a breadcrumb of module accesses.
Instances
mkApply :: ExpBase Info vn -> [(Diet, Maybe VName, ExpBase Info vn)] -> AppRes -> ExpBase Info vn Source #
Construct an Apply
node, with type information.