| Safe Haskell | Safe |
|---|---|
| Language | Haskell2010 |
Futhark.IR.SOACS
Description
A simple representation with SOACs and nested parallelism.
Synopsis
- data SOACS
- type Body = Body SOACS
- type Stm = Stm SOACS
- type Pattern = Pattern SOACS
- type Exp = Exp SOACS
- type Lambda = Lambda SOACS
- type FParam = FParam SOACS
- type LParam = LParam SOACS
- type RetType = RetType SOACS
- type PatElem = PatElem SOACS
- module Futhark.IR.Prop
- module Futhark.IR.Traversals
- module Futhark.IR.Pretty
- data Int8
- data Int16
- data Int32
- data Int64
- data Word8
- data Word16
- data Word32
- data Word64
- srclocOf :: Located a => a -> SrcLoc
- data Loc
- data SrcLoc
- class Located a where
- pretty :: Pretty a => a -> String
- data ConvOp
- data CmpOp
- 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 Safety
- data Overflow
- data UnOp
- data PrimValue
- = IntValue !IntValue
- | FloatValue !FloatValue
- | BoolValue !Bool
- | Checked
- data FloatValue
- data IntValue
- = Int8Value !Int8
- | Int16Value !Int16
- | Int32Value !Int32
- | Int64Value !Int64
- data PrimType
- data FloatType
- data IntType
- allIntTypes :: [IntType]
- allFloatTypes :: [FloatType]
- allPrimTypes :: [PrimType]
- intValue :: Integral int => IntType -> int -> IntValue
- intValueType :: IntValue -> IntType
- valueIntegral :: Integral int => IntValue -> int
- floatValue :: Real num => FloatType -> num -> FloatValue
- floatValueType :: FloatValue -> FloatType
- primValueType :: PrimValue -> PrimType
- blankPrimValue :: PrimType -> PrimValue
- allUnOps :: [UnOp]
- allBinOps :: [BinOp]
- allCmpOps :: [CmpOp]
- allConvOps :: [ConvOp]
- doUnOp :: UnOp -> PrimValue -> Maybe PrimValue
- doComplement :: IntValue -> IntValue
- doAbs :: IntValue -> IntValue
- doFAbs :: FloatValue -> FloatValue
- doSSignum :: IntValue -> IntValue
- doUSignum :: IntValue -> IntValue
- doBinOp :: BinOp -> PrimValue -> PrimValue -> Maybe PrimValue
- doAdd :: IntValue -> IntValue -> IntValue
- doMul :: IntValue -> IntValue -> IntValue
- doSDiv :: IntValue -> IntValue -> Maybe IntValue
- doSMod :: IntValue -> IntValue -> Maybe IntValue
- doPow :: IntValue -> IntValue -> Maybe IntValue
- doConvOp :: ConvOp -> PrimValue -> Maybe PrimValue
- doZExt :: IntValue -> IntType -> IntValue
- doSExt :: IntValue -> IntType -> IntValue
- doFPConv :: FloatValue -> FloatType -> FloatValue
- doFPToUI :: FloatValue -> IntType -> IntValue
- doFPToSI :: FloatValue -> IntType -> IntValue
- doUIToFP :: IntValue -> FloatType -> FloatValue
- doSIToFP :: IntValue -> FloatType -> FloatValue
- doCmpOp :: CmpOp -> PrimValue -> PrimValue -> Maybe Bool
- doCmpEq :: PrimValue -> PrimValue -> Bool
- doCmpUlt :: IntValue -> IntValue -> Bool
- doCmpUle :: IntValue -> IntValue -> Bool
- doCmpSlt :: IntValue -> IntValue -> Bool
- doCmpSle :: IntValue -> IntValue -> Bool
- doFCmpLt :: FloatValue -> FloatValue -> Bool
- doFCmpLe :: FloatValue -> FloatValue -> Bool
- intToWord64 :: IntValue -> Word64
- intToInt64 :: IntValue -> Int64
- binOpType :: BinOp -> PrimType
- cmpOpType :: CmpOp -> PrimType
- unOpType :: UnOp -> PrimType
- convOpType :: ConvOp -> (PrimType, PrimType)
- primFuns :: Map String ([PrimType], PrimType, [PrimValue] -> Maybe PrimValue)
- zeroIsh :: PrimValue -> Bool
- oneIsh :: PrimValue -> Bool
- negativeIsh :: PrimValue -> Bool
- zeroIshInt :: IntValue -> Bool
- oneIshInt :: IntValue -> Bool
- primBitSize :: PrimType -> Int
- primByteSize :: Num a => PrimType -> a
- intByteSize :: Num a => IntType -> a
- floatByteSize :: Num a => FloatType -> a
- commutativeBinOp :: BinOp -> Bool
- convOpFun :: ConvOp -> String
- prettySigned :: Bool -> PrimType -> String
- data VName = VName !Name !Int
- data Name
- data Commutativity
- data Uniqueness
- defaultEntryPoint :: Name
- nameToString :: Name -> String
- nameFromString :: String -> Name
- nameToText :: Name -> Text
- nameFromText :: Text -> Name
- locStr :: Located a => a -> String
- locStrRel :: (Located a, Located b) => a -> b -> String
- prettyStacktrace :: Int -> [String] -> String
- baseTag :: VName -> Int
- baseName :: VName -> Name
- baseString :: VName -> String
- quote :: String -> String
- pquote :: Doc -> Doc
- data ErrorMsgPart a
- = ErrorString String
- | ErrorInt32 a
- | ErrorInt64 a
- newtype ErrorMsg a = ErrorMsg [ErrorMsgPart a]
- data PatElemT dec
- type Slice d = [DimIndex d]
- data DimIndex d
- data Param dec = Param {}
- data SubExp
- newtype Certificates = Certificates {
- unCertificates :: [VName]
- data Ident = Ident {}
- data Diet
- type DeclExtType = TypeBase ExtShape Uniqueness
- type DeclType = TypeBase Shape Uniqueness
- type ExtType = TypeBase ExtShape NoUniqueness
- type Type = TypeBase Shape NoUniqueness
- data TypeBase shape u
- data NoUniqueness = NoUniqueness
- type SpaceId = String
- data Space
- class (Monoid a, Eq a, Ord a) => ArrayShape a where
- newtype Rank = Rank Int
- type ExtShape = ShapeBase ExtSize
- type ExtSize = Ext SubExp
- data Ext a
- type Shape = ShapeBase SubExp
- newtype ShapeBase d = Shape {
- shapeDims :: [d]
- dimFix :: DimIndex d -> Maybe d
- sliceIndices :: Slice d -> Maybe [d]
- sliceDims :: Slice d -> [d]
- unitSlice :: Num d => d -> d -> DimIndex d
- fixSlice :: Num d => Slice d -> [d] -> [d]
- sliceSlice :: Num d => Slice d -> Slice d -> Slice d
- errorMsgArgTypes :: ErrorMsg a -> [PrimType]
- class (Show rt, Eq rt, Ord rt, DeclExtTyped rt) => IsRetType rt where
- primRetType :: PrimType -> rt
- applyRetType :: Typed dec => [rt] -> [Param dec] -> [(SubExp, Type)] -> Maybe [rt]
- class (Show rt, Eq rt, Ord rt, ExtTyped rt) => IsBodyType rt where
- primBodyType :: PrimType -> rt
- expectedTypes :: Typed t => [VName] -> [t] -> [SubExp] -> [Type]
- class (Show (LetDec l), Show (ExpDec l), Show (BodyDec l), Show (FParamInfo l), Show (LParamInfo l), Show (RetType l), Show (BranchType l), Show (Op l), Eq (LetDec l), Eq (ExpDec l), Eq (BodyDec l), Eq (FParamInfo l), Eq (LParamInfo l), Eq (RetType l), Eq (BranchType l), Eq (Op l), Ord (LetDec l), Ord (ExpDec l), Ord (BodyDec l), Ord (FParamInfo l), Ord (LParamInfo l), Ord (RetType l), Ord (BranchType l), Ord (Op l), IsRetType (RetType l), IsBodyType (BranchType l), Typed (FParamInfo l), Typed (LParamInfo l), Typed (LetDec l), DeclTyped (FParamInfo l), SexpIso (LetDec l), SexpIso (ExpDec l), SexpIso (BodyDec l), SexpIso (FParamInfo l), SexpIso (LParamInfo l), SexpIso (RetType l), SexpIso (BranchType l), SexpIso (Op l)) => Decorations l where
- type LetDec l :: Type
- type ExpDec l :: Type
- type BodyDec l :: Type
- type FParamInfo l :: Type
- type LParamInfo l :: Type
- type BranchType l :: Type
- type Op l :: Type
- data Prog lore = Prog {
- progConsts :: Stms lore
- progFuns :: [FunDef lore]
- data EntryPointType
- type EntryPoint = ([EntryPointType], [EntryPointType])
- data FunDef lore = FunDef {
- funDefEntryPoint :: Maybe EntryPoint
- funDefAttrs :: Attrs
- funDefName :: Name
- funDefRetType :: [RetType lore]
- funDefParams :: [FParam lore]
- funDefBody :: BodyT lore
- data LambdaT lore
- data IfSort
- data IfDec rt = IfDec {}
- data LoopForm lore
- data ExpT lore
- 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
- type ShapeChange d = [DimChange d]
- data DimChange d
- = DimCoercion d
- | DimNew d
- data BodyT lore
- type Result = [SubExp]
- type Stms lore = Seq (Stm lore)
- pattern Let :: Pattern lore -> StmAux (ExpDec lore) -> Exp lore -> Stm lore
- stmExp :: Stm lore -> Exp lore
- stmPattern :: Stm lore -> Pattern lore
- stmAux :: Stm lore -> StmAux (ExpDec lore)
- data StmAux dec = StmAux {
- stmAuxCerts :: !Certificates
- stmAuxAttrs :: Attrs
- stmAuxDec :: dec
- data PatternT dec
- newtype Attrs = Attrs {}
- data Attr
- oneAttr :: Attr -> Attrs
- inAttrs :: Attr -> Attrs -> Bool
- withoutAttrs :: Attrs -> Attrs -> Attrs
- oneStm :: Stm lore -> Stms lore
- stmsFromList :: [Stm lore] -> Stms lore
- stmsToList :: Stms lore -> [Stm lore]
- stmsHead :: Stms lore -> Maybe (Stm lore, Stms lore)
- module Futhark.IR.SOACS.SOAC
- data LambdaT lore = Lambda [LParam lore] (BodyT lore) [Type]
- data BodyT lore = Body (BodyDec lore) (Stms lore) Result
- data PatternT dec = Pattern [PatElemT dec] [PatElemT dec]
- data PatElemT dec = PatElem VName dec
The Lore definition
The lore for the basic representation.
Instances
Syntax types
Module re-exports
module Futhark.IR.Prop
module Futhark.IR.Traversals
module Futhark.IR.Pretty
8-bit signed integer type
Instances
16-bit signed integer type
Instances
32-bit signed integer type
Instances
64-bit signed integer type
Instances
8-bit unsigned integer type
Instances
16-bit unsigned integer type
Instances
32-bit unsigned integer type
Instances
64-bit unsigned integer type
Instances
Location type, consisting of a beginning position and an end position.
Instances
| Eq Loc | |
| Data Loc | |
Defined in Data.Loc Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Loc -> c Loc # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Loc # dataTypeOf :: Loc -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Loc) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Loc) # gmapT :: (forall b. Data b => b -> b) -> Loc -> Loc # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r # gmapQ :: (forall d. Data d => d -> u) -> Loc -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Loc -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Loc -> m Loc # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Loc -> m Loc # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Loc -> m Loc # | |
| Read Loc | |
| Show Loc | |
| Semigroup Loc | |
| Monoid Loc | |
| Pretty Loc | |
| IsLocation Loc | |
| Located Loc | |
Source location type. Source location are all equal, which allows AST nodes to be compared modulo location information.
Instances
| Eq SrcLoc | |
| Data SrcLoc | |
Defined in Data.Loc Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SrcLoc -> c SrcLoc # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SrcLoc # toConstr :: SrcLoc -> Constr # dataTypeOf :: SrcLoc -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SrcLoc) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcLoc) # gmapT :: (forall b. Data b => b -> b) -> SrcLoc -> SrcLoc # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SrcLoc -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SrcLoc -> r # gmapQ :: (forall d. Data d => d -> u) -> SrcLoc -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SrcLoc -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SrcLoc -> m SrcLoc # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcLoc -> m SrcLoc # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcLoc -> m SrcLoc # | |
| Ord SrcLoc | |
| Read SrcLoc | |
| Show SrcLoc | |
| Semigroup SrcLoc | |
| Monoid SrcLoc | |
| IsLocation SrcLoc | |
| Located SrcLoc | |
| ToIdent (SrcLoc -> Id) | |
Located values have a location.
Minimal complete definition
Instances
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. |
Instances
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. |
Instances
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. |
Instances
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).
What to do in case of arithmetic overflow. Futhark's semantics are that overflow does wraparound, but for generated code (like address arithmetic), it can be beneficial for overflow to be undefined behaviour, as it allows better optimisation of things such as GPU kernels.
Note that all values of this type are considered equal for Eq and
Ord.
Constructors
| OverflowWrap | |
| OverflowUndef |
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: |
Instances
Non-array values.
Constructors
| IntValue !IntValue | |
| FloatValue !FloatValue | |
| BoolValue !Bool | |
| Checked | The only value of type |
Instances
| Eq PrimValue Source # | |
| Ord PrimValue Source # | |
| Show PrimValue Source # | |
| Generic PrimValue Source # | |
| ToExp PrimValue Source # | |
| Pretty PrimValue Source # | |
| SexpIso PrimValue Source # | |
Defined in Futhark.IR.Primitive Methods | |
| IsValue PrimValue Source # | |
| type Rep PrimValue Source # | |
Defined in Futhark.IR.Primitive type Rep PrimValue = D1 ('MetaData "PrimValue" "Futhark.IR.Primitive" "futhark-0.18.2-inplace" 'False) ((C1 ('MetaCons "IntValue" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 IntValue)) :+: C1 ('MetaCons "FloatValue" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 FloatValue))) :+: (C1 ('MetaCons "BoolValue" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Bool)) :+: C1 ('MetaCons "Checked" 'PrefixI 'False) (U1 :: Type -> Type))) | |
data FloatValue Source #
A floating-point value.
Constructors
| Float32Value !Float | |
| Float64Value !Double |
Instances
An integer value.
Constructors
| Int8Value !Int8 | |
| Int16Value !Int16 | |
| Int32Value !Int32 | |
| Int64Value !Int64 |
Instances
Low-level primitive types.
Instances
| Bounded PrimType Source # | |
| Enum PrimType Source # | |
Defined in Futhark.IR.Primitive | |
| Eq PrimType Source # | |
| Ord PrimType Source # | |
Defined in Futhark.IR.Primitive | |
| Show PrimType Source # | |
| Generic PrimType Source # | |
| Pretty PrimType Source # | |
| SexpIso PrimType Source # | |
Defined in Futhark.IR.Primitive Methods | |
| type Rep PrimType Source # | |
Defined in Futhark.IR.Primitive type Rep PrimType = D1 ('MetaData "PrimType" "Futhark.IR.Primitive" "futhark-0.18.2-inplace" 'False) ((C1 ('MetaCons "IntType" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 IntType)) :+: C1 ('MetaCons "FloatType" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 FloatType))) :+: (C1 ('MetaCons "Bool" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Cert" 'PrefixI 'False) (U1 :: Type -> Type))) | |
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 # | |
| Generic FloatType Source # | |
| Pretty FloatType Source # | |
| SexpIso FloatType Source # | |
Defined in Futhark.IR.Primitive Methods | |
| type Rep FloatType Source # | |
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 # | |
| Generic IntType Source # | |
| Pretty IntType Source # | |
| SexpIso IntType Source # | |
Defined in Futhark.IR.Primitive Methods | |
| type Rep IntType Source # | |
Defined in Futhark.IR.Primitive type Rep IntType = D1 ('MetaData "IntType" "Futhark.IR.Primitive" "futhark-0.18.2-inplace" 'False) ((C1 ('MetaCons "Int8" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Int16" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Int32" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Int64" 'PrefixI 'False) (U1 :: Type -> Type))) | |
allIntTypes :: [IntType] Source #
A list of all integer types.
allFloatTypes :: [FloatType] Source #
A list of all floating-point types.
allPrimTypes :: [PrimType] Source #
A list of all primitive types.
intValueType :: IntValue -> IntType Source #
The type of an integer value.
floatValue :: Real num => FloatType -> num -> FloatValue Source #
Create a FloatValue from a type and a Rational.
floatValueType :: FloatValue -> FloatType Source #
The type of a floating-point value.
primValueType :: PrimValue -> PrimType Source #
The type of a basic value.
blankPrimValue :: PrimType -> PrimValue Source #
A "blank" value of the given primitive type - this is zero, or whatever is close to it. Don't depend on this value, but use it for e.g. creating arrays to be populated by do-loops.
allConvOps :: [ConvOp] Source #
A list of all conversion operators for all types.
doComplement :: IntValue -> IntValue Source #
E.g., ~(~1) = 1.
doFAbs :: FloatValue -> FloatValue Source #
abs(-2.0) = 2.0.
doSDiv :: IntValue -> IntValue -> Maybe IntValue Source #
Signed integer division. Rounds towards negativity infinity. Note: this is different from LLVM.
doSMod :: IntValue -> IntValue -> Maybe IntValue Source #
Signed integer modulus; the countepart to SDiv.
doZExt :: IntValue -> IntType -> IntValue Source #
Zero-extend the given integer value to the size of the given type. If the type is smaller than the given value, the result is a truncation.
doSExt :: IntValue -> IntType -> IntValue Source #
Sign-extend the given integer value to the size of the given type. If the type is smaller than the given value, the result is a truncation.
doFPConv :: FloatValue -> FloatType -> FloatValue Source #
Convert the former floating-point type to the latter.
doFPToUI :: FloatValue -> IntType -> IntValue Source #
Convert a floating-point value to the nearest unsigned integer (rounding towards zero).
doFPToSI :: FloatValue -> IntType -> IntValue Source #
Convert a floating-point value to the nearest signed integer (rounding towards zero).
doUIToFP :: IntValue -> FloatType -> FloatValue Source #
Convert an unsigned integer to a floating-point value.
doSIToFP :: IntValue -> FloatType -> FloatValue Source #
Convert a signed integer to a floating-point value.
doCmpEq :: PrimValue -> PrimValue -> Bool Source #
Compare any two primtive values for exact equality.
doFCmpLt :: FloatValue -> FloatValue -> Bool Source #
Floating-point less than.
doFCmpLe :: FloatValue -> FloatValue -> Bool Source #
Floating-point less than or equal.
intToWord64 :: IntValue -> Word64 Source #
convOpType :: ConvOp -> (PrimType, PrimType) Source #
The input and output types of a conversion operator.
primFuns :: Map String ([PrimType], PrimType, [PrimValue] -> Maybe PrimValue) Source #
A mapping from names of primitive functions to their parameter types, their result type, and a function for evaluating them.
negativeIsh :: PrimValue -> Bool Source #
Is the given value kind of negative?
zeroIshInt :: IntValue -> Bool Source #
Is the given integer value kind of zero?
primBitSize :: PrimType -> Int Source #
The size of a value of a given primitive type in bites.
primByteSize :: Num a => PrimType -> a Source #
The size of a value of a given primitive type in eight-bit bytes.
intByteSize :: Num a => IntType -> a Source #
The size of a value of a given integer type in eight-bit bytes.
floatByteSize :: Num a => FloatType -> a Source #
The size of a value of a given floating-point type in eight-bit bytes.
commutativeBinOp :: BinOp -> Bool Source #
True if the given binary operator is commutative.
prettySigned :: Bool -> PrimType -> String Source #
True if signed. Only makes a difference for integer types.
A name tagged with some integer. Only the integer is used in
comparisons, no matter the type of vn.
Instances
The abstract (not really) type representing names in the Futhark
compiler. Strings, being lists of characters, are very slow,
while Texts are based on byte-arrays.
Instances
data Commutativity Source #
Whether some operator is commutative or not. The Monoid
instance returns the least commutative of its arguments.
Constructors
| Noncommutative | |
| Commutative |
Instances
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
defaultEntryPoint :: Name Source #
The name of the default program entry point (main).
nameToString :: Name -> String Source #
Convert a name to the corresponding list of characters.
nameFromString :: String -> Name Source #
Convert a list of characters to the corresponding name.
locStr :: Located a => a -> String Source #
A human-readable location string, of the form
filename:lineno:columnno. This follows the GNU coding standards
for error messages:
https://www.gnu.org/prep/standards/html_node/Errors.html
This function assumes that both start and end position is in the same file (it is not clear what the alternative would even mean).
locStrRel :: (Located a, Located b) => a -> b -> String Source #
Like locStr, but locStrRel prev now prints the location now
with the file name left out if the same as prev. This is useful
when printing messages that are all in the context of some
initially printed location (e.g. the first mention contains the
file name; the rest just line and column name).
prettyStacktrace :: Int -> [String] -> String Source #
Given a list of strings representing entries in the stack trace and the index of the frame to highlight, produce a final newline-terminated string for showing to the user. This string should also be preceded by a newline. The most recent stack frame must come first in the list.
quote :: String -> String Source #
Enclose a string in the prefered quotes used in error messages. These are picked to not collide with characters permitted in identifiers.
data ErrorMsgPart a Source #
A part of an error message.
Constructors
| ErrorString String | A literal string. |
| ErrorInt32 a | A run-time integer value. |
| ErrorInt64 a | A bigger run-time integer value. |
Instances
An error message is a list of error parts, which are concatenated to form the final message.
Constructors
| ErrorMsg [ErrorMsgPart a] |
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.
Instances
How to index a single dimension of an array.
Constructors
| DimFix d | Fix index in this dimension. |
| DimSlice d d d |
|
Instances
A function or lambda parameter.
Constructors
| Param | |
Instances
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
newtype Certificates Source #
A list of names used for certificates in some expressions.
Constructors
| Certificates | |
Fields
| |
Instances
An identifier consists of its name and the type of the value bound to the identifier.
Instances
| Eq Ident Source # | |
| Ord Ident Source # | |
| Show Ident Source # | |
| Generic Ident Source # | |
| Pretty Ident Source # | |
| SexpIso Ident Source # | |
Defined in Futhark.IR.Syntax.Core Methods sexpIso :: SexpGrammar Ident # | |
| Typed Ident Source # | |
| FreeIn Ident Source # | |
| Substitute Ident Source # | |
Defined in Futhark.Transform.Substitute | |
| Rename Ident Source # | |
| type Rep Ident Source # | |
Defined in Futhark.IR.Syntax.Core type Rep Ident = D1 ('MetaData "Ident" "Futhark.IR.Syntax.Core" "futhark-0.18.2-inplace" 'False) (C1 ('MetaCons "Ident" 'PrefixI 'True) (S1 ('MetaSel ('Just "identName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 VName) :*: S1 ('MetaSel ('Just "identType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Type))) | |
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 |
type DeclExtType = TypeBase ExtShape Uniqueness Source #
An ExtType with uniqueness information, used for function
return types.
type DeclType = TypeBase Shape Uniqueness Source #
A type with shape and uniqueness information, used declaring return- and parameters types.
type ExtType = TypeBase ExtShape NoUniqueness Source #
A type with existentially quantified shapes - used as part of function (and function-like) return types. Generally only makes sense when used in a list.
type Type = TypeBase Shape NoUniqueness Source #
A type with shape information, used for describing the type of variables.
data TypeBase shape u Source #
A Futhark type is either an array or an element type. When
comparing types for equality with ==, shapes must match.
Instances
data NoUniqueness Source #
A fancier name for () - encodes no uniqueness information.
Constructors
| NoUniqueness |
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. |
Instances
| Eq Space Source # | |
| Ord Space Source # | |
| Show Space Source # | |
| Generic Space Source # | |
| Pretty Space Source # | |
| SexpIso Space Source # | |
Defined in Futhark.IR.Syntax.Core Methods sexpIso :: SexpGrammar Space # | |
| FreeIn Space Source # | |
| Simplifiable Space Source # | |
Defined in Futhark.Optimise.Simplify.Engine | |
| type Rep Space Source # | |
Defined in Futhark.IR.Syntax.Core type Rep Space = D1 ('MetaData "Space" "Futhark.IR.Syntax.Core" "futhark-0.18.2-inplace" 'False) (C1 ('MetaCons "DefaultSpace" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "Space" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 SpaceId)) :+: C1 ('MetaCons "ScalarSpace" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 [SubExp]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 PrimType)))) | |
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 size of an array type as merely the number of dimensions, with no further information.
Instances
| Eq Rank Source # | |
| Ord Rank Source # | |
| Show Rank Source # | |
| Generic Rank Source # | |
| Semigroup Rank Source # | |
| Monoid Rank Source # | |
| SexpIso Rank Source # | |
Defined in Futhark.IR.Syntax.Core Methods sexpIso :: SexpGrammar Rank # | |
| ArrayShape Rank Source # | |
| Substitute Rank Source # | |
Defined in Futhark.Transform.Substitute | |
| Rename Rank Source # | |
| Pretty u => Pretty (TypeBase Rank u) Source # | |
| type Rep Rank Source # | |
Defined in Futhark.IR.Syntax.Core | |
type ExtShape = ShapeBase ExtSize Source #
Like Shape but some of its elements may be bound in a local
environment instead. These are denoted with integral indices.
Something that may be existential.
Instances
type Shape = ShapeBase SubExp Source #
The size of an array as a list of subexpressions. If a variable, that variable must be in scope where this array is used.
The size of an array type as a list of its dimension sizes, with the type of sizes being parametric.
Instances
errorMsgArgTypes :: ErrorMsg a -> [PrimType] Source #
How many non-constant parts does the error message have, and what is their type?
class (Show rt, Eq rt, Ord rt, DeclExtTyped rt) => IsRetType rt where Source #
A type representing the return type of a function. In practice,
a list of these will be used. It should contain at least the
information contained in an ExtType, but may have more, notably
an existential context.
Methods
primRetType :: PrimType -> rt Source #
Contruct a return type from a primitive type.
applyRetType :: Typed dec => [rt] -> [Param dec] -> [(SubExp, Type)] -> Maybe [rt] Source #
Given a function return type, the parameters of the function, and the arguments for a concrete call, return the instantiated return type for the concrete call, if valid.
Instances
| IsRetType DeclExtType Source # | |
Defined in Futhark.IR.RetType Methods primRetType :: PrimType -> DeclExtType Source # applyRetType :: Typed dec => [DeclExtType] -> [Param dec] -> [(SubExp, Type)] -> Maybe [DeclExtType] Source # | |
| IsRetType FunReturns Source # | |
Defined in Futhark.IR.Mem Methods primRetType :: PrimType -> FunReturns Source # applyRetType :: Typed dec => [FunReturns] -> [Param dec] -> [(SubExp, Type)] -> Maybe [FunReturns] Source # | |
class (Show rt, Eq rt, Ord rt, ExtTyped rt) => IsBodyType rt where Source #
A type representing the return type of a body. It should contain
at least the information contained in a list of ExtTypes, but may
have more, notably an existential context.
Instances
| IsBodyType ExtType Source # | |
Defined in Futhark.IR.RetType Methods primBodyType :: PrimType -> ExtType Source # | |
| IsBodyType BodyReturns Source # | |
Defined in Futhark.IR.Mem Methods primBodyType :: PrimType -> BodyReturns Source # | |
expectedTypes :: Typed t => [VName] -> [t] -> [SubExp] -> [Type] Source #
Given shape parameter names and value parameter types, produce the types of arguments accepted.
class (Show (LetDec l), Show (ExpDec l), Show (BodyDec l), Show (FParamInfo l), Show (LParamInfo l), Show (RetType l), Show (BranchType l), Show (Op l), Eq (LetDec l), Eq (ExpDec l), Eq (BodyDec l), Eq (FParamInfo l), Eq (LParamInfo l), Eq (RetType l), Eq (BranchType l), Eq (Op l), Ord (LetDec l), Ord (ExpDec l), Ord (BodyDec l), Ord (FParamInfo l), Ord (LParamInfo l), Ord (RetType l), Ord (BranchType l), Ord (Op l), IsRetType (RetType l), IsBodyType (BranchType l), Typed (FParamInfo l), Typed (LParamInfo l), Typed (LetDec l), DeclTyped (FParamInfo l), SexpIso (LetDec l), SexpIso (ExpDec l), SexpIso (BodyDec l), SexpIso (FParamInfo l), SexpIso (LParamInfo l), SexpIso (RetType l), SexpIso (BranchType l), SexpIso (Op l)) => Decorations l Source #
A collection of type families, along with constraints specifying that the types they map to should satisfy some minimal requirements.
Associated Types
type LetDec l :: Type Source #
Decoration for every let-pattern element.
type ExpDec l :: Type Source #
Decoration for every expression.
type ExpDec l = ()
type BodyDec l :: Type Source #
Decoration for every body.
type BodyDec l = ()
type FParamInfo l :: Type Source #
Decoration for every (non-lambda) function parameter.
type FParamInfo l = DeclType
type LParamInfo l :: Type Source #
Decoration for every lambda function parameter.
type LParamInfo l = Type
type BranchType l :: Type Source #
The return type decoration of branches.
type BranchType l = ExtType
Extensible operation.
type Op l = ()
Instances
| Decorations Seq Source # | |
| Decorations SOACS Source # | |
| Decorations MCMem Source # | |
| Decorations MC Source # | |
| Decorations SeqMem Source # | |
| Decorations Kernels Source # | |
| Decorations KernelsMem Source # | |
Defined in Futhark.IR.KernelsMem Associated Types type LetDec KernelsMem Source # type ExpDec KernelsMem Source # type BodyDec KernelsMem Source # type FParamInfo KernelsMem Source # type LParamInfo KernelsMem Source # type RetType KernelsMem Source # type BranchType KernelsMem Source # type Op KernelsMem Source # | |
| (Decorations lore, CanBeAliased (Op lore)) => Decorations (Aliases lore) Source # | |
Defined in Futhark.IR.Aliases | |
| (Decorations lore, CanBeWise (Op lore)) => Decorations (Wise lore) Source # | |
Defined in Futhark.Optimise.Simplify.Lore | |
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 # | |
| Generic (Prog lore) Source # | |
| PrettyLore lore => Pretty (Prog lore) Source # | |
| Decorations lore => SexpIso (Prog lore) Source # | |
Defined in Futhark.IR.Syntax Methods sexpIso :: SexpGrammar (Prog lore) # | |
| type Rep (Prog lore) Source # | |
Defined in Futhark.IR.Syntax type Rep (Prog lore) = D1 ('MetaData "Prog" "Futhark.IR.Syntax" "futhark-0.18.2-inplace" 'False) (C1 ('MetaCons "Prog" 'PrefixI 'True) (S1 ('MetaSel ('Just "progConsts") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Stms lore)) :*: S1 ('MetaSel ('Just "progFuns") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 [FunDef lore]))) | |
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
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.
Function Declarations
Constructors
| FunDef | |
Fields
| |
Instances
Anonymous function for use in a SOAC.
Instances
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). |
Data associated with a branch.
Instances
| Eq rt => Eq (IfDec rt) Source # | |
| Ord rt => Ord (IfDec rt) Source # | |
Defined in Futhark.IR.Syntax | |
| Show rt => Show (IfDec rt) Source # | |
| Generic (IfDec rt) Source # | |
| SexpIso rt => SexpIso (IfDec rt) Source # | |
Defined in Futhark.IR.Syntax Methods sexpIso :: SexpGrammar (IfDec rt) # | |
| FreeIn a => FreeIn (IfDec a) Source # | |
| type Rep (IfDec rt) Source # | |
Defined in Futhark.IR.Syntax type Rep (IfDec rt) = D1 ('MetaData "IfDec" "Futhark.IR.Syntax" "futhark-0.18.2-inplace" 'False) (C1 ('MetaCons "IfDec" 'PrefixI 'True) (S1 ('MetaSel ('Just "ifReturns") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 [rt]) :*: S1 ('MetaSel ('Just "ifSort") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 IfSort))) | |
For-loop or while-loop?
Instances
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) |
|
| Op (Op lore) |
Instances
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. |
Instances
type ShapeChange d = [DimChange d] Source #
A list of DimChanges, indicating the new dimensions of an array.
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
A body consists of a number of bindings, terminating in a result (essentially a tuple literal).
Instances
stmPattern :: Stm lore -> Pattern lore Source #
Pattern.
Auxilliary Information associated with a statement.
Constructors
| StmAux | |
Fields
| |
Instances
A pattern is conceptually just a list of names and their types.
Instances
Every statement is associated with a set of attributes, which can have various effects throughout the compiler.
Instances
| Eq Attrs Source # | |
| Ord Attrs Source # | |
| Show Attrs Source # | |
| Generic Attrs Source # | |
| Semigroup Attrs Source # | |
| Monoid Attrs Source # | |
| SexpIso Attrs Source # | |
Defined in Futhark.IR.Syntax Methods sexpIso :: SexpGrammar Attrs # | |
| FreeIn Attrs Source # | |
| Substitute Attrs Source # | |
Defined in Futhark.Transform.Substitute | |
| Rename Attrs Source # | |
| type Rep Attrs Source # | |
Defined in Futhark.IR.Syntax | |
A single attribute.
Instances
| Eq Attr Source # | |
| Ord Attr Source # | |
| Show Attr Source # | |
| IsString Attr Source # | |
Defined in Futhark.IR.Syntax Methods fromString :: String -> Attr # | |
| Generic Attr Source # | |
| Pretty Attr Source # | |
| SexpIso Attr Source # | |
Defined in Futhark.IR.Syntax Methods sexpIso :: SexpGrammar Attr # | |
| type Rep Attr Source # | |
Defined in Futhark.IR.Syntax type Rep Attr = D1 ('MetaData "Attr" "Futhark.IR.Syntax" "futhark-0.18.2-inplace" 'False) (C1 ('MetaCons "AttrAtom" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Name)) :+: C1 ('MetaCons "AttrComp" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 [Attr]))) | |
withoutAttrs :: Attrs -> Attrs -> Attrs Source #
x gives withoutAttrs yx except for any attributes also in y.
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.
stmsHead :: Stms lore -> Maybe (Stm lore, Stms lore) Source #
The first statement in the sequence, if any.
module Futhark.IR.SOACS.SOAC
Anonymous function for use in a SOAC.
Instances
A body consists of a number of bindings, terminating in a result (essentially a tuple literal).
Instances
A pattern is conceptually just a list of names and their types.
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.