| Safe Haskell | Trustworthy |
|---|---|
| Language | Haskell2010 |
Futhark.IR.Syntax
Description
Definition of the Futhark core language IR
For actually constructing ASTs, see Futhark.Construct.
Types and values
The core language type system is much more restricted than the core
language. This is a theme that repeats often. The only types that
are supported in the core language are various primitive types
PrimType which can be combined in arrays (ignore Mem for
now). Types are represented as TypeBase, which is parameterised
by the shape of the array and whether we keep uniqueness
information. The Type alias, which is the most commonly used,
uses Shape and NoUniqueness.
This means that the records, tuples, and sum types of the source language are represented merely as collections of primitives and arrays. This is implemented in Futhark.Internalise, but the specifics are not important for writing passes on the core language. What is important is that many constructs that conceptually return tuples instead return multiple values. This is not merely syntactic sugar for a tuple: each of those values are eventually bound to distinct variables. The prettyprinter for the IR will typically print such collections of values or types in curly braces.
The system of primitive types is interesting in itself. See Futhark.IR.Primitive.
Overall AST design
Internally, the Futhark compiler core intermediate representation
resembles a traditional compiler for an imperative language more
than it resembles, say, a Haskell or ML compiler. All functions
are monomorphic (except for sizes), first-order, and defined at the
top level. Notably, the IR does not use continuation-passing
style (CPS) at any time. Instead it uses Administrative Normal
Form (ANF), where all subexpressions SubExp are either
constants PrimValue or variables VName. Variables are
represented as a human-readable Name (which doesn't matter to
the compiler) as well as a numeric tag, which is what the
compiler actually looks at. All variable names when prettyprinted
are of the form foo_123. Function names are just Names,
though.
The body of a function (FunDef) is a Body, which consists of
a sequence of statements (Stms) and a Result. Execution of a
Body consists of executing all of the statements, then returning
the values of the variables indicated by the result.
A statement (Stm) consists of a Pattern alongside an
expression ExpT. A pattern contains a "context" part and a
"value" part. The context is used for things like the size of
arrays in the value part whose size is existential.
For example, the source language expression let z = x + y - 1 in
z would in the core language be represented (in prettyprinted
form) as something like:
let {a_12} = x_10 + y_11
let {b_13} = a_12 - 1
in {b_13}
Lores
Most AST types (Stm, ExpT, Prog, etc) are parameterised by a
type parameter with the somewhat silly name lore. The lore
specifies how to fill out various polymorphic parts of the AST.
For example, ExpT has a constructor Op whose payload depends
on lore, via the use of a type family called Op (a kind of
type-level function) which is applied to the lore. The SOACS
representation (Futhark.IR.SOACS) thus uses a lore
called SOACS, and defines that Op SOACS is a SOAC, while the
Kernels representation (Futhark.IR.Kernels) defines
Op Kernels as some kind of kernel construct. Similarly, various
other decorations (e.g. what information we store in a PatElemT)
are also type families.
The full list of possible decorations is defined as part of the
type class Decorations (although other type families are also
used elsewhere in the compiler on an ad hoc basis).
Essentially, the lore type parameter functions as a kind of
proxy, saving us from having to parameterise the AST type with all
the different forms of decorations that we desire (it would easily
become a type with a dozen type parameters).
Defining a new representation (or lore) thus requires you to define an empty datatype and implement a handful of type class instances for it. See the source of Futhark.IR.Seq for what is likely the simplest example.
Synopsis
- module Language.Futhark.Core
- module Futhark.IR.Decorations
- module Futhark.IR.Syntax.Core
- data Uniqueness
- data NoUniqueness = NoUniqueness
- newtype Rank = Rank Int
- class (Monoid a, Eq a, Ord a) => ArrayShape a where
- data Space
- data TypeBase shape u
- data Diet
- data Attr
- newtype Attrs = Attrs {}
- oneAttr :: Attr -> Attrs
- inAttrs :: Attr -> Attrs -> Bool
- withoutAttrs :: Attrs -> Attrs -> Attrs
- data Ident = Ident {}
- data SubExp
- type PatElem lore = PatElemT (LetDec lore)
- data PatElemT dec = PatElem {
- patElemName :: VName
- patElemDec :: dec
- data PatternT dec = Pattern {
- patternContextElements :: [PatElemT dec]
- patternValueElements :: [PatElemT dec]
- type Pattern lore = PatternT (LetDec lore)
- data StmAux dec = StmAux {
- stmAuxCerts :: !Certificates
- stmAuxAttrs :: Attrs
- stmAuxDec :: dec
- data Stm lore = Let {}
- type Stms lore = Seq (Stm lore)
- type Result = [SubExp]
- data BodyT lore = Body {}
- type Body = BodyT
- data BasicOp
- = SubExp SubExp
- | Opaque SubExp
- | ArrayLit [SubExp] Type
- | UnOp UnOp SubExp
- | BinOp BinOp SubExp SubExp
- | CmpOp CmpOp SubExp SubExp
- | ConvOp ConvOp SubExp
- | Assert SubExp (ErrorMsg SubExp) (SrcLoc, [SrcLoc])
- | Index VName (Slice SubExp)
- | Update VName (Slice SubExp) SubExp
- | Concat Int VName [VName] SubExp
- | Copy VName
- | Manifest [Int] VName
- | Iota SubExp SubExp SubExp IntType
- | Replicate Shape SubExp
- | Scratch PrimType [SubExp]
- | Reshape (ShapeChange SubExp) VName
- | Rearrange [Int] VName
- | Rotate [SubExp] VName
- | UpdateAcc VName [SubExp] [SubExp]
- data UnOp
- data BinOp
- = Add IntType Overflow
- | FAdd FloatType
- | Sub IntType Overflow
- | FSub FloatType
- | Mul IntType Overflow
- | FMul FloatType
- | UDiv IntType Safety
- | UDivUp IntType Safety
- | SDiv IntType Safety
- | SDivUp IntType Safety
- | FDiv FloatType
- | FMod FloatType
- | UMod IntType Safety
- | SMod IntType Safety
- | SQuot IntType Safety
- | SRem IntType Safety
- | SMin IntType
- | UMin IntType
- | FMin FloatType
- | SMax IntType
- | UMax IntType
- | FMax FloatType
- | Shl IntType
- | LShr IntType
- | AShr IntType
- | And IntType
- | Or IntType
- | Xor IntType
- | Pow IntType
- | FPow FloatType
- | LogAnd
- | LogOr
- data CmpOp
- data ConvOp
- data DimChange d
- = DimCoercion d
- | DimNew d
- type ShapeChange d = [DimChange d]
- data ExpT lore
- = BasicOp BasicOp
- | Apply Name [(SubExp, Diet)] [RetType lore] (Safety, SrcLoc, [SrcLoc])
- | If SubExp (BodyT lore) (BodyT lore) (IfDec (BranchType lore))
- | DoLoop [(FParam lore, SubExp)] [(FParam lore, SubExp)] (LoopForm lore) (BodyT lore)
- | WithAcc [(Shape, [VName], Maybe (Lambda lore, [SubExp]))] (Lambda lore)
- | Op (Op lore)
- type Exp = ExpT
- data LoopForm lore
- data IfDec rt = IfDec {}
- data IfSort
- data Safety
- data LambdaT lore = Lambda {
- lambdaParams :: [LParam lore]
- lambdaBody :: BodyT lore
- lambdaReturnType :: [Type]
- type Lambda = LambdaT
- data Param dec = Param {}
- type FParam lore = Param (FParamInfo lore)
- type LParam lore = Param (LParamInfo lore)
- data FunDef lore = FunDef {
- funDefEntryPoint :: Maybe EntryPoint
- funDefAttrs :: Attrs
- funDefName :: Name
- funDefRetType :: [RetType lore]
- funDefParams :: [FParam lore]
- funDefBody :: BodyT lore
- type EntryPoint = ([EntryPointType], [EntryPointType])
- data EntryPointType
- data Prog lore = Prog {
- progConsts :: Stms lore
- progFuns :: [FunDef lore]
- oneStm :: Stm lore -> Stms lore
- stmsFromList :: [Stm lore] -> Stms lore
- stmsToList :: Stms lore -> [Stm lore]
- stmsHead :: Stms lore -> Maybe (Stm lore, Stms lore)
Documentation
module Language.Futhark.Core
module Futhark.IR.Decorations
module Futhark.IR.Syntax.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
data NoUniqueness Source #
A fancier name for () - encodes no uniqueness information.
Constructors
| NoUniqueness |
Instances
The size of an array type as merely the number of dimensions, with no further information.
class (Monoid a, Eq a, Ord a) => ArrayShape a where Source #
A class encompassing types containing array shape information.
Methods
shapeRank :: a -> Int Source #
Return the rank of an array with the given size.
stripDims :: Int -> a -> a Source #
stripDims n shape strips the outer n dimensions from
shape.
subShapeOf :: a -> a -> Bool Source #
Check whether one shape if a subset of another shape.
Instances
The memory space of a block. If DefaultSpace, this is the "default"
space, whatever that is. The exact meaning of the SpaceId
depends on the backend used. In GPU kernels, for example, this is
used to distinguish between constant, global and shared memory
spaces. In GPU-enabled host code, it is used to distinguish
between host memory (DefaultSpace) and GPU space.
Constructors
| DefaultSpace | |
| Space SpaceId | |
| ScalarSpace [SubExp] PrimType | A special kind of memory that is a statically sized array of some primitive type. Used for private memory on GPUs. |
data TypeBase shape u Source #
The type of a value. When comparing types for equality with
==, shapes must match.
Constructors
| Prim PrimType | |
| Acc VName Shape [Type] u | Token, index space, element type, and uniqueness. |
| Array PrimType shape u | |
| Mem Space |
Instances
Information about which parts of a value/type are consumed. For
example, we might say that a function taking three arguments of
types ([int], *[int], [int]) has diet [Observe, Consume,
Observe].
Constructors
| Consume | Consumes this value. |
| Observe | Only observes value in this position, does not consume. A result may alias this. |
| ObservePrim | As |
Attributes
A single attribute.
Every statement is associated with a set of attributes, which can have various effects throughout the compiler.
withoutAttrs :: Attrs -> Attrs -> Attrs Source #
x gives withoutAttrs yx except for any attributes also in y.
Abstract syntax tree
An identifier consists of its name and the type of the value bound to the identifier.
A subexpression is either a scalar constant or a variable. One important property is that evaluation of a subexpression is guaranteed to complete in constant time.
Instances
An element of a pattern - consisting of a name and an addditional parametric decoration. This decoration is what is expected to contain the type of the resulting variable.
Constructors
| PatElem | |
Fields
| |
Instances
A pattern is conceptually just a list of names and their types.
Constructors
| Pattern | |
Fields
| |
Instances
Auxilliary Information associated with a statement.
Constructors
| StmAux | |
Fields
| |
Instances
| Eq dec => Eq (StmAux dec) Source # | |
| Ord dec => Ord (StmAux dec) Source # | |
| Show dec => Show (StmAux dec) Source # | |
| Semigroup dec => Semigroup (StmAux dec) Source # | |
| FreeIn dec => FreeIn (StmAux dec) Source # | |
| Substitute dec => Substitute (StmAux dec) Source # | |
Defined in Futhark.Transform.Substitute | |
| Rename dec => Rename (StmAux dec) Source # | |
A local variable binding.
Constructors
| Let | |
Instances
| Scoped lore (Stm lore) Source # | |
| Scoped lore (Stms lore) Source # | |
| Decorations lore => Eq (Stm lore) Source # | |
| Decorations lore => Ord (Stm lore) Source # | |
Defined in Futhark.IR.Syntax | |
| Decorations lore => Show (Stm lore) Source # | |
| PrettyLore lore => Pretty (Stms lore) Source # | |
| PrettyLore lore => Pretty (Stm lore) Source # | |
| FreeIn (Stm lore) => FreeIn (Stms lore) Source # | |
| (FreeDec (ExpDec lore), FreeDec (BodyDec lore), FreeIn (FParamInfo lore), FreeIn (LParamInfo lore), FreeIn (LetDec lore), FreeIn (RetType lore), FreeIn (BranchType lore), FreeIn (Op lore)) => FreeIn (Stm lore) Source # | |
| Substitute (Stm lore) => Substitute (Stms lore) Source # | |
Defined in Futhark.Transform.Substitute | |
| Substitutable lore => Substitute (Stm lore) Source # | |
Defined in Futhark.Transform.Substitute | |
| Renameable lore => Rename (Stm lore) Source # | |
A body consists of a number of bindings, terminating in a result (essentially a tuple literal).
Instances
| Decorations lore => Eq (BodyT lore) Source # | |
| Decorations lore => Ord (BodyT lore) Source # | |
| Decorations lore => Show (BodyT lore) Source # | |
| PrettyLore lore => Pretty (Body lore) Source # | |
| (FreeDec (ExpDec lore), FreeDec (BodyDec lore), FreeIn (FParamInfo lore), FreeIn (LParamInfo lore), FreeIn (LetDec lore), FreeIn (RetType lore), FreeIn (BranchType lore), FreeIn (Op lore)) => FreeIn (Body lore) Source # | |
| Substitutable lore => Substitute (Body lore) Source # | |
Defined in Futhark.Transform.Substitute | |
| Renameable lore => Rename (Body lore) Source # | |
A primitive operation that returns something of known size and does not itself contain any bindings.
Constructors
| SubExp SubExp | A variable or constant. |
| Opaque SubExp | Semantically and operationally just identity, but is invisible/impenetrable to optimisations (hopefully). This is just a hack to avoid optimisation (so, to work around compiler limitations). |
| ArrayLit [SubExp] Type | Array literals, e.g., |
| UnOp UnOp SubExp | Unary operation. |
| BinOp BinOp SubExp SubExp | Binary operation. |
| CmpOp CmpOp SubExp SubExp | Comparison - result type is always boolean. |
| ConvOp ConvOp SubExp | Conversion "casting". |
| Assert SubExp (ErrorMsg SubExp) (SrcLoc, [SrcLoc]) | Turn a boolean into a certificate, halting the program with the given error message if the boolean is false. |
| Index VName (Slice SubExp) | The certificates for bounds-checking are part of the |
| Update VName (Slice SubExp) SubExp | An in-place update of the given array at the given position. Consumes the array. |
| Concat Int VName [VName] SubExp |
|
| Copy VName | Copy the given array. The result will not alias anything. |
| Manifest [Int] VName | Manifest an array with dimensions represented in the given order. The result will not alias anything. |
| Iota SubExp SubExp SubExp IntType |
The |
| Replicate Shape SubExp | replicate([3][2],1) = [[1,1], [1,1], [1,1]] |
| Scratch PrimType [SubExp] | Create array of given type and shape, with undefined elements. |
| Reshape (ShapeChange SubExp) VName | 1st arg is the new shape, 2nd arg is the input array *) |
| Rearrange [Int] VName | Permute the dimensions of the input array. The list
of integers is a list of dimensions (0-indexed), which
must be a permutation of |
| Rotate [SubExp] VName | Rotate the dimensions of the input array. The list of subexpressions specify how much each dimension is rotated. The length of this list must be equal to the rank of the array. |
| UpdateAcc VName [SubExp] [SubExp] | Update an accumulator at the given index with the given value. Consumes the accumulator and produces a new one. |
Various unary operators. It is a bit ad-hoc what is a unary operator and what is a built-in function. Perhaps these should all go away eventually.
Constructors
| Not | E.g., |
| Complement IntType | E.g., |
| Abs IntType |
|
| FAbs FloatType |
|
| SSignum IntType | Signed sign function: |
| USignum IntType | Unsigned sign function: |
| FSignum FloatType | Floating-point sign function. |
Binary operators. These correspond closely to the binary operators in LLVM. Most are parametrised by their expected input and output types.
Constructors
| Add IntType Overflow | Integer addition. |
| FAdd FloatType | Floating-point addition. |
| Sub IntType Overflow | Integer subtraction. |
| FSub FloatType | Floating-point subtraction. |
| Mul IntType Overflow | Integer multiplication. |
| FMul FloatType | Floating-point multiplication. |
| UDiv IntType Safety | Unsigned integer division. Rounds towards negativity infinity. Note: this is different from LLVM. |
| UDivUp IntType Safety | Unsigned integer division. Rounds towards positive infinity. |
| SDiv IntType Safety | Signed integer division. Rounds towards negativity infinity. Note: this is different from LLVM. |
| SDivUp IntType Safety | Signed integer division. Rounds towards positive infinity. |
| FDiv FloatType | Floating-point division. |
| FMod FloatType | Floating-point modulus. |
| UMod IntType Safety | Unsigned integer modulus; the countepart to |
| SMod IntType Safety | Signed integer modulus; the countepart to |
| SQuot IntType Safety | Signed integer division. Rounds towards zero. This
corresponds to the |
| SRem IntType Safety | Signed integer division. Rounds towards zero. This
corresponds to the |
| SMin IntType | Returns the smallest of two signed integers. |
| UMin IntType | Returns the smallest of two unsigned integers. |
| FMin FloatType | Returns the smallest of two floating-point numbers. |
| SMax IntType | Returns the greatest of two signed integers. |
| UMax IntType | Returns the greatest of two unsigned integers. |
| FMax FloatType | Returns the greatest of two floating-point numbers. |
| Shl IntType | Left-shift. |
| LShr IntType | Logical right-shift, zero-extended. |
| AShr IntType | Arithmetic right-shift, sign-extended. |
| And IntType | Bitwise and. |
| Or IntType | Bitwise or. |
| Xor IntType | Bitwise exclusive-or. |
| Pow IntType | Integer exponentiation. |
| FPow FloatType | Floating-point exponentiation. |
| LogAnd | Boolean and - not short-circuiting. |
| LogOr | Boolean or - not short-circuiting. |
Comparison operators are like BinOps, but they always return a
boolean value. The somewhat ugly constructor names are straight
out of LLVM.
Constructors
| CmpEq PrimType | All types equality. |
| CmpUlt IntType | Unsigned less than. |
| CmpUle IntType | Unsigned less than or equal. |
| CmpSlt IntType | Signed less than. |
| CmpSle IntType | Signed less than or equal. |
| FCmpLt FloatType | Floating-point less than. |
| FCmpLe FloatType | Floating-point less than or equal. |
| CmpLlt | Boolean less than. |
| CmpLle | Boolean less than or equal. |
Conversion operators try to generalise the from t0 x to t1
instructions from LLVM.
Constructors
| ZExt IntType IntType | Zero-extend the former integer type to the latter. If the new type is smaller, the result is a truncation. |
| SExt IntType IntType | Sign-extend the former integer type to the latter. If the new type is smaller, the result is a truncation. |
| FPConv FloatType FloatType | Convert value of the former floating-point type to the latter. If the new type is smaller, the result is a truncation. |
| FPToUI FloatType IntType | Convert a floating-point value to the nearest unsigned integer (rounding towards zero). |
| FPToSI FloatType IntType | Convert a floating-point value to the nearest signed integer (rounding towards zero). |
| UIToFP IntType FloatType | Convert an unsigned integer to a floating-point value. |
| SIToFP IntType FloatType | Convert a signed integer to a floating-point value. |
| IToB IntType | Convert an integer to a boolean value. Zero becomes false; anything else is true. |
| BToI IntType | Convert a boolean to an integer. True is converted to 1 and False to 0. |
The new dimension in a Reshape-like operation. This allows us to
disambiguate "real" reshapes, that change the actual shape of the
array, from type coercions that are just present to make the types
work out. The two constructors are considered equal for purposes of Eq.
Constructors
| DimCoercion d | The new dimension is guaranteed to be numerically equal to the old one. |
| DimNew d | The new dimension is not necessarily numerically equal to the old one. |
Instances
type ShapeChange d = [DimChange d] Source #
A list of DimChanges, indicating the new dimensions of an array.
The root Futhark expression type. The Op constructor contains
a lore-specific operation. Do-loops, branches and function calls
are special. Everything else is a simple BasicOp.
Constructors
| BasicOp BasicOp | A simple (non-recursive) operation. |
| Apply Name [(SubExp, Diet)] [RetType lore] (Safety, SrcLoc, [SrcLoc]) | |
| If SubExp (BodyT lore) (BodyT lore) (IfDec (BranchType lore)) | |
| DoLoop [(FParam lore, SubExp)] [(FParam lore, SubExp)] (LoopForm lore) (BodyT lore) |
|
| WithAcc [(Shape, [VName], Maybe (Lambda lore, [SubExp]))] (Lambda lore) | Create accumulators backed by the given arrays (which are
consumed) and pass them to the lambda, which must return the
updated accumulators and possibly some extra values. The
accumulators are turned back into arrays. The |
| Op (Op lore) |
Instances
| Decorations lore => Eq (ExpT lore) Source # | |
| Decorations lore => Ord (ExpT lore) Source # | |
| Decorations lore => Show (ExpT lore) Source # | |
| PrettyLore lore => Pretty (Exp lore) Source # | |
| (FreeDec (ExpDec lore), FreeDec (BodyDec lore), FreeIn (FParamInfo lore), FreeIn (LParamInfo lore), FreeIn (LetDec lore), FreeIn (RetType lore), FreeIn (BranchType lore), FreeIn (Op lore)) => FreeIn (Exp lore) Source # | |
| Substitutable lore => Substitute (Exp lore) Source # | |
Defined in Futhark.Transform.Substitute | |
| Renameable lore => Rename (Exp lore) Source # | |
For-loop or while-loop?
Instances
| Scoped lore (LoopForm lore) Source # | |
| Decorations lore => Eq (LoopForm lore) Source # | |
| Decorations lore => Ord (LoopForm lore) Source # | |
Defined in Futhark.IR.Syntax Methods compare :: LoopForm lore -> LoopForm lore -> Ordering # (<) :: LoopForm lore -> LoopForm lore -> Bool # (<=) :: LoopForm lore -> LoopForm lore -> Bool # (>) :: LoopForm lore -> LoopForm lore -> Bool # (>=) :: LoopForm lore -> LoopForm lore -> Bool # | |
| Decorations lore => Show (LoopForm lore) Source # | |
| FreeIn (LParamInfo lore) => FreeIn (LoopForm lore) Source # | |
Data associated with a branch.
What kind of branch is this? This has no semantic meaning, but provides hints to simplifications.
Constructors
| IfNormal | An ordinary branch. |
| IfFallback | A branch where the "true" case is what we are actually interested in, and the "false" case is only present as a fallback for when the true case cannot be safely evaluated. The compiler is permitted to optimise away the branch if the true case contains only safe statements. |
| IfEquiv | Both of these branches are semantically equivalent, and it is fine to eliminate one if it turns out to have problems (e.g. contain things we cannot generate code for). |
Whether something is safe or unsafe (mostly function calls, and
in the context of whether operations are dynamically checked).
When we inline an Unsafe function, we remove all safety checks in
its body. The Ord instance picks Unsafe as being less than
Safe.
For operations like integer division, a safe division will not explode the computer in case of division by zero, but instead return some unspecified value. This always involves a run-time check, so generally the unsafe variant is what the compiler will insert, but guarded by an explicit assertion elsewhere. Safe operations are useful when the optimiser wants to move e.g. a division to a location where the divisor may be zero, but where the result will only be used when it is non-zero (so it doesn't matter what result is provided with a zero divisor, as long as the program keeps running).
Anonymous function for use in a SOAC.
Constructors
| Lambda | |
Fields
| |
Instances
| Scoped lore (Lambda lore) Source # | |
| Decorations lore => Eq (LambdaT lore) Source # | |
| Decorations lore => Ord (LambdaT lore) Source # | |
Defined in Futhark.IR.Syntax | |
| Decorations lore => Show (LambdaT lore) Source # | |
| PrettyLore lore => Pretty (Lambda lore) Source # | |
| (FreeDec (ExpDec lore), FreeDec (BodyDec lore), FreeIn (FParamInfo lore), FreeIn (LParamInfo lore), FreeIn (LetDec lore), FreeIn (RetType lore), FreeIn (BranchType lore), FreeIn (Op lore)) => FreeIn (Lambda lore) Source # | |
| Substitutable lore => Substitute (Lambda lore) Source # | |
Defined in Futhark.Transform.Substitute | |
| Renameable lore => Rename (Lambda lore) Source # | |
Definitions
A function or lambda parameter.
Constructors
| Param | |
Instances
| Functor Param Source # | |
| Foldable Param Source # | |
Defined in Futhark.IR.Syntax.Core Methods fold :: Monoid m => Param m -> m # foldMap :: Monoid m => (a -> m) -> Param a -> m # foldMap' :: Monoid m => (a -> m) -> Param a -> m # foldr :: (a -> b -> b) -> b -> Param a -> b # foldr' :: (a -> b -> b) -> b -> Param a -> b # foldl :: (b -> a -> b) -> b -> Param a -> b # foldl' :: (b -> a -> b) -> b -> Param a -> b # foldr1 :: (a -> a -> a) -> Param a -> a # foldl1 :: (a -> a -> a) -> Param a -> a # elem :: Eq a => a -> Param a -> Bool # maximum :: Ord a => Param a -> a # minimum :: Ord a => Param a -> a # | |
| Traversable Param Source # | |
| Eq dec => Eq (Param dec) Source # | |
| Ord dec => Ord (Param dec) Source # | |
| Show dec => Show (Param dec) Source # | |
| Pretty t => Pretty (Param t) Source # | |
| DeclTyped dec => DeclTyped (Param dec) Source # | |
Defined in Futhark.IR.Prop.Types Methods declTypeOf :: Param dec -> DeclType Source # | |
| Typed dec => Typed (Param dec) Source # | |
| FreeIn dec => FreeIn (Param dec) Source # | |
| Substitute dec => Substitute (Param dec) Source # | |
Defined in Futhark.Transform.Substitute | |
| Rename dec => Rename (Param dec) Source # | |
type FParam lore = Param (FParamInfo lore) Source #
A function and loop parameter.
type LParam lore = Param (LParamInfo lore) Source #
A lambda parameter.
Function Declarations
Constructors
| FunDef | |
Fields
| |
Instances
| Scoped lore (FunDef lore) Source # | |
| Decorations lore => Eq (FunDef lore) Source # | |
| Decorations lore => Ord (FunDef lore) Source # | |
Defined in Futhark.IR.Syntax | |
| Decorations lore => Show (FunDef lore) Source # | |
| PrettyLore lore => Pretty (FunDef lore) Source # | |
| (FreeDec (ExpDec lore), FreeDec (BodyDec lore), FreeIn (FParamInfo lore), FreeIn (LParamInfo lore), FreeIn (LetDec lore), FreeIn (RetType lore), FreeIn (BranchType lore), FreeIn (Op lore)) => FreeIn (FunDef lore) Source # | |
| Renameable lore => Rename (FunDef lore) Source # | |
type EntryPoint = ([EntryPointType], [EntryPointType]) Source #
Information about the parameters and return value of an entry point. The first element is for parameters, the second for return value.
data EntryPointType Source #
Every entry point argument and return value has an annotation indicating how it maps to the original source program type.
Constructors
| TypeUnsigned | Is an unsigned integer or array of unsigned integers. |
| TypeOpaque String Int | A black box type comprising this many core values. The string is a human-readable description with no other semantics. |
| TypeDirect | Maps directly. |
Instances
| Eq EntryPointType Source # | |
Defined in Futhark.IR.Syntax Methods (==) :: EntryPointType -> EntryPointType -> Bool # (/=) :: EntryPointType -> EntryPointType -> Bool # | |
| Ord EntryPointType Source # | |
Defined in Futhark.IR.Syntax Methods compare :: EntryPointType -> EntryPointType -> Ordering # (<) :: EntryPointType -> EntryPointType -> Bool # (<=) :: EntryPointType -> EntryPointType -> Bool # (>) :: EntryPointType -> EntryPointType -> Bool # (>=) :: EntryPointType -> EntryPointType -> Bool # max :: EntryPointType -> EntryPointType -> EntryPointType # min :: EntryPointType -> EntryPointType -> EntryPointType # | |
| Show EntryPointType Source # | |
Defined in Futhark.IR.Syntax Methods showsPrec :: Int -> EntryPointType -> ShowS # show :: EntryPointType -> String # showList :: [EntryPointType] -> ShowS # | |
| Pretty EntryPointType Source # | |
Defined in Futhark.IR.Pretty Methods ppr :: EntryPointType -> Doc # pprPrec :: Int -> EntryPointType -> Doc # pprList :: [EntryPointType] -> Doc # | |
An entire Futhark program.
Constructors
| Prog | |
Fields
| |
Instances
| Decorations lore => Eq (Prog lore) Source # | |
| Decorations lore => Ord (Prog lore) Source # | |
| Decorations lore => Show (Prog lore) Source # | |
| PrettyLore lore => Pretty (Prog lore) Source # | |
Utils
stmsFromList :: [Stm lore] -> Stms lore Source #
Convert a statement list to a statement sequence.
stmsToList :: Stms lore -> [Stm lore] Source #
Convert a statement sequence to a statement list.