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

Defined in Language.Embedded.CExp

Methods

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

hash :: Sym a -> Hash

Render Sym

Defined in Language.Embedded.CExp

Methods

renderSym :: Sym sig -> String

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

StringTree Sym

Defined in Language.Embedded.CExp

Methods

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

Symbol Sym

Defined in Language.Embedded.CExp

Methods

symSig :: Sym sig -> SigRep sig

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

data T sig where

Constructors

T

Fields

• :: CType (DenResult sig)
• => { unT :: Sym sig
•    } -> T sig

Instances

Equality T

Defined in Language.Embedded.CExp

Methods

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

hash :: T a -> Hash

Render T

Defined in Language.Embedded.CExp

Methods

renderSym :: T sig -> String

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

StringTree T

Defined in Language.Embedded.CExp

Methods

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

Symbol T

Defined in Language.Embedded.CExp

Methods

symSig :: T sig -> SigRep sig

newtype CExp a

C expression

Constructors

CExp

Fields

• unCExp :: ASTF T a

Instances

EvalExp CExp

Defined in Language.Embedded.CExp

Methods

evalExp :: CExp a -> a

FreeExp CExp

Defined in Language.Embedded.CExp

Associated Types

type FreePred CExp :: Type -> Constraint

Methods

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

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

CompExp CExp

Defined in Language.Embedded.CExp

Methods

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

Eq (CExp a)

Defined in Language.Embedded.CExp

Methods

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

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

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

Defined in Language.Embedded.CExp

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)

Defined in Language.Embedded.CExp

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)

Defined in Language.Embedded.CExp

Associated Types

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

type Internal (CExp a) :: Type

Methods

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

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

type FreePred CExp

Defined in Language.Embedded.CExp

type FreePred CExp = CType

type Internal (CExp a)

Defined in Language.Embedded.CExp

type Internal (CExp a) = a

type Domain (CExp a)

Defined in Language.Embedded.CExp

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 a. () => forall a1. (CType (DenResult (Full a)), Full a ~# Full a1) => a1 -> CExp a

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

pattern NonLitP :: forall a. CExp a

pattern NonLitP' :: forall a. ASTF T a

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

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

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

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

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