Language.Embedded.CExp

Typed deep embedding of simple C expressions

This is a subset of C expressions that only have simple non-compound and non-pointed types, and that don't contain any control structures.

(Of course, nothing stops one from translating CExp to something other than C, but its constructors and set of supported types is inspired by C.)

Expressions

data Unary a where

Constructors

UnNeg :: Num a => Unary (a -> a)

UnNot :: Unary (Bool -> Bool)

evalUnary :: Unary a -> a

unaryOp :: Unary a -> UnOp

data Binary a where

Constructors

BiAdd :: Num a => Binary (a -> a -> a)

BiSub :: Num a => Binary (a -> a -> a)

BiMul :: Num a => Binary (a -> a -> a)

BiDiv :: Fractional a => Binary (a -> a -> a)

BiQuot :: Integral a => Binary (a -> a -> a)

BiRem :: Integral a => Binary (a -> a -> a)

BiAnd :: Binary (Bool -> Bool -> Bool)

BiOr :: Binary (Bool -> Bool -> Bool)

BiEq :: CType a => Binary (a -> a -> Bool)

BiNEq :: CType a => Binary (a -> a -> Bool)

BiLt :: (Ord a, CType a) => Binary (a -> a -> Bool)

BiGt :: (Ord a, CType a) => Binary (a -> a -> Bool)

BiLe :: (Ord a, CType a) => Binary (a -> a -> Bool)

BiGe :: (Ord a, CType a) => Binary (a -> a -> Bool)

evalBinary :: Binary a -> a

binaryOp :: Binary a -> BinOp

type SupportCode = forall m. MonadC m => m ()

data Sym sig where

Syntactic symbols for C

Constructors

Lit :: String -> a -> Sym (Full a)

Const :: SupportCode -> String -> a -> Sym (Full a)

Fun :: Signature sig => SupportCode -> String -> Denotation sig -> Sym sig

UOp :: Unary (a -> b) -> Sym (a :-> Full b)

Op :: Binary (a -> b -> c) -> Sym (a :-> (b :-> Full c))

Cast :: (a -> b) -> Sym (a :-> Full b)

Cond :: Sym (Bool :-> (a :-> (a :-> Full a)))

Var :: VarId -> Sym (Full a)

ArrIx :: (Integral i, Ix i) => IArr i a -> Sym (i :-> Full a)

Instances

Equality Sym

Render Sym

StringTree Sym

Symbol Sym

data T sig where

Constructors

T :: CType (DenResult sig) => Sym sig -> T sig

Fields

unT :: Sym sig

Instances

Equality T

Render T

StringTree T

Symbol T

newtype CExp a

C expression

Constructors

CExp

Fields

unCExp :: ASTF T a

Instances

EvalExp CExp

FreeExp CExp

CompExp CExp

Eq (CExp a)

(Floating a, Ord a, CType a) => Floating (CExp a)

(Fractional a, Ord a, CType a) => Fractional (CExp a)

(Num a, Ord a, CType a) => Num (CExp a)

Syntactic (CExp a)

type VarPred CExp = CType

type Internal (CExp a) = a

type Domain (CExp a) = T

evalSym :: Sym sig -> Denotation sig

evalCExp :: CExp a -> a

Evaluate an expression

compCExp :: forall m a. MonadC m => CExp a -> m Exp

Compile an expression

constFold :: CExp a -> CExp a

One-level constant folding: if all immediate sub-expressions are literals, the expression is reduced to a single literal

castAST :: forall a b. Typeable b => ASTF T a -> Maybe (ASTF T b)

viewLit :: CExp a -> Maybe a

Get the value of a literal expression

pattern LitP :: (CType (DenResult (Full t)), (~) * (Full t) (Full a)) => a -> CExp t

pattern LitP' :: (CType (DenResult t), (~) * t (Full a)) => a -> AST T t

pattern NonLitP :: CExp a

pattern NonLitP' :: ASTF T a

pattern OpP :: (CType (DenResult ((:->) a ((:->) a (Full t)))), (~) * ((:->) a ((:->) a (Full t))) ((:->) a ((:->) b (Full c)))) => Binary (a -> b -> c) -> AST T (Full a) -> AST T (Full a) -> CExp t

pattern OpP' :: (CType (DenResult ((:->) a ((:->) a t))), (~) * ((:->) a ((:->) a t)) ((:->) a ((:->) b (Full c)))) => Binary (a -> b -> c) -> AST T (Full a) -> AST T (Full a) -> AST T t

pattern UOpP :: (CType (DenResult ((:->) a (Full t))), (~) * ((:->) a (Full t)) ((:->) a (Full b))) => Unary (a -> b) -> AST T (Full a) -> CExp t

pattern UOpP' :: (CType (DenResult ((:->) a t)), (~) * ((:->) a t) ((:->) a (Full b))) => Unary (a -> b) -> AST T (Full a) -> AST T t

isFloat :: forall a. CType a => CExp a -> Bool

Return whether the type of the expression is a floating-point numeric type

isExact :: CType a => CExp a -> Bool

Return whether the type of the expression is a non-floating-point type

isExact' :: CType a => ASTF T a -> Bool

Return whether the type of the expression is a non-floating-point type

User interface

value :: CType a => a -> CExp a

Construct a literal expression

constant

Arguments

:: CType a

=> SupportCode

Supporting C code

-> String

Name of constant

-> a

Value of constant

-> CExp a

Predefined constant

variable :: CType a => VarId -> CExp a

Create a named variable

true :: CExp Bool

false :: CExp Bool

quot_ :: (Integral a, CType a) => CExp a -> CExp a -> CExp a

Integer division truncated toward zero

(#%) :: (Integral a, CType a) => CExp a -> CExp a -> CExp a

Integer remainder satisfying

(x `quot_` y)*y + (x #% y) == x

round_ :: (RealFrac a, Integral b, CType b) => CExp a -> CExp b

i2n :: (Integral a, Num b, CType b) => CExp a -> CExp b

Integral type casting

i2b :: Integral a => CExp a -> CExp Bool

Cast integer to Bool

b2i :: (Integral a, CType a) => CExp Bool -> CExp a

Cast Bool to integer

not_ :: CExp Bool -> CExp Bool

Boolean negation

(#&&) :: CExp Bool -> CExp Bool -> CExp Bool

Logical and

(#||) :: CExp Bool -> CExp Bool -> CExp Bool

Logical or

(#==) :: (Eq a, CType a) => CExp a -> CExp a -> CExp Bool infix 4

Equality

(#!=) :: (Eq a, CType a) => CExp a -> CExp a -> CExp Bool infix 4

In-equality

(#<) :: (Ord a, CType a) => CExp a -> CExp a -> CExp Bool infix 4

(#>) :: (Ord a, CType a) => CExp a -> CExp a -> CExp Bool infix 4

(#<=) :: (Ord a, CType a) => CExp a -> CExp a -> CExp Bool infix 4

(#>=) :: (Ord a, CType a) => CExp a -> CExp a -> CExp Bool infix 4

cond

Arguments

:: CType a

=> CExp Bool

Condition

-> CExp a

True branch

-> CExp a

False branch

-> CExp a

Conditional expression

(?) infixl 1

Arguments

:: CType a

=> CExp Bool

Condition

-> CExp a

True branch

-> CExp a

False branch

-> CExp a

Condition operator; use as follows:

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

(#!) :: (CType a, Integral i, Ix i) => IArr i a -> CExp i -> CExp a

Array indexing