ProgramGenerator is a generalization of the old Memo type.

The vanilla program generator corresponding to Version 0.7.*

p is used to convert your primitive component set into the internal form.

setPrimitives creates a ProgGen from the given set of primitives using the current set of options, and sets it as the current program generator. It used to be equivalent to setPG . mkPG which overwrites the options with the default, but it is not now.

mkPGSF and mkMemoSF are provided mainly for backward compatibility. These functions are defined only for the ProgramGenerators whose names end with SF (i.e., generators with synergetic filtration). For such generators, they are defined as:

mkPGSF   gen nrnds optups tups = mkPGOpt (options{primopt = Just optups, contain = True,  stdgen = gen, nrands = nrnds}) tups
mkMemoSF gen nrnds optups tups = mkPGOpt (options{primopt = Just optups, contain = False, stdgen = gen, nrands = nrnds}) tups

mkPGSF and mkMemoSF are provided mainly for backward compatibility. These functions are defined only for the ProgramGenerators whose names end with SF (i.e., generators with synergetic filtration). For such generators, they are defined as:

mkPGSF   gen nrnds optups tups = mkPGOpt (options{primopt = Just optups, contain = True,  stdgen = gen, nrands = nrnds}) tups
mkMemoSF gen nrnds optups tups = mkPGOpt (options{primopt = Just optups, contain = False, stdgen = gen, nrands = nrnds}) tups

mkPG is defined as:

mkPG prims = mkPGSF (mkStdGen 123456) (repeat 5) prims prims

options for limiting the hypothesis space.

options that limit the hypothesis space.

default options

options = Opt{ primopt = Nothing
             , memodepth = 10
             , memoCondPure = \ _type depth -> 0<depth
             , memoCond = \ _type depth -> return $ if depth < 10 then Ram else Recompute
             , execute = unsafeExecute
             , timeout = Just 20000
             , forcibleTimeout = False
             , guess   = False
             , contain = True
             , constrL = False
             , tv1     = False

load loads a component library file.

f is supposed to be used by load, but not hidden.

Currently the default depth is 10. You may want to lower the value if your computer often swaps, or increase it if you have a lot of memory.

setTimeout sets the timeout in microseconds. Also, my implementation of timeout also catches inevitable exceptions like stack space overflow. Note that setting timeout makes the library referentially untransparent. (But currently setTimeout 20000 is the default!)

unsetTimeout disables timeout. This is the safe choice.

define eases use of this library by automating some function definitions. For example,

$( define ''ProgGen "Foo" (p [| (1 :: Int, (+) :: Int -> Int -> Int) |]) )

is equivalent to

memoFoo :: ProgGen
memoFoo = mkPG (p [| (1 :: Int, (+) :: Int -> Int -> Int) |])
everyFoo :: Everything
everyFoo = everything memoFoo
filterFoo :: Filter
filterFoo pred = filterThen pred everyFoo

If you do not think this function reduces the number of your keystrokes a lot, you can do without it.

findOne pred finds an expression e that satisfies pred e == True, and returns it in Exp.

printOne prints the expression found first.

printAll prints all the expressions satisfying the given predicate.

io2pred converts a specification given as a set of I/O pairs to the predicate form which other functions accept.

filterFirst is like printAll, but by itself it does not print anything. Instead, it creates a stream of expressions represented in tuples of Exp and the expressions themselves.

filterThen may be used to further filter the results.

getEverything uses the 'global' values set with set* functions. getEverythingF is its filtered version

everything generates all the expressions that fit the inferred type, and their representations in the Exp form. It returns a stream of lists, which is equivalent to Spivey's Matrix data type, i.e., that contains expressions consisted of n primitive components at the n-th element (n = 1,2,...). everythingF is its filtered version

Those functions are like everything, but take Type as an argument, which may be polymorphic. For example, printQ ([t| forall a. a->a->a |] >>= return . unifyable True 10 memo) will print all the expressions using memo whose types unify with forall a. a->a->a. (At first I (Susumu) could not find usefulness in finding unifyable expressions, but seemingly Hoogle does something alike, and these functions might enhance it.)

Those functions are like everything, but take Type as an argument, which may be polymorphic. For example, printQ ([t| forall a. a->a->a |] >>= return . unifyable True 10 memo) will print all the expressions using memo whose types unify with forall a. a->a->a. (At first I (Susumu) could not find usefulness in finding unifyable expressions, but seemingly Hoogle does something alike, and these functions might enhance it.)

everything generates all the expressions that fit the inferred type, and their representations in the Exp form. It returns a stream of lists, which is equivalent to Spivey's Matrix data type, i.e., that contains expressions consisted of n primitive components at the n-th element (n = 1,2,...). everythingF is its filtered version

Those functions are like everything, but take Type as an argument, which may be polymorphic. For example, printQ ([t| forall a. a->a->a |] >>= return . unifyable True 10 memo) will print all the expressions using memo whose types unify with forall a. a->a->a. (At first I (Susumu) could not find usefulness in finding unifyable expressions, but seemingly Hoogle does something alike, and these functions might enhance it.)

Those functions are like everything, but take Type as an argument, which may be polymorphic. For example, printQ ([t| forall a. a->a->a |] >>= return . unifyable True 10 memo) will print all the expressions using memo whose types unify with forall a. a->a->a. (At first I (Susumu) could not find usefulness in finding unifyable expressions, but seemingly Hoogle does something alike, and these functions might enhance it.)

pprs pretty prints the results to the console, using pprintUC

pprsIO is the EveryIO version of pprs

pprsIOn depth eio is the counterpart of pprs (take depth eio), while pprsIO eio is the counterpart of pprs eio. Example: pprsIOn 5 (everythingIO (mlist::ProgGen) :: EveryIO ([Char]->[Char]))

The function unsafeCoerce# allows you to side-step the typechecker entirely. That is, it allows you to coerce any type into any other type. If you use this function, you had better get it right, otherwise segmentation faults await. It is generally used when you want to write a program that you know is well-typed, but where Haskell's type system is not expressive enough to prove that it is well typed.

The following uses of unsafeCoerce# are supposed to work (i.e. not lead to spurious compile-time or run-time crashes):

• Casting any lifted type to Any
• Casting Any back to the real type
• Casting an unboxed type to another unboxed type of the same size (but not coercions between floating-point and integral types)
• Casting between two types that have the same runtime representation. One case is when the two types differ only in "phantom" type parameters, for example Ptr Int to Ptr Float, or [Int] to [Float] when the list is known to be empty. Also, a newtype of a type T has the same representation at runtime as T.

Other uses of unsafeCoerce# are undefined. In particular, you should not use unsafeCoerce# to cast a T to an algebraic data type D, unless T is also an algebraic data type. For example, do not cast Int->Int to Bool, even if you later cast that Bool back to Int->Int before applying it. The reasons have to do with GHC's internal representation details (for the congnoscenti, data values can be entered but function closures cannot). If you want a safe type to cast things to, use Any, which is not an algebraic data type.

printAll prints all the expressions satisfying the given predicate.