Safe Haskell | Safe-Inferred |
---|---|
Language | Haskell2010 |
Language.Futhark.Syntax
Description
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.
Synopsis
- module Language.Futhark.Core
- pretty :: Pretty a => a -> String
- data Uniqueness
- data IntType
- data FloatType
- data PrimType
- class Eq dim => ArrayDim dim where
- data DimDecl vn
- newtype ShapeDecl dim = ShapeDecl {
- shapeDims :: [dim]
- shapeRank :: ShapeDecl dim -> Int
- stripDims :: Int -> ShapeDecl dim -> Maybe (ShapeDecl dim)
- data TypeName = TypeName {}
- typeNameFromQualName :: QualName VName -> TypeName
- qualNameFromTypeName :: TypeName -> QualName VName
- data TypeBase dim as
- = Scalar (ScalarTypeBase dim as)
- | Array as Uniqueness (ScalarTypeBase dim ()) (ShapeDecl dim)
- data TypeArg dim
- = TypeArgDim dim SrcLoc
- | TypeArgType (TypeBase dim ()) SrcLoc
- data DimExp vn
- = DimExpNamed (QualName vn) SrcLoc
- | DimExpConst Int SrcLoc
- | DimExpAny
- data TypeExp vn
- = TEVar (QualName vn) SrcLoc
- | TETuple [TypeExp vn] SrcLoc
- | TERecord [(Name, TypeExp vn)] SrcLoc
- | TEArray (TypeExp vn) (DimExp vn) SrcLoc
- | TEUnique (TypeExp vn) SrcLoc
- | TEApply (TypeExp vn) (TypeArgExp vn) SrcLoc
- | TEArrow (Maybe vn) (TypeExp vn) (TypeExp vn) SrcLoc
- | TESum [(Name, [TypeExp vn])] SrcLoc
- | TEDim [vn] (TypeExp vn) SrcLoc
- data TypeArgExp vn
- = TypeArgExpDim (DimExp vn) SrcLoc
- | TypeArgExpType (TypeExp vn)
- data PName
- data ScalarTypeBase dim as
- data RetTypeBase dim as = RetType {}
- type PatType = TypeBase (DimDecl VName) Aliasing
- type StructType = TypeBase (DimDecl VName) ()
- type StructRetType = RetTypeBase (DimDecl VName) ()
- type PatRetType = RetTypeBase (DimDecl VName) Aliasing
- type ValueType = TypeBase Int64 ()
- data Diet
- data TypeDeclBase f vn = TypeDecl {
- declaredType :: TypeExp vn
- expandedType :: f StructType
- data IntValue
- = Int8Value !Int8
- | Int16Value !Int16
- | Int32Value !Int32
- | Int64Value !Int64
- data FloatValue
- data PrimValue
- class IsPrimValue v where
- data Value
- data AttrInfo vn
- data AttrAtom vn
- data BinOp
- data IdentBase f vn = Ident {
- identName :: vn
- identType :: f PatType
- 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) (ExpBase f vn) (f (Diet, Maybe VName)) SrcLoc
- | Coerce (ExpBase f vn) (TypeDeclBase f vn) SrcLoc
- | Range (ExpBase f vn) (Maybe (ExpBase f vn)) (Inclusiveness (ExpBase f vn)) SrcLoc
- | LetPat [SizeBinder vn] (PatBase f vn) (ExpBase f vn) (ExpBase f vn) SrcLoc
- | LetFun vn ([TypeParamBase vn], [PatBase f vn], Maybe (TypeExp vn), f StructRetType, ExpBase f vn) (ExpBase f vn) SrcLoc
- | If (ExpBase f vn) (ExpBase f vn) (ExpBase f vn) SrcLoc
- | DoLoop [VName] (PatBase f vn) (ExpBase f vn) (LoopFormBase f vn) (ExpBase f vn) SrcLoc
- | BinOp (QualName vn, SrcLoc) (f PatType) (ExpBase f vn, f (StructType, Maybe VName)) (ExpBase f vn, f (StructType, Maybe VName)) SrcLoc
- | LetWith (IdentBase f vn) (IdentBase f vn) (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 :: PatType
- appResExt :: [VName]
- data ExpBase f vn
- = Literal PrimValue SrcLoc
- | IntLit Integer (f PatType) SrcLoc
- | FloatLit Double (f PatType) SrcLoc
- | StringLit [Word8] SrcLoc
- | Var (QualName vn) (f PatType) 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 PatType) SrcLoc
- | Attr (AttrInfo vn) (ExpBase f vn) SrcLoc
- | Project Name (ExpBase f vn) (f PatType) SrcLoc
- | Negate (ExpBase f vn) SrcLoc
- | Not (ExpBase f vn) SrcLoc
- | Assert (ExpBase f vn) (ExpBase f vn) (f String) SrcLoc
- | Constr Name [ExpBase f vn] (f PatType) SrcLoc
- | Update (ExpBase f vn) (SliceBase f vn) (ExpBase f vn) SrcLoc
- | RecordUpdate (ExpBase f vn) [Name] (ExpBase f vn) (f PatType) SrcLoc
- | Lambda [PatBase f vn] (ExpBase f vn) (Maybe (TypeExp vn)) (f (Aliasing, StructRetType)) SrcLoc
- | OpSection (QualName vn) (f PatType) SrcLoc
- | OpSectionLeft (QualName vn) (f PatType) (ExpBase f vn) (f (PName, StructType, Maybe VName), f (PName, StructType)) (f PatRetType, f [VName]) SrcLoc
- | OpSectionRight (QualName vn) (f PatType) (ExpBase f vn) (f (PName, StructType), f (PName, StructType, Maybe VName)) (f PatRetType) SrcLoc
- | ProjectSection [Name] (f PatType) SrcLoc
- | IndexSection (SliceBase f vn) (f PatType) SrcLoc
- | Ascript (ExpBase f vn) (TypeDeclBase f vn) SrcLoc
- | AppExp (AppExpBase f vn) (f AppRes)
- data FieldBase f vn
- = RecordFieldExplicit Name (ExpBase f vn) SrcLoc
- | RecordFieldImplicit vn (f PatType) SrcLoc
- data CaseBase f vn = CasePat (PatBase f vn) (ExpBase f vn) SrcLoc
- data LoopFormBase f vn
- data PatLit
- data PatBase f vn
- = TuplePat [PatBase f vn] SrcLoc
- | RecordPat [(Name, PatBase f vn)] SrcLoc
- | PatParens (PatBase f vn) SrcLoc
- | Id vn (f PatType) SrcLoc
- | Wildcard (f PatType) SrcLoc
- | PatAscription (PatBase f vn) (TypeDeclBase f vn) SrcLoc
- | PatLit PatLit (f PatType) SrcLoc
- | PatConstr Name (f PatType) [PatBase f vn] SrcLoc
- | PatAttr (AttrInfo vn) (PatBase f vn) SrcLoc
- data SpecBase f vn
- = ValSpec {
- specName :: vn
- specTypeParams :: [TypeParamBase vn]
- specType :: TypeDeclBase f vn
- 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] (TypeDeclBase 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 FilePath) 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 String SrcLoc
- data ValBindBase f vn = ValBind {
- valBindEntryPoint :: Maybe (f EntryPoint)
- valBindName :: vn
- valBindRetDecl :: Maybe (TypeExp vn)
- valBindRetType :: f StructRetType
- valBindTypeParams :: [TypeParamBase vn]
- valBindParams :: [PatBase f vn]
- 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 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 FilePath) SrcLoc
- class (Show vn, Show (f VName), Show (f (Diet, Maybe VName)), Show (f String), Show (f [VName]), Show (f ([VName], [VName])), Show (f PatType), Show (f (PatType, [VName])), Show (f (StructType, [VName])), Show (f (StructRetType, [VName])), Show (f EntryPoint), Show (f StructType), Show (f StructRetType), Show (f PatRetType), Show (f (StructType, Maybe VName)), Show (f (PName, StructType)), Show (f (PName, StructType, Maybe VName)), Show (f (Aliasing, StructRetType)), Show (f (Map VName VName)), Show (f AppRes)) => Showable f vn
- data NoInfo a = NoInfo
- newtype Info a = Info {
- unInfo :: a
- data Alias
- type Aliasing = Set Alias
- data QualName vn = QualName {}
Documentation
module Language.Futhark.Core
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
.
Constructors
Nonunique | May have references outside current function. |
Unique | No references outside current function. |
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 # | |
Eq IntType Source # | |
Ord IntType Source # | |
Defined in Futhark.IR.Primitive | |
Show IntType Source # | |
Pretty IntType Source # | |
A floating point type.
Instances
Bounded FloatType Source # | |
Enum FloatType Source # | |
Defined in Futhark.IR.Primitive Methods 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] # | |
Eq FloatType Source # | |
Ord FloatType Source # | |
Show FloatType Source # | |
Pretty FloatType Source # | |
Low-level primitive types.
class Eq dim => ArrayDim dim where Source #
A type class for things that can be array dimensions.
Declaration of a dimension size.
Constructors
NamedDim (QualName vn) | The size of the dimension is this name, which must be in scope. In a return type, this will give rise to an assertion. |
ConstDim Int | The size is a constant. |
AnyDim (Maybe vn) | No known size - but still possibly given a unique name, so we
can recognise e.g. |
Instances
newtype ShapeDecl dim Source #
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 -> ShapeDecl dim -> Maybe (ShapeDecl dim) Source #
stripDims n shape
strips the outer n
dimensions from
shape
, returning Nothing
if this would result in zero or
fewer dimensions.
A type name consists of qualifiers (for error messages) and a
VName
(for equality checking).
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.
Constructors
Scalar (ScalarTypeBase dim as) | |
Array as Uniqueness (ScalarTypeBase dim ()) (ShapeDecl dim) |
Instances
An argument passed to a type constructor.
Constructors
TypeArgDim dim SrcLoc | |
TypeArgType (TypeBase dim ()) SrcLoc |
Instances
Functor TypeArg Source # | |
Foldable TypeArg Source # | |
Defined in Language.Futhark.Syntax Methods 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 # | |
Eq dim => Eq (TypeArg dim) Source # | |
Ord dim => Ord (TypeArg dim) Source # | |
Defined in Language.Futhark.Syntax | |
Show dim => Show (TypeArg dim) Source # | |
Pretty (ShapeDecl dim) => Pretty (TypeArg dim) Source # | |
A dimension declaration expression for use in a TypeExp
.
Constructors
DimExpNamed (QualName vn) SrcLoc | The size of the dimension is this name, which must be in scope. |
DimExpConst Int SrcLoc | The size is a constant. |
DimExpAny | No dimension declaration. |
Instances
Eq (DimExp VName) Source # | |
Eq (DimExp Name) Source # | |
Ord (DimExp VName) Source # | |
Defined in Language.Futhark.Syntax | |
Ord (DimExp Name) Source # | |
Defined in Language.Futhark.Syntax | |
Show vn => Show (DimExp vn) Source # | |
IsName vn => Pretty (DimExp vn) Source # | |
ASTMappable (DimExp VName) Source # | |
An unstructured 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.
Constructors
TEVar (QualName vn) SrcLoc | |
TETuple [TypeExp vn] SrcLoc | |
TERecord [(Name, TypeExp vn)] SrcLoc | |
TEArray (TypeExp vn) (DimExp vn) SrcLoc | |
TEUnique (TypeExp vn) SrcLoc | |
TEApply (TypeExp vn) (TypeArgExp vn) SrcLoc | |
TEArrow (Maybe vn) (TypeExp vn) (TypeExp vn) SrcLoc | |
TESum [(Name, [TypeExp vn])] SrcLoc | |
TEDim [vn] (TypeExp vn) SrcLoc |
Instances
Eq (TypeExp VName) Source # | |
Eq (TypeExp Name) Source # | |
Ord (TypeExp VName) Source # | |
Defined in Language.Futhark.Syntax Methods compare :: TypeExp VName -> TypeExp VName -> Ordering # (<) :: TypeExp VName -> TypeExp VName -> Bool # (<=) :: TypeExp VName -> TypeExp VName -> Bool # (>) :: TypeExp VName -> TypeExp VName -> Bool # (>=) :: TypeExp VName -> TypeExp VName -> Bool # | |
Ord (TypeExp Name) Source # | |
Defined in Language.Futhark.Syntax | |
Show vn => Show (TypeExp vn) Source # | |
(Eq vn, IsName vn) => Pretty (TypeExp vn) Source # | |
Located (TypeExp vn) Source # | |
ASTMappable (TypeExp VName) Source # | |
data TypeArgExp vn Source #
A type argument expression passed to a type constructor.
Constructors
TypeArgExpDim (DimExp vn) SrcLoc | |
TypeArgExpType (TypeExp 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 as 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.
Constructors
Prim PrimType | |
TypeVar as Uniqueness TypeName [TypeArg dim] | |
Record (Map Name (TypeBase dim as)) | |
Sum (Map Name [TypeBase dim as]) | |
Arrow as PName (TypeBase dim as) (RetTypeBase dim as) | 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 PatType = TypeBase (DimDecl VName) Aliasing Source #
A type with aliasing information and shape annotations, used for describing the type patterns and expressions.
type StructType = TypeBase (DimDecl VName) () Source #
A "structural" type with shape annotations and no aliasing information, used for declarations.
type StructRetType = RetTypeBase (DimDecl VName) () Source #
The return type version of StructType
.
type PatRetType = RetTypeBase (DimDecl VName) Aliasing Source #
The return type version of PatType
.
Information about which parts of a value/type are consumed.
Constructors
RecordDiet (Map Name Diet) | Consumes these fields in the record. |
SumDiet (Map Name [Diet]) | Consume these parts of the constructors. |
FuncDiet Diet Diet | A function that consumes its argument(s) like this.
The final |
Consume | Consumes this value. |
Observe | Only observes value in this position, does not consume. |
data TypeDeclBase f vn Source #
A declaration of the type of something.
Constructors
TypeDecl | |
Fields
|
Instances
Values
An integer value.
Constructors
Int8Value !Int8 | |
Int16Value !Int16 | |
Int32Value !Int32 | |
Int64Value !Int64 |
data FloatValue Source #
A floating-point value.
Constructors
Float16Value !Half | |
Float32Value !Float | |
Float64Value !Double |
Instances
Eq FloatValue Source # | |
Defined in Futhark.IR.Primitive | |
Ord FloatValue Source # | |
Defined in Futhark.IR.Primitive Methods compare :: FloatValue -> FloatValue -> Ordering # (<) :: FloatValue -> FloatValue -> Bool # (<=) :: FloatValue -> FloatValue -> Bool # (>) :: FloatValue -> FloatValue -> Bool # (>=) :: FloatValue -> FloatValue -> Bool # max :: FloatValue -> FloatValue -> FloatValue # min :: FloatValue -> FloatValue -> FloatValue # | |
Show FloatValue Source # | |
Defined in Futhark.IR.Primitive Methods showsPrec :: Int -> FloatValue -> ShowS # show :: FloatValue -> String # showList :: [FloatValue] -> ShowS # | |
ToExp FloatValue Source # | |
Defined in Futhark.CodeGen.Backends.SimpleRep Methods toExp :: FloatValue -> SrcLoc -> Exp # | |
Pretty FloatValue Source # | |
Defined in Futhark.IR.Primitive Methods ppr :: FloatValue -> Doc # pprPrec :: Int -> FloatValue -> Doc # pprList :: [FloatValue] -> Doc # | |
IsValue FloatValue Source # | |
Defined in Futhark.IR.Prop.Constants Methods value :: FloatValue -> PrimValue Source # |
Non-array values.
Constructors
SignedValue !IntValue | |
UnsignedValue !IntValue | |
FloatValue !FloatValue | |
BoolValue !Bool |
Instances
Eq PrimValue Source # | |
Ord PrimValue Source # | |
Show PrimValue Source # | |
Pretty PrimValue Source # | |
class IsPrimValue v where Source #
A class for converting ordinary Haskell values to primitive Futhark values.
Instances
Simple Futhark values. Values are fully evaluated and their type is always unambiguous.
Constructors
PrimValue !PrimValue | |
ArrayValue !(Array Int Value) ValueType | It is assumed that the array is 0-indexed. The type is the full type. |
Abstract syntax tree
The payload of an attribute.
Instances
Eq (AttrInfo vn) Source # | |
Ord (AttrInfo vn) Source # | |
Defined in Language.Futhark.Syntax | |
Show (AttrInfo vn) Source # | |
IsName vn => Pretty (AttrInfo vn) Source # | |
The value of an AttrAtom
.
Instances
Eq (AttrAtom vn) Source # | |
Ord (AttrAtom vn) Source # | |
Defined in Language.Futhark.Syntax | |
Show (AttrAtom vn) Source # | |
IsName vn => Pretty (AttrAtom vn) Source # | |
Default binary operators.
Constructors
Backtick | A pseudo-operator standing in for any normal identifier used as an operator (they all have the same fixity). Binary Ops for Numbers |
Plus | |
Minus | |
Pow | |
Times | |
Divide | |
Mod | |
Quot | |
Rem | |
ShiftR | |
ShiftL | |
Band | |
Xor | |
Bor | |
LogAnd | |
LogOr | |
Equal | |
NotEqual | |
Less | |
Leq | |
Greater | |
Geq | |
PipeRight | |> |
PipeLeft |
|
An identifier consists of its name and the type of the value bound to the identifier.
Instances
Eq vn => Eq (IdentBase ty vn) Source # | |
Ord vn => Ord (IdentBase ty vn) Source # | |
Defined in Language.Futhark.Syntax Methods compare :: IdentBase ty vn -> IdentBase ty vn -> Ordering # (<) :: IdentBase ty vn -> IdentBase ty vn -> Bool # (<=) :: IdentBase ty vn -> IdentBase ty vn -> Bool # (>) :: IdentBase ty vn -> IdentBase ty vn -> Bool # (>=) :: IdentBase ty vn -> IdentBase ty vn -> Bool # max :: IdentBase ty vn -> IdentBase ty vn -> IdentBase ty vn # min :: IdentBase ty vn -> IdentBase ty vn -> IdentBase ty vn # | |
Showable f vn => Show (IdentBase f vn) Source # | |
IsName vn => Pretty (IdentBase f vn) Source # | |
Located (IdentBase ty vn) Source # | |
ASTMappable (IdentBase Info VName) Source # | |
data Inclusiveness a Source #
Whether a bound for an end-point of a DimSlice
or a range
literal is inclusive or exclusive.
Constructors
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.
Constructors
DimFix (ExpBase f vn) | |
DimSlice (Maybe (ExpBase f vn)) (Maybe (ExpBase f vn)) (Maybe (ExpBase f vn)) |
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).
Constructors
SizeBinder | |
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.
Constructors
Apply (ExpBase f vn) (ExpBase f vn) (f (Diet, Maybe VName)) SrcLoc | The |
Coerce (ExpBase f vn) (TypeDeclBase f vn) SrcLoc | Size coercion: |
Range (ExpBase f vn) (Maybe (ExpBase f vn)) (Inclusiveness (ExpBase f vn)) SrcLoc | |
LetPat [SizeBinder vn] (PatBase f vn) (ExpBase f vn) (ExpBase f vn) SrcLoc | |
LetFun vn ([TypeParamBase vn], [PatBase f vn], Maybe (TypeExp vn), f StructRetType, ExpBase f vn) (ExpBase f vn) SrcLoc | |
If (ExpBase f vn) (ExpBase f vn) (ExpBase f vn) SrcLoc | |
DoLoop [VName] (PatBase f vn) (ExpBase f vn) (LoopFormBase f vn) (ExpBase f vn) SrcLoc | |
BinOp (QualName vn, SrcLoc) (f PatType) (ExpBase f vn, f (StructType, Maybe VName)) (ExpBase f vn, f (StructType, Maybe VName)) SrcLoc | |
LetWith (IdentBase f vn) (IdentBase f vn) (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.
Constructors
AppRes | |
Fields
|
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
Constructors
Literal PrimValue SrcLoc | |
IntLit Integer (f PatType) SrcLoc | A polymorphic integral literal. |
FloatLit Double (f PatType) SrcLoc | A polymorphic decimal literal. |
StringLit [Word8] SrcLoc | A string literal is just a fancy syntax for an array of bytes. |
Var (QualName vn) (f PatType) 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 PatType) 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 PatType) 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 String) 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 PatType) 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 PatType) SrcLoc | |
Lambda [PatBase f vn] (ExpBase f vn) (Maybe (TypeExp vn)) (f (Aliasing, StructRetType)) SrcLoc | |
OpSection (QualName vn) (f PatType) SrcLoc |
|
OpSectionLeft (QualName vn) (f PatType) (ExpBase f vn) (f (PName, StructType, Maybe VName), f (PName, StructType)) (f PatRetType, f [VName]) SrcLoc |
|
OpSectionRight (QualName vn) (f PatType) (ExpBase f vn) (f (PName, StructType), f (PName, StructType, Maybe VName)) (f PatRetType) SrcLoc |
|
ProjectSection [Name] (f PatType) SrcLoc | Field projection as a section: |
IndexSection (SliceBase f vn) (f PatType) SrcLoc | Array indexing as a section: |
Ascript (ExpBase f vn) (TypeDeclBase f vn) SrcLoc | Type ascription: |
AppExp (AppExpBase f vn) (f AppRes) |
Instances
Eq (ExpBase NoInfo VName) Source # | |
Ord (ExpBase NoInfo VName) Source # | |
Defined in Language.Futhark.Syntax Methods compare :: ExpBase NoInfo VName -> ExpBase NoInfo VName -> Ordering # (<) :: ExpBase NoInfo VName -> ExpBase NoInfo VName -> Bool # (<=) :: ExpBase NoInfo VName -> ExpBase NoInfo VName -> Bool # (>) :: ExpBase NoInfo VName -> ExpBase NoInfo VName -> Bool # (>=) :: ExpBase NoInfo VName -> ExpBase NoInfo VName -> Bool # max :: ExpBase NoInfo VName -> ExpBase NoInfo VName -> ExpBase NoInfo VName # min :: ExpBase NoInfo VName -> ExpBase NoInfo VName -> ExpBase NoInfo VName # | |
Showable f vn => Show (ExpBase f vn) Source # | |
(Eq vn, IsName vn, Annot f) => Pretty (ExpBase f vn) Source # | |
Located (ExpBase f vn) Source # | |
ASTMappable (ExpBase Info VName) Source # | |
An entry in a record literal.
Constructors
RecordFieldExplicit Name (ExpBase f vn) SrcLoc | |
RecordFieldImplicit vn (f PatType) SrcLoc |
Instances
Eq (FieldBase NoInfo VName) Source # | |
Ord (FieldBase NoInfo VName) Source # | |
Defined in Language.Futhark.Syntax Methods compare :: FieldBase NoInfo VName -> FieldBase NoInfo VName -> Ordering # (<) :: FieldBase NoInfo VName -> FieldBase NoInfo VName -> Bool # (<=) :: FieldBase NoInfo VName -> FieldBase NoInfo VName -> Bool # (>) :: FieldBase NoInfo VName -> FieldBase NoInfo VName -> Bool # (>=) :: FieldBase NoInfo VName -> FieldBase NoInfo VName -> Bool # max :: FieldBase NoInfo VName -> FieldBase NoInfo VName -> FieldBase NoInfo VName # min :: FieldBase NoInfo VName -> FieldBase NoInfo VName -> FieldBase NoInfo VName # | |
Showable f vn => Show (FieldBase f vn) Source # | |
(Eq vn, IsName vn, Annot f) => Pretty (FieldBase f vn) Source # | |
Located (FieldBase f vn) Source # | |
ASTMappable (FieldBase Info VName) Source # | |
A case in a match expression.
Instances
Eq (CaseBase NoInfo VName) Source # | |
Ord (CaseBase NoInfo VName) Source # | |
Defined in Language.Futhark.Syntax Methods compare :: CaseBase NoInfo VName -> CaseBase NoInfo VName -> Ordering # (<) :: CaseBase NoInfo VName -> CaseBase NoInfo VName -> Bool # (<=) :: CaseBase NoInfo VName -> CaseBase NoInfo VName -> Bool # (>) :: CaseBase NoInfo VName -> CaseBase NoInfo VName -> Bool # (>=) :: CaseBase NoInfo VName -> CaseBase NoInfo VName -> Bool # max :: CaseBase NoInfo VName -> CaseBase NoInfo VName -> CaseBase NoInfo VName # min :: CaseBase NoInfo VName -> CaseBase NoInfo VName -> CaseBase NoInfo VName # | |
Showable f vn => Show (CaseBase f vn) Source # | |
(Eq vn, IsName vn, Annot f) => Pretty (CaseBase f vn) Source # | |
Located (CaseBase f vn) Source # | |
ASTMappable (CaseBase Info VName) Source # | |
data LoopFormBase f vn Source #
Whether the loop is a for
-loop or a while
-loop.
Constructors
For (IdentBase f vn) (ExpBase f vn) | |
ForIn (PatBase f vn) (ExpBase f vn) | |
While (ExpBase f vn) |
Instances
A literal in a pattern.
Constructors
PatLitInt Integer | |
PatLitFloat Double | |
PatLitPrim PrimValue |
A pattern as used most places where variables are bound (function
parameters, let
expressions, etc).
Constructors
TuplePat [PatBase f vn] SrcLoc | |
RecordPat [(Name, PatBase f vn)] SrcLoc | |
PatParens (PatBase f vn) SrcLoc | |
Id vn (f PatType) SrcLoc | |
Wildcard (f PatType) SrcLoc | |
PatAscription (PatBase f vn) (TypeDeclBase f vn) SrcLoc | |
PatLit PatLit (f PatType) SrcLoc | |
PatConstr Name (f PatType) [PatBase f vn] SrcLoc | |
PatAttr (AttrInfo vn) (PatBase f vn) SrcLoc |
Instances
Substitutable Pat Source # | |
Defined in Language.Futhark.TypeChecker.Types | |
Eq (PatBase NoInfo VName) Source # | |
Ord (PatBase NoInfo VName) Source # | |
Defined in Language.Futhark.Syntax Methods compare :: PatBase NoInfo VName -> PatBase NoInfo VName -> Ordering # (<) :: PatBase NoInfo VName -> PatBase NoInfo VName -> Bool # (<=) :: PatBase NoInfo VName -> PatBase NoInfo VName -> Bool # (>) :: PatBase NoInfo VName -> PatBase NoInfo VName -> Bool # (>=) :: PatBase NoInfo VName -> PatBase NoInfo VName -> Bool # max :: PatBase NoInfo VName -> PatBase NoInfo VName -> PatBase NoInfo VName # min :: PatBase NoInfo VName -> PatBase NoInfo VName -> PatBase NoInfo VName # | |
Showable f vn => Show (PatBase f vn) Source # | |
(Eq vn, IsName vn, Annot f) => Pretty (PatBase f vn) Source # | |
Located (PatBase f vn) Source # | |
ASTMappable (PatBase Info VName) Source # | |
Module language
A spec is a component of a module type.
Constructors
ValSpec | |
Fields
| |
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.
Constructors
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
Showable f vn => Show (SigExpBase f vn) Source # | |
Defined in Language.Futhark.Syntax Methods showsPrec :: Int -> SigExpBase f vn -> ShowS # show :: SigExpBase f vn -> String # showList :: [SigExpBase f vn] -> ShowS # | |
(Eq vn, IsName vn, Annot f) => Pretty (SigExpBase f vn) Source # | |
Defined in Language.Futhark.Pretty Methods ppr :: SigExpBase f vn -> Doc # pprPrec :: Int -> SigExpBase f vn -> Doc # pprList :: [SigExpBase f vn] -> Doc # | |
Located (SigExpBase f vn) Source # | |
Defined in Language.Futhark.Syntax |
data TypeRefBase f vn Source #
A type refinement.
Constructors
TypeRef (QualName vn) [TypeParamBase vn] (TypeDeclBase f vn) SrcLoc |
Instances
Showable f vn => Show (TypeRefBase f vn) Source # | |
Defined in Language.Futhark.Syntax Methods showsPrec :: Int -> TypeRefBase f vn -> ShowS # show :: TypeRefBase f vn -> String # showList :: [TypeRefBase f vn] -> ShowS # | |
Located (TypeRefBase f vn) Source # | |
Defined in Language.Futhark.Syntax |
data SigBindBase f vn Source #
Module type binding.
Constructors
SigBind | |
Fields
|
Instances
Showable f vn => Show (SigBindBase f vn) Source # | |
Defined in Language.Futhark.Syntax Methods showsPrec :: Int -> SigBindBase f vn -> ShowS # show :: SigBindBase f vn -> String # showList :: [SigBindBase f vn] -> ShowS # | |
(Eq vn, IsName vn, Annot f) => Pretty (SigBindBase f vn) Source # | |
Defined in Language.Futhark.Pretty Methods ppr :: SigBindBase f vn -> Doc # pprPrec :: Int -> SigBindBase f vn -> Doc # pprList :: [SigBindBase f vn] -> Doc # | |
Located (SigBindBase f vn) Source # | |
Defined in Language.Futhark.Syntax |
data ModExpBase f vn Source #
Module expression.
Constructors
ModVar (QualName vn) SrcLoc | |
ModParens (ModExpBase f vn) SrcLoc | |
ModImport FilePath (f FilePath) 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
Showable f vn => Show (ModExpBase f vn) Source # | |
Defined in Language.Futhark.Syntax Methods showsPrec :: Int -> ModExpBase f vn -> ShowS # show :: ModExpBase f vn -> String # showList :: [ModExpBase f vn] -> ShowS # | |
(Eq vn, IsName vn, Annot f) => Pretty (ModExpBase f vn) Source # | |
Defined in Language.Futhark.Pretty Methods ppr :: ModExpBase f vn -> Doc # pprPrec :: Int -> ModExpBase f vn -> Doc # pprList :: [ModExpBase f vn] -> Doc # | |
Located (ModExpBase f vn) Source # | |
Defined in Language.Futhark.Syntax |
data ModBindBase f vn Source #
A module binding.
Constructors
ModBind | |
Fields
|
Instances
Showable f vn => Show (ModBindBase f vn) Source # | |
Defined in Language.Futhark.Syntax Methods showsPrec :: Int -> ModBindBase f vn -> ShowS # show :: ModBindBase f vn -> String # showList :: [ModBindBase f vn] -> ShowS # | |
(Eq vn, IsName vn, Annot f) => Pretty (ModBindBase f vn) Source # | |
Defined in Language.Futhark.Pretty Methods ppr :: ModBindBase f vn -> Doc # pprPrec :: Int -> ModBindBase f vn -> Doc # pprList :: [ModBindBase f vn] -> Doc # | |
Located (ModBindBase f vn) Source # | |
Defined in Language.Futhark.Syntax |
data ModParamBase f vn Source #
A module parameter.
Constructors
ModParam | |
Fields
|
Instances
Showable f vn => Show (ModParamBase f vn) Source # | |
Defined in Language.Futhark.Syntax Methods showsPrec :: Int -> ModParamBase f vn -> ShowS # show :: ModParamBase f vn -> String # showList :: [ModParamBase f vn] -> ShowS # | |
(Eq vn, IsName vn, Annot f) => Pretty (ModParamBase f vn) Source # | |
Defined in Language.Futhark.Pretty Methods ppr :: ModParamBase f vn -> Doc # pprPrec :: Int -> ModParamBase f vn -> Doc # pprList :: [ModParamBase f vn] -> Doc # | |
Located (ModParamBase f vn) Source # | |
Defined in Language.Futhark.Syntax |
Definitions
data DocComment Source #
Documentation strings, including source location.
Constructors
DocComment String SrcLoc |
Instances
Show DocComment Source # | |
Defined in Language.Futhark.Syntax Methods showsPrec :: Int -> DocComment -> ShowS # show :: DocComment -> String # showList :: [DocComment] -> ShowS # | |
Located DocComment Source # | |
Defined in Language.Futhark.Syntax |
data ValBindBase f vn Source #
Function Declarations
Constructors
ValBind | |
Fields
|
Instances
Showable f vn => Show (ValBindBase f vn) Source # | |
Defined in Language.Futhark.Syntax Methods showsPrec :: Int -> ValBindBase f vn -> ShowS # show :: ValBindBase f vn -> String # showList :: [ValBindBase f vn] -> ShowS # | |
(Eq vn, IsName vn, Annot f) => Pretty (ValBindBase f vn) Source # | |
Defined in Language.Futhark.Pretty Methods ppr :: ValBindBase f vn -> Doc # pprPrec :: Int -> ValBindBase f vn -> Doc # pprList :: [ValBindBase f vn] -> Doc # | |
Located (ValBindBase f vn) Source # | |
Defined in Language.Futhark.Syntax |
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.
Constructors
EntryPoint | |
Fields
|
Instances
Show EntryPoint Source # | |
Defined in Language.Futhark.Syntax Methods 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.
Constructors
EntryType | |
Fields
|
data EntryParam Source #
A parameter of an entry point.
Constructors
EntryParam | |
Fields |
Instances
Show EntryParam Source # | |
Defined in Language.Futhark.Syntax Methods 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
.
Constructors
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
Eq Liftedness Source # | |
Defined in Language.Futhark.Syntax | |
Ord Liftedness Source # | |
Defined in Language.Futhark.Syntax Methods compare :: Liftedness -> Liftedness -> Ordering # (<) :: Liftedness -> Liftedness -> Bool # (<=) :: Liftedness -> Liftedness -> Bool # (>) :: Liftedness -> Liftedness -> Bool # (>=) :: Liftedness -> Liftedness -> Bool # max :: Liftedness -> Liftedness -> Liftedness # min :: Liftedness -> Liftedness -> Liftedness # | |
Show Liftedness Source # | |
Defined in Language.Futhark.Syntax Methods showsPrec :: Int -> Liftedness -> ShowS # show :: Liftedness -> String # showList :: [Liftedness] -> ShowS # | |
Pretty Liftedness Source # | |
Defined in Language.Futhark.Pretty Methods ppr :: Liftedness -> Doc # pprPrec :: Int -> Liftedness -> Doc # pprList :: [Liftedness] -> Doc # |
data TypeBindBase f vn Source #
Type Declarations
Constructors
TypeBind | |
Fields
|
Instances
Showable f vn => Show (TypeBindBase f vn) Source # | |
Defined in Language.Futhark.Syntax Methods showsPrec :: Int -> TypeBindBase f vn -> ShowS # show :: TypeBindBase f vn -> String # showList :: [TypeBindBase f vn] -> ShowS # | |
(Eq vn, IsName vn, Annot f) => Pretty (TypeBindBase f vn) Source # | |
Defined in Language.Futhark.Pretty Methods ppr :: TypeBindBase f vn -> Doc # pprPrec :: Int -> TypeBindBase f vn -> Doc # pprList :: [TypeBindBase f vn] -> Doc # | |
Located (TypeBindBase f vn) Source # | |
Defined in Language.Futhark.Syntax |
data TypeParamBase vn Source #
A type parameter.
Constructors
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.
Constructors
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 FilePath) SrcLoc |
Miscellaneous
class (Show vn, Show (f VName), Show (f (Diet, Maybe VName)), Show (f String), Show (f [VName]), Show (f ([VName], [VName])), Show (f PatType), Show (f (PatType, [VName])), Show (f (StructType, [VName])), Show (f (StructRetType, [VName])), Show (f EntryPoint), Show (f StructType), Show (f StructRetType), Show (f PatRetType), Show (f (StructType, Maybe VName)), Show (f (PName, StructType)), Show (f (PName, StructType, Maybe VName)), Show (f (Aliasing, StructRetType)), Show (f (Map VName VName)), Show (f AppRes)) => Showable f vn Source #
Convenience class for deriving Show
instances for the AST.
No information functor. Usually used for placeholder type- or aliasing information.
Constructors
NoInfo |
Instances
Some information. The dual to NoInfo
Instances
A variable that is aliased. Can be still in-scope, or have gone out of scope and be free. In the latter case, it behaves more like an equivalence class. See uniqueness-error18.fut for an example of why this is necessary.
Instances
Eq Alias Source # | |
Ord Alias Source # | |
Show Alias Source # | |
ASTMappable PatRetType Source # | |
Defined in Language.Futhark.Traversals Methods astMap :: Monad m => ASTMapper m -> PatRetType -> m PatRetType Source # | |
ASTMappable PatType Source # | |
ASTMappable Aliasing Source # | |
ASTMappable Alias Source # | |
Substitutable (TypeBase (DimDecl VName) Aliasing) Source # | |
Substitutable (RetTypeBase (DimDecl VName) Aliasing) Source # | |
Defined in Language.Futhark.TypeChecker.Types Methods applySubst :: TypeSubs -> RetTypeBase (DimDecl VName) Aliasing -> RetTypeBase (DimDecl VName) Aliasing Source # |
type Aliasing = Set Alias Source #
Aliasing for a type, which is a set of the variables that are aliased.
A name qualified with a breadcrumb of module accesses.