<+      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R STU V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m nopqrstuvwxyz{|}~                                                                                                                !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*:None +,-./01234567,234567 +,-./01234567None89:;89:;89:;NoneE<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~<<=>?@ABCDEIJFGHKMNOPRTVWXYZ\]^_adefhijklmnoprstvxyz{|}~=<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~I J NoneNoneNoneNone  NonereadHsTypeSigsR reads a module string and returns an Exp that can be supplied to MagicHaskeller.p  None  NoneBOT NoneNone0       None[      !"#$%&'()*+,-./012:     W      !"#$%&'()*+,-./012None3456789:;<=>?@3456789:;<=>?@4 NoneABOPTABCDEFGHIJKLMNOP ACDEFGHIJKLMABCDEFGHIJKLMNOP!None ACDEFGHIJKLM"None QRSTUVWXYZ[\] QRSTUVWXYZ[\] QRSTUVWXYZ[\]#None^_`abcdefghijklmnop^_`abcdefhijmno ^_`abcdefghijklmnop$NoneAOTqqn can be used as a VarLib for testing and debugging. Currently this is used only by the analytical synthesizer.rdefaultPrimitives is the set of primitives that we want to make sure to appear in VarLib but may not appear in the primitive set with which to synthesize. In other words, it is the set of primitives we want to make sure to assign IDs to.8stuvwxyz{|}~qr5stuv{wzyx|}~qrstuvwxyz{|}~qr %NoneB  NoneB !Fvisible modules (including package modules). You may omit the Prelude."-modules to be loaded (except package modules)+visible modules (including package modules)#$%&'()*+,-./012345 !"#$%&'()*+,-./01234 !"#$%&'()*+,-./012345 !"#$%&'()*+,-./012345&NoneB6789:;<=>?@ABCDEFGHIJKLMNOPQlength of availsarity of the head functionR6789:;<=>?@ABCDEFGHIJKLMNOPQR6789:;<=>?@ABCDEFGHIJKLMNOPQR'None(None)NoneXexistential variable. When doing analytical synthesis, there is no functional variable. suniversal variable. When doing analytical synthesis, there is no functional variable. Int0g0o0j0OTH.Name0vcO0c0_e0L00D*number of variables quantified with forall?input example for each argument. The last argument comes first.N applies a substitution which replaces existential variables to an expression. fusion of apply s and fresh f<the to-be-sought list9. *None:  +NoneFMExpr a is a finite trie representing  Expr () -> a      !"#$%&      !"#$      !"#$%&,NoneOT' MapList m a is a memoization of |[b]->a|, where m c is the memoization of b->c. Because we cannot memoize functions taking infinite lists (and long lists practically), functions are silently recomputed if the length if its argument list is more than the length limit.h()*+,-./012345678'9:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ab length limitcdefghijkrangelmnopqrstuvwxyz{|}~h()*+,-./012345678'9:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Y()*+,-./012345678'9:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~I0None9<=gg. applies a function to the bag at each depth. hh flattens each bag.ii converts bags to sets, by (possibly sorting each bag and) removing duplicates. Efficiency on lists with lots of duplicates is required.shrinkDB can be used instead of mergesortDepthWithBy when you want to shrink each depth in different ways using different annotations.~STUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ASTUVWXYZ[\]^_`abcdefghijknlmoqprstuvwxyz{|}~Dxyzuvwrst_`abcdefghijklmnp{|}~n\]^YZ[qSTUVWXopq`STUVWXYZ[\]^_ `abcdefghijklmnopqrstuvwxyz{|}~-None9;jreserveTVars takes the number of requested tvIDs, reserves consecutive tvIDs, and returns the first tvID. *"(.None$$/None#function specification by examples.]the function is really a background knowledge (and thus there is no need for loop check)  it is actually a recursive call.:background knowledge.      !"#$:      !"#$3       !"#$0None%&'()*+,-./0123456%&'()*+,-./0123456 %&'()*+,-./01234561NoneMOPT77 converts a->b->c->d->e->r into ((((a,b),c),d),e)->r Note that Arbitrary (a,b,c,d,e) is not defined in Test.QuickCheck.;89:;<=>?@ABCDEFGHIJKLMNOPQ7RSTUVWXYZ[\]^_`abcdefghijklmnopq?DIJKLNO7TU\`ae;89:;<=>?@ABCDEFGHIJKLMNOPQ7RSTUVWXYZ[\]^_`abcdefghijklmnopqNone@Z6789:;<=>?@ABCDEFGHIJKLMNOPQR^6789:;<=>?@ABCDEFGHIJKLMNOPQR.2NoneRecompute instead of memoizing.KUse the memoization table based on lazy evaluation, like in older versions.Use the directory specified by FilePath% as the persistent memoization table.rDGeneral-purposed memoizer (This could be put in a different module.) stuv4This will be used instead if the entry is not found.w)look up the memoization table in the RAM.4This will be used instead if the entry is not found.xrparserprinterwhere to memoize invoked if there is no such file stuvwxrstuvwxrNone (options that limit the hypothesis space. wUse this option if you want to use a different component library for the stage of solving the inhabitation problem. Nothing means using the same one. This option makes sense only when using *SF style generators, because otherwise the program generation is not staged. Using a minimal set for solving the inhabitation and a redundant library for the real program generation can be a good bet. memoization depth. (Sub)expressions within this size are memoized, while greater expressions will be recomputed (to save the heap space). Only effective when using ProgGen and unless using the  everythingIO family. ZThis represents when to memoize. It takes the query type and the query depth, and returns Truer if the corresponding entry should be looked up from the lazy memo table. Currently this only works for ProgGenSF.pThis represents which memoization table to be used based on the query type and the search depth, when using the  everythingIO family.Just ms sets the timeout to ms 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  Just 20000) is the default!) Setting this option to Nothing0 disables both timeout and capturing exceptions.If this option is True, 34 instead of 56 is used for timeout. The former is much heavier than the latter, but is more preemptive and thus is necessary for interrupting some infinite loops. This record is ignored if FORCIBLETO is not defined.If this option is True5, the program guesses whether each function is a case catamorphismparamorphism or not. This information is used to filter out some duplicate expressions. (History: I once abandoned this guessing strategy around the time I moved to the library implementation, because I could not formally prove the exhaustiveness of the resulting algorithm. For this reason, the old standalone version of MagicHaskeller uses this strategy, but almost the same effect can be obtained by setting this option to True, or using 7 instead of 8. RThis option is now obsolete, and we always assume True now. If this option was FalseC, data structures might not contain functions, and thus types like  [Int->Int], (Int->Bool, Char)G, etc. were not permitted. (NB: recently I noticed that making this False" might not improve the efficiency of generating lambda terms at all, though when I generated combinatory expressions it WAS necessary. In fact, I mistakenly turned this limitation off, and my code always regarded this as True, but I did not notice that, so this option can be obsoleted.)If this option is True, matching at the antecedent of induction rules may occur, which constrains generation of existential types. You need to use prefixed (->)H to show that some parameter can be matched at the antecedent, e.g., pK [| ( []::[a], (:)::a->[a]->[a], foldr :: (a->b->b) -> b -> (->) [a] b ) |] See LibTH.hs for examples.QEach time the type variable which appears in the return type of a function (e.g. b in foldr::(a->b->b)->b->[a]->b) is expanded to a function type, the search priority of the current computation is lowered by this number. It's default value is 1, which means there is nothing special, and the priority for each expression corresponds to the number of function applications in the expression.Example: when tvndelay = 1,The priority of \xs -> foldr (\x y -> x+y) 0 xs is 5, because there are five $'s in 1\xs -> ((foldr $ (\x y -> ((+) $ x) $ y)) $ 0) xsThe priority of 5\xs ys -> foldr (\x y zs -> x : y zs) (\ws->ws) xs ys!is 7, because there are seven $'s in O\xs ys -> (((foldr $ (\x y zs -> (((:) $ x) $ y) $ zs)) $ (\ws->ws)) $ xs) $ ysExample: when tvndelay = 2,The priority of \xs -> foldr (\x y -> x+y) 0 xs is 5, because there are five $'s in 1\xs -> ((foldr $ (\x y -> ((+) $ x) $ y)) $ 0) xsThe priority of 5\xs ys -> foldr (\x y zs -> x : y zs) (\ws->ws) xs ys!is 8, because there are eight $'s in P\xs ys -> (((foldr $ (\x y zs -> (((:) $ x) $ y) $ zs)) $ (\ws->ws)) $ xs) $$ yswhere $$[ denotes the function application caused by expanding a type variable into a function type.If this option is True?, the return type of functions returning a type variable (e.g. b in foldr::(a->b->b)->b->[a]->b) can only be replaced with  Eval t => t and Eval t => u -> t , while if False with  Eval t => t, Eval t => u->t, Eval t => u->v->t, etc., where Eval t means t cannot be replaced with a function. The restriction can be amended if the tuple constructor and destructors are available.The random seed.xnumber of random samples at each depth, for each type, for the filter applied during synthesis (used by ProgGenSF, &c.).ynumber of random samples at each depth, for each type, for the filter applied after synthesis (used by filterThenF, &c.).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                    9NoneTyz{|]seq or deepSeq(=Control.Parallel.Strategies.sforce). For our purposes seq is enough, because a is either } or ~.yz{|yz{| None9;3 !"#$%&'()*+,-./0123456789:microsecs until timeout;<=>?@ABCDEFGHIJKLMNOPQR* !#"$%(&')*+,-./0123456789:;<=>?@ABCDEFGHI3,-.RQ/012345%&'()*+67P8ON9:; !"#$MLK<=J>?@ABCDEFGHI' !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQR:NoneS*options for limiting the hypothesis space.;|mkTrie| creates the generator with the default parameters.Use memoization requiring IOUse memoization requiring IOT0ProgramGenerator is a generalization of the old Memo type. ;|mkTrie| creates the generator with the default parameters.annotated 'Typed [CoreExpr]'YSTYSTIST;NoneB2       0     <None !"#$%&recursive call $ !"#$%&=None'()*+,-./0123456),-./'()*+,-./0123456>None789:;<=>?@ABCDE789:;<=>?@ABCDE789:;<=>?@ABCDE None9;W<The vanilla program generator corresponding to Version 0.7.*Xinternal data representation FGHUVWXIJKLMNOPQRSYTUVWXZYZ[recursive call\[\]UVWXYZWXYUVZFGHUVWXIJKLMNOPQRSYTUVWXZYZ[\[\] None9;^?Program generator with synergetic filtration. This program generator employs filtration by random testing, and rarely generate semantically equivalent expressions more than once, while different expressions will eventually appear (for most of the types, represented with Prelude types, whose arguments are instance of Arbitrary and which return instance of Ord). The idea is to apply random numbers to the generated expressions, compute the quotient set of the resulting values at each depth of the search tree, and adopt the complete system of representatives for the depth and push the remaining expressions to one step deeper in the search tree. (Thus, adoption of expressions that may be equivalent to another already-generated-expression will be postponed until their "uniqueness" is proved.) As a result, (unlike ProgGenK,) expressions with size N may not appear at depth N but some deeper place. ProgGenSFA is more efficient along with a middle-sized primitive set (like  reallyall+ found in LibTH.hs), but is slower than ProgGen for a small-sized one.Also note that  ProgGenSFP depends on hard use of unsafe* stuff, so if there is a bug, it may segfault....Z]^_`abc^_`defghijklmnopqrstauvwxybz{|}~cdefghi ^_`abcdef `^_bcdefaY]^_`abc^_`defghijklmnopqrstauvwxybz{|}~cdefghi None9;j?Program generator with synergetic filtration. This program generator employs filtration by random testing, and rarely generate semantically equivalent expressions more than once, while different expressions will eventually appear (for most of the types, represented with Prelude types, whose arguments are instance of Arbitrary and which return instance of Ord). The idea is to apply random numbers to the generated expressions, compute the quotient set of the resulting values at each depth of the search tree, and adopt the complete system of representatives for the depth and push the remaining expressions to one step deeper in the search tree. (Thus, adoption of expressions that may be equivalent to another already-generated-expression will be postponed until their "uniqueness" is proved.) As a result, (unlike ProgGenK,) expressions with size N may not appear at depth N but some deeper place. ProgGenSFA is more efficient along with a middle-sized primitive set (like  reallyall+ found in LibTH.hs), but is slower than ProgGen for a small-sized one.Also note that  ProgGenSFP depends on hard use of unsafe* stuff, so if there is a bug, it may segfault....4jklmjkkj3jklmNoneBOTssQ eases use of this library by automating some function definitions. For example,  J$( 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 everyFooeIf you do not think this function reduces the number of your keystrokes a lot, you can do without it.ttH is used to convert your primitive component set into the internal form.wv is defined as: <mkPG prims = mkPGSF (mkStdGen 123456) (repeat 5) prims primsyy and zZ are provided mainly for backward compatibility. These functions are defined only for the Ts 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}) tupszy and zZ are provided mainly for backward compatibility. These functions are defined only for the Ts 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 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 . mkPGB which overwrites the options with the default, but it is not now. loads a component library file.1f is supposed to be used by load, but not hidden. 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!)+ disables timeout. This is the safe choice.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.# uses the 'global' values set with set* functions.  is its filtered version\ generates all the expressions that fit the inferred type, and their representations in the H form. It returns a stream of lists, which is equivalent to Spivey's Matrixv data type, i.e., that contains expressions consisted of n primitive components at the n-th element (n = 1,2,...).  is its filtered version\ generates all the expressions that fit the inferred type, and their representations in the H form. It returns a stream of lists, which is equivalent to Spivey's Matrixv data type, i.e., that contains expressions consisted of n primitive components at the n-th element (n = 1,2,...).  is its filtered versionThose functions are like  , but take ; as an argument, which may be polymorphic. For example, ( ([t| forall a. a->a->a |] >>= return .  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  , but take ; as an argument, which may be polymorphic. For example, ( ([t| forall a. a->a->a |] >>= return .  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  , but take ; as an argument, which may be polymorphic. For example, ( ([t| forall a. a->a->a |] >>= return .  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  , but take ; as an argument, which may be polymorphic. For example, ( ([t| forall a. a->a->a |] >>= return .  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.) pred finds an expression e that satisfies pred e == True, and returns it in . $ prints the expression found first. ; prints all the expressions satisfying the given predicate.; prints all the expressions satisfying the given predicate. is like q, but by itself it does not print anything. Instead, it creates a stream of expressions represented in tuples of ! and the expressions themselves. + may be used to further filter the results.io2predi converts a specification given as a set of I/O pairs to the predicate form which other functions accept.1 pretty prints the results to the console, using  is the p version of pprspprsIOn depth eio is the counterpart of pprs (take depth eio), while  pprsIO eio is the counterpart of pprs eio. Example: EpprsIOn 5 (everythingIO (mlist::ProgGen) :: EveryIO ([Char]->[Char])) is like ?@, but unqualifies (:) before pprinting in order to avoid printing "GHC.Types.:" which GHCi does not accept and sometimes annoys when doing some demo._nopqrst+Quote a tuple of primitive components here. This becomes  [Primitive] when spliced.uvwxy6number of random samples at each depth, for each type.z6number of random samples at each depth, for each type.{|}~ This becomes  [Primitive] when spliced.time in microsecondsmemoization depth. (Sub)expressions within this size are memoized, while greater expressions will be recomputed (to save the heap space).2whether to include functions with unused arguments2whether to include functions with unused argumentsprogram generator2whether to include functions with unused argumentsprogram generator2whether to include functions with unused argumentsdummy argumentprogram generator2whether to include functions with unused argumentsdummy argumentprogram generator2whether to include functions with unused argumentsprogram generator2whether to include functions with unused arguments query depthdummy argumentprogram generator2whether to include functions with unused argumentsprogram generatordummy argumentprogram generatorprogram generator query typeprogram generator query typeprogram generator query typeprogram generator query type2whether to include functions with unused arguments2whether to include functions with unused arguments2whether to include functions with unused arguments2whether to include functions with unused arguments2whether to include functions with unused arguments2whether to include functions with unused arguments2whether to include functions with unused arguments2whether to include functions with unused arguments      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                           ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y      STW`knopqrstuvwxyz{|}~dTW`ktvyxz{|}w~S     sonqpu r_nopqrstuvwxyz{|}~ANonePPP NoneMJ replaces uncommon functions like catamorphisms with well-known functions.     o     o          NoneKKJ replaces uncommon functions like catamorphisms with well-known functions.*Library used by the program server backend !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`a2whether to include functions with unused argumentsbcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                           ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y      STW`knopqrstuvwxyz{|}~ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~¥'()*+,-.123468579:;<=>?@ABEFGIb/0CDHJKLMNOPQRSTUVWXYZ[\]^_`a$%&cdef!"#ghijklmnopqrstuvwxyz{ |}~ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~BNone z z makes sure the predicate string does not use either let or where, and may correct grammatical mistakes. This check should be done on both the CGI frontend side and the backend server side. (But actually is done only on the CGI side.), { | } ~  z  { | } ~  z & { | } ~  z None9; is a variant of  for presenting I/O example pairs. It uses everythingF for generating printable functions. Here `good presentation' is more important than `good randomness'.= annotaterCGI.myPath, which is usually "cgi-binMagicHaskeller.cgi"'predicate before escaping single quotes%?;None  f is the set of available values (except partial functions) that can be included/excluded individually.  V is the set of available partial functions that can be included/excluded individually.  P is the set of aliases that can be used instead of the exact names appearing in   in order to increase readability of primitive library files. Also, aliases can be used to group a set of primitives and enable at once.      None  `K `K None<=Unlike x, u , etc., the  monad only keeps the best set of results. This makes the analytical synthesis like IgorII, and the exhaustive synthesis like Djinn, i.e., the resulting algorithms are more efficient, but cannot be used for (analytically-)generate-and-test.                   None;get1 can be used to synthesize one expression. For example,JputStrLn $ pprint $ get1 $(c [d| f [] = 0; f [a] = 1; f [a,b] = 2 |]) noBK> \a -> let fa (b@([])) = 0(> fa (b@(_ : d)) = succ (fa d)> in fa a+getMany does what you expect from its name.getManyTyped is a variant of  that generates typed expressions. This alone is not very useful, but the type info is required when compiling the expression and is used in MagicHaskeller.RunAnalytical.Also, ! $(c [d| ... |]) :: SplicedPrims  L is a helper function for extracting some info from the quoted declarations.Example:\runQ [d| f [] = 0; f [a] = 1; f [a,b] = 2 |] >>= \iops -> putStrLn $ pprint $ getOne iops []> \a -> let fa (b@([])) = 0(> fa (b@(_ : d)) = succ (fa d)> in fa a!! is like synth, but adds the infered type signature to each expression. This is useful for executing the expression at runtime using GHC API. %target function definition by example4background knowledge function definitions by example%target function definition by example4background knowledge function definitions by example%target function definition by example4background knowledge function definitions by example%target function definition by example4background knowledge function definitions by example  !  !  !   ! None# Example of #BquickStart [d| f [] = 0; f [a] = 1 |] noBKQ (\f -> f "12345" == 5)> \a -> let fa (b@([])) = 0(> fa (b@(c : d)) = succ (fa d)*> in fa a :: forall t2 . [t2] -> Int> ^CInterrupted. target I/O pairs,I/O pairs for background knowledge functions test function target I/O pairs,I/O pairs for background knowledge functions test function 1session in which synthesized expressions are run target I/O pairs test function 1session in which synthesized expressions are run target I/O pairs test function 1session in which synthesized expressions are run target I/O pairs,I/O pairs for background knowledge functions test function 1session in which synthesized expressions are run target I/O pairs,I/O pairs for background knowledge functions test function 1session in which synthesized expressions are run target I/O pairs,I/O pairs for background knowledge functions test function 1session in which synthesized expressions are run target I/O pairs,I/O pairs for background knowledge functions"#target I/O pairs,I/O pairs for background knowledge functions test function$target I/O pairs,I/O pairs for background knowledge functions test function %&0session in which synthesized expressions are runtarget I/O pairs test function'0session in which synthesized expressions are runtarget I/O pairs,I/O pairs for background knowledge functions test function(0session in which synthesized expressions are runtarget I/O pairs,I/O pairs for background knowledge functions test function)0session in which synthesized expressions are runtarget I/O pairs,I/O pairs for background knowledge functions test function*0session in which synthesized expressions are runtarget I/O pairs,I/O pairs for background knowledge functions       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                           ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y !"#$%&'()*+,-./01234      STW`knopqrstuvwxyz{|}~ !"#$%&'()* #$%&'()*" "#$ %&'()* CDEFGHIJKLMNOPQRSTUVWXYZ[\]^_$`$a$b$c$defghijklmnopqrstuvwxyz&{&|&}&~&&&&&&&&&&&&&&&&&&&&&&&&&      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGH2I2J2K2LMMNOPQRSTUVWXYZ[\]^_`ab c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                       ::                         AAAAAAAAAAAAAAAAAAAAAAAAA A A A A AAAAAAAAAAAAAAAAAAA A!A"A#A$A%A&A'A(A)A*A+A,A-A.A/A0A1A2A3A4A5A6A7A8A9A:A;A<A=A>A?A@ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z ` [ \ ] ^_`abcdefgABhij87klmnopqrstuvwxyz{|}~DEFGHIJKLMNZ`rs     @ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Cl      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghi                "j"k"l"m"n"o"p"q"r"s"t"u"v#w#x#y#z#{#|#}#~###########$$$$$$$$$$$$$$$$$$$$$b$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%r%s%t%u%''''''''''''''''(())))))))))f))))))))))))))))))))))))))))))))))))))))))))))w)))z) * * * * * ******+++++++++++++ +!+"+#+$+%+&+'+(+)+*+++,+-+.+/+0+1+2,3,4,5,6,7,8,9,:,;,<,=,>,?,@,A,B,C,D,E,F,G,H,I,,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,[,\,],^,_,`,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,{,|,},~,,,,,,,,,,,,,,,,,,,,,,,,,,,---------------------------------u---------....................................////////////////////// / / / / //////////////////// /!/"/#/$/%/&/'/(/)/*/+/,0-0.0/000102030405060708090:0;0<0=0>1?1@1A1B1C1D1E1F1G1H1I1J1K1L1M1N1v11O1P1Q1R1S1T1U1V1W1X1Y1Z1[1\1]1^1_1`1a1b1c1d1e1f1g1h1i1j1k1l1m1n1o1p1q1r1s1t1u1v1w2x2y22z2{2|2}9~999CC999999999999:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::;;p;q;;v;|;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; ;; ; ; ;;<J<<<<<<<<<<<<<<<z<<<====== =!="=#=$=%=&='=(=)=*>+>,>->.>/>0>1>2>3>4>5>6>7>8>9 J         :  ; < =   z > ? @   A B J C  D E F G H I J K   L M N O P ; Q R S T U V W X Y  Z z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~          A J C  D E  G I J K   O P < S   V W X Y  Z [ \ ] ^   ` g  k O     |       u Ao      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMLNLOPQRSTUVWXYZ[\]^_`abcdefghhiijklmnopqrstuvwxyz{|}~jnClLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL                                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] \ ^ \ _ \ ` \@ \ a \ b \ c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                                                                                                       Y    ! " # $ % & ' ( ) * + ,B -B .B /B 0B 1B 2BjB 3B 4B 5B 6B 7B 8B 9B :BB ;B <B =B >B ?B @B AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u/MagicHaskeller-0.9.6.6.1-7rf7Jn6dqi66wiMxIZdsuvMagicHaskellerMagicHaskeller.GetTimeMagicHaskeller.FastRatioMagicHaskeller.IOGeneratorMagicHaskeller.ExpressionMagicHaskeller.ExecuteAPI610"Control.Monad.Search.CombinatorialMagicHaskeller.OptionsMagicHaskeller.ClassificationMagicHaskeller.ProgGenMagicHaskeller.ProgGenSFMagicHaskeller.ProgGenSFIORefMagicHaskeller.LibExcelMagicHaskeller.LibTHMagicHaskeller.IndividualMagicHaskeller.MinimalControl.Monad.Search.BestMagicHaskeller.AnalyticalMagicHaskeller.RunAnalyticalPaths_MagicHaskellerMagicHaskeller.VersionInfoMagicHaskeller.TypesMagicHaskeller.TyConLibMagicHaskeller.T10MagicHaskeller.ReadTypeRepMagicHaskeller.ReadTHTypeMagicHaskeller.ReadHsTypeMagicHaskeller.MHTHMagicHaskeller.PolyDynamicMagicHaskeller.MyCheckMagicHaskeller.NearEqMagicHaskeller.FakeDynamicMagicHaskeller.MyDynamicMagicHaskeller.ReadDynamicMagicHaskeller.FMTypeMagicHaskeller.CoreLangMagicHaskeller.ExecuteMagicHaskeller.ExprStagedMagicHaskeller.ShortStringMagicHaskeller.Combinators MagicHaskeller.Analytical.SyntaxMagicHaskeller.Analytical.UniT MagicHaskeller.Analytical.FMExpr Data.MemoMagicHaskeller.PriorSubsts MagicHaskeller.Analytical.Parser$MagicHaskeller.Analytical.SynthesizeMagicHaskeller.DebMTMagicHaskeller.InstantiateMagicHaskeller.MemoToFilesSystem.Posix.Process forkProcessControl.ConcurrentforkIOinit075 initializeMagicHaskeller.TimeOutMagicHaskeller.ProgramGeneratorMagicHaskeller.ClassifyMagicHaskeller.ClassLibMagicHaskeller.ClassifyDMMagicHaskeller.ClassifyTrLanguage.Haskell.THpprintMagicHaskeller.LibExcelStagedMagicHaskeller.ExpToHtmlghc-primGHC.Prim unsafeCoerce# trToTHType batchWritebatchRuntimeshowZero showCPUTimelenPrecRationalRatio:%% numerator denominator notANumberreducechoose $fEnumRatio $fRealRatio $fShowRatio$fRealFracRatio$fFractionalRatio $fNumRatio $fEqRatio $fOrdRatioNearEq~=HValueHV PrimitiveCoreExpr exprToTHExp pathToGHCloadObj prepareAPIpackageNameToFlagunsafeExecuteAPI executeAPI executeTHExpcompileCoreExpr unwrapCorece2b runCoreExprrunPrepedCoreExpr stmtToCoreperror thExpToStmt wrapLHsExprthExpToLHsExprcompileExprHscMainrepeatNrepeatIOforce$fEqExprseeseeTypeseesseesTypee2THE printTables printTable pprintTypemkVNamemkVNamesmkEsmkAsmkXsmkHdhdmnTHEQaimnTHEQhdmnTHEaimnTHEhdmntyaimntymkTVtvrstvastvrmaxArity maxLenavails maxDebindexmkCEmkCE_LambdaBoundHeadDBMemoDBMunDBMMemoabletabulate applyMemoDBoundTDBTunDBTDBoundDBunDBSearchfromRctoRcfromMxtoMxfromDBfromDFtoDFmapDepthcatBagsmergesortDepthWithByifDepthDelaydelayndelaygetDepth mapDepthDB zipDepthDBRecompTRcTunRcTRecompRcunRcMatrixMxunMxBagStreamcattoList/\\/diagmsumMxmsumRclistToRcrcToMxmxToRcconsMxconsRc zipDepthMx zipDepthRc zipDepth3Mx zipDepth3RcprintMxprintNMx zipWithBFscanl1BFscanlRcshrinkdbtToRcT$fMemoableDBMemoDBound$fMemoableMatrixRecomp$fSearchDBoundT$fSearchDBound$fDelayDBoundT $fDelayDBound$fMonadPlusDBoundT$fAlternativeDBoundT$fMonadPlusDBound$fAlternativeDBound$fMonadDBoundT$fApplicativeDBoundT $fMonadDBound$fApplicativeDBound $fShowDBound $fShowRecomp$fSearchMatrix$fSearchRecompT$fSearchRecomp $fSearch[] $fDelayStateT$fDelayRecompT $fDelayMatrix $fDelayRecomp $fDelay[] $fDBDBoundT $fDBDBound$fMonadPlusRecompT$fAlternativeRecompT$fMonadPlusRecomp$fAlternativeRecomp$fMonadRecompT$fApplicativeRecompT $fMonadRecomp$fApplicativeRecomp$fFunctorDBoundT$fFunctorRecompT$fFunctorDBound$fFunctorRecomp$fFunctorMatrix$fMonadPlusMatrix$fAlternativeMatrix $fMonadMatrix$fApplicativeMatrix$fMonoidRecompT$fMonoidRecomp$fMonoidMatrix $fShowMatrix ExpressionmkHeadtoCEfromCEmapCEaeAppErrappEnv toAnnExpr toAnnExprWindtoAnnExprWindWind fromAnnExpr reorganize reorganize' reorganizeId replaceVars' reorganizeId' decodeVarsMemoExprMEAnnExprAEaeToMEmeToAEmapFst3 decodeVarsPos decodeVarsCE decodeVarsCE' decodeVarsAE decodeVarsDyn insAbsents<$>mkHeadAEwindTypedynSngetDyndynssmkDynx finiteDynar finiteDynarr finiteDynss finiteDynsssgetDyn_LambdaBoundHeaddynsssmkDyn_LambdaBoundHeaddynBK reorganizer reorganizerId replaceVars cvtAvailstkr10annotate reorganizeCE'replaceVarsCE' cvtAvails' uniqSorteruniqSort swapUniqSort uniqSortAVLuniqSortPatAVL$fExpressionAnnExpr$fExpressionCoreExpr $fOrdAnnExpr $fEqAnnExpr $fShowAnnExprMemoType RecomputeRamDiskOptprimopt memodepth memoCondPurememoCondexecutetimeoutforcibleTimeoutguesscontainconstrLtvndelaytv1tv0stdgennrandsfcnrandoptionsforgetnrndschopRndsfnrnds FiltrablefiltfiltFun unsafeFilt unsafeFiltFunRelation fromListBy fromListByDB/ appendWithBydiffBycEQ SStrategysfilterofilter arbitrariesarbs/~ nubSortBy nubSortByBot/</)$fRelationMaybe$fRelationOrdering$fRelationBool$fSStrategyDBound$fSStrategyMatrixOptionsProgramGeneratorClassLibCLProgGenPGmkCL mguPrograms$fProgramGeneratorIOProgGen$fProgramGeneratorProgGen$fWithCommonProgGenPGSF ProgGenSF mkTrieOptSFIOfreezePS funApSub_ funApSub_speclookupNormalized tokoro10fst$fMonoidWord32$fWithCommonPGSF$fProgramGeneratorPGSFPGSFIORProgGenSFIORef$fWithCommonPGSFIOR$fProgramGeneratorIOPGSFIORFilter EverythingEveryIOEverymkCurriedDeclsdefinepp1mkPGmkPGXmkMemomkPGSFmkMemoSFmkPG075 mkMemo075mkPGOptmkPGXOptmkPGIO mkPGXOptIO mkPGXOptssetPG setPrimitives zipAppendloadf setTimeout unsetTimeoutsetDepth getEverythinggetEverythingF everything everythingFetup everythingM everythingIO stripEvery unifyablematching unifyableF matchingFfindOneprintOneprintAnyprintAll printAllF filterFirst filterFirstF filterThenFeveryF filterThenfpfpartial fpartialIOfpIOfIOmapIOio2predpprspprsIOpprsIOnlengths lengthsIO lengthsIOn lengthsIOnLnprintQtotalGCDcurry2curry3curry4curry5curry6iFupperlowerproperleft1right1leftrightdropLeftmidlen concatenate concatenatE concatenaTE concatenATE concateNATEcEILINGmroundfLOOR0fLOORrOUNDroundup rounddowntrimfINDifERRORaNDoRsignpowersQRTlOGlnpIaTAN2factcombinmODdegreesradiansgCDfindIxfinDchar sUBsTITUTE sUBSTITUTEsUBsUBST4countStrleft'2right'2 concatenate'2 cEILING'2mround'2rOUND'2 roundup'2 rounddown'2 ifERROR'2aND'2oR'2power'2lOG'2aTAN2'2combin'2mOD'2gCD'2iF'3mid'3fIND'3 sUBsTITUTE'3 concatenatE'3 concatenaTE'4 concatenATE'5 concateNATE'6succOnlyForNumberslast'ppExcelppvppopnppdropconstEflipEplusEdropEreverseElengthEsumEproductEleftErightElenEabsEmkIF mkUncurriedmkSUBST4mkVarOpchar7lit0lit1procSucc mkPgExcel mkPgExcels<>excelOrderedOrd by1_compare EquivalenceEq--#==PartialPartundeftailgcdenumFromThenToinittv1tupletuple'mallmlistmlist'mnatmnaturalmlistnat mlistnaturalmnat_nchdmbmb'natnaturalnat' nat'woPrednatural'plusInt plusIntegernat_paranat_catalist''list'list list_parabool postprocessbyMapbyEqsbyOrdsskipskipEqskipOrd appearsInppLambda postprocessQexploitbooleanundefsby1_head--#!! prelPartialeq by1_eqMaybe eqMaybeBy by1_eqListeqListBy by2_eqEither eqEitherBy by2_eqPaireqPairByeqs prelEqRelateddataListEqRelated--#/=by1_elem by1_groupby1_nubby1_isPrefixOfby1_isSuffixOf by1_isInfixOfby1_stripPrefix by1_lookupcmp by1_cmpMaybecompareMaybeBy by1_cmpList compareListBy by2_cmpEithercompareEitherBy by2_cmpPair comparePairByordsprelOrdRelateddataListOrdRelated--#<=--#<by1_maxby1_minby1_sortintinstintinst1 intpartialsintinst2list1list1'list2list3list3'nats reallyall generatormixsosorichpoormixrarich'mxdebugpgfullpgfullsmkPgFull mkPgTotal mkDebugPgdebpgfullIOfull clspartialss tupartialsstupartialssNormalliterals fromPrelude fromDataList fromDataChar fromDataMaybepgWithDoubleRatiopgWithDoubleRatioswithDoubleRatio pgWithRatio pgWithRatiospgRatiopgRatios withRatioratioCls fromPrelRatio fromDataRatio pgWithDouble pgWithDoublesmkPgWithDouble withDouble doubleClsfromPrelDouble ShowArbitraryshowArbitraries IOGeneratorgenerateIOPairsAnnShowS ShownIOPairshowIOPairsHTMLshowIOPairsWithFormsHTMLshowIOPairsHTML'nubOn nubSortedOn nubSortedOn'iopairToInputs assToStringshowIOPairHTMLshowIOPairWithFormHTMLmkForm showsInputs escapeQuotegenerateIOPairsLitNum integralsmhGenerateIOPairssassasNumsasFalse sasIntegralmapSAchopBycvt showsListgenerateIOPairsFun$fIOGeneratora$fShowArbitrary(->)$fShowArbitrary[]$fShowArbitrary(,,)$fShowArbitrary(,)$fShowArbitraryEither$fShowArbitraryMaybe$fShowArbitraryRatio$fShowArbitraryOrdering$fShowArbitraryChar$fShowArbitraryDouble$fShowArbitraryFloat$fShowArbitraryInteger$fShowArbitraryInt$fShowArbitraryBool$fShowArbitrary()$fIOGenerator(->)$fIOGenerator(->)0$fIOGenerator(->)1$fIOGenerator(->)2$fIOGenerator(->)3$fIOGenerator(->)4$fIOGenerator(->)5$fIOGenerator(->)6$fIOGenerator(->)7$fIOGenerator(->)8availableNamesprioritizedNamesToPgf1Ef1EFef1EIOf1EFIOBestResultgetBestszero fromLists$fMemoableBestBest $fSearchBest $fDelayBest$fMonadPlusBest$fAlternativeBest $fMonadBest$fApplicativeBest $fFunctorBest $fShowBest $fReadBest SplicedPrimsget1getManygetManyM getManyTypednoBKcgetOnesynthsynthM synthTypednoBKQ quickStart quickStartF filterGetOne_ filterGetOnefilterGetOneBK synthFilt synthFiltFsynthAllcatchIOversionbindirlibdirdatadir libexecdir sysconfdir getBinDir getLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName versionInfo mhVersion ghcVersionnowSubstTyped:::DecoderDecTypeNameTyConTyVarKindTypeTVTCTA:>:->:=>tracesizemapTV negateTVIDs limitTypelt alltyvars alltyvars'tyvarstyvars'maxVarIDnormalizeVarIDs normalizeeqType saferQuantify negUnquantifyquantify quantify' unquantify unifyFunApuniFunApmguFunApmfa pushArgsCPSpushArgsgetRetgetArgs getNumCxtsgetArity getArities getAritiesRet splitArgs revSplitArgs revGetArgspopArgstypeetyper showsAssoc emptySubst unitSubstmatchmatch2Apmgumgu2ApvarBindsubstOK assertsubst plusSubst lookupSubstapply applyCheck $fShowType$fFunctorTyped GHC.TypesIntbaseGHC.IntInt8Int16Int32Int64TyConLibMap defaultTCL tyConsToTCL defaultTyConstupleMax tuplenameunitdisj nameToTyCon thTypesToTCLthTypesToTyConsthTypeToTyConsliftListscan10mergesortWithBymergesortWithByBotmergesortWithByBotIOmergesortWithByBot'mergesortWithByBot'IOmerge_pairsBotmerge_pairsBotIO mergeWithBymergeWithByBotmergeWithByBotIO diffSortedBydiffSortedByBot tokoro10niltokoro10!?trToTypefunTyConundefTC showTypeName thTypeToType thTypeToType'tyVarBndrToName typeToTHType typeToTHType'plainTV unPlainTVtvToNamesectionedArrowreadHsTypeSigsmkSigEhsQTypeToTHTypehsTypeToTHTypevarnameshsNameToTHNamehsNameToStringhsAsstToTHTypehsQNameToTHType readHsDecls nameToNameStrshowName showVarName expToExpExp typeToExpType patToExpPat decsToExpDecs decToExpDecclauseToExpClauseDynamicdynType unsafeFromDyndynExp unsafeToDynaLittleSafeFromDynfromDyn fromDynamicdynApplydynApp dynAppErrfromPDdynamicdynamicHp'px $fShowDynamic Coarbitrary coarbitrary Arbitrary arbitraryCoarbGenunGensized arbitraryR arbitraryUnitcoarbitraryUnit arbitraryBoolcoarbitraryBool arbitraryIntcoarbitraryIntarbitraryIntegercoarbitraryIntegerarbitraryIntegral logvariant newvariantcoarbitraryBitsarbitraryFloatarbitraryDoublecoarbitraryFloatcoarbitraryDoublefractionarbitraryRealFloatcoarbitraryRealFloat arbitraryCharretSpcarbASCarbNumarbLowarbUppcoarbitraryChararbitraryOrderingarbitraryRatioarbitraryMaybe arbitraryList sequenceSizedklglg'multiplyDeBruijnBitPosition arbitraryPairarbitraryEitherarbitraryTriplet arbitraryFunarbitraryRationalcoarbitraryOrderingcoarbitraryListcoarbitraryMaybecoarbitraryEithercoarbitraryRatiocoarbitraryPaircoarbitraryTripletcoarbitraryFun$fCoarbitraryRatio$fArbitraryRatio$fCoarbitrary(->)$fArbitrary(->)$fCoarbitrary(,,)$fArbitrary(,,)$fCoarbitraryEither$fArbitraryEither$fCoarbitrary(,)$fArbitrary(,)$fCoarbitrary[] $fArbitrary[]$fCoarbitraryMaybe$fArbitraryMaybe$fCoarbitraryOrdering$fArbitraryOrdering$fCoarbitraryChar$fArbitraryChar$fCoarbitraryDouble$fArbitraryDouble$fCoarbitraryFloat$fArbitraryFloat$fCoarbitraryInteger$fArbitraryInteger$fCoarbitraryInt$fArbitraryInt$fCoarbitraryBool$fArbitraryBool$fCoarbitrary() $fArbitrary() $fMonadGen$fApplicativeGen $fFunctorGen $fNearEq(,,) $fNearEq(,)$fNearEqEither $fNearEqMaybe $fNearEq[] $fNearEqRatio$fNearEqInteger $fNearEqInt $fNearEqChar$fNearEqOrdering $fNearEqBool $fNearEq() $fNearEqFloat$fNearEqDoubledynSdynKdynIdynBdynCdynS'dynB'dynC'ssprimebprimecprimeundefTCLFMTypeEmptyFMTFMTtvFMTtcFMTtaFMTfnFMTfunFMT lookupFMT lookupFMTFMTmapFMTeltsFMT fmtToList fmToTypedVars fmToTypedCons updateFMTunitFMTunionFMT$fMonoidFMType defaultVarLibdefaultPrimitivesVarLib DictionaryDictundictSKIBCS'B'C'YLambdaX FunLambdaFunXTuplePrimConContext:$CaseFixVarNameprimIdVarisAbsentisa actualVarName stripByd_exprToTHExpLite exprToTHExp' funOccursIn lightBetareplaceliftFunnliftnliftIntnapplyisObviouslyBoringiOBmatchExpprimitivesToTCLprimitivesToVLlenDefaultPrimitives $fReadExp$fEqDictionary$fOrdDictionary unDeBruijnundeblambdaisFreeInfreeVar unsafeExecutefix ShortString showsBriefly readsBriefly showBriefly readBriefly$fShortStringType$fShortString()$fShortString(,)$fShortString(,,)$fShortStringWord8$fShortStringInt8$fShortStringInt16$fShortStringInt$fShortStringCoreExpr$fShortStringBool$fShortString[] finiteHVss finiteHVsssEU numUniIDsinputsapfreshTermStatTSunTSConstrExpranniDszctorfieldsTBSIOPairIOPoutputnormalizeMkIOPvrmapU maybeCtorhasExistentialvisiblesunify unifyListbindoccursInfreshmapE applyIOPsapplyIOPmapIOPmapTypeeinitTSupdateTSevalTStermCritfullyLex revFullyLexaWiserevAWiselinearrevArgslessRevListsLex lessListsLex cmpExprsscmpExprs cmpExprSzscap $fFunctorExpr$fFunctorIOPairStsubstnextVarUniTemptyStfreshIOPapplyUT applyIOPUTunifyUT appUnifyUTFMExprFMExprs EmptyFMEsFMEsnilFMEsconsFMEsEmptyFMEFMEexistentialFME universalFMEconApFME iopsToVisFME iopsToFMEvisIOP iop2Assoc assocsToFME updateFME updateFMEsemptyFME insertNthunifyFME unifyFME' unifyFMEsvalsFMEvalsFMEsmatchFME matchFME'matchExistential matchFMEs$fFunctorFMExprs$fFunctorFMExprMapListMapRealMapCharMapIxMIxMapNat MapIntegralMInegArrow nonnegArrowMapIntMapLargeIntegralMLI MapInteger MapFiniteListMFLnilArrow consArrowML MapTripletMapPairMP MapEitherMapMaybeMM MapOrderingMOMapBoolMBMapUnitMUFunctionProperty==> getFunctionmemoUnitappUnitmemoBoolappBoolprop_inverseBool memoOrdering appOrdering memoMaybeappMaybeprop_inverseMaybe memoEither appEitherprop_inverseEithermemoPairappPair memoTriplet appTripletprop_inverseTripletmemoList appList10appList5appList3appList1appListmemoFiniteList appFiniteList isLongerThanprop_inverseListprop_inverseListB memoInteger appIntegermemoLargeIntegralappLargeIntegralmemoIntappInt memoIntegral memoPosNat bitsToPosNat appIntegral appPosNat posNatToBitsprop_inverseIntegralprop_inversePosNatprop_bitsToFromPosNatmemoIx10memoIx3memoIxappIxmemoCharappCharprp_inverseCharmemoRealappRealprop_inverseRealheavy memoHeavy memoizedHeavyheavy2 memoHeavy2memoizedHeavy2 memoHeavy2'memoizedHeavy2'heavy3 memoHeavy3memoizedHeavy3 heavyList memoHeavyListmemoizedHeavyListshrinkDBDepthFstnilsjOINconstrans categorizeDB categorizeuncategorizeDB uncategorizeswaptest''test'main reserveTVars PriorSubstsPSunPS substOKPSmonsubstmkPSrunPSdelayPSndelayPS convertPSdistPSapplyPSupdatePS updateSubstPSsetSubstmguPSmgtPS varBindPSmatchPS lookupSubstPSgetSubstgetMxupdateMxnewTVarpsListToPSRecomppsRecompToPSListpsListToPSDBoundpsDBoundToPSListtup23tup32uniqBy$fFunctorPriorSubsts$fMonoidPriorSubsts$fMonoidPriorSubsts0$fDelayPriorSubsts$fMonadPlusPriorSubsts$fAlternativePriorSubsts$fMonadPriorSubsts$fApplicativePriorSubstsXVarLibXVLvarLib invVarLibzeroIDsuccIDnegateID mkXVarLib extractNameparseTypedIOPairssinferTypedIOPairssparseTypedIOPairss'plus parseTypes parseIOPairssclauseToIOPairclauseToIOPair' matchTypeunquantifySubstmguType inferTypeinferTfunApMfAM tapplyIOP tapplyExpr unzipTypedgetMbTypedConstrgetTypedConstr mkTypedConstrpatToExpstrToIntnatLimit natToConExpsmallNat thExpToExprFunBKFRec IntroUniT IntroducerBK maxNumBVsarityiopairsfmexpr toBeSoughtmkBKFunmkRecFun mkInitRecFun setIOPairsapplyFun analyticSynthanalyticSynthAndInfTypefastAnalSynthNoUniTfastAnalSynthmNoUniTanalSynthNoUniT analSynth analSynthm headSpine analSynthUTmmkArgs+++ ndelayIntrointroAny+/ introVarUTm introVarm introVarm'introVar introConstr divideIOP shareConstr sConstrIsselect introCasedropNthintroBKm introBKUTmintroBKsubtractIOPairsFromIOPairsBKUTmsubtractIOPairsBKUTmsubtractIOPairsFromIOPairsUTmsubtractIOPairsFromIOPairsUTm'subtractIOPairsUTmsubtractIOPairUTmsubtractIOPairsFromIOPairsmsubtractIOPairsFromIOPairsmFMEsubtractIOPairsmFMEsubtractIOPairsFromIOPairsBKm subtractIOPairsFromIOPairsBKmFMEsubtractIOPairsBKmFMEunifyingIOPairsMapTypeMTtvMTtcMTgenMTtaMTfunMT PossibilitylookupMTretrievedecode decodeVarencodemkMTmkMT'mkMTIOmkMTIO'interleaveActions uncurryTyArbMemoMap SpecialMapCoarbMapArbMapCmpMapMapTCRTrieTriesMaps GeneratorCmp PackedOrd ExpResultOrder mkUncurry uncurryDynmkCurrycurryDyn uniqueVarstypeToRandomsOrdtypeToRandomsOrdDMttro dynToCompare uncurryTy'pair mkRandTrieargTypeToRandomsargTypeToRandomssnubByCmpmkMapmkCmpMap compareMaybe compareRatiocompareRealFloat compareList compareEither comparePair typeToCompare typeToOrdmkArbMap mkSpecialMap combineTCs typeToArb mkCoarbMap typeToCoarb mkMemoMap memoLength typeToMemoarbitrariesByDyn arbsByDyn genAppDynarbitrariessByDynabd arbsByDyn'gens memoToFileMemoCondfps memoPSRTIOmemoRTIOmemoerunsafeWithPTOOptmaybeWithTOOpt unsafeWithPTO maybeWithTOBoolOrderingnewPTOunsafeOpWithPTO maybeWithTO'withTO' wrapExecutionmeasureExecutionTimecatchIthandler realHandler catchYield childHandlerrealChildHandlermkTrieIOmatchingProgramsIOunifyingProgramsIOmkTriePrimCommonCmnopttclvlpvlrtProgramGeneratorIO mkTrieOptIO mkTrieOptmatchingProgramsmatchingProgramsWOAbsentsunifyingPrograms WithCommon extractCommon extractTCL extractVL extractRTriereducermkCommonretsTVar annotateTCEs splitPrims splitPrimssmapSumapplyDowindwind_fromAssumptionsretMono fromAvailmguAssumptionsmguAssumptions'matchAssumptionsmguAssumptions_mguAssumptions_' retPrimMonofunApSub funApSubOpfap mapAndFoldMretGenretGen' retGenOrdorderedAndUsedArgsusedArg retGenTV1 retGenTV0 filtExprs filterExprs getArgExprsgaeconstEqceqrecHead retSameValrsvrsv' returnsAtoA returnsIdisIdisId'isId''retValrvmapsub isConstrExprisClosed isClosed'includesStrictArganyRec recursiveconstRec belowIsUsedisUsedmkSubstsmkSubstmkRetty reorganizer_hitcombstails FiltrableBFCmpBotfilterBF spreexecute opreexecuteunscanlfilterDBfilterRc sfilterRcunscanlByListMxunscanlByListRcdeleteListByList comparers liftCompareliftCmpliftCompareBot liftCmpBotcmpBotcmpBotIOdlbBotdlbrepEqClsBy_simple repEqClsByMx repEqClsByRc eqClsBy_naivefcnrndcnrndstcnrnds repEqClsByeqClsBy eqClsByNth eqClsByFstNs isLongEnoughfilterEligiblesmergeBy ofilterRc unscanlBy///$fFiltrableBFDBound$fFiltrableBFRecomp$fFiltrableBFMatrixMemoDebMemoTrieBFMBFtraceTyfromMemotoMemolmtlookupFunsPolymkTrieMDmguFuns generateFuns sortWithByBot spreexecuteDMsprDM forceList filterList filterListDBfilterDM filterDMIO filterDMlitelistCmp nthCompareBot listCmpBotnthCompareBotIO listCmpBotIO sfilterDMTreeTrForestfilterTrbagCmp prop_mkTipmkTip mkForestsmkForestaccumulateForests mergeForests differencediff flattenTrremoveFirstOfFirstlookupFunsSharedunifyingPossibilitiesunifyingPossibilitiesIOmkTriePG mguProgramsIO mguProgsIOmguProgs lookupListrieBitSetBFTTypeTrieExpTrieExpTip reorganize_ reorganizer'reorganizerId'classify traceExpTyfiltBFfDMfiltBFIOlmttymemocond matchProgsspecializedPossibleTypes mkTrieOptSFdbToCumulativeMxdbtToCumulativeMxmkMTtymkMTexpmondepthunBFM tokoro10apspecializedTypesspecializedCases specCases uniExprs_lookupReorganized specTypesfunApSub_forcingNilfunApSub_forcingNil_specfunApSub_forcingNil_contfunApSub_forcingNil_cont_specmguAssumptionsBitsmguAssumptionsBits' specCases'lookupWithAbsentslookupNormalizedSharedETunifyableExprs memocondexplookupTypeTrielookupTypeTrieAndExpTrielookupNormReorganized lookupNormlookupNormalizedShared countBitslookupNormalizedSharedBitsmatchFunctions matchFuns matchFuns'fromAssumptionsBits retMonoBitsretPrimMonoBits funApSubBitsfunApSubOpBitsfunApSubBits_resettingfunApSubOpBits_resettingfapBitsforceNilfunApSubBits_forcingNilfunApSubBits_forcingNil_contfunApSubOpBits_forcingNil_contfunApSubOpBits_forcingNil countBits32 retGenOrdBits retGenTV1Bits retGenTV0BitsmatchAssumptionsBitsfiltBFminconsistentDBTToRcT computeExpTiplookupUniExprs makeUniExprsunifyableExprsIOlookupTypeTrieIOprocTuplookupReorganizedIOlmtIO ensureAtHand makeAtHand addToLastmkSinglematchFunctionsIO matchFunsIOtemplate-haskellLanguage.Haskell.TH.SyntaxExppprintUCp1' useArrowTuAT primitivesp expIsAConstrnumCxtstoCxt primitivescmkPG'mkPGSF' refmemodeb defaultMDtrsToTCL trsToTCstrsetnoFiltermatchPs mxExprToEverymxExprFiltEveryunwrapAEeMeIOstripgenExpsfindDofpartfpartIOspawnIOunqConsnewNamemkNameLanguage.Haskell.TH.LibcharLstringLintegerLintPrimL wordPrimL floatPrimL doublePrimL rationalL stringPrimL charPrimLlitPvarPtupPconPinfixPtildePbangPasPwildPrecPlistPsigPviewPfieldPatclausevarEconElitEappEinfixEinfixAppsectionLsectionRlamElamCaseEtupEcondEmultiIfEletEcaseEdoEcompEfromE fromThenEfromToE fromThenToElistEsigErecConErecUpdEstaticEfieldExpguardedBnormalBnormalGEpatGEbindSletSnoBindSparSfunDvalDdataDnewtypeDtySynDclassDinstanceWithOverlapDsigDforImpDpragInlD pragSpecD pragSpecInlD pragSpecInstD pragRuleDpragAnnD dataFamilyDopenTypeFamilyD dataInstD newtypeInstD tySynInstDclosedTypeFamilyD roleAnnotDstandaloneDerivD defaultSigDcxtnoSourceUnpackednesssourceNoUnpack sourceUnpacknoSourceStrictness sourceLazy sourceStrictnormalCrecCinfixCforallCgadtCrecGadtCbangbangType varBangTypeforallTvarTconTtupleTarrowTlistTappTsigT equalityTlitT promotedTpromotedTupleT promotedNilT promotedConsTnumTyLitstrTyLitnominalRrepresentationalRphantomRinferRvarKconKtupleKarrowKlistKappKstarK constraintKnoSigkindSigtyVarSiginjectivityAnncCallstdCallcApiprim javaScriptunsafesafetypeFamdataFamtySynEqnruleVar typedRuleVarData.Typeable.InternalmkAppTyTypeableTypeRepVarEConELitEAppEInfixEUInfixEParensELamELamCaseETupE UnboxedTupECondEMultiIfELetECaseEDoECompE ArithSeqEListESigERecConERecUpdEStaticE UnboundVarEMatchClauseQExpQDecQPatLitPVarPTupP UnboxedTupPConPInfixPUInfixPParensPTildePBangPAsPWildPRecPListPSigPViewPMatchQClauseQStmtQConQTypeQListTForallTAppTSigTVarTConT PromotedTInfixTUInfixTParensTTupleT UnboxedTupleTArrowT EqualityTPromotedTupleT PromotedNilT PromotedConsTStarT ConstraintTLitT WildCardTValDSigD RoleAnnotDFunDDataDNewtypeDTySynDClassD InstanceDForeignDInfixDPragmaD DataFamilyD DataInstD NewtypeInstD TySynInstDOpenTypeFamilyDClosedTypeFamilyDStandaloneDerivD DefaultSigD BangTypeQ VarBangTypeQFieldExpFieldPatNamePatQ FieldPatQFunDepPredPredQ TyVarBndrPlainTVKindedTVDecsQ RuleBndrQ TySynEqnQTExpunTypeInjectivityAnnOverlap Overlappable OverlappingOverlaps Incoherent Data.Typeablegcast2gcast1gcasteqTcast rnfTypeRep showsTypeReptypeOf7typeOf6typeOf5typeOf4typeOf3typeOf2typeOf1typeOftypeRep typeRepArgs typeRepTyCon funResultTy splitTyConAppmkFunTy mkTyConApptypeRepFingerprintrnfTyConmkTyCon3tyConFingerprint tyConString tyConName tyConModule tyConPackage Typeable1 Typeable2 Typeable3 Typeable4 Typeable5 Typeable6 Typeable7Data.Type.Equality:~:Refl Data.ProxyProxyghc-boot-th-8.0.1.20161018GHC.LanguageExtensions.Type ExtensionCpp UnicodeSyntaxOverlappingInstancesUndecidableInstancesIncoherentInstancesUndecidableSuperClassesMonomorphismRestriction MonoPatBindsMonoLocalBindsRelaxedPolyRecExtendedDefaultRulesForeignFunctionInterfaceUnliftedFFITypesInterruptibleFFICApiFFIGHCForeignImportPrim JavaScriptFFIParallelArraysArrowsTemplateHaskellTemplateHaskellQuotes QuasiQuotesImplicitParamsImplicitPreludeScopedTypeVariablesAllowAmbiguousTypes UnboxedTuples BangPatterns TypeFamiliesTypeFamilyDependencies TypeInTypeOverloadedStringsOverloadedLists NumDecimalsDisambiguateRecordFieldsRecordWildCards RecordPuns ViewPatternsGADTs GADTSyntaxNPlusKPatternsDoAndIfThenElseRebindableSyntaxConstraintKinds PolyKinds DataKinds InstanceSigs ApplicativeDoStandaloneDerivingDeriveDataTypeableAutoDeriveTypeable DeriveFunctorDeriveTraversableDeriveFoldable DeriveGenericDefaultSignaturesDeriveAnyClass DeriveLiftTypeSynonymInstancesFlexibleContextsFlexibleInstancesConstrainedClassMethodsMultiParamTypeClassesNullaryTypeClassesFunctionalDependenciesExistentialQuantification MagicHashEmptyDataDeclsKindSignaturesRoleAnnotationsParallelListCompTransformListCompMonadComprehensionsGeneralizedNewtypeDeriving RecursiveDoPostfixOperators TupleSections PatternGuardsLiberalTypeSynonyms RankNTypesImpredicativeTypes TypeOperatorsExplicitNamespacesPackageImportsExplicitForAllAlternativeLayoutRule!AlternativeLayoutRuleTransitionalDatatypeContextsNondecreasingIndentation RelaxedLayoutTraditionalRecordSyntax LambdaCase MultiWayIfBinaryLiteralsNegativeLiteralsDuplicateRecordFieldsOverloadedLabels EmptyCasePatternSynonymsPartialTypeSignaturesNamedWildCardsStaticPointersTypeApplicationsStrict StrictDataMonadFailDesugaringLanguage.Haskell.TH.Ppr pprParendTypepprPatpprLitpprExpPprpprppr_list thisModuleappsE varStrictType strictTypeunpacked notStrictisStrictequalPclassPparensTuInfixTinfixTclosedTypeFamilyKindDclosedTypeFamilyNoKindD familyKindD familyNoKindD pragLineD instanceDstringE arithSeqElam1EuInfixEparensEdynpatGnormalG fromThenToRfromToR fromThenRfromRparensPuInfixPInfoQTyLitQCxtQBodyQGuardQRangeQSourceStrictnessQSourceUnpackednessQ StrictTypeQVarStrictTypeQ defaultFixity maxPrecedenceunboxedTupleTypeNameunboxedTupleDataName tupleTypeName tupleDataName nameSpace namePackage nameModulenameBase extsEnabled isExtEnabledrunIOlocation isInstancereifyConStrictness reifyModulereifyAnnotations reifyRolesreifyInstances reifyFixityreifylookupValueNamelookupTypeNamerecover reportWarning reportErrorreportrunQ NameSpaceLoc loc_filename loc_package loc_module loc_startloc_endInfoClassIClassOpITyConIFamilyI PrimTyConIDataConIVarITyVarI ModuleInfo ParentNameArityUnlifted InstanceDecFixityFixityDirectionInfixLInfixRInfixNLitCharLStringLIntegerL RationalLIntPrimL WordPrimL FloatPrimL DoublePrimL StringPrimL CharPrimLBodyGuardedBNormalBGuardNormalGPatGStmtBindSLetSNoBindSParSRangeFromR FromThenRFromToR FromThenToRTypeFamilyHeadTySynEqn FamFlavourTypeFamDataFamForeignImportFExportFCallconvCCallStdCallCApi JavaScriptSafetyUnsafeSafe InterruptiblePragmaInlineP SpecialisePSpecialiseInstPRulePAnnPLinePInlineNoInline Inlinable RuleMatchConLikeFunLikePhases AllPhases FromPhase BeforePhaseRuleBndrRuleVar TypedRuleVar AnnTargetModuleAnnotationTypeAnnotationValueAnnotationCxtSourceUnpackedness SourceUnpackSourceNoUnpackNoSourceUnpackednessSourceStrictness SourceLazy SourceStrictNoSourceStrictnessDecidedStrictness DecidedLazy DecidedStrict DecidedUnpackConNormalCRecCInfixCForallCGadtCRecGadtCBangFamilyResultSigNoSigKindSigTyVarSigTyLitNumTyLitStrTyLitRoleNominalRRepresentationalRPhantomRInferR AnnLookupAnnLookupModule AnnLookupNamereviewLanguageLHaskellLExcel LJavaScript QueryOptionsdepthabsents defaultQO loopErrMsgexpToPlainString expToStringexpSigToStringpprnnreplaceRightArrowmkButtonusesBlackListedpartial escapeHTMLannotateString annotateWordxlmapannotateEverywhere annotateFree patsToNames patToNames annotateNamerefLinkrefermkLinkreferMb mapNameModulerepch3mkAssocpreludeNameBasesdataCharNameBases primssToStrs primsToStrs primsToNames referHackage hackageEncode referHoogletotalspartialsaliasesnormalizeSpaces mapAvailablesassocAvailables pprintPrimsimplifysimpnamesToPrimitives!!!namessToPrimitivesprioritizedNamesToNamesspNTPchopNStrategyconEsconPs synthesizeprepare quickStartC quickStartCF filterGet1_ filterGet1 filterGet1BKgetFiltgetFiltFgetAll batchExamplethExpssToEvery