Language.Atom.Expressions

Types

data E a where

A typed expression.

Constructors

VRef :: V a -> E a

Const :: a -> E a

Cast :: (NumE a, NumE b) => E a -> E b

Add :: NumE a => E a -> E a -> E a

Sub :: NumE a => E a -> E a -> E a

Mul :: NumE a => E a -> E a -> E a

Div :: NumE a => E a -> E a -> E a

Mod :: IntegralE a => E a -> E a -> E a

Not :: E Bool -> E Bool

And :: E Bool -> E Bool -> E Bool

BWNot :: IntegralE a => E a -> E a

BWAnd :: IntegralE a => E a -> E a -> E a

BWOr :: IntegralE a => E a -> E a -> E a

Shift :: IntegralE a => E a -> Int -> E a

Eq :: (EqE a, OrdE a) => E a -> E a -> E Bool

Lt :: OrdE a => E a -> E a -> E Bool

Mux :: E Bool -> E a -> E a -> E a

F2B :: E Float -> E Word32

D2B :: E Double -> E Word64

B2F :: E Word32 -> E Float

B2D :: E Word64 -> E Double

Instances

Expr a => Eq (E a)

(OrdE a, NumE a, Num a, Fractional a) => Fractional (E a)

(Num a, NumE a, OrdE a) => Num (E a)

Show (E a)

(Expr a, OrdE a, EqE a, IntegralE a, Bits a) => Bits (E a)

Expr a => TypeOf (E a)

Expr a => Width (E a)

data V a

Variables updated by state transition rules.

Constructors

V UV

Instances

Eq (V a)

TypeOf (V a)

Expr a => Width (V a)

data UE

An untyped term.

Constructors

UVRef UV

UConst Const

UCast Type UE

UAdd UE UE

USub UE UE

UMul UE UE

UDiv UE UE

UMod UE UE

UNot UE

UAnd [UE]

UBWNot UE

UBWAnd UE UE

UBWOr UE UE

UShift UE Int

UEq UE UE

ULt UE UE

UMux UE UE UE

UF2B UE

UD2B UE

UB2F UE

UB2D UE

Instances

Eq UE

Ord UE

Show UE

TypeOf UE

Width UE

data UV

Untyped variables.

Constructors

UV UVLocality

Instances

Eq UV

Ord UV

Show UV

TypeOf UV

data UVLocality

UV locality.

Constructors

Array UA UE

External String Type

Instances

Eq UVLocality

Ord UVLocality

Show UVLocality

data A a

A typed array.

Constructors

A UA

Instances

Eq (A a)

TypeOf (A a)

data UA

An untyped array.

Constructors

UA Int String [Const]

Instances

Eq UA

Ord UA

Show UA

TypeOf UA

class Eq a => Expr a where

Methods

eType :: E a -> Type

constant :: a -> Const

expression :: E a -> Expression

variable :: V a -> Variable

rawBits :: E a -> E Word64

Instances

Expr Bool

Expr Double

Expr Float

Expr Int8

Expr Int16

Expr Int32

Expr Int64

Expr Word8

Expr Word16

Expr Word32

Expr Word64

data Expression

Constructors

EBool (E Bool)

EInt8 (E Int8)

EInt16 (E Int16)

EInt32 (E Int32)

EInt64 (E Int64)

EWord8 (E Word8)

EWord16 (E Word16)

EWord32 (E Word32)

EWord64 (E Word64)

EFloat (E Float)

EDouble (E Double)

data Variable

Constructors

VBool (V Bool)

VInt8 (V Int8)

VInt16 (V Int16)

VInt32 (V Int32)

VInt64 (V Int64)

VWord8 (V Word8)

VWord16 (V Word16)

VWord32 (V Word32)

VWord64 (V Word64)

VFloat (V Float)

VDouble (V Double)

Instances

Eq Variable

data Type

The type of a E.

Constructors

Bool

Int8

Int16

Int32

Int64

Word8

Word16

Word32

Word64

Float

Double

Instances

Eq Type

Ord Type

Read Type

Show Type

Width Type

data Const

Constructors

CBool Bool

CInt8 Int8

CInt16 Int16

CInt32 Int32

CInt64 Int64

CWord8 Word8

CWord16 Word16

CWord32 Word32

CWord64 Word64

CFloat Float

CDouble Double

Instances

Eq Const

Ord Const

Show Const

TypeOf Const

Width Const

class Width a where

Methods

width :: a -> Int

Instances

Width UE

Width Const

Width Type

Expr a => Width (E a)

Expr a => Width (V a)

class TypeOf a where

Methods

typeOf :: a -> Type

Instances

TypeOf UE

TypeOf UA

TypeOf UV

TypeOf Const

Expr a => TypeOf (E a)

TypeOf (A a)

TypeOf (V a)

bytes :: Width a => a -> Int

ue :: Expr a => E a -> UE

uv :: V a -> UV

ueUpstream :: UE -> [UE]

The list of UEs adjacent upstream of a UE.

class (Num a, Expr a, EqE a, OrdE a) => NumE a

Instances

NumE Double

NumE Float

NumE Int8

NumE Int16

NumE Int32

NumE Int64

NumE Word8

NumE Word16

NumE Word32

NumE Word64

class (NumE a, Integral a) => IntegralE a

Instances

IntegralE Int8

IntegralE Int16

IntegralE Int32

IntegralE Int64

IntegralE Word8

IntegralE Word16

IntegralE Word32

IntegralE Word64

class (RealFloat a, NumE a, OrdE a) => FloatingE a

Instances

FloatingE Double

FloatingE Float

class (Eq a, Expr a) => EqE a

Instances

EqE Bool

EqE Double

EqE Float

EqE Int8

EqE Int16

EqE Int32

EqE Int64

EqE Word8

EqE Word16

EqE Word32

EqE Word64

class (Eq a, Ord a, EqE a) => OrdE a

Instances

OrdE Double

OrdE Float

OrdE Int8

OrdE Int16

OrdE Int32

OrdE Int64

OrdE Word8

OrdE Word16

OrdE Word32

OrdE Word64

Constants

true :: E Bool

True term.

false :: E Bool

False term.

Variable Reference and Assignment

value :: V a -> E a

Returns the value of a V.

Logical Operations

not_ :: E Bool -> E Bool

Logical negation.

(&&.) :: E Bool -> E Bool -> E Bool

Logical AND.

(||.) :: E Bool -> E Bool -> E Bool

Logical OR.

and_ :: [E Bool] -> E Bool

The conjunction of a E Bool list.

or_ :: [E Bool] -> E Bool

The disjunction of a E Bool list.

any_ :: (a -> E Bool) -> [a] -> E Bool

True iff the predicate is true for any element.

all_ :: (a -> E Bool) -> [a] -> E Bool

True iff the predicate is true for all elements.

Equality and Comparison

(==.) :: (EqE a, OrdE a) => E a -> E a -> E Bool

Equal.

(/=.) :: (EqE a, OrdE a) => E a -> E a -> E Bool

Not equal.

(<.) :: OrdE a => E a -> E a -> E Bool

Less than.

(<=.) :: OrdE a => E a -> E a -> E Bool

Less than or equal.

(>.) :: OrdE a => E a -> E a -> E Bool

Greater than.

(>=.) :: OrdE a => E a -> E a -> E Bool

Greater than or equal.

min_ :: OrdE a => E a -> E a -> E a

Returns the minimum of two numbers.

minimum_ :: OrdE a => [E a] -> E a

Returns the minimum of a list of numbers.

max_ :: OrdE a => E a -> E a -> E a

Returns the maximum of two numbers.

maximum_ :: OrdE a => [E a] -> E a

Returns the maximum of a list of numbers.

limit :: OrdE a => E a -> E a -> E a -> E a

Limits between min and max.

Arithmetic Operations

div_ :: IntegralE a => E a -> E a -> E a

Division.

mod_ :: IntegralE a => E a -> E a -> E a

Modulo.

Conditional Operator

mux :: Expr a => E Bool -> E a -> E a -> E a

Conditional expression.

 mux test onTrue onFalse

Array Indexing

(!) :: (Expr a, IntegralE b) => A a -> E b -> V a

Array index to variable.

(!.) :: (Expr a, IntegralE b) => A a -> E b -> E a

Array index to expression.

Smart constructors for untyped expressions.

ubool :: Bool -> UE

unot :: UE -> UE

uand :: UE -> UE -> UE

uor :: UE -> UE -> UE

ueq :: UE -> UE -> UE

umux :: UE -> UE -> UE -> UE