Data.Express.Fixtures

Defines some Expr fixtures to facilitate testing and playing around on the REPL (GHCI).

• Instead of having to write:

  > value "&&" (&&) :$ (value "not" not :$ val True) :$ val False
  not True && False :: Bool

  Using this module, we can just write:

  > not' true -&&- false
  not True && False :: Bool

• Instead of having to write:

  > value "+" ((+)::Int->Int->Int) :$ (value "*" ((*)::Int->Int->Int) :$ var "x" (undefined::Int) :$ var "y" (undefined::Int)) :$ (value "*" ((*)::Int->Int->Int) :$ val (1::Int) :$ val (2::Int))
  x * y + 1 * 2 :: Int

  Using this module, we can just write:

  > xx -*- yy -+- one -*- two
  x * y + 1 * 2 :: Int

• Instead of having to write:

  > value "||" (||) :$ (value "==" ((==)::Int->Int->Bool) :$ val (3::Int) :$ (value "+" ((+)::Int->Int->Int) :$ var "y" (undefined::Int) :$ val (1::Int))) :$ (value "not" not :$ val False)
  3 == y + 1 || not False :: Bool

  We can just write:

  > (three -==- yy -+- one) -||- not' false
  x == y + 1 || not False :: Bool

This exports over a hundred symbols to be used mainly when writing unit tests or playing around on GHCi.

Since the Expr type only allows monomorphic values, encoded polymorphic values are monomorphized usually to the Int type.

Beware: lifted Expr functions sometimes work for different types. The current version does not have a rationale for types that are included: you have to either try around on the REPL or look at the source to really know.

Convenience re-export

module Data.Express

Functions and values encoded as Expr or functions of Exprs

The naming rules are:

• Ints are encoded using their English names, e.g.: zero, one, two;
• Chars are encoded using their English names, e.g.: bee, cee, dee;
• 0-argument constructors are encoded in lowercase, e.g.: false, true, nothing, just;
• lifted constructors are lowercased, e.g.: just;
• lifted functions are primed e.g.: id', negate', head';
• lifted operators are surrounded by dashes, e.g.: -+-, -*-, -&&-, -||-, -:-.
• operators are encoded using their English names, e.g.: plus, times, cons;
• encoded functions are followed by E, e.g.: idE, notE, absE;
• variables have the first character duplicated, e.g.: xx, yy, xxs;
• encoded values may have the element type appended, e.g.: idInt, idBool, justInt, nilChar.

Unqualified polymorphic constructors and functions have their element types bound to Int.

There are exceptions to the above rules such as: when a name would conflict with a Prelude function. (e.g.: orE and andE)

Booleans

b_ :: Expr

Expr representing a hole of Bool type.

> b_
_ :: Bool

pp :: Expr

Expr representing a variable p :: Bool.

> pp
p :: Bool

qq :: Expr

Expr representing a variable q :: Bool.

> qq
q :: Bool

rr :: Expr

Expr representing a variable r :: Bool.

> rr
r :: Bool

pp' :: Expr

Expr representing a variable p' :: Bool.

> pp'
p' :: Bool

false :: Expr

False encoded as an Expr.

> false
False :: Bool

true :: Expr

True encoded as an Expr.

> true
True :: Bool

notE :: Expr

The function not encoded as an Expr.

> notE
not :: Bool -> Bool

orE :: Expr

The function or encoded as an Expr.

> orE
(||) :: Bool -> Bool -> Bool

andE :: Expr

The function and encoded as an Expr.

> andE
(&&) :: Bool -> Bool -> Bool

implies :: Expr

The ==> operator encoded as an Expr

not' :: Expr -> Expr

The function not lifted over the Expr type.

> not' false
not False :: Bool

> evalBool $ not' false
True

> not' pp
not p :: Bool

(-||-) :: Expr -> Expr -> Expr infixr 2

The function || lifted over the Expr type.

> pp -||- qq
p || q :: Bool

> false -||- true
False || True :: Bool

> evalBool $ false -||- true
True

(-&&-) :: Expr -> Expr -> Expr infixr 3

The function && lifted over the Expr type.

> pp -&&- qq
p && q :: Bool

> false -&&- true
False && True :: Bool

> evalBool $ false -&&- true
False

(-==>-) :: Expr -> Expr -> Expr infixr 0

The function ==> lifted over Exprs.

> false -==>- true
False ==> True :: Bool

> evl $ false -==>- true :: Bool
True

(-==-) :: Expr -> Expr -> Expr infix 4

Constructs an equation between two Exprs.

> xx -==- zero
x == 0 :: Bool

> cc -==- dee
c == 'd' :: Bool

This works for the Int, Bool, Char argument types and their lists.

(-/=-) :: Expr -> Expr -> Expr infix 4

Constructs an inequation between two Exprs.

> xx -/=- zero
x /= 0 :: Bool

> cc -/=- ae
c /= 'a' :: Bool

(-<=-) :: Expr -> Expr -> Expr infix 4

Constructs a less-than-or-equal inequation between two Exprs.

> xx -<=- zero
x <= 0 :: Bool

> cc -<=- ae
c <= 'a' :: Bool

(-<-) :: Expr -> Expr -> Expr infix 4

Constructs a less-than inequation between two Exprs.

> xx -<- zero
x < 0 :: Bool

> cc -<- bee
c < 'b' :: Bool

compare' :: Expr -> Expr -> Expr

Constructs an Expr-encoded compare operation between two Exprs.

> xx `compare'` zero
compare x 0 :: Ordering

> compare' ae bee
compare 'a' 'b' :: Ordering

if' :: Expr -> Expr -> Expr -> Expr

A function if :: Bool -> a -> a -> a lifted over the Expr type that encodes if-then-else functionality. This is properly displayed as an if-then-else.

> if' pp zero xx
(if p then 0 else x) :: Int

> zz -*- if' pp xx yy
z * (if p then x else y) :: Int

> if' pp false true -||- if' qq true false
(if p then False else True) || (if q then True else False) :: Bool

> evl $ if' true (val 't') (val 'f') :: Char
't'

caseBool :: Expr -> Expr -> Expr -> Expr

A function case :: Bool -> a -> a -> a lifted over the Expr type that encodes case-of-False-True functionality. This is properly displayed as a case-of-False-True expression.

> caseBool pp zero xx
(case p of False -> 0; True -> x) :: Int

> zz -*- caseBool pp xx yy
z * (case p of False -> x; True -> y) :: Int

> caseBool pp false true -||- caseBool qq true false
(caseBool p of False -> False; True -> True) || (caseBool q of False -> True; True -> False) :: Bool

> evl $ caseBool true (val 'f') (val 't') :: Char
't'

By convention, the False case comes before True as False < True and data Bool = False | True.

When evaluating, this is equivalent to if with arguments reversed. Instead of using this, you are perhaps better of using if encoded as an expression. This is just here to be consistent with caseOrdering.

caseOrdering :: Expr -> Expr -> Expr -> Expr -> Expr

A function case :: Ordering -> a -> a -> a -> a lifted over the Expr type that encodes case-of-LT-EQ-GT functionality. This is properly displayed as a case-of-LT-EQ-GT expression. (cf. caseBool)

> caseOrdering (xx `compare'` yy) zero one two
(case compare x y of LT -> 0; EQ -> 1; GT -> 2) :: Int

> evl $ caseOrdering (val EQ) (val 'l') (val 'e') (val 'g') :: Char
'e'

By convention cases are given in LT, EQ and GT order as LT < EQ < GT and data Ordering = LT | EQ | GT.

Integers

i_ :: Expr

A typed hole of Int type.

> i_
_ :: Int

xx :: Expr

A variable x of Int type.

> xx
x :: Int

yy :: Expr

A variable y of Int type.

> yy
y :: Int

zz :: Expr

A variable z of Int type.

> zz
z :: Int

xx' :: Expr

A variable x' of Int type.

> xx'
x' :: Int

ii :: Expr

A variable i of Int type.

> ii
i :: Int

jj :: Expr

A variable j of Int type.

> jj
j :: Int

kk :: Expr

A variable k of Int type.

> kk
k :: Int

ii' :: Expr

A variable i' of Int type.

> ii'
i' :: Int

ll :: Expr

A variable l of Int type.

> ll
l :: Int

mm :: Expr

A variable m of Int type.

> mm
m :: Int

nn :: Expr

A variable n of Int type.

> nn
n :: Int

zero :: Expr

The value 0 bound to the Int type encoded as an Expr.

> zero
0 :: Int

one :: Expr

The value 1 bound to the Int type encoded as an Expr.

> one
1 :: Int

two :: Expr

The value 2 bound to the Int type encoded as an Expr.

> two
2 :: Int

three :: Expr

The value 3 bound to the Int type encoded as an Expr.

> three
3 :: Int

four :: Expr

The value 4 bound to the Int type encoded as an Expr.

> four
4 :: Int

five :: Expr

The value 5 bound to the Int type encoded as an Expr.

> five
5 :: Int

six :: Expr

The value 6 bound to the Int type encoded as an Expr.

> six
6 :: Int

seven :: Expr

The value 7 bound to the Int type encoded as an Expr.

> seven
7 :: Int

eight :: Expr

The value 8 bound to the Int type encoded as an Expr.

> eight
8 :: Int

nine :: Expr

The value 9 bound to the Int type encoded as an Expr.

> nine
9 :: Int

ten :: Expr

The value 10 bound to the Int type encoded as an Expr.

> ten
10 :: Int

eleven :: Expr

The value 11 bound to the Int type encoded as an Expr.

> eleven
11 :: Int

twelve :: Expr

The value 12 bound to the Int type encoded as an Expr.

> twelve
12 :: Int

minusOne :: Expr

The value -1 bound to the Int type encoded as an Expr.

> minusOne
-1 :: Int

minusTwo :: Expr

The value -2 bound to the Int type encoded as an Expr.

> minusOne
-2 :: Int

idE :: Expr

The function id for the Int type encoded as an Expr. (See also id'.)

> idE :$ xx
id x :: Int

> idE :$ zero
id 0 :: Int

> evaluate $ idE :$ zero :: Maybe Int
Just 0

negateE :: Expr

negate over the Int type encoded as an Expr

> negateE
negate :: Int -> Int

absE :: Expr

abs over the Int type encoded as an Expr.

> absE
abs :: Int -> Int

signumE :: Expr

signum over the Int type encoded as an Expr.

> signumE
signum :: Int -> Int

idInt :: Expr

The function id encoded as an Expr. (cf. id')

idBool :: Expr

The function id encoded as an Expr. (cf. id')

idChar :: Expr

The function id encoded as an Expr. (cf. id')

idInts :: Expr

The function id encoded as an Expr. (cf. id')

idBools :: Expr

The function id encoded as an Expr. (cf. id')

idString :: Expr

The function id encoded as an Expr. (cf. id')

id' :: Expr -> Expr

Constructs an application of id as an Expr. Only works for Int, Bool, Char, String, [Int], [Bool].

> id' yy
id yy :: Int

> id' one
id 1 :: Int

> evl (id' one) :: Int
1

> id' pp
id p :: Bool

> id' false
id' False :: Bool

> evl (id' true) :: Bool
True :: Bool

const' :: Expr -> Expr -> Expr

The const function lifted over the Expr type.

> const' zero one
const 0 1 :: Int

This works for the argument types Int, Char, Bool and their lists.

negate' :: Expr -> Expr

negate over the Int type lifted over the Expr type.

> negate' xx
negate x :: Int

> evl (negate' one) :: Int
-1

abs' :: Expr -> Expr

abs over the Int type lifted over the Expr type.

> abs' xx'
abs x' :: Int

> evl (abs' minusTwo) :: Int
2

signum' :: Expr -> Expr

signum over the Int type lifted over the Expr type.

> signum' xx'
signum x' :: Int

> evl (signum' minusTwo) :: Int
-1

plus :: Expr

The operator + for the Int type. (See also -+-.)

> plus
(+) :: Int -> Int -> Int

> plus :$ one
(1 +) :: Int -> Int

> plus :$ xx :$ yy
x + y :: Int

times :: Expr

The operator * for the Int type. (See also -*-.)

> times
(*) :: Int -> Int -> Int

> times :$ two
(2 *) :: Int -> Int

> times :$ xx :$ yy
x * y :: Int

minus :: Expr

The subtraction - operator encoded as an Expr.

> minus :$ one
(1 -) :: Int -> Int

> minus :$ one :$ zero
1 - 0 :: Int

(-+-) :: Expr -> Expr -> Expr infixl 6

The operator + for the Int type for use on Exprs. (See also plus.)

> two -+- three
2 + 3 :: Int

> minusOne -+- minusTwo -+- zero
((-1) + (-2)) + 0 :: Int

> xx -+- (yy -+- zz)
x + (y + z) :: Int

(-*-) :: Expr -> Expr -> Expr infixl 7

The operator * for the Int type lifted over the Expr type. (See also times.)

> three -*- three
3 * 3 :: Int

> one -*- two -*- three
(1 * 2) * 3 :: Int

> two -*- xx
2 * x :: Int

divE :: Expr

Integer division div encoded as an Expr.

> divE :$ two
(2 `div`) :: Int -> Int

> divE :$ two :$ three
2 `div` 3 :: Int

modE :: Expr

Integer modulo mod encoded as an Expr.

> modE :$ two
(2 `mod`) :: Int -> Int

> modE :$ two :$ three
2 `mod` 3 :: Int

quotE :: Expr

Integer quotient quot encoded as an Expr.

> quotE :$ two
(2 `quot`) :: Int -> Int

> quotE :$ two :$ three
2 `quot` 3 :: Int

remE :: Expr

Integer remainder rem encoded as an Expr.

> remE :$ two
(2 `rem`) :: Int -> Int

> remE :$ two :$ three
2 `rem` 3 :: Int

div' :: Expr -> Expr -> Expr

The function div for the Int type lifted over the Expr type. (See also mod.)

> six `div'` four
6 `div` 4 :: Int

mod' :: Expr -> Expr -> Expr

The function mod for the Int type lifted over the Expr type. (See also div.)

> six `mod'` four
6 `mod` 4 :: Int

quot' :: Expr -> Expr -> Expr

The function quot for the Int type lifted over the Expr type. (See also rem.)

> six `quot'` four
6 `quot` 4 :: Int

rem' :: Expr -> Expr -> Expr

The function rem for the Int type lifted over the Expr type. (See also quot.)

> six `rem'` four
6 `rem` 4 :: Int

ff :: Expr -> Expr

A variable function f of 'a -> a' type lifted over the Expr type. This works for Int, Bool, Char and their lists

> ff xx
f x :: Int

> ff one
f 1 :: Int

ffE :: Expr

A variable f of 'Int -> Int' type encoded as an Expr.

> ffE
f :: Int -> Int

gg :: Expr -> Expr

A variable function g of 'a -> a' type lifted over the Expr type. This works for Int, Bool, Char and their lists.

> gg yy
g y :: Int

> gg minusTwo
gg (-2) :: Int

ggE :: Expr

A variable g of 'Int -> Int' type encoded as an Expr.

> ggE
g :: Int -> Int

hh :: Expr -> Expr

A variable function h of 'Int -> Int' type lifted over the Expr type.

> hh zz
h z :: Int

hhE :: Expr

A variable h of 'Int -> Int' type encoded as an Expr.

> hhE
h :: Int -> Int

oo :: Expr -> Expr -> Expr

A variable binary operator o lifted over the Expr type. Works for Int, Bool, Char, [Int] and String.

> xx `oo` yy
x `o` y :: Int

> pp `oo` qq
p `o` q :: Bool

> xx `oo` qq
*** Exception: oo: unhandled type: 1 :: Int, False :: Bool
    accepted types are:
    o :: Int -> Int -> Int
    o :: Bool -> Bool -> Bool
    o :: Char -> Char -> Char
    o :: [Int] -> [Int] -> [Int]
    o :: [Char] -> [Char] -> [Char]

ooE :: Expr

A variable binary function o encoded as an Expr (cf. oo)

> ooE :$ xx :$ yy
x `o` y :: Int

> ooE :$ pp :$ qq
p `o` q :: Bool

ff2 :: Expr -> Expr -> Expr

A variable function f of 'a -> a -> a' type lifted over the Expr type. This works for Int, Bool, Char and their lists

> ff2 xx yy
f x y :: Int

> ff2 one two
f 1 2 :: Int

The result type is bound to the type of the last argument.

ff3 :: Expr -> Expr -> Expr -> Expr

A variable function f of 'a -> a -> a -> a' type lifted over the Expr type. This works for Int, Bool, Char and their lists

> ff3 xx yy zz
f x y z :: Int

> ff3 one two three
f 1 2 3 :: Int

The result type is bound to the type of the last argument.

ff4 :: Expr -> Expr -> Expr -> Expr -> Expr

A variable function f of 'a -> a -> a -> a -> a' type lifted over the Expr type. This works for Int, Bool, Char and their lists

> ff3 xx yy zz xx'
f x y z xx' :: Int

> ff3 one two three four
f 1 2 3 4 :: Int

The result type is bound to the type of the last argument.

question :: Expr

A variable binary operator ? encoded as an Expr (cf. -?-)

> question :$ xx :$ yy
x ? y :: Int

> question :$ pp :$ qq
p ? q :: Bool

(-?-) :: Expr -> Expr -> Expr

A variable binary operator ? lifted over the Expr type. Works for Int, Bool, Char, [Int] and String.

> xx -?- yy
x ? y :: Int

> pp -?- qq
p ? q :: Bool

> xx -?- qq
*** Exception: (-?-): unhandled type: 1 :: Int, False :: Bool
    accepted types are:
    (?) :: Int -> Int -> Int
    (?) :: Bool -> Bool -> Bool
    (?) :: Char -> Char -> Char
    (?) :: [Int] -> [Int] -> [Int]
    (?) :: [Char] -> [Char] -> [Char]
    (?) :: Int -> [Int] -> [Int]
    (?) :: Char -> [Char] -> [Char]

(-$-) :: Expr -> Expr -> Expr infixl 6

$ lifted over Exprs

> absE -$- one
abs $ 1 :: Int

Works for Int, Bool, Char argument types and their lists.

odd' :: Expr -> Expr

odd with an Int argument lifted over the Expr type.

> odd' (xx -+- one)
odd (x + 1) :: Bool

> evl (odd' two) :: Bool
False

even' :: Expr -> Expr

even with an Int argument lifted over the Expr type.

> even' (xx -+- two)
even (x + 2) :: Bool

> evl (even' two) :: Bool
True

Chars

c_ :: Expr

A hole of Char type encoded as an Expr.

> c_
_ :: Char

cs_ :: Expr

A hole of String type encoded as an Expr.

> cs_
_ :: [Char]

cc :: Expr

A variable named c of type Char encoded as an Expr.

> cc
c :: Char

dd :: Expr

A variable named c of type Char encoded as an Expr.

> dd
d :: Char

ccs :: Expr

A variable named cs of type String encoded as an Expr.

> ccs
cs :: [Char]

ae :: Expr

The character 'a' encoded as an Expr.

> ae
'a' :: Char

> evl ae :: Char
'a'

bee :: Expr

The character 'b' encoded as an Expr

> bee
'b' :: Char

> evl bee :: Char
'b'

cee :: Expr

The character 'c' encoded as an Expr

> cee
'c' :: Char

> evl cee :: Char
'c'

dee :: Expr

The character 'd' encoded as an Expr

> dee
'd' :: Char

> evl dee :: Char
'd'

zed :: Expr

The character 'z' encoded as an Expr

> zed
'z' :: Char

> evl zed :: Char
'z'

(cf. zee)

zee :: Expr

The character 'z' encoded as an Expr

> zee
'z' :: Char

> evl zee :: Char
'z'

(cf. zed)

space :: Expr

The space character encoded as an Expr

> space
' ' :: Char

lineBreak :: Expr

The line break character encoded as an Expr

> lineBreak
'\n' :: Char

ord' :: Expr -> Expr

The ord function lifted over Expr

> ord' bee
ord 'b' :: Int

> evl (ord' bee)
98

ordE :: Expr

The ord function encoded as an Expr

Lists

is_ :: Expr

A typed hole of [Int] type encoded as an Expr.

> is_
_ :: [Int]

xxs :: Expr

A variable named xs of type [Int] encoded as an Expr.

> xxs
xs :: [Int]

yys :: Expr

A variable named ys of type [Int] encoded as an Expr.

> yys
ys :: [Int]

zzs :: Expr

A variable named zs of type [Int] encoded as an Expr.

> yys
ys :: [Int]

nil :: Expr

An empty list of type [Int] encoded as an Expr.

> nil
[] :: [Int]

emptyString :: Expr

An empty String encoded as an Expr.

> emptyString
"" :: String

nilInt :: Expr

The empty list '[]' encoded as an Expr.

nilBool :: Expr

The empty list '[]' encoded as an Expr.

nilChar :: Expr

The empty list '[]' encoded as an Expr.

cons :: Expr

The list constructor with Int as element type encoded as an Expr.

> cons
(:) :: Int -> [Int] -> [Int]

> cons :$ one :$ nil
[1] :: [Int]

Consider using -:- and unit when building lists of Expr.

consInt :: Expr

The list constructor : encoded as an Expr.

consBool :: Expr

The list constructor : encoded as an Expr.

consChar :: Expr

The list constructor : encoded as an Expr.

(-:-) :: Expr -> Expr -> Expr infixr 5

The list constructor lifted over the Expr type. Works for the element types Int, Char and Bool.

> zero -:- one -:- unit two
[0,1,2] :: [Int]

> zero -:- one -:- two -:- nil
[0,1,2] :: [Int]

> bee -:- unit cee
"bc" :: [Char]

unit :: Expr -> Expr

unit constructs a list with a single element. This works for elements of type Int, Char and Bool.

> unit one
[1]

> unit false
[False]

(-++-) :: Expr -> Expr -> Expr infixr 5

List concatenation lifted over the Expr type. Works for the element types Int, Char and Bool.

> (zero -:- one -:- nil) -:- (two -:- three -:- nil)
[0,1] -++- [2,3] :: [Int]

> (bee -:- unit cee) -:- unit dee
"bc" -++- "c" :: [Char]

head' :: Expr -> Expr

List head lifted over the Expr type. Works for the element types Int, Char and Bool.

> head' $ unit one
head [1] :: Int

> head' $ unit bee
head "b" :: Char

> head' $ zero -:- unit two
head [0,2] :: Int

> evl $ head' $ unit one :: Int
1

tail' :: Expr -> Expr

List tail lifted over the Expr type. Works for the element types Int, Char and Bool.

> tail' $ unit one
tail [1] :: [Int]

> tail' $ unit bee
tail "b" :: [Char]

> tail' $ zero -:- unit two
tail [0,2] :: [Int]

> evl $ tail' $ zero -:- unit two :: [Int]
[2]

null' :: Expr -> Expr

List null lifted over the Expr type. Works for the element types Int, Char and Bool.

> null' $ unit one
null [1] :: Bool

> null' $ nil
null [] :: Bool

> evl $ null' nil :: Bool
True

length' :: Expr -> Expr

List length lifted over the Expr type. Works for the element types Int, Char and Bool.

> length' $ unit one
length [1] :: Int

> length' $ unit bee
length "b" :: Int

> length' $ zero -:- unit two
length [0,2] :: Int

> evl $ length' $ unit one :: Int
1

init' :: Expr -> Expr

List init lifted over the Expr type. Works for the element types Int, Char and Bool.

> init' $ unit one
init [1] :: [Int]

> init' $ unit bee
init "b" :: [Char]

> init' $ zero -:- unit two
init [0,2] :: [Int]

> evl $ init' $ zero -:- unit two :: [Int]
[0]

elem' :: Expr -> Expr -> Expr

List elem lifted over the Expr type. Works for the element types Int, Char and Bool.

> elem' false (false -:- unit true)
elem False [False,True] :: Bool

> evl $ elem' false (false -:- unit true) :: Bool
True

sort' :: Expr -> Expr

List sort lifted over the Expr type. Works for the element types Int, Char and Bool.

> sort' $ unit one
sort [1] :: Int

> sort' $ unit bee
sort "b" :: Int

> sort' $ zero -:- unit two
sort [0,2] :: Int

> evl $ sort' $ two -:- unit one :: [Int]
[1,2]

insert' :: Expr -> Expr -> Expr

List insert lifted over the Expr type. Works for the element types Int, Char and Bool.

> insert' zero nilInt
insert 0 [] :: [Int]

> insert' false (false -:- unit true)
insert False [False,True] :: [Bool]

drop' :: Expr -> Expr -> Expr

List drop lifted over the Expr type. Works for the element types Int, Char and Bool.

> drop' zero nilInt
drop 0 [] :: [Int]

> drop' one (false -:- unit true)
drop 1 [False,True] :: [Bool]

take' :: Expr -> Expr -> Expr

List take lifted over the Expr type. Works for the element types Int, Char and Bool.

> take' zero nilInt
take 0 [] :: [Int]

> take' one (false -:- unit true)
take 1 [False,True] :: [Bool]

bs_ :: Expr

A typed hole of [Bool] type encoded as an Expr.

> bs_
_ :: [Bool]

pps :: Expr

Expr representing a variable p' :: `[Bool]`.

> pps
ps :: [Bool]

qqs :: Expr

A typed hole of '[Bool]' type

> qqs
qs :: [Bool]

and' :: Expr -> Expr

and lifted over the Expr type.

> and' pps
and ps :: Bool

> evl (and' $ expr [False,True]) :: Bool
False

or' :: Expr -> Expr

or lifted over the Expr type.

> or' pps
or ps :: Bool

> evl (or' $ expr [False,True]) :: Bool
True

sum' :: Expr -> Expr

sum of Int elements lifted over the Expr type.

> sum' xxs
sum xs :: Int

> evl (sum' $ expr [1,2,3::Int]) :: Int
6

product' :: Expr -> Expr

product of Int elements lifted over the Expr type.

> product' xxs
product xs :: Int

> evl (product' $ expr [1,2,3::Int]) :: Int
6

appendInt :: Expr

Append for list of Ints encoded as an Expr.

Maybes

nothing :: Expr

Nothing bound to the Maybe Int type encoded as an Expr.

This is an alias to nothingInt.

nothingInt :: Expr

Nothing bound to the Maybe Int type encoded as an Expr.

nothingBool :: Expr

Nothing bound to the Maybe Bool type encoded as an Expr.

just :: Expr -> Expr

The Just constructor lifted over the Expr type.

This works for the Bool, Int, Char argument types and their lists.

> just zero
Just 0 :: Maybe Int
> just false
Just False :: Maybe Bool

justInt :: Expr

The Just constructor of the Int element type encoded as an Expr.

justBool :: Expr

The Just constructor of the Bool element type encoded as an Expr.

Tuples

comma :: Expr

The pair constructor ( :: ... -> (Int,Int) ) encoded as an Expr.

pair :: Expr -> Expr -> Expr

The pair constructor lifted over Exprs.

This works for some variations of Int, Bool and Char element types and their lists.

> pair zero xxs

(0,xs) :: (Int,[Int])

Differently from foldPair, when this works,- it always constructs a well-typed expression.

(-|-) :: Expr -> Expr -> Expr

An infix synonym of pair.

> zero -|- xxs

(0,xs) :: (Int,[Int])

> ae -|- (bee -:- unit cee)
('a',"bc") :: (Char,[Char])

triple :: Expr -> Expr -> Expr -> Expr

The triple/trio constructor lifted over Exprs.

This works for some combinations of the Int, Bool and Char element types and their lists.

quadruple :: Expr -> Expr -> Expr -> Expr -> Expr

The quadruple constructor lifted over Exprs.

This works for some combinations of the Int, Bool and Char element types and their lists.

quintuple :: Expr -> Expr -> Expr -> Expr -> Expr -> Expr

The quintuple constructor lifted over Exprs.

This only works for the Int element type.

sixtuple :: Expr -> Expr -> Expr -> Expr -> Expr -> Expr -> Expr

The sixtuple constructor lifted over Exprs.

This only works for the Int element type.

Ratios

(-%-) :: Expr -> Expr -> Expr

The % constructor lifted over Exprs.

> val (2 :: Integer) -%- val (3 :: Integer)
2 % 3 :: Ratio Integer

This only accepts Exprs bound to the Integer type.

Higher order

compose :: Expr

Function composition encoded as an Expr:

> compose
(.) :: (Int -> Int) -> (Int -> Int) -> Int -> Int

mapE :: Expr

map over the Int element type encoded as an Expr

> mapE
map :: (Int -> Int) -> [Int] -> [Int]

(-.-) :: Expr -> Expr -> Expr

Function composition . lifted over Expr.

> absE -.- negateE
abs . negate :: Int -> Int

> absE -.- negateE :$ one
(abs . negate) 1 :: Int

This works for Int, Bool, Char and their lists.

map' :: Expr -> Expr -> Expr

map lifted over Exprs.

> map' absE (unit one)
map abs [1] :: [Int]

foldr' :: Expr -> Expr -> Expr -> Expr

foldr lifted over Exprs.

> foldr' plus zero (unit one)
foldr (+) zero [1] :: [Int]

filter' :: Expr -> Expr -> Expr

filter lifted over Exprs.

> filter' absE (unit one)
filter odd [1] :: [Int]

Enum

enumFrom' :: Expr -> Expr

enumFrom lifted over Exprs.

> enumFrom' zero
enumFrom 0 :: [Int]

Works for Ints, Bools and Chars.

(-..) :: Expr -> () -> Expr

enumFrom lifted over Exprs named as ".." for pretty-printing.

> one -.. ()
[1..] :: [Int]

Works for Ints, Bools and Chars.

enumFromTo' :: Expr -> Expr -> Expr

enumFromTo lifted over Exprs

> enumFromTo' zero four
enumFromTo 0 4 :: [Int]

(-..-) :: Expr -> Expr -> Expr

enumFromTo lifted over Exprs but named as ".." for pretty-printing.

> zero -..- four
[0..4] :: [Int]

enumFromThen' :: Expr -> Expr -> Expr

enumFromThen lifted over Exprs

> enumFromThen' zero ten
enumFromThen 0 10 :: [Int]

(--..) :: (Expr, Expr) -> () -> Expr

enumFromThen lifted over Exprs but named as ",.." for pretty printing.

> (zero,ten) --.. ()
[0,10..] :: [Int]

enumFromThenTo' :: Expr -> Expr -> Expr -> Expr

enumFromThenTo lifted over Exprs.

> enumFromThenTo' zero two ten
enumFromThenTo 0 2 10 :: [Int]

(--..-) :: (Expr, Expr) -> Expr -> Expr

enumFromThenTo lifted over Exprs but named as ",.." for pretty-printing.

> (zero,two) --..- ten
[0,2..10] :: [Int]