Documentation

A primitive expression (paired with instance reification). Create Prims with pr and prim.

Provides a primitive value to Conjure. To be used on values that are not Show instances such as functions. (cf. pr)

conjure "fun" fun [ ...
                  , prim "&&" (&&)
                  , prim "||" (||)
                  , prim "+" ((+) :: Int -> Int -> Int)
                  , prim "*" ((*) :: Int -> Int -> Int)
                  , prim "-" ((-) :: Int -> Int -> Int)
                  , ...
                  ]

Argument types have to be monomorphized, so use type bindings when applicable.

Provides a primitive value to Conjure. To be used on Show instances. (cf. prim)

conjure "fun" fun [ pr False
                  , pr True
                  , pr (0 :: Int)
                  , pr (1 :: Int)
                  , ...
                  ]

Argument types have to be monomorphized, so use type bindings when applicable.

Provides an if condition bound to the given return type.

This should be used when one wants Conjure to consider if-expressions at all:

last' :: [Int] -> Int
last' [x]  =  x
last' [x,y]  =  y
last' [x,y,z]  =  z

> conjure "last" last' [ pr ([] :: [Int])
>                      , prim ":" ((:) :: Int -> [Int] -> [Int])
>                      , prim "null" (null :: [Int] -> Bool)
>                      , prif (undefined :: Int)
>                      , prim "undefined" (undefined :: Int)
>                      ]
last :: [Int] -> Int
-- ...  ...  ...
-- looking through 4 candidates of size 7
-- tested 5 candidates
last []  =  undefined
last (x:xs)  =  if null xs
                then x
                else last xs

Provides a case condition bound to the given return type.

This should be used when one wants Conjure to consider ord-case expressions:

> conjure "mem" mem
>   [ pr False
>   , pr True
>   , prim "`compare`" (compare :: Int -> Int -> Ordering)
>   , primOrdCaseFor (undefined :: Bool)
>   ]
mem :: Int -> Tree -> Bool
-- ...  ...  ...
-- looking through 384 candidates of size 12
-- tested 371 candidates
mem x Leaf  =  False
mem x (Node t1 y t2)  =  case x `compare` y of
                         LT -> mem x t1
                         EQ -> True
                         GT -> mem x t2

Computes a list of holes encoded as Exprs from a list of Prims.

This function mirrors functionality from conjureHoles.

Given a list of Prims, returns a function that given an Expr will return tiers of test Expr values.

This is used in cjAreEqual.

Given a list of Prims, computes a function that checks whether two Exprs are equal up to a given number of tests.

Computes a function that equates two Exprs from a list of Prims.

This function mirrors functionality from conjureMkEquation.