Language.Futhark.Syntax

This is an ever-changing syntax representation for Futhark. Some types, such as Exp, are parametrised by type and name representation. See the https://futhark.readthedocs.org for a language reference, or this module may be a little hard to understand.

Documentation

module Language.Futhark.Core

Types

data Uniqueness

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

Eq Uniqueness

Defined in Language.Futhark.Core

Methods

(==) :: Uniqueness -> Uniqueness -> Bool

(/=) :: Uniqueness -> Uniqueness -> Bool

Ord Uniqueness

Defined in Language.Futhark.Core

Methods

compare :: Uniqueness -> Uniqueness -> Ordering

(<) :: Uniqueness -> Uniqueness -> Bool

(<=) :: Uniqueness -> Uniqueness -> Bool

(>) :: Uniqueness -> Uniqueness -> Bool

(>=) :: Uniqueness -> Uniqueness -> Bool

max :: Uniqueness -> Uniqueness -> Uniqueness

min :: Uniqueness -> Uniqueness -> Uniqueness

Show Uniqueness

Defined in Language.Futhark.Core

Methods

showsPrec :: Int -> Uniqueness -> ShowS

show :: Uniqueness -> String

showList :: [Uniqueness] -> ShowS

Semigroup Uniqueness

Defined in Language.Futhark.Core

Methods

(<>) :: Uniqueness -> Uniqueness -> Uniqueness

sconcat :: NonEmpty Uniqueness -> Uniqueness

stimes :: Integral b => b -> Uniqueness -> Uniqueness

Monoid Uniqueness

Defined in Language.Futhark.Core

Methods

mempty :: Uniqueness

mappend :: Uniqueness -> Uniqueness -> Uniqueness

mconcat :: [Uniqueness] -> Uniqueness

Pretty Uniqueness

Defined in Language.Futhark.Core

Methods

ppr :: Uniqueness -> Doc

pprPrec :: Int -> Uniqueness -> Doc

pprList :: [Uniqueness] -> Doc

DeclExtTyped DeclExtType

Defined in Futhark.Representation.AST.Attributes.Types

Methods

declExtTypeOf :: DeclExtType -> DeclExtType

DeclTyped DeclType

Defined in Futhark.Representation.AST.Attributes.Types

Methods

declTypeOf :: DeclType -> DeclType

Typed DeclType

Defined in Futhark.Representation.AST.Attributes.Types

Methods

typeOf :: DeclType -> Type

IsRetType DeclExtType

Defined in Futhark.Representation.AST.RetType

Methods

primRetType :: PrimType -> DeclExtType

applyRetType :: Typed attr => [DeclExtType] -> [Param attr] -> [(SubExp, Type)] -> Maybe [DeclExtType]

IsRetType FunReturns

Defined in Futhark.Representation.ExplicitMemory

Methods

primRetType :: PrimType -> FunReturns

applyRetType :: Typed attr => [FunReturns] -> [Param attr] -> [(SubExp, Type)] -> Maybe [FunReturns]

Pretty (Param (MemInfo SubExp Uniqueness ret))

Defined in Futhark.Representation.ExplicitMemory

Methods

ppr :: Param (MemInfo SubExp Uniqueness ret) -> Doc

pprPrec :: Int -> Param (MemInfo SubExp Uniqueness ret) -> Doc

pprList :: [Param (MemInfo SubExp Uniqueness ret)] -> Doc

Pretty (ParamT DeclType)

Defined in Futhark.Representation.AST.Pretty

Methods

ppr :: ParamT DeclType -> Doc

pprPrec :: Int -> ParamT DeclType -> Doc

pprList :: [ParamT DeclType] -> Doc

Simplifiable [FunReturns]

Defined in Futhark.Representation.ExplicitMemory

Methods

simplify :: SimplifiableLore lore => [FunReturns] -> SimpleM lore [FunReturns]

FixExt ret => DeclExtTyped (MemInfo ExtSize Uniqueness ret)

Defined in Futhark.Representation.ExplicitMemory

Methods

declExtTypeOf :: MemInfo ExtSize Uniqueness ret -> DeclExtType

DeclTyped (MemInfo SubExp Uniqueness ret)

Defined in Futhark.Representation.ExplicitMemory

Methods

declTypeOf :: MemInfo SubExp Uniqueness ret -> DeclType

Typed (MemInfo SubExp Uniqueness ret)

Defined in Futhark.Representation.ExplicitMemory

Methods

typeOf :: MemInfo SubExp Uniqueness ret -> Type

data IntType

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.

Constructors

Int8

Int16

Int32

Int64

Instances

Bounded IntType

Defined in Futhark.Representation.Primitive

Methods

minBound :: IntType

maxBound :: IntType

Enum IntType

Defined in Futhark.Representation.Primitive

Methods

succ :: IntType -> IntType

pred :: IntType -> IntType

toEnum :: Int -> IntType

fromEnum :: IntType -> Int

enumFrom :: IntType -> [IntType]

enumFromThen :: IntType -> IntType -> [IntType]

enumFromTo :: IntType -> IntType -> [IntType]

enumFromThenTo :: IntType -> IntType -> IntType -> [IntType]

Eq IntType

Defined in Futhark.Representation.Primitive

Methods

(==) :: IntType -> IntType -> Bool

(/=) :: IntType -> IntType -> Bool

Ord IntType

Defined in Futhark.Representation.Primitive

Methods

compare :: IntType -> IntType -> Ordering

(<) :: IntType -> IntType -> Bool

(<=) :: IntType -> IntType -> Bool

(>) :: IntType -> IntType -> Bool

(>=) :: IntType -> IntType -> Bool

max :: IntType -> IntType -> IntType

min :: IntType -> IntType -> IntType

Show IntType

Defined in Futhark.Representation.Primitive

Methods

showsPrec :: Int -> IntType -> ShowS

show :: IntType -> String

showList :: [IntType] -> ShowS

Pretty IntType

Defined in Futhark.Representation.Primitive

Methods

ppr :: IntType -> Doc

pprPrec :: Int -> IntType -> Doc

pprList :: [IntType] -> Doc

data FloatType

A floating point type.

Constructors

Float32

Float64

Instances

Bounded FloatType

Defined in Futhark.Representation.Primitive

Methods

minBound :: FloatType

maxBound :: FloatType

Enum FloatType

Defined in Futhark.Representation.Primitive

Methods

succ :: FloatType -> FloatType

pred :: FloatType -> FloatType

toEnum :: Int -> FloatType

fromEnum :: FloatType -> Int

enumFrom :: FloatType -> [FloatType]

enumFromThen :: FloatType -> FloatType -> [FloatType]

enumFromTo :: FloatType -> FloatType -> [FloatType]

enumFromThenTo :: FloatType -> FloatType -> FloatType -> [FloatType]

Eq FloatType

Defined in Futhark.Representation.Primitive

Methods

(==) :: FloatType -> FloatType -> Bool

(/=) :: FloatType -> FloatType -> Bool

Ord FloatType

Defined in Futhark.Representation.Primitive

Methods

compare :: FloatType -> FloatType -> Ordering

(<) :: FloatType -> FloatType -> Bool

(<=) :: FloatType -> FloatType -> Bool

(>) :: FloatType -> FloatType -> Bool

(>=) :: FloatType -> FloatType -> Bool

max :: FloatType -> FloatType -> FloatType

min :: FloatType -> FloatType -> FloatType

Show FloatType

Defined in Futhark.Representation.Primitive

Methods

showsPrec :: Int -> FloatType -> ShowS

show :: FloatType -> String

showList :: [FloatType] -> ShowS

Pretty FloatType

Defined in Futhark.Representation.Primitive

Methods

ppr :: FloatType -> Doc

pprPrec :: Int -> FloatType -> Doc

pprList :: [FloatType] -> Doc

data PrimType

Low-level primitive types.

Constructors

Signed IntType

Unsigned IntType

FloatType FloatType

Bool

Instances

Eq PrimType

Defined in Language.Futhark.Syntax

Methods

(==) :: PrimType -> PrimType -> Bool

(/=) :: PrimType -> PrimType -> Bool

Ord PrimType

Defined in Language.Futhark.Syntax

Methods

compare :: PrimType -> PrimType -> Ordering

(<) :: PrimType -> PrimType -> Bool

(<=) :: PrimType -> PrimType -> Bool

(>) :: PrimType -> PrimType -> Bool

(>=) :: PrimType -> PrimType -> Bool

max :: PrimType -> PrimType -> PrimType

min :: PrimType -> PrimType -> PrimType

Show PrimType

Defined in Language.Futhark.Syntax

Methods

showsPrec :: Int -> PrimType -> ShowS

show :: PrimType -> String

showList :: [PrimType] -> ShowS

Pretty PrimType

Defined in Language.Futhark.Syntax

Methods

ppr :: PrimType -> Doc

pprPrec :: Int -> PrimType -> Doc

pprList :: [PrimType] -> Doc

class (Eq dim, Ord dim) => ArrayDim dim where

Methods

unifyDims :: dim -> dim -> Maybe dim

unifyDims x y combines x and y to contain their maximum common information, and fails if they conflict.

Instances

ArrayDim ()

Defined in Language.Futhark.Syntax

Methods

unifyDims :: () -> () -> Maybe ()

(Eq vn, Ord vn) => ArrayDim (DimDecl vn)

Defined in Language.Futhark.Syntax

Methods

unifyDims :: DimDecl vn -> DimDecl vn -> Maybe (DimDecl vn)

data DimDecl vn

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

No dimension declaration.

Instances

Functor DimDecl

Defined in Language.Futhark.Syntax

Methods

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

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

Foldable DimDecl

Defined in Language.Futhark.Syntax

Methods

fold :: Monoid m => DimDecl m -> m

foldMap :: Monoid m => (a -> m) -> DimDecl a -> m

foldr :: (a -> b -> b) -> b -> DimDecl a -> b

foldr' :: (a -> b -> b) -> b -> DimDecl a -> b

foldl :: (b -> a -> b) -> b -> DimDecl a -> b

foldl' :: (b -> a -> b) -> b -> DimDecl a -> b

foldr1 :: (a -> a -> a) -> DimDecl a -> a

foldl1 :: (a -> a -> a) -> DimDecl a -> a

toList :: DimDecl a -> [a]

null :: DimDecl a -> Bool

length :: DimDecl a -> Int

elem :: Eq a => a -> DimDecl a -> Bool

maximum :: Ord a => DimDecl a -> a

minimum :: Ord a => DimDecl a -> a

sum :: Num a => DimDecl a -> a

product :: Num a => DimDecl a -> a

Traversable DimDecl

Defined in Language.Futhark.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> DimDecl a -> f (DimDecl b)

sequenceA :: Applicative f => DimDecl (f a) -> f (DimDecl a)

mapM :: Monad m => (a -> m b) -> DimDecl a -> m (DimDecl b)

sequence :: Monad m => DimDecl (m a) -> m (DimDecl a)

ASTMappable StructType

Defined in Language.Futhark.Traversals

Methods

astMap :: Monad m => ASTMapper m -> StructType -> m StructType

ASTMappable PatternType

Defined in Language.Futhark.Traversals

Methods

astMap :: Monad m => ASTMapper m -> PatternType -> m PatternType

Eq vn => Eq (DimDecl vn)

Defined in Language.Futhark.Syntax

Methods

(==) :: DimDecl vn -> DimDecl vn -> Bool

(/=) :: DimDecl vn -> DimDecl vn -> Bool

Ord vn => Ord (DimDecl vn)

Defined in Language.Futhark.Syntax

Methods

compare :: DimDecl vn -> DimDecl vn -> Ordering

(<) :: DimDecl vn -> DimDecl vn -> Bool

(<=) :: DimDecl vn -> DimDecl vn -> Bool

(>) :: DimDecl vn -> DimDecl vn -> Bool

(>=) :: DimDecl vn -> DimDecl vn -> Bool

max :: DimDecl vn -> DimDecl vn -> DimDecl vn

min :: DimDecl vn -> DimDecl vn -> DimDecl vn

Show vn => Show (DimDecl vn)

Defined in Language.Futhark.Syntax

Methods

showsPrec :: Int -> DimDecl vn -> ShowS

show :: DimDecl vn -> String

showList :: [DimDecl vn] -> ShowS

IsName vn => Pretty (ShapeDecl (DimDecl vn))

Defined in Language.Futhark.Pretty

Methods

ppr :: ShapeDecl (DimDecl vn) -> Doc

pprPrec :: Int -> ShapeDecl (DimDecl vn) -> Doc

pprList :: [ShapeDecl (DimDecl vn)] -> Doc

IsName vn => Pretty (DimDecl vn)

Defined in Language.Futhark.Pretty

Methods

ppr :: DimDecl vn -> Doc

pprPrec :: Int -> DimDecl vn -> Doc

pprList :: [DimDecl vn] -> Doc

(Eq vn, Ord vn) => ArrayDim (DimDecl vn)

Defined in Language.Futhark.Syntax

Methods

unifyDims :: DimDecl vn -> DimDecl vn -> Maybe (DimDecl vn)

ASTMappable (DimDecl VName)

Defined in Language.Futhark.Traversals

Methods

astMap :: Monad m => ASTMapper m -> DimDecl VName -> m (DimDecl VName)

Substitutable (TypeBase (DimDecl VName) ())

Defined in Language.Futhark.TypeChecker.Types

Methods

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

Substitutable (TypeBase (DimDecl VName) Aliasing)

Defined in Language.Futhark.TypeChecker.Types

Methods

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

newtype ShapeDecl dim

The size of an array type is a list of its dimension sizes. If Nothing, that dimension is of a (statically) unknown size.

Constructors

ShapeDecl

Fields

• shapeDims :: [dim]

Instances

Functor ShapeDecl

Defined in Language.Futhark.Syntax

Methods

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

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

Foldable ShapeDecl

Defined in Language.Futhark.Syntax

Methods

fold :: Monoid m => ShapeDecl m -> m

foldMap :: Monoid m => (a -> m) -> ShapeDecl a -> m

foldr :: (a -> b -> b) -> b -> ShapeDecl a -> b

foldr' :: (a -> b -> b) -> b -> ShapeDecl a -> b

foldl :: (b -> a -> b) -> b -> ShapeDecl a -> b

foldl' :: (b -> a -> b) -> b -> ShapeDecl a -> b

foldr1 :: (a -> a -> a) -> ShapeDecl a -> a

foldl1 :: (a -> a -> a) -> ShapeDecl a -> a

toList :: ShapeDecl a -> [a]

null :: ShapeDecl a -> Bool

length :: ShapeDecl a -> Int

elem :: Eq a => a -> ShapeDecl a -> Bool

maximum :: Ord a => ShapeDecl a -> a

minimum :: Ord a => ShapeDecl a -> a

sum :: Num a => ShapeDecl a -> a

product :: Num a => ShapeDecl a -> a

Traversable ShapeDecl

Defined in Language.Futhark.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> ShapeDecl a -> f (ShapeDecl b)

sequenceA :: Applicative f => ShapeDecl (f a) -> f (ShapeDecl a)

mapM :: Monad m => (a -> m b) -> ShapeDecl a -> m (ShapeDecl b)

sequence :: Monad m => ShapeDecl (m a) -> m (ShapeDecl a)

Eq dim => Eq (ShapeDecl dim)

Defined in Language.Futhark.Syntax

Methods

(==) :: ShapeDecl dim -> ShapeDecl dim -> Bool

(/=) :: ShapeDecl dim -> ShapeDecl dim -> Bool

Ord dim => Ord (ShapeDecl dim)

Defined in Language.Futhark.Syntax

Methods

compare :: ShapeDecl dim -> ShapeDecl dim -> Ordering

(<) :: ShapeDecl dim -> ShapeDecl dim -> Bool

(<=) :: ShapeDecl dim -> ShapeDecl dim -> Bool

(>) :: ShapeDecl dim -> ShapeDecl dim -> Bool

(>=) :: ShapeDecl dim -> ShapeDecl dim -> Bool

max :: ShapeDecl dim -> ShapeDecl dim -> ShapeDecl dim

min :: ShapeDecl dim -> ShapeDecl dim -> ShapeDecl dim

Show dim => Show (ShapeDecl dim)

Defined in Language.Futhark.Syntax

Methods

showsPrec :: Int -> ShapeDecl dim -> ShowS

show :: ShapeDecl dim -> String

showList :: [ShapeDecl dim] -> ShowS

Semigroup (ShapeDecl dim)

Defined in Language.Futhark.Syntax

Methods

(<>) :: ShapeDecl dim -> ShapeDecl dim -> ShapeDecl dim

sconcat :: NonEmpty (ShapeDecl dim) -> ShapeDecl dim

stimes :: Integral b => b -> ShapeDecl dim -> ShapeDecl dim

Monoid (ShapeDecl dim)

Defined in Language.Futhark.Syntax

Methods

mempty :: ShapeDecl dim

mappend :: ShapeDecl dim -> ShapeDecl dim -> ShapeDecl dim

mconcat :: [ShapeDecl dim] -> ShapeDecl dim

Pretty (ShapeDecl ())

Defined in Language.Futhark.Pretty

Methods

ppr :: ShapeDecl () -> Doc

pprPrec :: Int -> ShapeDecl () -> Doc

pprList :: [ShapeDecl ()] -> Doc

IsName vn => Pretty (ShapeDecl (DimDecl vn))

Defined in Language.Futhark.Pretty

Methods

ppr :: ShapeDecl (DimDecl vn) -> Doc

pprPrec :: Int -> ShapeDecl (DimDecl vn) -> Doc

pprList :: [ShapeDecl (DimDecl vn)] -> Doc

shapeRank :: ShapeDecl dim -> Int

The number of dimensions contained in a shape.

stripDims :: Int -> ShapeDecl dim -> Maybe (ShapeDecl dim)

stripDims n shape strips the outer n dimensions from shape, returning Nothing if this would result in zero or fewer dimensions.

unifyShapes :: ArrayDim dim => ShapeDecl dim -> ShapeDecl dim -> Maybe (ShapeDecl dim)

unifyShapes x y combines x and y to contain their maximum common information, and fails if they conflict.

data TypeName

A type name consists of qualifiers (for error messages) and a VName (for equality checking).

Constructors

TypeName

Fields

• typeQuals :: [VName]
• typeLeaf :: VName

Instances

Eq TypeName

Defined in Language.Futhark.Syntax

Methods

(==) :: TypeName -> TypeName -> Bool

(/=) :: TypeName -> TypeName -> Bool

Ord TypeName

Defined in Language.Futhark.Syntax

Methods

compare :: TypeName -> TypeName -> Ordering

(<) :: TypeName -> TypeName -> Bool

(<=) :: TypeName -> TypeName -> Bool

(>) :: TypeName -> TypeName -> Bool

(>=) :: TypeName -> TypeName -> Bool

max :: TypeName -> TypeName -> TypeName

min :: TypeName -> TypeName -> TypeName

Show TypeName

Defined in Language.Futhark.Syntax

Methods

showsPrec :: Int -> TypeName -> ShowS

show :: TypeName -> String

showList :: [TypeName] -> ShowS

typeNameFromQualName :: QualName VName -> TypeName

qualNameFromTypeName :: TypeName -> QualName VName

data TypeBase dim as

An expanded Futhark type is either an array, a prim type, a tuple, or a type variable. When comparing types for equality with ==, aliases are ignored, but dimensions much match. Function parameter names are ignored.

Constructors

Prim PrimType

Enum [Name]

Array as Uniqueness (ArrayElemTypeBase dim) (ShapeDecl dim)

Record (Map Name (TypeBase dim as))

TypeVar as Uniqueness TypeName [TypeArg dim]

Arrow as (Maybe VName) (TypeBase dim as) (TypeBase dim as)

The aliasing corresponds to the lexical closure of the function.

Instances

Bitraversable TypeBase

Defined in Language.Futhark.Syntax

Methods

bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> TypeBase a b -> f (TypeBase c d)

Bifoldable TypeBase

Defined in Language.Futhark.Syntax

Methods

bifold :: Monoid m => TypeBase m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> TypeBase a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> TypeBase a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> TypeBase a b -> c

Bifunctor TypeBase

Defined in Language.Futhark.Syntax

Methods

bimap :: (a -> b) -> (c -> d) -> TypeBase a c -> TypeBase b d

first :: (a -> b) -> TypeBase a c -> TypeBase b c

second :: (b -> c) -> TypeBase a b -> TypeBase a c

ASTMappable StructType

Defined in Language.Futhark.Traversals

Methods

astMap :: Monad m => ASTMapper m -> StructType -> m StructType

ASTMappable PatternType

Defined in Language.Futhark.Traversals

Methods

astMap :: Monad m => ASTMapper m -> PatternType -> m PatternType

ASTMappable CompType

Defined in Language.Futhark.Traversals

Methods

astMap :: Monad m => ASTMapper m -> CompType -> m CompType

(Eq dim, Eq as) => Eq (TypeBase dim as)

Defined in Language.Futhark.Syntax

Methods

(==) :: TypeBase dim as -> TypeBase dim as -> Bool

(/=) :: TypeBase dim as -> TypeBase dim as -> Bool

(Show as, Show dim) => Show (TypeBase dim as)

Defined in Language.Futhark.Syntax

Methods

showsPrec :: Int -> TypeBase dim as -> ShowS

show :: TypeBase dim as -> String

showList :: [TypeBase dim as] -> ShowS

Pretty (ShapeDecl dim) => Pretty (TypeBase dim as)

Defined in Language.Futhark.Pretty

Methods

ppr :: TypeBase dim as -> Doc

pprPrec :: Int -> TypeBase dim as -> Doc

pprList :: [TypeBase dim as] -> Doc

ASTMappable (TypeBase () ())

Defined in Language.Futhark.Traversals

Methods

astMap :: Monad m => ASTMapper m -> TypeBase () () -> m (TypeBase () ())

Substitutable (TypeBase () ())

Defined in Language.Futhark.TypeChecker.Types

Methods

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

Substitutable (TypeBase () Aliasing)

Defined in Language.Futhark.TypeChecker.Types

Methods

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

Substitutable (TypeBase (DimDecl VName) ())

Defined in Language.Futhark.TypeChecker.Types

Methods

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

Substitutable (TypeBase (DimDecl VName) Aliasing)

Defined in Language.Futhark.TypeChecker.Types

Methods

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

data TypeArg dim

Constructors

TypeArgDim dim SrcLoc

TypeArgType (TypeBase dim ()) SrcLoc

Instances

Functor TypeArg

Defined in Language.Futhark.Syntax

Methods

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

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

Foldable TypeArg

Defined in Language.Futhark.Syntax

Methods

fold :: Monoid m => TypeArg m -> 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

toList :: TypeArg a -> [a]

null :: TypeArg a -> Bool

length :: TypeArg a -> Int

elem :: Eq a => a -> TypeArg a -> Bool

maximum :: Ord a => TypeArg a -> a

minimum :: Ord a => TypeArg a -> a

sum :: Num a => TypeArg a -> a

product :: Num a => TypeArg a -> a

Traversable TypeArg

Defined in Language.Futhark.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> TypeArg a -> f (TypeArg b)

sequenceA :: Applicative f => TypeArg (f a) -> f (TypeArg a)

mapM :: Monad m => (a -> m b) -> TypeArg a -> m (TypeArg b)

sequence :: Monad m => TypeArg (m a) -> m (TypeArg a)

Eq dim => Eq (TypeArg dim)

Defined in Language.Futhark.Syntax

Methods

(==) :: TypeArg dim -> TypeArg dim -> Bool

(/=) :: TypeArg dim -> TypeArg dim -> Bool

Show dim => Show (TypeArg dim)

Defined in Language.Futhark.Syntax

Methods

showsPrec :: Int -> TypeArg dim -> ShowS

show :: TypeArg dim -> String

showList :: [TypeArg dim] -> ShowS

Pretty (ShapeDecl dim) => Pretty (TypeArg dim)

Defined in Language.Futhark.Pretty

Methods

ppr :: TypeArg dim -> Doc

pprPrec :: Int -> TypeArg dim -> Doc

pprList :: [TypeArg dim] -> Doc

data TypeExp vn

An unstructured type with type variables and possibly shape declarations - this is what the user types in the source program.

Constructors

TEVar (QualName vn) SrcLoc

TETuple [TypeExp vn] SrcLoc

TERecord [(Name, TypeExp vn)] SrcLoc

TEArray (TypeExp vn) (DimDecl vn) SrcLoc

TEUnique (TypeExp vn) SrcLoc

TEApply (TypeExp vn) (TypeArgExp vn) SrcLoc

TEArrow (Maybe vn) (TypeExp vn) (TypeExp vn) SrcLoc

TEEnum [Name] SrcLoc

Instances

Eq vn => Eq (TypeExp vn)

Defined in Language.Futhark.Syntax

Methods

(==) :: TypeExp vn -> TypeExp vn -> Bool

(/=) :: TypeExp vn -> TypeExp vn -> Bool

Show vn => Show (TypeExp vn)

Defined in Language.Futhark.Syntax

Methods

showsPrec :: Int -> TypeExp vn -> ShowS

show :: TypeExp vn -> String

showList :: [TypeExp vn] -> ShowS

(Eq vn, IsName vn) => Pretty (TypeExp vn)

Defined in Language.Futhark.Pretty

Methods

ppr :: TypeExp vn -> Doc

pprPrec :: Int -> TypeExp vn -> Doc

pprList :: [TypeExp vn] -> Doc

Located (TypeExp vn)

Defined in Language.Futhark.Syntax

Methods

locOf :: TypeExp vn -> Loc

locOfList :: [TypeExp vn] -> Loc

ASTMappable (TypeExp VName)

Defined in Language.Futhark.Traversals

Methods

astMap :: Monad m => ASTMapper m -> TypeExp VName -> m (TypeExp VName)

data TypeArgExp vn

Constructors

TypeArgExpDim (DimDecl vn) SrcLoc

TypeArgExpType (TypeExp vn)

Instances

Eq vn => Eq (TypeArgExp vn)

Defined in Language.Futhark.Syntax

Methods

(==) :: TypeArgExp vn -> TypeArgExp vn -> Bool

(/=) :: TypeArgExp vn -> TypeArgExp vn -> Bool

Show vn => Show (TypeArgExp vn)

Defined in Language.Futhark.Syntax

Methods

showsPrec :: Int -> TypeArgExp vn -> ShowS

show :: TypeArgExp vn -> String

showList :: [TypeArgExp vn] -> ShowS

(Eq vn, IsName vn) => Pretty (TypeArgExp vn)

Defined in Language.Futhark.Pretty

Methods

ppr :: TypeArgExp vn -> Doc

pprPrec :: Int -> TypeArgExp vn -> Doc

pprList :: [TypeArgExp vn] -> Doc

Located (TypeArgExp vn)

Defined in Language.Futhark.Syntax

Methods

locOf :: TypeArgExp vn -> Loc

locOfList :: [TypeArgExp vn] -> Loc

ASTMappable (TypeArgExp VName)

Defined in Language.Futhark.Traversals

Methods

astMap :: Monad m => ASTMapper m -> TypeArgExp VName -> m (TypeArgExp VName)

data RecordArrayElemTypeBase dim

Types that can be elements of tuple-arrays.

Constructors

RecordArrayElem (ArrayElemTypeBase dim)

RecordArrayArrayElem (ArrayElemTypeBase dim) (ShapeDecl dim)

Instances

Functor RecordArrayElemTypeBase

Defined in Language.Futhark.Syntax

Methods

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

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

Foldable RecordArrayElemTypeBase

Defined in Language.Futhark.Syntax

Methods

fold :: Monoid m => RecordArrayElemTypeBase m -> m

foldMap :: Monoid m => (a -> m) -> RecordArrayElemTypeBase a -> m

foldr :: (a -> b -> b) -> b -> RecordArrayElemTypeBase a -> b

foldr' :: (a -> b -> b) -> b -> RecordArrayElemTypeBase a -> b

foldl :: (b -> a -> b) -> b -> RecordArrayElemTypeBase a -> b

foldl' :: (b -> a -> b) -> b -> RecordArrayElemTypeBase a -> b

foldr1 :: (a -> a -> a) -> RecordArrayElemTypeBase a -> a

foldl1 :: (a -> a -> a) -> RecordArrayElemTypeBase a -> a

toList :: RecordArrayElemTypeBase a -> [a]

null :: RecordArrayElemTypeBase a -> Bool

length :: RecordArrayElemTypeBase a -> Int

elem :: Eq a => a -> RecordArrayElemTypeBase a -> Bool

maximum :: Ord a => RecordArrayElemTypeBase a -> a

minimum :: Ord a => RecordArrayElemTypeBase a -> a

sum :: Num a => RecordArrayElemTypeBase a -> a

product :: Num a => RecordArrayElemTypeBase a -> a

Traversable RecordArrayElemTypeBase

Defined in Language.Futhark.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> RecordArrayElemTypeBase a -> f (RecordArrayElemTypeBase b)

sequenceA :: Applicative f => RecordArrayElemTypeBase (f a) -> f (RecordArrayElemTypeBase a)

mapM :: Monad m => (a -> m b) -> RecordArrayElemTypeBase a -> m (RecordArrayElemTypeBase b)

sequence :: Monad m => RecordArrayElemTypeBase (m a) -> m (RecordArrayElemTypeBase a)

Eq dim => Eq (RecordArrayElemTypeBase dim)

Defined in Language.Futhark.Syntax

Methods

(==) :: RecordArrayElemTypeBase dim -> RecordArrayElemTypeBase dim -> Bool

(/=) :: RecordArrayElemTypeBase dim -> RecordArrayElemTypeBase dim -> Bool

Show dim => Show (RecordArrayElemTypeBase dim)

Defined in Language.Futhark.Syntax

Methods

showsPrec :: Int -> RecordArrayElemTypeBase dim -> ShowS

show :: RecordArrayElemTypeBase dim -> String

showList :: [RecordArrayElemTypeBase dim] -> ShowS

Pretty (ShapeDecl dim) => Pretty (RecordArrayElemTypeBase dim)

Defined in Language.Futhark.Pretty

Methods

ppr :: RecordArrayElemTypeBase dim -> Doc

pprPrec :: Int -> RecordArrayElemTypeBase dim -> Doc

pprList :: [RecordArrayElemTypeBase dim] -> Doc

data ArrayElemTypeBase dim

Constructors

ArrayPrimElem PrimType

ArrayPolyElem TypeName [TypeArg dim]

ArrayRecordElem (Map Name (RecordArrayElemTypeBase dim))

ArrayEnumElem [Name]

Instances

Functor ArrayElemTypeBase

Defined in Language.Futhark.Syntax

Methods

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

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

Foldable ArrayElemTypeBase

Defined in Language.Futhark.Syntax

Methods

fold :: Monoid m => ArrayElemTypeBase m -> m

foldMap :: Monoid m => (a -> m) -> ArrayElemTypeBase a -> m

foldr :: (a -> b -> b) -> b -> ArrayElemTypeBase a -> b

foldr' :: (a -> b -> b) -> b -> ArrayElemTypeBase a -> b

foldl :: (b -> a -> b) -> b -> ArrayElemTypeBase a -> b

foldl' :: (b -> a -> b) -> b -> ArrayElemTypeBase a -> b

foldr1 :: (a -> a -> a) -> ArrayElemTypeBase a -> a

foldl1 :: (a -> a -> a) -> ArrayElemTypeBase a -> a

toList :: ArrayElemTypeBase a -> [a]

null :: ArrayElemTypeBase a -> Bool

length :: ArrayElemTypeBase a -> Int

elem :: Eq a => a -> ArrayElemTypeBase a -> Bool

maximum :: Ord a => ArrayElemTypeBase a -> a

minimum :: Ord a => ArrayElemTypeBase a -> a

sum :: Num a => ArrayElemTypeBase a -> a

product :: Num a => ArrayElemTypeBase a -> a

Traversable ArrayElemTypeBase

Defined in Language.Futhark.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> ArrayElemTypeBase a -> f (ArrayElemTypeBase b)

sequenceA :: Applicative f => ArrayElemTypeBase (f a) -> f (ArrayElemTypeBase a)

mapM :: Monad m => (a -> m b) -> ArrayElemTypeBase a -> m (ArrayElemTypeBase b)

sequence :: Monad m => ArrayElemTypeBase (m a) -> m (ArrayElemTypeBase a)

Eq dim => Eq (ArrayElemTypeBase dim)

Defined in Language.Futhark.Syntax

Methods

(==) :: ArrayElemTypeBase dim -> ArrayElemTypeBase dim -> Bool

(/=) :: ArrayElemTypeBase dim -> ArrayElemTypeBase dim -> Bool

Show dim => Show (ArrayElemTypeBase dim)

Defined in Language.Futhark.Syntax

Methods

showsPrec :: Int -> ArrayElemTypeBase dim -> ShowS

show :: ArrayElemTypeBase dim -> String

showList :: [ArrayElemTypeBase dim] -> ShowS

Pretty (ShapeDecl dim) => Pretty (ArrayElemTypeBase dim)

Defined in Language.Futhark.Pretty

Methods

ppr :: ArrayElemTypeBase dim -> Doc

pprPrec :: Int -> ArrayElemTypeBase dim -> Doc

pprList :: [ArrayElemTypeBase dim] -> Doc

type CompType = TypeBase () Aliasing

A type with aliasing information and no shape annotations, used for describing the type of a computation.

type PatternType = TypeBase (DimDecl VName) Aliasing

A type with aliasing information and shape annotations, used for describing the type of a pattern.

type StructType = TypeBase (DimDecl VName) ()

A "structural" type with shape annotations and no aliasing information, used for declarations.

data Diet

Information about which parts of a value/type are consumed.

Constructors

RecordDiet (Map Name Diet)

Consumes these fields in the record.

FuncDiet Diet Diet

A function that consumes its argument(s) like this. The final Diet should always be Observe, as there is no way for a function to consume its return value.

Consume

Consumes this value.

Observe

Only observes value in this position, does not consume.

Instances

Eq Diet

Defined in Language.Futhark.Syntax

Methods

(==) :: Diet -> Diet -> Bool

(/=) :: Diet -> Diet -> Bool

Show Diet

Defined in Language.Futhark.Syntax

Methods

showsPrec :: Int -> Diet -> ShowS

show :: Diet -> String

showList :: [Diet] -> ShowS

data TypeDeclBase f vn

A declaration of the type of something.

Constructors

TypeDecl

Fields

• declaredType :: TypeExp vn

  The type declared by the user.

• expandedType :: f StructType

  The type deduced by the type checker.

Instances

Showable f vn => Show (TypeDeclBase f vn)

Defined in Language.Futhark.Syntax

Methods

showsPrec :: Int -> TypeDeclBase f vn -> ShowS

show :: TypeDeclBase f vn -> String

showList :: [TypeDeclBase f vn] -> ShowS

(Eq vn, IsName vn, Annot f) => Pretty (TypeDeclBase f vn)

Defined in Language.Futhark.Pretty

Methods

ppr :: TypeDeclBase f vn -> Doc

pprPrec :: Int -> TypeDeclBase f vn -> Doc

pprList :: [TypeDeclBase f vn] -> Doc

Located (TypeDeclBase f vn)

Defined in Language.Futhark.Syntax

Methods

locOf :: TypeDeclBase f vn -> Loc

locOfList :: [TypeDeclBase f vn] -> Loc

ASTMappable (TypeDeclBase Info VName)

Defined in Language.Futhark.Traversals

Methods

astMap :: Monad m => ASTMapper m -> TypeDeclBase Info VName -> m (TypeDeclBase Info VName)

Values

data IntValue

An integer value.

Constructors

Int8Value !Int8

Int16Value !Int16

Int32Value !Int32

Int64Value !Int64

Instances

Eq IntValue

Defined in Futhark.Representation.Primitive

Methods

(==) :: IntValue -> IntValue -> Bool

(/=) :: IntValue -> IntValue -> Bool

Ord IntValue

Defined in Futhark.Representation.Primitive

Methods

compare :: IntValue -> IntValue -> Ordering

(<) :: IntValue -> IntValue -> Bool

(<=) :: IntValue -> IntValue -> Bool

(>) :: IntValue -> IntValue -> Bool

(>=) :: IntValue -> IntValue -> Bool

max :: IntValue -> IntValue -> IntValue

min :: IntValue -> IntValue -> IntValue

Show IntValue

Defined in Futhark.Representation.Primitive

Methods

showsPrec :: Int -> IntValue -> ShowS

show :: IntValue -> String

showList :: [IntValue] -> ShowS

ToExp IntValue

Defined in Futhark.CodeGen.Backends.GenericC

Methods

toExp :: IntValue -> SrcLoc -> Exp

Pretty IntValue

Defined in Futhark.Representation.Primitive

Methods

ppr :: IntValue -> Doc

pprPrec :: Int -> IntValue -> Doc

pprList :: [IntValue] -> Doc

IsValue IntValue

Defined in Futhark.Representation.AST.Attributes.Constants

Methods

value :: IntValue -> PrimValue

data FloatValue

A floating-point value.

Constructors

Float32Value !Float

Float64Value !Double

Instances

Eq FloatValue

Defined in Futhark.Representation.Primitive

Methods

(==) :: FloatValue -> FloatValue -> Bool

(/=) :: FloatValue -> FloatValue -> Bool

Ord FloatValue

Defined in Futhark.Representation.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

Defined in Futhark.Representation.Primitive

Methods

showsPrec :: Int -> FloatValue -> ShowS

show :: FloatValue -> String

showList :: [FloatValue] -> ShowS

ToExp FloatValue

Defined in Futhark.CodeGen.Backends.GenericC

Methods

toExp :: FloatValue -> SrcLoc -> Exp

Pretty FloatValue

Defined in Futhark.Representation.Primitive

Methods

ppr :: FloatValue -> Doc

pprPrec :: Int -> FloatValue -> Doc

pprList :: [FloatValue] -> Doc

IsValue FloatValue

Defined in Futhark.Representation.AST.Attributes.Constants

Methods

value :: FloatValue -> PrimValue

data PrimValue

Non-array values.

Constructors

SignedValue !IntValue

UnsignedValue !IntValue

FloatValue !FloatValue

BoolValue !Bool

Instances

Eq PrimValue

Defined in Language.Futhark.Syntax

Methods

(==) :: PrimValue -> PrimValue -> Bool

(/=) :: PrimValue -> PrimValue -> Bool

Ord PrimValue

Defined in Language.Futhark.Syntax

Methods

compare :: PrimValue -> PrimValue -> Ordering

(<) :: PrimValue -> PrimValue -> Bool

(<=) :: PrimValue -> PrimValue -> Bool

(>) :: PrimValue -> PrimValue -> Bool

(>=) :: PrimValue -> PrimValue -> Bool

max :: PrimValue -> PrimValue -> PrimValue

min :: PrimValue -> PrimValue -> PrimValue

Show PrimValue

Defined in Language.Futhark.Syntax

Methods

showsPrec :: Int -> PrimValue -> ShowS

show :: PrimValue -> String

showList :: [PrimValue] -> ShowS

Pretty PrimValue

Defined in Language.Futhark.Pretty

Methods

ppr :: PrimValue -> Doc

pprPrec :: Int -> PrimValue -> Doc

pprList :: [PrimValue] -> Doc

class IsPrimValue v where

Methods

primValue :: v -> PrimValue

Instances

IsPrimValue Bool

Defined in Language.Futhark.Syntax

Methods

primValue :: Bool -> PrimValue

IsPrimValue Double

Defined in Language.Futhark.Syntax

Methods

primValue :: Double -> PrimValue

IsPrimValue Float

Defined in Language.Futhark.Syntax

Methods

primValue :: Float -> PrimValue

IsPrimValue Int

Defined in Language.Futhark.Syntax

Methods

primValue :: Int -> PrimValue

IsPrimValue Int8

Defined in Language.Futhark.Syntax

Methods

primValue :: Int8 -> PrimValue

IsPrimValue Int16

Defined in Language.Futhark.Syntax

Methods

primValue :: Int16 -> PrimValue

IsPrimValue Int32

Defined in Language.Futhark.Syntax

Methods

primValue :: Int32 -> PrimValue

IsPrimValue Int64

Defined in Language.Futhark.Syntax

Methods

primValue :: Int64 -> PrimValue

IsPrimValue Word8

Defined in Language.Futhark.Syntax

Methods

primValue :: Word8 -> PrimValue

IsPrimValue Word16

Defined in Language.Futhark.Syntax

Methods

primValue :: Word16 -> PrimValue

IsPrimValue Word32

Defined in Language.Futhark.Syntax

Methods

primValue :: Word32 -> PrimValue

IsPrimValue Word64

Defined in Language.Futhark.Syntax

Methods

primValue :: Word64 -> PrimValue

data Value

Simple Futhark values. Values are fully evaluated and their type is always unambiguous.

Constructors

PrimValue !PrimValue

ArrayValue !(Array Int Value) (TypeBase () ())

It is assumed that the array is 0-indexed. The type is the full type.

Instances

Eq Value

Defined in Language.Futhark.Syntax

Methods

(==) :: Value -> Value -> Bool

(/=) :: Value -> Value -> Bool

Show Value

Defined in Language.Futhark.Syntax

Methods

showsPrec :: Int -> Value -> ShowS

show :: Value -> String

showList :: [Value] -> ShowS

Pretty Value

Defined in Language.Futhark.Pretty

Methods

ppr :: Value -> Doc

pprPrec :: Int -> Value -> Doc

pprList :: [Value] -> Doc

Abstract syntax tree

data BinOp

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

<| Misc

Instances

Bounded BinOp

Defined in Language.Futhark.Syntax

Methods

minBound :: BinOp

maxBound :: BinOp

Enum BinOp

Defined in Language.Futhark.Syntax

Methods

succ :: BinOp -> BinOp

pred :: BinOp -> BinOp

toEnum :: Int -> BinOp

fromEnum :: BinOp -> Int

enumFrom :: BinOp -> [BinOp]

enumFromThen :: BinOp -> BinOp -> [BinOp]

enumFromTo :: BinOp -> BinOp -> [BinOp]

enumFromThenTo :: BinOp -> BinOp -> BinOp -> [BinOp]

Eq BinOp

Defined in Language.Futhark.Syntax

Methods

(==) :: BinOp -> BinOp -> Bool

(/=) :: BinOp -> BinOp -> Bool

Ord BinOp

Defined in Language.Futhark.Syntax

Methods

compare :: BinOp -> BinOp -> Ordering

(<) :: BinOp -> BinOp -> Bool

(<=) :: BinOp -> BinOp -> Bool

(>) :: BinOp -> BinOp -> Bool

(>=) :: BinOp -> BinOp -> Bool

max :: BinOp -> BinOp -> BinOp

min :: BinOp -> BinOp -> BinOp

Show BinOp

Defined in Language.Futhark.Syntax

Methods

showsPrec :: Int -> BinOp -> ShowS

show :: BinOp -> String

showList :: [BinOp] -> ShowS

Pretty BinOp

Defined in Language.Futhark.Syntax

Methods

ppr :: BinOp -> Doc

pprPrec :: Int -> BinOp -> Doc

pprList :: [BinOp] -> Doc

data IdentBase f vn

An identifier consists of its name and the type of the value bound to the identifier.

Constructors

Ident

Fields

• identName :: vn
• identType :: f CompType
• identSrcLoc :: SrcLoc

Instances

Eq vn => Eq (IdentBase ty vn)

Defined in Language.Futhark.Syntax

Methods

(==) :: IdentBase ty vn -> IdentBase ty vn -> Bool

(/=) :: IdentBase ty vn -> IdentBase ty vn -> Bool

Ord vn => Ord (IdentBase ty vn)

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)

Defined in Language.Futhark.Syntax

Methods

showsPrec :: Int -> IdentBase f vn -> ShowS

show :: IdentBase f vn -> String

showList :: [IdentBase f vn] -> ShowS

IsName vn => Pretty (IdentBase f vn)

Defined in Language.Futhark.Pretty

Methods

ppr :: IdentBase f vn -> Doc

pprPrec :: Int -> IdentBase f vn -> Doc

pprList :: [IdentBase f vn] -> Doc

Located (IdentBase ty vn)

Defined in Language.Futhark.Syntax

Methods

locOf :: IdentBase ty vn -> Loc

locOfList :: [IdentBase ty vn] -> Loc

ASTMappable (IdentBase Info VName)

Defined in Language.Futhark.Traversals

Methods

astMap :: Monad m => ASTMapper m -> IdentBase Info VName -> m (IdentBase Info VName)

data Inclusiveness a

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

Functor Inclusiveness

Defined in Language.Futhark.Syntax

Methods

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

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

Foldable Inclusiveness

Defined in Language.Futhark.Syntax

Methods

fold :: Monoid m => Inclusiveness m -> m

foldMap :: Monoid m => (a -> m) -> Inclusiveness a -> m

foldr :: (a -> b -> b) -> b -> Inclusiveness a -> b

foldr' :: (a -> b -> b) -> b -> Inclusiveness a -> b

foldl :: (b -> a -> b) -> b -> Inclusiveness a -> b

foldl' :: (b -> a -> b) -> b -> Inclusiveness a -> b

foldr1 :: (a -> a -> a) -> Inclusiveness a -> a

foldl1 :: (a -> a -> a) -> Inclusiveness a -> a

toList :: Inclusiveness a -> [a]

null :: Inclusiveness a -> Bool

length :: Inclusiveness a -> Int

elem :: Eq a => a -> Inclusiveness a -> Bool

maximum :: Ord a => Inclusiveness a -> a

minimum :: Ord a => Inclusiveness a -> a

sum :: Num a => Inclusiveness a -> a

product :: Num a => Inclusiveness a -> a

Traversable Inclusiveness

Defined in Language.Futhark.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> Inclusiveness a -> f (Inclusiveness b)

sequenceA :: Applicative f => Inclusiveness (f a) -> f (Inclusiveness a)

mapM :: Monad m => (a -> m b) -> Inclusiveness a -> m (Inclusiveness b)

sequence :: Monad m => Inclusiveness (m a) -> m (Inclusiveness a)

Eq a => Eq (Inclusiveness a)

Defined in Language.Futhark.Syntax

Methods

(==) :: Inclusiveness a -> Inclusiveness a -> Bool

(/=) :: Inclusiveness a -> Inclusiveness a -> Bool

Ord a => Ord (Inclusiveness a)

Defined in Language.Futhark.Syntax

Methods

compare :: Inclusiveness a -> Inclusiveness a -> Ordering

(<) :: Inclusiveness a -> Inclusiveness a -> Bool

(<=) :: Inclusiveness a -> Inclusiveness a -> Bool

(>) :: Inclusiveness a -> Inclusiveness a -> Bool

(>=) :: Inclusiveness a -> Inclusiveness a -> Bool

max :: Inclusiveness a -> Inclusiveness a -> Inclusiveness a

min :: Inclusiveness a -> Inclusiveness a -> Inclusiveness a

Show a => Show (Inclusiveness a)

Defined in Language.Futhark.Syntax

Methods

showsPrec :: Int -> Inclusiveness a -> ShowS

show :: Inclusiveness a -> String

showList :: [Inclusiveness a] -> ShowS

Located a => Located (Inclusiveness a)

Defined in Language.Futhark.Syntax

Methods

locOf :: Inclusiveness a -> Loc

locOfList :: [Inclusiveness a] -> Loc

data DimIndexBase f vn

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

Showable f vn => Show (DimIndexBase f vn)

Defined in Language.Futhark.Syntax

Methods

showsPrec :: Int -> DimIndexBase f vn -> ShowS

show :: DimIndexBase f vn -> String

showList :: [DimIndexBase f vn] -> ShowS

(Eq vn, IsName vn, Annot f) => Pretty (DimIndexBase f vn)

Defined in Language.Futhark.Pretty

Methods

ppr :: DimIndexBase f vn -> Doc

pprPrec :: Int -> DimIndexBase f vn -> Doc

pprList :: [DimIndexBase f vn] -> Doc

ASTMappable (DimIndexBase Info VName)

Defined in Language.Futhark.Traversals

Methods

astMap :: Monad m => ASTMapper m -> DimIndexBase Info VName -> m (DimIndexBase Info VName)

data ExpBase f vn

The Futhark expression language.

In a value of type Exp f vn, annotations are wrapped in the functor f, and all names are of type vn.

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 NoInfo Name, and the type checker will convert these to Exp Info VName, in which type information is always present and all names are unique.

Constructors

Literal PrimValue SrcLoc

IntLit Integer (f (TypeBase () ())) SrcLoc

A polymorphic integral literal.

FloatLit Double (f (TypeBase () ())) SrcLoc

A polymorphic decimal literal.

Parens (ExpBase f vn) SrcLoc

A parenthesized expression.

QualParens (QualName vn) (ExpBase f vn) SrcLoc

TupLit [ExpBase f vn] SrcLoc

Tuple literals, e.g., {1+3, {x, y+z}}.

RecordLit [FieldBase f vn] SrcLoc

Record literals, e.g. {x=2,y=3,z}.

ArrayLit [ExpBase f vn] (f CompType) SrcLoc

Array literals, e.g., [ [1+x, 3], [2, 1+4] ]. Second arg is the row type of the rows of the array.

Range (ExpBase f vn) (Maybe (ExpBase f vn)) (Inclusiveness (ExpBase f vn)) (f CompType) SrcLoc

Var (QualName vn) (f PatternType) SrcLoc

Ascript (ExpBase f vn) (TypeDeclBase f vn) SrcLoc

Type ascription: e : t.

LetPat [TypeParamBase vn] (PatternBase f vn) (ExpBase f vn) (ExpBase f vn) SrcLoc

LetFun vn ([TypeParamBase vn], [PatternBase f vn], Maybe (TypeExp vn), f StructType, ExpBase f vn) (ExpBase f vn) SrcLoc

If (ExpBase f vn) (ExpBase f vn) (ExpBase f vn) (f CompType) SrcLoc

Apply (ExpBase f vn) (ExpBase f vn) (f Diet) (f PatternType) SrcLoc

Negate (ExpBase f vn) SrcLoc

Numeric negation (ugly special case; Haskell did it first).

Lambda [TypeParamBase vn] [PatternBase f vn] (ExpBase f vn) (Maybe (TypeDeclBase f vn)) (f (Aliasing, StructType)) SrcLoc

OpSection (QualName vn) (f PatternType) SrcLoc

+; first two types are operands, third is result.

OpSectionLeft (QualName vn) (f PatternType) (ExpBase f vn) (f StructType, f StructType) (f PatternType) SrcLoc

2+; first type is operand, second is result.

OpSectionRight (QualName vn) (f PatternType) (ExpBase f vn) (f StructType, f StructType) (f PatternType) SrcLoc

+2; first type is operand, second is result.

ProjectSection [Name] (f PatternType) SrcLoc

Field projection as a section: (.x.y.z).

IndexSection [DimIndexBase f vn] (f PatternType) SrcLoc

Array indexing as a section: (.[i,j]).

DoLoop [TypeParamBase vn] (PatternBase f vn) (ExpBase f vn) (LoopFormBase f vn) (ExpBase f vn) SrcLoc

BinOp (QualName vn) (f PatternType) (ExpBase f vn, f StructType) (ExpBase f vn, f StructType) (f PatternType) SrcLoc

Project Name (ExpBase f vn) (f CompType) SrcLoc

LetWith (IdentBase f vn) (IdentBase f vn) [DimIndexBase f vn] (ExpBase f vn) (ExpBase f vn) SrcLoc

Index (ExpBase f vn) [DimIndexBase f vn] (f CompType) SrcLoc

Update (ExpBase f vn) [DimIndexBase f vn] (ExpBase f vn) SrcLoc

RecordUpdate (ExpBase f vn) [Name] (ExpBase f vn) (f PatternType) SrcLoc

Map (ExpBase f vn) (ExpBase f vn) (f CompType) SrcLoc

map (+1) [1, 2, ..., n] = [2, 3, ..., n+1].

Reduce Commutativity (ExpBase f vn) (ExpBase f vn) (ExpBase f vn) SrcLoc

reduce (+) 0 ([1,2,...,n]) = (0+1+2+...+n).

GenReduce (ExpBase f vn) (ExpBase f vn) (ExpBase f vn) (ExpBase f vn) (ExpBase f vn) SrcLoc

gen_reduce 1,1,1 0 [1,1,1] [1,1,1] = [4,1,1]

Scan (ExpBase f vn) (ExpBase f vn) (ExpBase f vn) SrcLoc

scan (+) 0 ([ 1, 2, 3 ]) = [ 1, 3, 6 ].

Filter (ExpBase f vn) (ExpBase f vn) SrcLoc

Return those elements of the array that satisfy the predicate.

Partition Int (ExpBase f vn) (ExpBase f vn) SrcLoc

partition k f a, where f returns an integer, returns a tuple (a', is) that describes a partitioning of a into n equivalence classes. Here, a' is a re-ordering of a, and is is an array of k offsets into a'.

Stream (StreamForm f vn) (ExpBase f vn) (ExpBase f vn) SrcLoc

Streaming: intuitively, this gives a size-parameterized composition for SOACs that cannot be fused, e.g., due to scan. For example, assuming A : [int], f : int->int, g : real->real, the code: let x = map(f,A) in let y = scan(op+,0,x) in map(g,y) can be re-written (streamed) in the source-Futhark language as: let (acc, z) = stream (fn (int,[real]) (real chunk, real acc, [int] a) => let x = map (f, A ) let y0= scan(op +, 0, x ) let y = map (op +(acc), y0) ( acc+y0[chunk-1], map(g, y) ) ) 0 A where (i) chunk is a symbolic int denoting the chunk size, (ii) 0 is the initial value of the accumulator, which allows the streaming of scan. Finally, the unnamed function (fn...) implements the a fold that: computes the accumulator of scan, as defined inside its body, AND implicitly concatenates each of the result arrays across the iteration space. In essence, sequential codegen can choose chunk = 1 and thus eliminate the SOACs on the outermost level, while parallel codegen may choose the maximal chunk size that still satisfies the memory requirements of the device.

Zip Int (ExpBase f vn) [ExpBase f vn] (f CompType) SrcLoc

Conventional zip taking nonzero arrays as arguments. All arrays must have the exact same length.

Unzip (ExpBase f vn) [f CompType] SrcLoc

Unzip that can unzip to tuples of arbitrary size. The types are the elements of the tuple.

Unsafe (ExpBase f vn) SrcLoc

Explore the Danger Zone and elide safety checks on array operations and other assertions during execution of this expression. Make really sure the code is correct.

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.

VConstr0 Name (f CompType) SrcLoc

An enum element, e.g., #foo.

Match (ExpBase f vn) [CaseBase f vn] (f CompType) SrcLoc

A match expression.

Instances

Showable f vn => Show (ExpBase f vn)

Defined in Language.Futhark.Syntax

Methods

showsPrec :: Int -> ExpBase f vn -> ShowS

show :: ExpBase f vn -> String

showList :: [ExpBase f vn] -> ShowS

(Eq vn, IsName vn, Annot f) => Pretty (ExpBase f vn)

Defined in Language.Futhark.Pretty

Methods

ppr :: ExpBase f vn -> Doc

pprPrec :: Int -> ExpBase f vn -> Doc

pprList :: [ExpBase f vn] -> Doc

Located (ExpBase f vn)

Defined in Language.Futhark.Syntax

Methods

locOf :: ExpBase f vn -> Loc

locOfList :: [ExpBase f vn] -> Loc

ASTMappable (ExpBase Info VName)

Defined in Language.Futhark.Traversals

Methods

astMap :: Monad m => ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)

data FieldBase f vn

An entry in a record literal.

Constructors

RecordFieldExplicit Name (ExpBase f vn) SrcLoc

RecordFieldImplicit vn (f CompType) SrcLoc

Instances

Showable f vn => Show (FieldBase f vn)

Defined in Language.Futhark.Syntax

Methods

showsPrec :: Int -> FieldBase f vn -> ShowS

show :: FieldBase f vn -> String

showList :: [FieldBase f vn] -> ShowS

(Eq vn, IsName vn, Annot f) => Pretty (FieldBase f vn)

Defined in Language.Futhark.Pretty

Methods

ppr :: FieldBase f vn -> Doc

pprPrec :: Int -> FieldBase f vn -> Doc

pprList :: [FieldBase f vn] -> Doc

Located (FieldBase f vn)

Defined in Language.Futhark.Syntax

Methods

locOf :: FieldBase f vn -> Loc

locOfList :: [FieldBase f vn] -> Loc

ASTMappable (FieldBase Info VName)

Defined in Language.Futhark.Traversals

Methods

astMap :: Monad m => ASTMapper m -> FieldBase Info VName -> m (FieldBase Info VName)

data CaseBase f vn

A case in a match expression.

Constructors

CasePat (PatternBase f vn) (ExpBase f vn) SrcLoc

Instances

Showable f vn => Show (CaseBase f vn)

Defined in Language.Futhark.Syntax

Methods

showsPrec :: Int -> CaseBase f vn -> ShowS

show :: CaseBase f vn -> String

showList :: [CaseBase f vn] -> ShowS

(Eq vn, IsName vn, Annot f) => Pretty (CaseBase f vn)

Defined in Language.Futhark.Pretty

Methods

ppr :: CaseBase f vn -> Doc

pprPrec :: Int -> CaseBase f vn -> Doc

pprList :: [CaseBase f vn] -> Doc

Located (CaseBase f vn)

Defined in Language.Futhark.Syntax

Methods

locOf :: CaseBase f vn -> Loc

locOfList :: [CaseBase f vn] -> Loc

ASTMappable (CaseBase Info VName)

Defined in Language.Futhark.Traversals

Methods

astMap :: Monad m => ASTMapper m -> CaseBase Info VName -> m (CaseBase Info VName)

data LoopFormBase f vn

Whether the loop is a for-loop or a while-loop.

Constructors

For (IdentBase f vn) (ExpBase f vn)

ForIn (PatternBase f vn) (ExpBase f vn)

While (ExpBase f vn)

Instances

Showable f vn => Show (LoopFormBase f vn)

Defined in Language.Futhark.Syntax

Methods

showsPrec :: Int -> LoopFormBase f vn -> ShowS

show :: LoopFormBase f vn -> String

showList :: [LoopFormBase f vn] -> ShowS

(Eq vn, IsName vn, Annot f) => Pretty (LoopFormBase f vn)

Defined in Language.Futhark.Pretty

Methods

ppr :: LoopFormBase f vn -> Doc

pprPrec :: Int -> LoopFormBase f vn -> Doc

pprList :: [LoopFormBase f vn] -> Doc

ASTMappable (LoopFormBase Info VName)

Defined in Language.Futhark.Traversals

Methods

astMap :: Monad m => ASTMapper m -> LoopFormBase Info VName -> m (LoopFormBase Info VName)

data PatternBase f vn

A pattern as used most places where variables are bound (function parameters, let expressions, etc).

Constructors

TuplePattern [PatternBase f vn] SrcLoc

RecordPattern [(Name, PatternBase f vn)] SrcLoc

PatternParens (PatternBase f vn) SrcLoc

Id vn (f PatternType) SrcLoc

Wildcard (f PatternType) SrcLoc

PatternAscription (PatternBase f vn) (TypeDeclBase f vn) SrcLoc

PatternLit (ExpBase f vn) (f PatternType) SrcLoc

Instances

Showable f vn => Show (PatternBase f vn)

Defined in Language.Futhark.Syntax

Methods

showsPrec :: Int -> PatternBase f vn -> ShowS

show :: PatternBase f vn -> String

showList :: [PatternBase f vn] -> ShowS

(Eq vn, IsName vn, Annot f) => Pretty (PatternBase f vn)

Defined in Language.Futhark.Pretty

Methods

ppr :: PatternBase f vn -> Doc

pprPrec :: Int -> PatternBase f vn -> Doc

pprList :: [PatternBase f vn] -> Doc

Located (PatternBase f vn)

Defined in Language.Futhark.Syntax

Methods

locOf :: PatternBase f vn -> Loc

locOfList :: [PatternBase f vn] -> Loc

ASTMappable (PatternBase Info VName)

Defined in Language.Futhark.Traversals

Methods

astMap :: Monad m => ASTMapper m -> PatternBase Info VName -> m (PatternBase Info VName)

data StreamForm f vn

Constructors

MapLike StreamOrd

RedLike StreamOrd Commutativity (ExpBase f vn)

Instances

Showable f vn => Show (StreamForm f vn)

Defined in Language.Futhark.Syntax

Methods

showsPrec :: Int -> StreamForm f vn -> ShowS

show :: StreamForm f vn -> String

showList :: [StreamForm f vn] -> ShowS

Module language

data SpecBase f vn

Constructors

ValSpec

Fields

• 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

Abstract type.

ModSpec vn (SigExpBase f vn) (Maybe DocComment) SrcLoc

IncludeSpec (SigExpBase f vn) SrcLoc

Instances

Showable f vn => Show (SpecBase f vn)

Defined in Language.Futhark.Syntax

Methods

showsPrec :: Int -> SpecBase f vn -> ShowS

show :: SpecBase f vn -> String

showList :: [SpecBase f vn] -> ShowS

(Eq vn, IsName vn, Annot f) => Pretty (SpecBase f vn)

Defined in Language.Futhark.Pretty

Methods

ppr :: SpecBase f vn -> Doc

pprPrec :: Int -> SpecBase f vn -> Doc

pprList :: [SpecBase f vn] -> Doc

Located (SpecBase f vn)

Defined in Language.Futhark.Syntax

Methods

locOf :: SpecBase f vn -> Loc

locOfList :: [SpecBase f vn] -> Loc

data SigExpBase f vn

Constructors

SigVar (QualName vn) 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)

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)

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)

Defined in Language.Futhark.Syntax

Methods

locOf :: SigExpBase f vn -> Loc

locOfList :: [SigExpBase f vn] -> Loc

data TypeRefBase f vn

A type refinement.

Constructors

TypeRef (QualName vn) [TypeParamBase vn] (TypeDeclBase f vn) SrcLoc

Instances

Showable f vn => Show (TypeRefBase f vn)

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)

Defined in Language.Futhark.Syntax

Methods

locOf :: TypeRefBase f vn -> Loc

locOfList :: [TypeRefBase f vn] -> Loc

data SigBindBase f vn

Constructors

SigBind

Fields

• sigName :: vn
• sigExp :: SigExpBase f vn
• sigDoc :: Maybe DocComment
• sigLoc :: SrcLoc

Instances

Showable f vn => Show (SigBindBase f vn)

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)

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)

Defined in Language.Futhark.Syntax

Methods

locOf :: SigBindBase f vn -> Loc

locOfList :: [SigBindBase f vn] -> Loc

data ModExpBase f vn

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.

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)

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)

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)

Defined in Language.Futhark.Syntax

Methods

locOf :: ModExpBase f vn -> Loc

locOfList :: [ModExpBase f vn] -> Loc

data ModBindBase f vn

Constructors

ModBind

Fields

• modName :: vn
• modParams :: [ModParamBase f vn]
• modSignature :: Maybe (SigExpBase f vn, f (Map VName VName))
• modExp :: ModExpBase f vn
• modDoc :: Maybe DocComment
• modLocation :: SrcLoc

Instances

Showable f vn => Show (ModBindBase f vn)

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)

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)

Defined in Language.Futhark.Syntax

Methods

locOf :: ModBindBase f vn -> Loc

locOfList :: [ModBindBase f vn] -> Loc

data ModParamBase f vn

Constructors

ModParam

Fields

• modParamName :: vn
• modParamType :: SigExpBase f vn
• modParamAbs :: f [VName]
• modParamLocation :: SrcLoc

Instances

Showable f vn => Show (ModParamBase f vn)

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)

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)

Defined in Language.Futhark.Syntax

Methods

locOf :: ModParamBase f vn -> Loc

locOfList :: [ModParamBase f vn] -> Loc

Definitions

data DocComment

Documentation strings, including source location.

Constructors

DocComment String SrcLoc

Instances

Show DocComment

Defined in Language.Futhark.Syntax

Methods

showsPrec :: Int -> DocComment -> ShowS

show :: DocComment -> String

showList :: [DocComment] -> ShowS

Located DocComment

Defined in Language.Futhark.Syntax

Methods

locOf :: DocComment -> Loc

locOfList :: [DocComment] -> Loc

data ValBindBase f vn

Function Declarations

Constructors

ValBind

Fields

• valBindEntryPoint :: Bool

  True if this function is an entry point.

• valBindName :: vn
• valBindRetDecl :: Maybe (TypeExp vn)
• valBindRetType :: f StructType
• valBindTypeParams :: [TypeParamBase vn]
• valBindParams :: [PatternBase f vn]
• valBindBody :: ExpBase f vn
• valBindDoc :: Maybe DocComment
• valBindLocation :: SrcLoc

Instances

Showable f vn => Show (ValBindBase f vn)

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)

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)

Defined in Language.Futhark.Syntax

Methods

locOf :: ValBindBase f vn -> Loc

locOfList :: [ValBindBase f vn] -> Loc

data Liftedness

The liftedness of a type parameter. By the Ord instance, Unlifted is less than Lifted.

Constructors

Unlifted

May only be instantiated with a zero-order type.

Lifted

May be instantiated to a functional type.

Instances

Eq Liftedness

Defined in Language.Futhark.Syntax

Methods

(==) :: Liftedness -> Liftedness -> Bool

(/=) :: Liftedness -> Liftedness -> Bool

Ord Liftedness

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

Defined in Language.Futhark.Syntax

Methods

showsPrec :: Int -> Liftedness -> ShowS

show :: Liftedness -> String

showList :: [Liftedness] -> ShowS

data TypeBindBase f vn

Type Declarations

Constructors

TypeBind

Fields

• typeAlias :: vn
• typeParams :: [TypeParamBase vn]
• typeExp :: TypeDeclBase f vn
• typeDoc :: Maybe DocComment
• typeBindLocation :: SrcLoc

Instances

Showable f vn => Show (TypeBindBase f vn)

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)

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)

Defined in Language.Futhark.Syntax

Methods

locOf :: TypeBindBase f vn -> Loc

locOfList :: [TypeBindBase f vn] -> Loc

data TypeParamBase vn

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

Functor TypeParamBase

Defined in Language.Futhark.Syntax

Methods

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

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

Foldable TypeParamBase

Defined in Language.Futhark.Syntax

Methods

fold :: Monoid m => TypeParamBase m -> m

foldMap :: Monoid m => (a -> m) -> TypeParamBase a -> m

foldr :: (a -> b -> b) -> b -> TypeParamBase a -> b

foldr' :: (a -> b -> b) -> b -> TypeParamBase a -> b

foldl :: (b -> a -> b) -> b -> TypeParamBase a -> b

foldl' :: (b -> a -> b) -> b -> TypeParamBase a -> b

foldr1 :: (a -> a -> a) -> TypeParamBase a -> a

foldl1 :: (a -> a -> a) -> TypeParamBase a -> a

toList :: TypeParamBase a -> [a]

null :: TypeParamBase a -> Bool

length :: TypeParamBase a -> Int

elem :: Eq a => a -> TypeParamBase a -> Bool

maximum :: Ord a => TypeParamBase a -> a

minimum :: Ord a => TypeParamBase a -> a

sum :: Num a => TypeParamBase a -> a

product :: Num a => TypeParamBase a -> a

Traversable TypeParamBase

Defined in Language.Futhark.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> TypeParamBase a -> f (TypeParamBase b)

sequenceA :: Applicative f => TypeParamBase (f a) -> f (TypeParamBase a)

mapM :: Monad m => (a -> m b) -> TypeParamBase a -> m (TypeParamBase b)

sequence :: Monad m => TypeParamBase (m a) -> m (TypeParamBase a)

Eq vn => Eq (TypeParamBase vn)

Defined in Language.Futhark.Syntax

Methods

(==) :: TypeParamBase vn -> TypeParamBase vn -> Bool

(/=) :: TypeParamBase vn -> TypeParamBase vn -> Bool

Show vn => Show (TypeParamBase vn)

Defined in Language.Futhark.Syntax

Methods

showsPrec :: Int -> TypeParamBase vn -> ShowS

show :: TypeParamBase vn -> String

showList :: [TypeParamBase vn] -> ShowS

(Eq vn, IsName vn) => Pretty (TypeParamBase vn)

Defined in Language.Futhark.Pretty

Methods

ppr :: TypeParamBase vn -> Doc

pprPrec :: Int -> TypeParamBase vn -> Doc

pprList :: [TypeParamBase vn] -> Doc

Located (TypeParamBase vn)

Defined in Language.Futhark.Syntax

Methods

locOf :: TypeParamBase vn -> Loc

locOfList :: [TypeParamBase vn] -> Loc

ASTMappable (TypeParamBase VName)

Defined in Language.Futhark.Traversals

Methods

astMap :: Monad m => ASTMapper m -> TypeParamBase VName -> m (TypeParamBase VName)

typeParamName :: TypeParamBase vn -> vn

data ProgBase f vn

The program described by a single Futhark file. May depend on other files.

Constructors

Prog

Fields

• progDoc :: Maybe DocComment
• progDecs :: [DecBase f vn]

Instances

Showable f vn => Show (ProgBase f vn)

Defined in Language.Futhark.Syntax

Methods

showsPrec :: Int -> ProgBase f vn -> ShowS

show :: ProgBase f vn -> String

showList :: [ProgBase f vn] -> ShowS

(Eq vn, IsName vn, Annot f) => Pretty (ProgBase f vn)

Defined in Language.Futhark.Pretty

Methods

ppr :: ProgBase f vn -> Doc

pprPrec :: Int -> ProgBase f vn -> Doc

pprList :: [ProgBase f vn] -> Doc

data DecBase f vn

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

Instances

Showable f vn => Show (DecBase f vn)

Defined in Language.Futhark.Syntax

Methods

showsPrec :: Int -> DecBase f vn -> ShowS

show :: DecBase f vn -> String

showList :: [DecBase f vn] -> ShowS

(Eq vn, IsName vn, Annot f) => Pretty (DecBase f vn)

Defined in Language.Futhark.Pretty

Methods

ppr :: DecBase f vn -> Doc

pprPrec :: Int -> DecBase f vn -> Doc

pprList :: [DecBase f vn] -> Doc

Located (DecBase f vn)

Defined in Language.Futhark.Syntax

Methods

locOf :: DecBase f vn -> Loc

locOfList :: [DecBase f vn] -> Loc

Miscellaneous

data NoInfo a

No information functor. Usually used for placeholder type- or aliasing information.

Constructors

NoInfo

Instances

Functor NoInfo

Defined in Language.Futhark.Syntax

Methods

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

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

Foldable NoInfo

Defined in Language.Futhark.Syntax

Methods

fold :: Monoid m => NoInfo m -> m

foldMap :: Monoid m => (a -> m) -> NoInfo a -> m

foldr :: (a -> b -> b) -> b -> NoInfo a -> b

foldr' :: (a -> b -> b) -> b -> NoInfo a -> b

foldl :: (b -> a -> b) -> b -> NoInfo a -> b

foldl' :: (b -> a -> b) -> b -> NoInfo a -> b

foldr1 :: (a -> a -> a) -> NoInfo a -> a

foldl1 :: (a -> a -> a) -> NoInfo a -> a

toList :: NoInfo a -> [a]

null :: NoInfo a -> Bool

length :: NoInfo a -> Int

elem :: Eq a => a -> NoInfo a -> Bool

maximum :: Ord a => NoInfo a -> a

minimum :: Ord a => NoInfo a -> a

sum :: Num a => NoInfo a -> a

product :: Num a => NoInfo a -> a

Traversable NoInfo

Defined in Language.Futhark.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> NoInfo a -> f (NoInfo b)

sequenceA :: Applicative f => NoInfo (f a) -> f (NoInfo a)

mapM :: Monad m => (a -> m b) -> NoInfo a -> m (NoInfo b)

sequence :: Monad m => NoInfo (m a) -> m (NoInfo a)

Annot NoInfo

Defined in Language.Futhark.Pretty

Methods

unAnnot :: NoInfo a -> Maybe a

Eq (NoInfo a)

Defined in Language.Futhark.Syntax

Methods

(==) :: NoInfo a -> NoInfo a -> Bool

(/=) :: NoInfo a -> NoInfo a -> Bool

Ord (NoInfo a)

Defined in Language.Futhark.Syntax

Methods

compare :: NoInfo a -> NoInfo a -> Ordering

(<) :: NoInfo a -> NoInfo a -> Bool

(<=) :: NoInfo a -> NoInfo a -> Bool

(>) :: NoInfo a -> NoInfo a -> Bool

(>=) :: NoInfo a -> NoInfo a -> Bool

max :: NoInfo a -> NoInfo a -> NoInfo a

min :: NoInfo a -> NoInfo a -> NoInfo a

Show (NoInfo a)

Defined in Language.Futhark.Syntax

Methods

showsPrec :: Int -> NoInfo a -> ShowS

show :: NoInfo a -> String

showList :: [NoInfo a] -> ShowS

newtype Info a

Some information. The dual to NoInfo

Constructors

Info

Fields

• unInfo :: a

Instances

Functor Info

Defined in Language.Futhark.Syntax

Methods

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

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

Foldable Info

Defined in Language.Futhark.Syntax

Methods

fold :: Monoid m => Info m -> m

foldMap :: Monoid m => (a -> m) -> Info a -> m

foldr :: (a -> b -> b) -> b -> Info a -> b

foldr' :: (a -> b -> b) -> b -> Info a -> b

foldl :: (b -> a -> b) -> b -> Info a -> b

foldl' :: (b -> a -> b) -> b -> Info a -> b

foldr1 :: (a -> a -> a) -> Info a -> a

foldl1 :: (a -> a -> a) -> Info a -> a

toList :: Info a -> [a]

null :: Info a -> Bool

length :: Info a -> Int

elem :: Eq a => a -> Info a -> Bool

maximum :: Ord a => Info a -> a

minimum :: Ord a => Info a -> a

sum :: Num a => Info a -> a

product :: Num a => Info a -> a

Traversable Info

Defined in Language.Futhark.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> Info a -> f (Info b)

sequenceA :: Applicative f => Info (f a) -> f (Info a)

mapM :: Monad m => (a -> m b) -> Info a -> m (Info b)

sequence :: Monad m => Info (m a) -> m (Info a)

Annot Info

Defined in Language.Futhark.Pretty

Methods

unAnnot :: Info a -> Maybe a

Eq a => Eq (Info a)

Defined in Language.Futhark.Syntax

Methods

(==) :: Info a -> Info a -> Bool

(/=) :: Info a -> Info a -> Bool

Ord a => Ord (Info a)

Defined in Language.Futhark.Syntax

Methods

compare :: Info a -> Info a -> Ordering

(<) :: Info a -> Info a -> Bool

(<=) :: Info a -> Info a -> Bool

(>) :: Info a -> Info a -> Bool

(>=) :: Info a -> Info a -> Bool

max :: Info a -> Info a -> Info a

min :: Info a -> Info a -> Info a

Show a => Show (Info a)

Defined in Language.Futhark.Syntax

Methods

showsPrec :: Int -> Info a -> ShowS

show :: Info a -> String

showList :: [Info a] -> ShowS

ASTMappable a => ASTMappable (Info a)

Defined in Language.Futhark.Traversals

Methods

astMap :: Monad m => ASTMapper m -> Info a -> m (Info a)

ASTMappable (PatternBase Info VName)

Defined in Language.Futhark.Traversals

Methods

astMap :: Monad m => ASTMapper m -> PatternBase Info VName -> m (PatternBase Info VName)

ASTMappable (LoopFormBase Info VName)

Defined in Language.Futhark.Traversals

Methods

astMap :: Monad m => ASTMapper m -> LoopFormBase Info VName -> m (LoopFormBase Info VName)

ASTMappable (CaseBase Info VName)

Defined in Language.Futhark.Traversals

Methods

astMap :: Monad m => ASTMapper m -> CaseBase Info VName -> m (CaseBase Info VName)

ASTMappable (FieldBase Info VName)

Defined in Language.Futhark.Traversals

Methods

astMap :: Monad m => ASTMapper m -> FieldBase Info VName -> m (FieldBase Info VName)

ASTMappable (ExpBase Info VName)

Defined in Language.Futhark.Traversals

Methods

astMap :: Monad m => ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)

ASTMappable (DimIndexBase Info VName)

Defined in Language.Futhark.Traversals

Methods

astMap :: Monad m => ASTMapper m -> DimIndexBase Info VName -> m (DimIndexBase Info VName)

ASTMappable (IdentBase Info VName)

Defined in Language.Futhark.Traversals

Methods

astMap :: Monad m => ASTMapper m -> IdentBase Info VName -> m (IdentBase Info VName)

ASTMappable (TypeDeclBase Info VName)

Defined in Language.Futhark.Traversals

Methods

astMap :: Monad m => ASTMapper m -> TypeDeclBase Info VName -> m (TypeDeclBase Info VName)

data Alias

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.

Constructors

AliasBound

Fields

• aliasVar :: VName

AliasFree

Fields

• aliasVar :: VName

Instances

Eq Alias

Defined in Language.Futhark.Syntax

Methods

(==) :: Alias -> Alias -> Bool

(/=) :: Alias -> Alias -> Bool

Ord Alias

Defined in Language.Futhark.Syntax

Methods

compare :: Alias -> Alias -> Ordering

(<) :: Alias -> Alias -> Bool

(<=) :: Alias -> Alias -> Bool

(>) :: Alias -> Alias -> Bool

(>=) :: Alias -> Alias -> Bool

max :: Alias -> Alias -> Alias

min :: Alias -> Alias -> Alias

Show Alias

Defined in Language.Futhark.Syntax

Methods

showsPrec :: Int -> Alias -> ShowS

show :: Alias -> String

showList :: [Alias] -> ShowS

ASTMappable PatternType

Defined in Language.Futhark.Traversals

Methods

astMap :: Monad m => ASTMapper m -> PatternType -> m PatternType

ASTMappable CompType

Defined in Language.Futhark.Traversals

Methods

astMap :: Monad m => ASTMapper m -> CompType -> m CompType

ASTMappable Aliasing

Defined in Language.Futhark.Traversals

Methods

astMap :: Monad m => ASTMapper m -> Aliasing -> m Aliasing

ASTMappable Alias

Defined in Language.Futhark.Traversals

Methods

astMap :: Monad m => ASTMapper m -> Alias -> m Alias

Substitutable (TypeBase () Aliasing)

Defined in Language.Futhark.TypeChecker.Types

Methods

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

Substitutable (TypeBase (DimDecl VName) Aliasing)

Defined in Language.Futhark.TypeChecker.Types

Methods

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

type Aliasing = Set Alias

Aliasing for a type, which is a set of the variables that are aliased.

data QualName vn

A name qualified with a breadcrumb of module accesses.

Constructors

QualName

Fields

• qualQuals :: ![vn]
• qualLeaf :: !vn

Instances

Functor QualName

Defined in Language.Futhark.Syntax

Methods

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

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

Foldable QualName

Defined in Language.Futhark.Syntax

Methods

fold :: Monoid m => QualName m -> m

foldMap :: Monoid m => (a -> m) -> QualName a -> m

foldr :: (a -> b -> b) -> b -> QualName a -> b

foldr' :: (a -> b -> b) -> b -> QualName a -> b

foldl :: (b -> a -> b) -> b -> QualName a -> b

foldl' :: (b -> a -> b) -> b -> QualName a -> b

foldr1 :: (a -> a -> a) -> QualName a -> a

foldl1 :: (a -> a -> a) -> QualName a -> a

toList :: QualName a -> [a]

null :: QualName a -> Bool

length :: QualName a -> Int

elem :: Eq a => a -> QualName a -> Bool

maximum :: Ord a => QualName a -> a

minimum :: Ord a => QualName a -> a

sum :: Num a => QualName a -> a

product :: Num a => QualName a -> a

Traversable QualName

Defined in Language.Futhark.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> QualName a -> f (QualName b)

sequenceA :: Applicative f => QualName (f a) -> f (QualName a)

mapM :: Monad m => (a -> m b) -> QualName a -> m (QualName b)

sequence :: Monad m => QualName (m a) -> m (QualName a)

Eq vn => Eq (QualName vn)

Defined in Language.Futhark.Syntax

Methods

(==) :: QualName vn -> QualName vn -> Bool

(/=) :: QualName vn -> QualName vn -> Bool

Ord vn => Ord (QualName vn)

Defined in Language.Futhark.Syntax

Methods

compare :: QualName vn -> QualName vn -> Ordering

(<) :: QualName vn -> QualName vn -> Bool

(<=) :: QualName vn -> QualName vn -> Bool

(>) :: QualName vn -> QualName vn -> Bool

(>=) :: QualName vn -> QualName vn -> Bool

max :: QualName vn -> QualName vn -> QualName vn

min :: QualName vn -> QualName vn -> QualName vn

Show vn => Show (QualName vn)

Defined in Language.Futhark.Syntax

Methods

showsPrec :: Int -> QualName vn -> ShowS

show :: QualName vn -> String

showList :: [QualName vn] -> ShowS

IsName vn => Pretty (QualName vn)

Defined in Language.Futhark.Pretty

Methods

ppr :: QualName vn -> Doc

pprPrec :: Int -> QualName vn -> Doc

pprList :: [QualName vn] -> Doc