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

data Sym sig where

Syntactic symbols for C

Constructors

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

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

Fun :: Signature sig => 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)

WithCode :: SupportCode -> Sym (a :-> Full a)

Instances

Equality Sym

Methods

equal :: Sym a -> Sym b -> Bool

hash :: Sym a -> Hash

Render Sym

Methods

renderSym :: Sym sig -> String

renderArgs :: [String] -> Sym sig -> String

StringTree Sym

Methods

stringTreeSym :: [Tree String] -> Sym a -> Tree String

Symbol Sym

Methods

symSig :: Sym sig -> SigRep sig

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

data T sig where

Constructors

T :: CType (DenResult sig) => {..} -> T sig

Fields

• unT :: Sym sig

Instances

Equality T

Methods

equal :: T a -> T b -> Bool

hash :: T a -> Hash

Render T

Methods

renderSym :: T sig -> String

renderArgs :: [String] -> T sig -> String

StringTree T

Methods

stringTreeSym :: [Tree String] -> T a -> Tree String

Symbol T

Methods

symSig :: T sig -> SigRep sig

newtype CExp a

C expression

Constructors

CExp

Fields

• unCExp :: ASTF T a

Instances

EvalExp CExp

Methods

evalExp :: CExp a -> a

FreeExp CExp

Associated Types

type FreePred (CExp :: * -> *) :: * -> Constraint

Methods

constExp :: FreePred CExp a => a -> CExp a

varExp :: FreePred CExp a => VarId -> CExp a

CompExp CExp

Methods

compExp :: MonadC m => CExp a -> m Exp

Eq (CExp a)

Methods

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

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

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

Methods

(/) :: CExp a -> CExp a -> CExp a

recip :: CExp a -> CExp a

fromRational :: Rational -> CExp a

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

Methods

(+) :: CExp a -> CExp a -> CExp a

(-) :: CExp a -> CExp a -> CExp a

(*) :: CExp a -> CExp a -> CExp a

negate :: CExp a -> CExp a

abs :: CExp a -> CExp a

signum :: CExp a -> CExp a

fromInteger :: Integer -> CExp a

Syntactic (CExp a)

Associated Types

type Domain (CExp a) :: * -> *

type Internal (CExp a) :: *

Methods

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

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

type FreePred CExp

type FreePred CExp = CType

type Internal (CExp a)

type Internal (CExp a) = a

type Domain (CExp 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 :: forall t. () => forall a. (CType (DenResult (Full t)), (~#) * * (Full t) (Full a)) => a -> CExp t

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

pattern NonLitP :: forall a. CExp a

pattern NonLitP' :: forall a. ASTF T a

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

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

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

pattern UOpP' :: forall t. () => forall a a1 b. (CType (DenResult ((:->) a t)), (~#) * * ((:->) a t) ((:->) a1 (Full b))) => Unary (a1 -> 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

=> String

Name of constant

-> a

Value of constant

-> CExp a

Predefined constant

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

Create a named variable

withCode :: CType a => (forall m. MonadC m => m ()) -> CExp a -> CExp a

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

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