Data.Express.Express

Defines the Express type class.

Documentation

class (Show a, Typeable a) => Express a where

Express typeclass instances provide an expr function that allows values to be deeply encoded as applications of Exprs.

expr False  =  val False
expr (Just True)  =  value "Just" (Just :: Bool -> Maybe Bool) :$ val True

The function expr can be contrasted with the function val:

• val always encodes values as atomic Value Exprs -- shallow encoding.
• expr ideally encodes expressions as applications (:$) between Value Exprs -- deep encoding.

Depending on the situation, one or the other may be desirable.

Instances can be automatically derived using the TH function deriveExpress.

The following example shows a datatype and its instance:

data Stack a = Stack a (Stack a) | Empty

instance Express a => Express (Stack a) where
  expr s@(Stack x y) = value "Stack" (Stack ->>: s) :$ expr x :$ expr y
  expr s@Empty       = value "Empty" (Empty   -: s)

To declare expr it may be useful to use auxiliary type binding operators: -:, ->:, ->>:, ->>>:, ->>>>:, ->>>>>:, ...

For types with atomic values, just declare expr = val

Methods

expr :: a -> Expr

Instances

Express Bool

Defined in Data.Express.Express

Methods

expr :: Bool -> Expr

Express Char

Defined in Data.Express.Express

Methods

expr :: Char -> Expr

Express Int

Defined in Data.Express.Express

Methods

expr :: Int -> Expr

Express Integer

Defined in Data.Express.Express

Methods

expr :: Integer -> Expr

Express Ordering

Defined in Data.Express.Express

Methods

expr :: Ordering -> Expr

Express ()

Defined in Data.Express.Express

Methods

expr :: () -> Expr

Express a => Express [a]

Defined in Data.Express.Express

Methods

expr :: [a] -> Expr

Express a => Express (Maybe a)

Defined in Data.Express.Express

Methods

expr :: Maybe a -> Expr

(Integral a, Express a) => Express (Ratio a)

Defined in Data.Express.Express

Methods

expr :: Ratio a -> Expr

(Express a, Express b) => Express (Either a b)

Defined in Data.Express.Express

Methods

expr :: Either a b -> Expr

(Express a, Express b) => Express (a, b)

Defined in Data.Express.Express

Methods

expr :: (a, b) -> Expr

(Express a, Express b, Express c) => Express (a, b, c)

Defined in Data.Express.Express

Methods

expr :: (a, b, c) -> Expr

(Express a, Express b, Express c, Express d) => Express (a, b, c, d)

Defined in Data.Express.Express

Methods

expr :: (a, b, c, d) -> Expr

(Express a, Express b, Express c, Express d, Express e) => Express (a, b, c, d, e)

Defined in Data.Express.Express

Methods

expr :: (a, b, c, d, e) -> Expr

(Express a, Express b, Express c, Express d, Express e, Express f) => Express (a, b, c, d, e, f)

Defined in Data.Express.Express

Methods

expr :: (a, b, c, d, e, f) -> Expr

(Express a, Express b, Express c, Express d, Express e, Express f, Express g) => Express (a, b, c, d, e, f, g)

Defined in Data.Express.Express

Methods

expr :: (a, b, c, d, e, f, g) -> Expr

(Express a, Express b, Express c, Express d, Express e, Express f, Express g, Express h) => Express (a, b, c, d, e, f, g, h)

Defined in Data.Express.Express

Methods

expr :: (a, b, c, d, e, f, g, h) -> Expr

(Express a, Express b, Express c, Express d, Express e, Express f, Express g, Express h, Express i) => Express (a, b, c, d, e, f, g, h, i)

Defined in Data.Express.Express

Methods

expr :: (a, b, c, d, e, f, g, h, i) -> Expr

(Express a, Express b, Express c, Express d, Express e, Express f, Express g, Express h, Express i, Express j) => Express (a, b, c, d, e, f, g, h, i, j)

Defined in Data.Express.Express

Methods

expr :: (a, b, c, d, e, f, g, h, i, j) -> Expr

(Express a, Express b, Express c, Express d, Express e, Express f, Express g, Express h, Express i, Express j, Express k) => Express (a, b, c, d, e, f, g, h, i, j, k)

Defined in Data.Express.Express

Methods

expr :: (a, b, c, d, e, f, g, h, i, j, k) -> Expr

(Express a, Express b, Express c, Express d, Express e, Express f, Express g, Express h, Express i, Express j, Express k, Express l) => Express (a, b, c, d, e, f, g, h, i, j, k, l)

Defined in Data.Express.Express

Methods

expr :: (a, b, c, d, e, f, g, h, i, j, k, l) -> Expr

(-:) :: a -> a -> a infixl 1

Type restricted version of const that forces its first argument to have the same type as the second.

 value -: (undefined :: Ty)  =  value :: Ty

(->:) :: (a -> b) -> b -> a -> b infixl 1

Type restricted version of const that forces the result of its first argument to have the same type as the second.

 f ->: (undefined :: Ty)  =  f :: a -> Ty

(->>:) :: (a -> b -> c) -> c -> a -> b -> c infixl 1

Type restricted version of const that forces the result of the result of its first argument to have the same type as the second.

f ->>: (undefined :: Ty)  =  f :: a -> b -> Ty

(->>>:) :: (a -> b -> c -> d) -> d -> a -> b -> c -> d infixl 1

Type restricted version of const that forces the result of the result of the result of its first argument to have the same type as the second.

(->>>>:) :: (a -> b -> c -> d -> e) -> e -> a -> b -> c -> d -> e infixl 1

Forces the result type of a 4-argument function.

(->>>>>:) :: (a -> b -> c -> d -> e -> f) -> f -> a -> b -> c -> d -> e -> f infixl 1

Forces the result type of a 5-argument function.

(->>>>>>:) :: (a -> b -> c -> d -> e -> f -> g) -> g -> a -> b -> c -> d -> e -> f -> g infixl 1

Forces the result type of a 6-argument function.

(->>>>>>>:) :: (a -> b -> c -> d -> e -> f -> g -> h) -> h -> a -> b -> c -> d -> e -> f -> g -> h infixl 1

Forces the result type of a 7-argument function.

(->>>>>>>>:) :: (a -> b -> c -> d -> e -> f -> g -> h -> i) -> i -> a -> b -> c -> d -> e -> f -> g -> h -> i infixl 1

Forces the result type of a 8-argument function.

(->>>>>>>>>:) :: (a -> b -> c -> d -> e -> f -> g -> h -> i -> j) -> j -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j infixl 1

Forces the result type of a 9-argument function.

(->>>>>>>>>>:) :: (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k) -> k -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k infixl 1

Forces the result type of a 10-argument function.

(->>>>>>>>>>>:) :: (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l) -> l -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l infixl 1

Forces the result type of a 11-argument function.

(->>>>>>>>>>>>:) :: (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m) -> m -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m infixl 1

Forces the result type of a 12-argument function.