Feldspar.Frontend

Pure expressions

General constructs

share

Arguments

:: (Syntax a, Syntax b)

=> a

Value to share

-> (a -> b)

Body in which to share the value

-> b

Force evaluation of a value and share the result. Note that due to common sub-expression elimination, this function is rarely needed in practice.

shareTag

Arguments

:: (Syntax a, Syntax b)

=> String

A tag (that may be empty). May be used by a back end to generate a sensible variable name.

-> a

Value to share

-> (a -> b)

Body in which to share the value

-> b

Explicit tagged sharing

forLoop :: Syntax st => Data Length -> st -> (Data Index -> st -> st) -> st

For loop

cond

Arguments

:: Syntax a

=> Data Bool

Condition

-> a

True branch

-> a

False branch

-> a

Conditional expression

(?) infixl 1

Arguments

:: Syntax a

=> Data Bool

Condition

-> a

True branch

-> a

False branch

-> a

Condition operator; use as follows:

cond1 ? a $
cond2 ? b $
cond3 ? c $
        default

switch

Arguments

:: (Syntax a, Syntax b, PrimType (Internal a))

=> b

Default result

-> [(a, b)]

Cases (match, result)

-> a

Scrutinee

-> b

Result

Multi-way conditional expression

The first association (a,b) in the list of cases for which a is equal to the scrutinee is selected, and the associated b is returned as the result. If no case matches, the default value is returned.

Literals

value :: Syntax a => Internal a -> a

Literal

false :: Data Bool

true :: Data Bool

example :: Syntax a => a

Example value

example can be used similarly to undefined in normal Haskell, i.e. to create an expression whose value is irrelevant.

Note that it is generally not possible to use undefined in Feldspar expressions, as this will crash the compiler.

Primitive functions

π :: (Floating a, PrimType a) => Data a

Alias for pi

quot :: (Integral a, PrimType a) => Data a -> Data a -> Data a

Integer division truncated toward zero

rem :: (Integral a, PrimType a) => Data a -> Data a -> Data a

Integer remainder satisfying

(x `quot` y)*y + (x `rem` y) == x

quotRem :: (Integral a, PrimType a) => Data a -> Data a -> (Data a, Data a)

Simultaneous quot and rem

div :: (Integral a, PrimType a) => Data a -> Data a -> Data a

Integer division truncated toward negative infinity

mod :: (Integral a, PrimType a) => Data a -> Data a -> Data a

Integer modulus, satisfying

(x `div` y)*y + (x `mod` y) == x

unsafeBalancedDiv :: (Integral a, PrimType a) => Data a -> Data a -> Data a

Integer division assuming `unsafeBalancedDiv x y * y == x` (i.e. no remainder)

The advantage of using unsafeBalancedDiv over quot or div is that the above assumption can be used for simplifying the expression.

complex

Arguments

:: (Num a, PrimType a, PrimType (Complex a))

=> Data a

Real part

-> Data a

Imaginary part

-> Data (Complex a)

Construct a complex number

polar

Arguments

:: (Floating a, PrimType a, PrimType (Complex a))

=> Data a

Magnitude

-> Data a

Phase

-> Data (Complex a)

Construct a complex number

realPart :: (PrimType a, PrimType (Complex a)) => Data (Complex a) -> Data a

Extract the real part of a complex number

imagPart :: (PrimType a, PrimType (Complex a)) => Data (Complex a) -> Data a

Extract the imaginary part of a complex number

magnitude :: (RealFloat a, PrimType a, PrimType (Complex a)) => Data (Complex a) -> Data a

Extract the magnitude of a complex number's polar form

phase :: (RealFloat a, PrimType a, PrimType (Complex a)) => Data (Complex a) -> Data a

Extract the phase of a complex number's polar form

conjugate :: (RealFloat a, PrimType (Complex a)) => Data (Complex a) -> Data (Complex a)

Complex conjugate

i2n :: (Integral i, Num n, PrimType i, PrimType n) => Data i -> Data n

Integral type casting

i2b :: (Integral a, PrimType a) => Data a -> Data Bool

Cast integer to Bool

b2i :: (Integral a, PrimType a) => Data Bool -> Data a

Cast Bool to integer

round :: (RealFrac a, Num b, PrimType a, PrimType b) => Data a -> Data b

Round a floating-point number to an integer

not :: Data Bool -> Data Bool

Boolean negation

(&&) :: Data Bool -> Data Bool -> Data Bool infixr 3

Boolean conjunction

(||) :: Data Bool -> Data Bool -> Data Bool infixr 2

Boolean disjunction

(==) :: PrimType a => Data a -> Data a -> Data Bool infix 4

Equality

(/=) :: PrimType a => Data a -> Data a -> Data Bool infix 4

Inequality

(<) :: (Ord a, PrimType a) => Data a -> Data a -> Data Bool infix 4

Less than

(>) :: (Ord a, PrimType a) => Data a -> Data a -> Data Bool infix 4

Greater than

(<=) :: (Ord a, PrimType a) => Data a -> Data a -> Data Bool infix 4

Less than or equal

(>=) :: (Ord a, PrimType a) => Data a -> Data a -> Data Bool infix 4

Greater than or equal

min :: (Ord a, PrimType a) => Data a -> Data a -> Data a

Return the smallest of two values

max :: (Ord a, PrimType a) => Data a -> Data a -> Data a

Return the greatest of two values

Bit manipulation

(.&.) :: (Bits a, PrimType a) => Data a -> Data a -> Data a infixl 7

Bit-wise "and"

(.|.) :: (Bits a, PrimType a) => Data a -> Data a -> Data a infixl 5

Bit-wise "or"

xor :: (Bits a, PrimType a) => Data a -> Data a -> Data a infixl 6

Bit-wise "xor"

(⊕) :: (Bits a, PrimType a) => Data a -> Data a -> Data a

Bit-wise "xor"

complement :: (Bits a, PrimType a) => Data a -> Data a

Bit-wise complement

shiftL infixl 8

Arguments

:: (Bits a, PrimType a)

=> Data a

Value to shift

-> Data Int32

Shift amount (negative value gives right shift)

-> Data a

Left shift

shiftR infixl 8

Arguments

:: (Bits a, PrimType a)

=> Data a

Value to shift

-> Data Int32

Shift amount (negative value gives left shift)

-> Data a

Right shift

(.<<.) infixl 8

Arguments

:: (Bits a, PrimType a)

=> Data a

Value to shift

-> Data Int32

Shift amount (negative value gives right shift)

-> Data a

Left shift

(.>>.) infixl 8

Arguments

:: (Bits a, PrimType a)

=> Data a

Value to shift

-> Data Int32

Shift amount (negative value gives left shift)

-> Data a

Right shift

bitSize :: forall a. FiniteBits a => Data a -> Length

allOnes :: (Bits a, Num a, PrimType a) => Data a

Set all bits to one

oneBits :: (Bits a, Num a, PrimType a) => Data Int32 -> Data a

Set the n lowest bits to one

lsbs :: (Bits a, Num a, PrimType a) => Data Int32 -> Data a -> Data a

Extract the k lowest bits

ilog2 :: (FiniteBits a, Integral a, PrimType a) => Data a -> Data a

Integer logarithm in base 2. Returns \(\lfloor log_2(x) \rfloor\). Assumes \(x>0\).

Arrays

arrIx :: Syntax a => IArr a -> Data Index -> a

Index into an array

class Indexed a where

Minimal complete definition

(!)

Associated Types

type IndexedElem a

Methods

(!) :: a -> Data Index -> IndexedElem a infixl 9

Indexing operator. If a is Finite, it is assumed that i < length a in any expression a ! i.

Instances

Syntax a => Indexed (IArr a)

Associated Types

type IndexedElem (IArr a) :: *

Methods

(!) :: IArr a -> Data Index -> IndexedElem (IArr a)

Slicable a => Indexed (Nest a)

Associated Types

type IndexedElem (Nest a) :: *

Methods

(!) :: Nest a -> Data Index -> IndexedElem (Nest a)

Indexed (Pull2 a)

Indexing the rows

Associated Types

type IndexedElem (Pull2 a) :: *

Methods

(!) :: Pull2 a -> Data Index -> IndexedElem (Pull2 a)

Indexed (Pull a)

Associated Types

type IndexedElem (Pull a) :: *

Methods

(!) :: Pull a -> Data Index -> IndexedElem (Pull a)

class Finite a where

Linear structures with a length. If the type is also Indexed, the length is the successor of the maximal allowed index.

Minimal complete definition

length

Methods

length :: a -> Data Length

The length of a finite structure

Instances

Finite (IArr a)

Methods

length :: IArr a -> Data Length

Finite (Arr a)

Methods

length :: Arr a -> Data Length

Finite (Nest a)

Methods

length :: Nest a -> Data Length

Finite (Pull2 a)

length gives number of rows

Methods

length :: Pull2 a -> Data Length

Finite (Pull a)

Methods

length :: Pull a -> Data Length

Finite (Push2 m a)

length gives number of rows

Methods

length :: Push2 m a -> Data Length

Finite (Push m a)

Methods

length :: Push m a -> Data Length

class Slicable a where

Linear structures that can be sliced

Minimal complete definition

slice

Methods

slice :: Data Index -> Data Length -> a -> a

Take a slice of a structure

Instances

Slicable (IArr a)

Methods

slice :: Data Index -> Data Length -> IArr a -> IArr a

Slicable (Arr a)

Methods

slice :: Data Index -> Data Length -> Arr a -> Arr a

Slicable a => Slicable (Nest a)

Methods

slice :: Data Index -> Data Length -> Nest a -> Nest a

Slicable (Pull2 a)

Take a slice of the rows

Methods

slice :: Data Index -> Data Length -> Pull2 a -> Pull2 a

Slicable (Pull a)

Methods

slice :: Data Index -> Data Length -> Pull a -> Pull a

Syntactic conversion

desugar :: Syntax a => a -> Data (Internal a)

sugar :: Syntax a => Data (Internal a) -> a

resugar :: (Syntax a, Syntax b, Internal a ~ Internal b) => a -> b

Cast between two values that have the same syntactic representation

Assertions

guardVal

Arguments

:: Syntax a

=> Data Bool

Condition that is expected to be true

-> String

Error message

-> a

Value to attach the assertion to

-> a

Guard a value by an assertion (with implicit label UserAssertion "")

guardValLabel

Arguments

:: Syntax a

=> AssertionLabel

Assertion label

-> Data Bool

Condition that is expected to be true

-> String

Error message

-> a

Value to attach the assertion to

-> a

Like guardVal but with an explicit assertion label

Unsafe operations

unsafePerform :: Syntax a => Comp a -> a

Turn a Comp computation into a pure value. For this to be safe, the computation should be free of side effects and independent of its environment.

Programs with computational effects

class Monad m => MonadComp m where

Monads that support computational effects: mutable data structures and control flow

Minimal complete definition

liftComp, iff, for, while

Methods

liftComp :: Comp a -> m a

Lift a Comp computation

iff :: Data Bool -> m () -> m () -> m ()

Conditional statement

for :: (Integral n, PrimType n) => IxRange (Data n) -> (Data n -> m ()) -> m ()

For loop

while :: m (Data Bool) -> m () -> m ()

While loop

Instances

MonadComp Comp

Methods

liftComp :: Comp a -> Comp a

iff :: Data Bool -> Comp () -> Comp () -> Comp ()

for :: (Integral n, PrimType n) => IxRange (Data n) -> (Data n -> Comp ()) -> Comp ()

while :: Comp (Data Bool) -> Comp () -> Comp ()

MonadComp Run

Methods

liftComp :: Comp a -> Run a

iff :: Data Bool -> Run () -> Run () -> Run ()

for :: (Integral n, PrimType n) => IxRange (Data n) -> (Data n -> Run ()) -> Run ()

while :: Run (Data Bool) -> Run () -> Run ()

MonadComp m => MonadComp (OptionT m)

Methods

liftComp :: Comp a -> OptionT m a

iff :: Data Bool -> OptionT m () -> OptionT m () -> OptionT m ()

for :: (Integral n, PrimType n) => IxRange (Data n) -> (Data n -> OptionT m ()) -> OptionT m ()

while :: OptionT m (Data Bool) -> OptionT m () -> OptionT m ()

References

newRef :: (Syntax a, MonadComp m) => m (Ref a)

Create an uninitialized reference

newNamedRef

Arguments

:: (Syntax a, MonadComp m)

=> String

Base name

-> m (Ref a)

Create an uninitialized named reference

The provided base name may be appended with a unique identifier to avoid name collisions.

initRef :: (Syntax a, MonadComp m) => a -> m (Ref a)

Create an initialized named reference

initNamedRef

Arguments

:: (Syntax a, MonadComp m)

=> String

Base name

-> a

Initial value

-> m (Ref a)

Create an initialized reference

The provided base name may be appended with a unique identifier to avoid name collisions.

getRef :: (Syntax a, MonadComp m) => Ref a -> m a

Get the contents of a reference.

setRef :: (Syntax a, MonadComp m) => Ref a -> a -> m ()

Set the contents of a reference.

modifyRef :: (Syntax a, MonadComp m) => Ref a -> (a -> a) -> m ()

Modify the contents of reference.

unsafeFreezeRef :: (Syntax a, MonadComp m) => Ref a -> m a

Freeze the contents of reference (only safe if the reference is not updated as long as the resulting value is alive).

Arrays

newArr :: (Type (Internal a), MonadComp m) => Data Length -> m (Arr a)

Create an uninitialized array

newNamedArr

Arguments

:: (Type (Internal a), MonadComp m)

=> String

Base name

-> Data Length

-> m (Arr a)

Create an uninitialized named array

The provided base name may be appended with a unique identifier to avoid name collisions.

constArr

Arguments

:: (PrimType (Internal a), MonadComp m)

=> [Internal a]

Initial contents

-> m (Arr a)

Create an array and initialize it with a constant list

constNamedArr

Arguments

:: (PrimType (Internal a), MonadComp m)

=> String

Base name

-> [Internal a]

Initial contents

-> m (Arr a)

Create a named array and initialize it with a constant list

The provided base name may be appended with a unique identifier to avoid name collisions.

getArr :: (Syntax a, MonadComp m) => Arr a -> Data Index -> m a

Get an element of an array

setArr :: forall m a. (Syntax a, MonadComp m) => Arr a -> Data Index -> a -> m ()

Set an element of an array

copyArr

Arguments

:: MonadComp m

=> Arr a

Destination

-> Arr a

Source

-> m ()

Copy the contents of an array to another array. The length of the destination array must not be less than that of the source array.

In order to copy only a part of an array, use slice before calling copyArr.

freezeArr :: (Type (Internal a), MonadComp m) => Arr a -> m (IArr a)

Freeze a mutable array to an immutable one. This involves copying the array to a newly allocated one.

freezeSlice :: (Type (Internal a), MonadComp m) => Data Length -> Arr a -> m (IArr a)

A version of freezeArr that slices the array from 0 to the given length

unsafeFreezeArr :: MonadComp m => Arr a -> m (IArr a)

Freeze a mutable array to an immutable one without making a copy. This is generally only safe if the the mutable array is not updated as long as the immutable array is alive.

unsafeFreezeSlice :: MonadComp m => Data Length -> Arr a -> m (IArr a)

A version of unsafeFreezeArr that slices the array from 0 to the given length

thawArr :: (Type (Internal a), MonadComp m) => IArr a -> m (Arr a)

Thaw an immutable array to a mutable one. This involves copying the array to a newly allocated one.

unsafeThawArr :: MonadComp m => IArr a -> m (Arr a)

Thaw an immutable array to a mutable one without making a copy. This is generally only safe if the the mutable array is not updated as long as the immutable array is alive.

constIArr :: (PrimType (Internal a), MonadComp m) => [Internal a] -> m (IArr a)

Create an immutable array and initialize it with a constant list

Control-flow

ifE

Arguments

:: (Syntax a, MonadComp m)

=> Data Bool

Condition

-> m a

True branch

-> m a

False branch

-> m a

Conditional statement that returns an expression

break :: MonadComp m => m ()

Break out from a loop

assert

Arguments

:: MonadComp m

=> Data Bool

Expression that should be true

-> String

Message in case of failure

-> m ()

Assertion (with implicit label UserAssertion "")

assertLabel

Arguments

:: MonadComp m

=> AssertionLabel

Assertion label

-> Data Bool

Expression that should be true

-> String

Message in case of failure

-> m ()

Like assert but tagged with an explicit assertion label

Misc.

shareM :: (Syntax a, MonadComp m) => a -> m a

Force evaluation of a value and share the result (monadic version of share)

Orphan instances

Syntactic ()

Associated Types

type Domain () :: * -> *

type Internal () :: *

Methods

desugar :: () -> ASTF (Domain ()) (Internal ())

sugar :: ASTF (Domain ()) (Internal ()) -> ()

(Bounded a, Type a) => Bounded (Data a)

Methods

minBound :: Data a

maxBound :: Data a

(Floating a, PrimType a) => Floating (Data a)

Methods

pi :: Data a

exp :: Data a -> Data a

log :: Data a -> Data a

sqrt :: Data a -> Data a

(**) :: Data a -> Data a -> Data a

logBase :: Data a -> Data a -> Data a

sin :: Data a -> Data a

cos :: Data a -> Data a

tan :: Data a -> Data a

asin :: Data a -> Data a

acos :: Data a -> Data a

atan :: Data a -> Data a

sinh :: Data a -> Data a

cosh :: Data a -> Data a

tanh :: Data a -> Data a

asinh :: Data a -> Data a

acosh :: Data a -> Data a

atanh :: Data a -> Data a

log1p :: Data a -> Data a

expm1 :: Data a -> Data a

log1pexp :: Data a -> Data a

log1mexp :: Data a -> Data a

(Fractional a, PrimType a) => Fractional (Data a)

Methods

(/) :: Data a -> Data a -> Data a

recip :: Data a -> Data a

fromRational :: Rational -> Data a

(Num a, PrimType a) => Num (Data a)

Methods

(+) :: Data a -> Data a -> Data a

(-) :: Data a -> Data a -> Data a

(*) :: Data a -> Data a -> Data a

negate :: Data a -> Data a

abs :: Data a -> Data a

signum :: Data a -> Data a

fromInteger :: Integer -> Data a