Documentation

The type of terms-and-their-values generators.

A term along with the corresponding Haskell value.

Generates application of a builtin that returns a function, immediately saturated afterwards.

ifThenElse {integer -> integer -> integer} (lessThanInteger i j) addInteger subtractInteger i j
    == if i < j then i + j else i - j 

i -> product [1 :: Integer .. i] as a PLC term.

\(i : integer) -> product (enumFromTo 1 i) 

Generate a term that computes the factorial of an integer and return it along with the factorial of the corresponding Integer computed on the Haskell side.

The naive exponential fibonacci function as a PLC term.

\(i0 : integer) ->
    fix {integer} {integer}
        (\(rec : integer -> integer) (i : integer) ->
                ifThenElse {integer}
                    (lessThanEqInteger i 1)
                    (\(u : unit) -> i)
                    (\(u : unit) -> addInteger
                        (rec (subtractInteger i 1))
                        (rec (subtractInteger i 2)))
        i0 

Generate a term that computes the ith Fibonacci number and return it along with the corresponding Integer computed on the Haskell side.

Generate an Integer, turn it into a Scott-encoded PLC Nat (see Nat), turn that Nat into the corresponding PLC integer using a fold (see FoldNat) defined in terms of generic fix (see Fix) and return the result along with the original Integer

sumNat as a PLC term.

Generate a list of Integers, turn it into a Scott-encoded PLC List (see List), sum elements of the list (see Sum) and return it along with the sum of the original list.

Generate a boolean and two integers and check whether if b then i1 else i2 means the same thing in Haskell and PLC. Terms are generated using genTermLoose.

Apply a function to all interesting generators and collect the results.