h$4      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                                                                                   9NoneMagicHaskellerMapList 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.MagicHaskeller length limitMagicHaskellerrange 0None3   NoneNone8 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNO8 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNONoneqrr4None None>MagicHaskeller. applies a function to the bag at each depth. MagicHaskeller flattens each bag.MagicHaskeller converts bags to sets, by (possibly sorting each bag and) removing duplicates. Efficiency on lists with lots of duplicates is required.MagicHaskellerCombiner, which is used when there are equivalent elements (compared by the comparer specified by the next argument). The return value of this combiner should also be equivalent to the two arguments.MagicHaskellerComparerstuvwxyz{|}~|}~yz{stuvwxNone^MagicHaskellerUnlike ,  , 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=   None; Nonez None  NoneG MagicHaskellerreadHsTypeSigs reads a module string and returns an Exp that can be supplied to MagicHaskeller.p !Nonej "None> MagicHaskellerreserveTVars takes the number of requested tvIDs, reserves consecutive tvIDs, and returns the first tvID. # None None"9MagicHaskeller collects branch nodes whose children are leaf nodes. This can be used for incremental learning.MagicHaskeller$ is useful for incremental learning.MagicHaskeller can be used as a VarLib for testing and debugging. Currently this is used only by the analytical synthesizer.MagicHaskellerdefaultPrimitives 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. #None#x $None#  %None#  &None$ 'None$\  None?$(None$ )None%TMagicHaskellerlength of availsMagicHaskellerarity of the head function*None%  None ?&MagicHaskellervisible modules (including package modules). You may omit the Prelude.MagicHaskeller-modules to be loaded (except package modules)MagicHaskeller+visible modules (including package modules)+None'5 ,None*?MagicHaskellerRecompute instead of memoizing.MagicHaskellerUse the memoization table based on lazy evaluation, like in older versions.MagicHaskellerUse the directory specified by FilePath% as the persistent memoization table. MagicHaskellerGeneral-purposed memoizer (This could be put in a different module.) MagicHaskeller4This will be used instead if the entry is not found. MagicHaskeller)look up the memoization table in the RAM.MagicHaskeller4This will be used instead if the entry is not found. MagicHaskellerparserMagicHaskellerprinterMagicHaskellerwhere to memoizeMagicHaskeller invoked if there is no such file  NoneB1MagicHaskeller(options that limit the hypothesis space.MagicHaskellerUse 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.MagicHaskellermemoization 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.MagicHaskellerThis represents when to memoize. It takes the query type and the query depth, and returns True if the corresponding entry should be looked up from the lazy memo table. Currently this only works for ProgGenSF.MagicHaskellerThis represents which memoization table to be used based on the query type and the search depth, when using the  everythingIO family.MagicHaskellerJust 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.MagicHaskellerIf this option is True, -. instead of /0 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.MagicHaskellerIf 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 1 instead of 2. MagicHaskellerThis option is now obsolete, and we always assume True now. If this option was False, data structures might not contain functions, and thus types like  [Int->Int], (Int->Bool, Char), 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.)MagicHaskellerIf this option is True, matching at the antecedent of induction rules may occur, which constrains generation of existential types. You need to use prefixed (->) to show that some parameter can be matched at the antecedent, e.g., p [| ( []::[a], (:)::a->[a]->[a], foldr :: (a->b->b) -> b -> (->) [a] b ) |] See LibTH.hs for examples.MagicHaskellerEach 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 \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 \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.MagicHaskellerIf 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.MagicHaskellerThe random seed.MagicHaskellernumber of random samples at each depth, for each type, for the filter applied during synthesis (used by ProgGenSF, &c.).MagicHaskellernumber of random samples at each depth, for each type, for the filter applied after synthesis (used by filterThenF, &c.).MagicHaskellerdefault options options = Opt{ primopt = Nothing , memodepth = 10 , memoCondPure = \ _type depth -> 0 return $ if depth < 10 then Ram else Recompute , execute = unsafeExecute , timeout = Just 20000 , forcibleTimeout = False , guess = False , contain = True , constrL = False , tv1 = False3NoneCN MagicHaskellerseq or deepSeq(=Control.Parallel.Strategies.sforce). For our purposes seq is enough, because a is either   or  . NoneDMagicHaskeller 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.MagicHaskeller mkRandTrieExt is an extensible version of  that can be used with various types including user-defined ones.None>EiMagicHaskellermicrosecs until timeout** NoneF1 NoneIMagicHaskeller*options for limiting the hypothesis space.MagicHaskeller;|mkTrie| creates the generator with the default parameters.MagicHaskellerUse memoization requiring IOMagicHaskellerUse memoization requiring IOMagicHaskeller0ProgramGenerator is a generalization of the old Memo type. MagicHaskeller;|mkTrie| creates the generator with the default parameters.MagicHaskellerannotated 'Typed [CoreExpr]'MagicHaskeller$ can be used for incremetal learning4NoneKf None>L"MagicHaskellerQMagicHaskellerProgram 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 ProgGen,) expressions with size N may not appear at depth N but some deeper place. ProgGenSF 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  ProgGenSF depends on hard use of unsafe* stuff, so if there is a bug, it may segfault....  None>VMagicHaskellerProgram 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 ProgGen,) expressions with size N may not appear at depth N but some deeper place. ProgGenSF 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  ProgGenSF depends on hard use of unsafe* stuff, so if there is a bug, it may segfault....8NoneY| MagicHaskellerexistential variable. When doing analytical synthesis, there is no functional variable. MagicHaskelleruniversal variable. When doing analytical synthesis, there is no functional variable. Int````TH.Namea```a` MagicHaskeller*number of variables quantified with forall MagicHaskeller?input example for each argument. The last argument comes first. MagicHaskeller  applies a substitution which replaces existential variables to an expression. MagicHaskeller fusion of apply s and fresh f MagicHaskellerthe to-be-sought list9 9None?Z :NoneZG% ;None[ MagicHaskellerFMExpr a is a finite trie representing  Expr () -> a <None\n MagicHaskeller#function specification by examples. MagicHaskellerthe function is really a background knowledge (and thus there is no need for loop check) MagicHaskeller it is actually a recursive call. MagicHaskellerbackground knowledge.: None`MagicHaskeller 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 everyFooIf you do not think this function reduces the number of your keystrokes a lot, you can do without it.MagicHaskeller is used to convert your primitive component set into the internal form.MagicHaskeller is defined as: 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.)MagicHaskellerThose 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.)MagicHaskellerThose 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.)MagicHaskellerThose 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.)MagicHaskeller pred finds an expression e that satisfies pred e == True, and returns it in  . MagicHaskeller$ prints the expression found first. MagicHaskeller; prints all the expressions satisfying the given predicate.MagicHaskeller; prints all the expressions satisfying the given predicate.MagicHaskeller is like , but by itself it does not print anything. Instead, it creates a stream of expressions represented in tuples of  ! and the expressions themselves. MagicHaskeller+ may be used to further filter the results.MagicHaskellerio2pred converts a specification given as a set of I/O pairs to the predicate form which other functions accept.MagicHaskeller1 pretty prints the results to the console, using  MagicHaskeller is the  version of pprsMagicHaskellerpprsIOn 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]))MagicHaskeller+Quote a tuple of primitive components here.MagicHaskeller This becomes  [Primitive] when spliced.MagicHaskeller6number of random samples at each depth, for each type.MagicHaskeller6number of random samples at each depth, for each type.MagicHaskeller This becomes  [Primitive] when spliced.MagicHaskellertime in microsecondsMagicHaskellermemoization depth. (Sub)expressions within this size are memoized, while greater expressions will be recomputed (to save the heap space).MagicHaskeller2whether to include functions with unused argumentsMagicHaskeller2whether to include functions with unused argumentsMagicHaskellerprogram generatorMagicHaskeller2whether to include functions with unused argumentsMagicHaskellerprogram generatorMagicHaskeller2whether to include functions with unused argumentsMagicHaskellerprogram generatorMagicHaskeller2whether to include functions with unused argumentsMagicHaskellerdummy argumentMagicHaskellerprogram generatorMagicHaskeller2whether to include functions with unused argumentsMagicHaskellerprogram generatorMagicHaskeller2whether to include functions with unused argumentsMagicHaskeller query depthMagicHaskellerprogram generatorMagicHaskellerprogram generatorMagicHaskeller query typeMagicHaskellerprogram generatorMagicHaskeller query typeMagicHaskellerprogram generatorMagicHaskeller query typeMagicHaskellerprogram generatorMagicHaskeller query typeMagicHaskeller2whether to include functions with unused argumentsMagicHaskeller2whether to include functions with unused argumentsMagicHaskeller2whether to include functions with unused argumentsMagicHaskeller2whether to include functions with unused argumentsMagicHaskeller2whether to include functions with unused argumentsMagicHaskeller2whether to include functions with unused argumentsMagicHaskeller2whether to include functions with unused arguments  NoneMagicHaskeller replaces uncommon functions like catamorphisms with well-known functions.MagicHaskeller*Library used by the program server backendMagicHaskeller2whether to include functions with unused arguments  None=NoneANoneiMagicHaskeller replaces uncommon functions like catamorphisms with well-known functions.NoneG qr qrNoneMagicHaskeller;get1 can be used to synthesize one expression. For example,putStrLn $ 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 aMagicHaskeller+getMany does what you expect from its name.MagicHaskellergetManyTyped 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.MagicHaskellerAlso, ! $(c [d| ... |]) :: SplicedPrims   is a helper function for extracting some info from the quoted declarations.MagicHaskellerExample: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 aMagicHaskeller is like synth, but adds the infered type signature to each expression. This is useful for executing the expression at runtime using GHC API.MagicHaskeller%target function definition by exampleMagicHaskeller4background knowledge function definitions by exampleMagicHaskeller%target function definition by exampleMagicHaskeller4background knowledge function definitions by exampleMagicHaskeller%target function definition by exampleMagicHaskeller4background knowledge function definitions by exampleMagicHaskeller%target function definition by exampleMagicHaskeller4background knowledge function definitions by example  NoneMagicHaskeller Example of quickStart [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.MagicHaskellertarget I/O pairsMagicHaskeller,I/O pairs for background knowledge functionsMagicHaskeller test functionMagicHaskellertarget I/O pairsMagicHaskeller,I/O pairs for background knowledge functionsMagicHaskeller test functionMagicHaskeller0session in which synthesized expressions are runMagicHaskellertarget I/O pairsMagicHaskeller test functionMagicHaskeller0session in which synthesized expressions are runMagicHaskellertarget I/O pairsMagicHaskeller,I/O pairs for background knowledge functionsMagicHaskeller test functionMagicHaskeller0session in which synthesized expressions are runMagicHaskellertarget I/O pairsMagicHaskeller,I/O pairs for background knowledge functionsMagicHaskeller test functionMagicHaskeller0session in which synthesized expressions are runMagicHaskellertarget I/O pairsMagicHaskeller,I/O pairs for background knowledge functionsMagicHaskeller test functionMagicHaskeller0session in which synthesized expressions are runMagicHaskellertarget I/O pairsMagicHaskeller,I/O pairs for background knowledge functions   >None?None'@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^__`abcdefghijklmnopqrstuvwxyz{|}~                                                                             $    )))))))))))))))))))))))))))))                      ,,,,                                                                                                                                                              21================================================================================                                                          @                                                                                  ! ! ! " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " "" # # # # # $$$$$$$$$$$& & & & & & & & & & & & & ' ' ' ' ' ' ' ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( * * + + + + + + + + + + + + + + + + + + , , , , ,, , 3 @  @  3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 4 4 44 4 4 4 4 4 45 5 5 5 5 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 77778 8 8 8 8 8 8 8 8 8 8 8 8 88 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 9 9 9 9 9 9 9 9 9 9 9 : : : : : : : :: : : : : : : : : : : : : : : : : : : : : : : : : : : : : ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < <                                                                                                                                             @                                                                                                                                                                                                                                                                                                                        >>>>>>>>????-MagicHaskeller-0.9.7.1-ESqxO1uL8z66lkbIDsDnD5MagicHaskellerMagicHaskeller.FastRatioMagicHaskeller.GetTimeMagicHaskeller.MyCheckMagicHaskeller.Minimal"Control.Monad.Search.CombinatorialControl.Monad.Search.BestMagicHaskeller.PolyDynamicMagicHaskeller.CoreLangMagicHaskeller.ProgramGeneratorMagicHaskeller.TICEMagicHaskeller.ExpressionMagicHaskeller.ExecuteAPI610MagicHaskeller.OptionsMagicHaskeller.InstantiateMagicHaskeller.ClassificationMagicHaskeller.ProgGenMagicHaskeller.ProgGenSFMagicHaskeller.ProgGenSFIORefMagicHaskeller.LibTHMagicHaskeller.IndividualMagicHaskeller.LibExcelMagicHaskeller.AnalyticalMagicHaskeller.RunAnalytical Data.MemoMagicHaskeller.NearEqMagicHaskeller.T10MagicHaskeller.TypesMagicHaskeller.TyConLibMagicHaskeller.ReadTypeRepMagicHaskeller.ReadTHTypeMagicHaskeller.ReadHsTypeMagicHaskeller.MHTHMagicHaskeller.PriorSubstsMagicHaskeller.ShortStringMagicHaskeller.FakeDynamicMagicHaskeller.MyDynamicMagicHaskeller.ReadDynamicMagicHaskeller.ExecuteMagicHaskeller.FMTypeMagicHaskeller.ExprStagedMagicHaskeller.CombinatorsMagicHaskeller.DebMTMagicHaskeller.MemoToFilesSystem.Posix.Process forkProcessControl.ConcurrentforkIOinit075 initializeMagicHaskeller.TimeOutMagicHaskeller.ClassifyMagicHaskeller.ClassifyDMMagicHaskeller.ClassifyTrMagicHaskeller.ClassLib MagicHaskeller.Analytical.SyntaxMagicHaskeller.Analytical.UniT MagicHaskeller.Analytical.Parser MagicHaskeller.Analytical.FMExpr$MagicHaskeller.Analytical.SynthesizeMagicHaskeller.LibExcelStagedPaths_MagicHaskellerMagicHaskeller.VersionInfoghc-primGHC.Prim unsafeCoerce#RationalRatio:%% numerator denominator notANumberreducechoose $fEnumRatio $fRealRatio $fShowRatio$fRealFracRatio$fFractionalRatio $fNumRatio $fEqRatio $fOrdRatio batchWritebatchRuntimeshowZero showCPUTimelenPrec Coarbitrary coarbitrary Arbitrary arbitraryCoarbGenunGensized arbitraryR arbitraryUnitcoarbitraryUnit arbitraryBoolcoarbitraryBool arbitraryIntcoarbitraryIntarbitraryIntegercoarbitraryIntegerarbitraryIntegral logvariant newvariantarbitraryFloatarbitraryDoublecoarbitraryFloatcoarbitraryDoublefractionarbitraryRealFloatcoarbitraryRealFloat arbitraryCharretSpcarbASCarbNumarbLowarbUppcoarbitraryChararbitraryOrderingarbitraryRatioarbitraryMaybe arbitraryListklglg'multiplyDeBruijnBitPosition arbitraryPairarbitraryEitherarbitraryTriplet arbitraryFunarbitraryRationalcoarbitraryOrderingcoarbitraryListcoarbitraryMaybecoarbitraryEithercoarbitraryRatiocoarbitraryPaircoarbitraryTripletcoarbitraryFun $fMonadGen$fApplicativeGen $fFunctorGen$fArbitraryRatio$fArbitrary(,,)$fArbitraryEither$fArbitrary(,) $fArbitrary[]$fArbitraryMaybe$fArbitraryOrdering$fArbitraryChar$fArbitraryDouble$fArbitraryFloat$fArbitraryInteger$fArbitraryInt$fArbitraryBool $fArbitrary()$fCoarbitraryRatio$fCoarbitrary-> $fArbitrary->$fCoarbitrary(,,)$fCoarbitraryEither$fCoarbitrary(,)$fCoarbitrary[]$fCoarbitraryMaybe$fCoarbitraryOrdering$fCoarbitraryChar$fCoarbitraryDouble$fCoarbitraryFloat$fCoarbitraryInteger$fCoarbitraryInt$fCoarbitraryBool$fCoarbitrary()NearEq~=DBMemoDBMunDBMMemoabletabulate applyMemoDBoundTDBTunDBTDBoundDBunDBSearchfromRctoRcfromMxtoMxfromDBfromDFtoDFmapDepthcatBagsmergesortDepthWithByifDepthDelaydelayndelaygetDepth mapDepthDB zipDepthDBRecompTRcTunRcTRecompRcunRcMatrixMxunMxBagStreamcattoList/\\/diagmsumMxmsumRclistToRcrcToMxmxToRcconsMxconsRc zipDepthMx zipDepthRc zipDepth3Mx zipDepth3RcprintMxprintNMx zipWithBFscanl1BFscanlRcshrinkdbtToRcT$fFunctorMatrix$fMonadPlusMatrix$fAlternativeMatrix $fMonadMatrix$fApplicativeMatrix$fMonoidMatrix$fSemigroupMatrix $fShowRecomp$fMonadPlusRecomp$fAlternativeRecomp $fMonadRecomp$fApplicativeRecomp$fFunctorRecomp$fMonoidRecomp$fSemigroupRecomp$fMonadPlusRecompT$fAlternativeRecompT$fMonadRecompT$fApplicativeRecompT$fFunctorRecompT$fMonoidRecompT$fSemigroupRecompT $fDelayStateT$fDelayRecompT $fDelayRecomp $fDelay[] $fDelayDBound$fMonadPlusDBound$fAlternativeDBound $fMonadDBound$fApplicativeDBound $fShowDBound$fFunctorDBound$fSearchMatrix$fSearchRecompT$fSearchRecomp $fSearch[] $fDelayMatrix$fSearchDBound $fDBDBound$fSearchDBoundT$fDelayDBoundT$fMonadPlusDBoundT$fAlternativeDBoundT$fMonadDBoundT$fApplicativeDBoundT $fDBDBoundT$fFunctorDBoundT$fMemoableMatrixRecomp$fMemoableDBMemoDBound $fShowMatrixBestResultgetBestszero fromLists$fMemoableBestBest $fSearchBest $fDelayBest$fMonadPlusBest$fAlternativeBest $fMonadBest$fApplicativeBest $fFunctorBest $fShowBest $fReadBest trToTHTypeDynamicdynType unsafeFromDyndynExp unsafeToDynaLittleSafeFromDynfromDyn fromDynamicdynApplydynApp dynAppErrfromPDdynamicdynamicH $fShowDynamicHValueHV PrimitiveVarPriorityLibVarLib DictionaryDictundictCoreExprSKIBCS'B'C'YLambdaX FunLambdaFunXTuplePrimConContext:$CaseFixVarNameprimIdVararityCEisAbsentisa actualVarName stripByd_headIsXisAPrimitiveCombinator removeAbsentsadjustXs unboundXssubexprssubbranchesbraparentsOfLeavespolargsisALeaf ceToPriority exprToTHExpexprToTHExpLite exprToTHExp' funOccursIn lightBetareplaceliftFunnliftnliftIntnapplyprimitivesToTCLprimitivesToVL dynamicsToVLprioritiesToVPL listToArrayprimitiveToDynamic defaultVarLiblenDefaultPrimitivesdefaultPrimitives $fReadExp$fEqDictionary$fOrdDictionary $fEqCoreExpr$fShowCoreExpr $fOrdCoreExpr$fShowDictionaryTI ceToDynamictiCEtiExseeseeTypeseesseesTypee2THE printTables printTable pprintTypemkVNamemkVNamesmkEsmkAsmkXsmkHdhdmnTHEQaimnTHEQhdmnTHEaimnTHEhdmntyaimntymkTVtvrstvastvrmaxArity maxLenavails maxDebindexmkCEmkCE_LambdaBoundHead pathToGHCloadObj prepareAPIpackageNameToFlagunsafeExecuteAPI executeAPI executeTHExpcompileCoreExpr unwrapCorece2b runCoreExprrunPrepedCoreExpr stmtToCoreperror thExpToStmt wrapLHsExprthExpToLHsExprcompileExprHscMainrepeatNrepeatIOforce$fEqExprMemoType RecomputeRamDiskOptprimopt memodepth memoCondPurememoCondexecutetimeoutforcibleTimeoutguesscontainconstrLtvndelaytv1tv0stdgennrandsfcnrandoptionsforgetnrndschopRndsfnrndsRTrie PackedOrd mkUncurry uncurryDynmkCurrycurryDyntypeToRandomsOrdtypeToRandomsOrdDM uncurryTy mkRandTrie mkRandTrieExtargTypeToRandomscompareRealFloat typeToCompare typeToOrd typeToArb FiltrablefiltfiltFun unsafeFilt unsafeFiltFunRelation fromListBy fromListByDB/ appendWithBydiffBycEQ SStrategysfilterofilter arbitrariesarbs/~ nubSortBy nubSortByBot/</ 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 $fShowAnnExprOptionsCommonCmnopttclvlpvlvplrtProgramGeneratorIOmkTrieIO mkTrieOptIOmatchingProgramsIOunifyingProgramsIOProgramGeneratormkTrie mkTrieOptmatchingProgramsmatchingProgramsWOAbsentsunifyingPrograms WithCommon extractCommonPrim extractTCL extractVL extractRTriereducermkCommon initCommon initCommonExt updateCommonretsTVar 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_hitcombstailsClassLibCLProgGenPGmkCL mguPrograms$fProgramGeneratorIOProgGen$fProgramGeneratorProgGen$fWithCommonProgGenPGSF ProgGenSF mkTrieOptSFIOfreezePS funApSub_ funApSub_speclookupNormalized tokoro10fst$fWithCommonPGSF$fProgramGeneratorPGSF$fMonoidWord32$fSemigroupWord32PGSFIORProgGenSFIORef$fWithCommonPGSFIOR$fProgramGeneratorIOPGSFIORFilter EverythingEveryIOEverytupunJustmkCurriedDeclsdefinepp1mkPGmkPGXmkMemomkPGSFmkMemoSFmkPG075 mkMemo075mkPGOptmkPGXOptmkPGIO mkPGXOptIO mkPGXOpts mkPGXOptsExt updatePGXOptsupdatePGXOptsFiltsetPG setPrimitives zipAppendloadf setTimeout unsetTimeoutsetDepth getEverythinggetEverythingF everything everythingFeveryACEetup everythingM everythingIO stripEvery unifyablematching unifyableF matchingFfindOneprintOneprintAnyprintAll printAllF filterFirst filterFirstF filterThenFeveryF filterThenfpfpartial fpartialIOftotalIOfpIOfIOmapIOio2predpprspprsIOpprsIOnlengths lengthsIO lengthsIOn lengthsIOnLnprintQOrderedOrd by1_compare EquivalenceEq--#==PartialPartundefsuccOnlyForNumberslast'tailgcdenumFromThenToinittv1tupletuple'mallmlistmlist'mnatmnaturalmlistnat mlistnaturalmnat_nchdmbmb'natnaturalnat' nat'woPrednatural'plusInt plusIntegernat_paranat_catalist''list'list list_parabooliF postprocessbyMapbyEqsbyOrdsskipskipEqskipOrd appearsInppLambdappvppopnppdropconstEflipEplusEdropEreverseElengthEsumEproductEprocSucc 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 doubleClsfromPrelDoubleavailableNamesprioritizedNamesToPgtotalGCDcurry2curry3curry4curry5curry6upperlowerproperleft1right1leftrightdropLeftmidlen 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'6ppExcelleftErightElenEabsEmkIF mkUncurriedmkSUBST4mkVarOpchar7lit0lit1 mkPgExcel mkPgExcels<>excelf1Ef1EFef1EIOf1EFIOsimpleEF SplicedPrimsget1getManygetManyM getManyTypednoBKcgetOnesynthsynthM synthTypednoBKQ quickStart quickStartF filterGetOne_ filterGetOnefilterGetOneBK synthFilt synthFiltFsynthAllMapListappListappLargeIntegralMapRealMapCharMapIxMIxMapNat MapIntegralMI nonnegArrownegArrowMapIntMapLargeIntegralMLI MapInteger MapFiniteListMFL consArrownilArrowML MapTripletMapPairMP MapEitherMapMaybeMM MapOrderingMOMapBoolMBMapUnitMUFunctionProperty==> getFunctionmemoUnitappUnitmemoBoolappBoolprop_inverseBool memoOrdering appOrdering memoMaybeappMaybeprop_inverseMaybe memoEither appEitherprop_inverseEithermemoPairappPair memoTriplet appTripletprop_inverseTripletmemoList appList10appList5appList3appList1memoFiniteList appFiniteList isLongerThanprop_inverseListprop_inverseListB memoInteger appIntegermemoLargeIntegralmemoIntappInt memoIntegral memoPosNat bitsToPosNat appIntegral appPosNat posNatToBitsprop_inverseIntegralprop_inversePosNatprop_bitsToFromPosNatmemoIx10memoIx3memoIxappIxmemoCharappCharprp_inverseCharmemoRealappRealprop_inverseRealheavy memoHeavy memoizedHeavyheavy2 memoHeavy2memoizedHeavy2 memoHeavy2'memoizedHeavy2'heavy3 memoHeavy3memoizedHeavy3 heavyList memoHeavyListmemoizedHeavyListliftListscan10mergesortWithBymergesortWithByBotmergesortWithByBotIOmergesortWithByBot'mergesortWithByBot'IOmerge_pairsBotmerge_pairsBotIO mergeWithBymergeWithByBotmergeWithByBotIO diffSortedBydiffSortedByBot tokoro10niltokoro10!? GHC.TypesIntbaseGHC.IntInt8Int16Int32Int64SubstTyped:::DecoderDecTypeNameTyConTyVarKindType:>:->TVTCTA:=>sizemapTV negateTVIDs limitType alltyvarstyvarsmaxVarIDnormalizeVarIDs normalizeeqType saferQuantifyquantify quantify' unquantify unifyFunApmguFunAppushArgsgetRetgetArgsgetArity getArities getAritiesRet splitArgs revSplitArgs revGetArgspopArgstypeetyper emptySubst unitSubstmatchunChinmguvarBindsubstOK assertsubst plusSubst lookupSubstapply applyCheckTyConLibMap defaultTCL tyConsToTCL defaultTyConstupleMax tuplenameunitdisj nameToTyCon thTypesToTCLthTypesToTyConsthTypeToTyConstrToTypefunTyCon showTypeName thTypeToType typeToTHTypeplainTV unPlainTVreadHsTypeSigs expToExpExp typeToExpType decsToExpDecs reserveTVars PriorSubstsPSunPS substOKPSmonsubstmkPSrunPSdelayPSndelayPS convertPSdistPSapplyPSupdatePS updateSubstPSsetSubstmguPSmgtPS varBindPSmatchPS lookupSubstPSgetSubstgetMxupdateMxunifynewTVar freshInstpsListToPSRecomppsRecompToPSListpsListToPSDBoundpsDBoundToPSListtup23tup32uniqBy ShortString readsBriefly showsBriefly showBriefly readBrieflydynSdynKdynIdynBdynCdynS'dynB'dynC'ssprimebprimecprimeundefTCL unDeBruijn unsafeExecutefixFMTypeEmptyFMTFMTtvFMTtcFMTtaFMTfnFMTfunFMT lookupFMTmapFMTeltsFMT fmtToList updateFMTunitFMTunionFMT finiteHVss finiteHVsssMapTypeMTfunMTtaMTgenMTtcMTtvMT PossibilitylookupMTretrievedecode decodeVarencodemkMTmkMT'mkMTIOmkMTIO'interleaveActions memoToFile memoPSRTIOmemoRTIOMemoCondfpsmemoer maybeWithTOBoolOrderingunsafeWithPTOOptmaybeWithTOOpt unsafeWithPTOnewPTOunsafeOpWithPTO maybeWithTO'withTO' wrapExecutionmeasureExecutionTimecatchIthandler realHandler catchYield childHandlerrealChildHandler FiltrableBFCmpBotfilterBF opreexecutefilterDBfilterRccmpBotcmpBotIO spreexecuteDM filterList filterListDBfilterDM filterDMIOTreeTrForestfilterTrbagCmp prop_mkTipmkTip mkForestsmkForestaccumulateForests mergeForests differencediff flattenTrremoveFirstOfFirstEU numUniIDsinputsapfreshTBSTermStatTSunTSConstrExprfieldsszctoranniDIOPairIOPoutputnormalizeMkIOPvrmapU maybeCtorhasExistentialvisibles unifyListbindoccursInfreshmapE applyIOPsapplyIOPmapIOPmapTypeeinitTSupdateTSevalTStermCritfullyLex revFullyLexaWiserevAWiselinearrevArgslessRevListsLex lessListsLex cmpExprsscmpExprs cmpExprSzscapStnextVarsubstUniTemptyStfreshIOPapplyUT applyIOPUTunifyUT appUnifyUTXVarLibXVLnegateIDsuccIDzeroID invVarLibvarLib mkXVarLib extractNameparseTypedIOPairssinferTypedIOPairssparseTypedIOPairss'plus parseTypes parseIOPairssclauseToIOPairclauseToIOPair' matchTypeunquantifySubstmguType inferTypeinferTfunApMfAM tapplyIOP tapplyExpr unzipTypedgetMbTypedConstrgetTypedConstr mkTypedConstrpatToExpstrToIntnatLimit natToConExpsmallNat thExpToExprFMExprFMExprsFMEs EmptyFMEsconsFMEsnilFMEsFMEEmptyFMEconApFME universalFMEexistentialFME iopsToVisFME iopsToFMEvisIOP iop2Assoc assocsToFME updateFME updateFMEsemptyFME insertNthunifyFME unifyFME' unifyFMEsvalsFMEvalsFMEsmatchFME matchFME'matchExistential matchFMEsFunBKFRecBK IntroUniT Introducer toBeSoughtfmexpriopairs maxNumBVsaritymkBKFunmkRecFun mkInitRecFun setIOPairsapplyFun analyticSynthanalyticSynthAndInfTypefastAnalSynthNoUniTfastAnalSynthmNoUniTanalSynthNoUniT analSynth analSynthm headSpine analSynthUTmmkArgs+++ ndelayIntrointroAny+/ introVarUTm introVarm introVarm'introVar introConstr divideIOP shareConstr sConstrIsselect introCasedropNthintroBKm introBKUTmintroBKsubtractIOPairsFromIOPairsBKUTmsubtractIOPairsBKUTmsubtractIOPairsFromIOPairsUTmsubtractIOPairsFromIOPairsUTm'subtractIOPairsUTmsubtractIOPairUTmsubtractIOPairsFromIOPairsmsubtractIOPairsFromIOPairsmFMEsubtractIOPairsmFMEsubtractIOPairsFromIOPairsBKm subtractIOPairsFromIOPairsBKmFMEsubtractIOPairsBKmFMEunifyingIOPairstemplate-haskellLanguage.Haskell.TH.SyntaxExppprintUCnewNamemkName Language.Haskell.TH.Lib.InternalcharLstringLintegerLintPrimL wordPrimL floatPrimL doublePrimL rationalL stringPrimL charPrimLlitPvarPtupP unboxedTupP unboxedSumPconPinfixPtildePbangPasPwildPrecPlistPsigPviewPfieldPatclausevarEconElitEappEappTypeEinfixEinfixAppsectionLsectionRlamElamCaseE unboxedSumEcondEmultiIfEletEcaseEdoEcompEfromE fromThenEfromToE fromThenToElistEsigErecConErecUpdEstaticE unboundVarElabelEimplicitParamVarEmdoEfieldExpguardedBnormalBnormalGEpatGEbindSletSnoBindSparSrecSfunDvalDinstanceWithOverlapDsigDforImpDpragInlD pragSpecD pragSpecInlD pragSpecInstDpragAnnD tySynInstDinfixLDinfixRDinfixND roleAnnotD defaultSigDpatSynD patSynSigD pragCompleteDimplicitParamBindDkiSigDcxtnoSourceUnpackednesssourceNoUnpack sourceUnpacknoSourceStrictness sourceLazy sourceStrictnormalCrecCinfixCgadtCrecGadtCbangbangType varBangTypeunidir implBidir explBidir prefixPatSyn infixPatSyn recordPatSyn forallVisTvarTconTtupleT unboxedTupleT unboxedSumTarrowTlistTappTappKindT equalityTlitT promotedTpromotedTupleT promotedNilT promotedConsT wildCardTimplicitParamTinfixTnumTyLitstrTyLitnominalRrepresentationalRphantomRinferRvarKconKtupleKarrowKlistKappKinjectivityAnncCallstdCallcApiprim javaScriptunsafesafe interruptiblefunDepruleVar typedRuleVarvalueAnnotationtypeAnnotationmoduleAnnotationData.Typeable.InternalTypeableImplicitParamVarELabelE UnboundVarEStaticERecUpdERecConESigEListE ArithSeqECompEMDoEDoECaseELetEMultiIfECondE UnboxedSumE UnboxedTupETupELamCaseELamEParensEUInfixEInfixEAppTypeEAppELitEVarEConEMatchClauseQExpQDecQPatViewPSigPListPRecPWildPAsPBangPTildePParensPUInfixPInfixPConP UnboxedSumP UnboxedTupPTupPLitPVarPMatchQClauseQStmtQConQTypeQImplicitParamT WildCardTLitT ConstraintTStarT PromotedConsT PromotedNilTPromotedTupleT EqualityTArrowT UnboxedSumT UnboxedTupleTTupleTParensTUInfixTInfixT PromotedTConTVarTSigTAppKindTAppT ForallVisTListTForallTImplicitParamBindD PatSynSigDPatSynD DefaultSigDStandaloneDerivDClosedTypeFamilyDOpenTypeFamilyD TySynInstD NewtypeInstD DataInstD DataFamilyDPragmaDInfixDForeignDKiSigD InstanceDClassDTySynDNewtypeDDataDFunD RoleAnnotDValDSigD BangTypeQ VarBangTypeQFieldExpFieldPatNamePatQ FieldPatQ FieldExpQFunDepPredPredQ TyVarBndrQDecsQ RuleBndrQ TySynEqnQTExpunTypeInjectivityAnnKindQOverlap IncoherentOverlaps Overlappable Overlapping DerivClauseQDerivStrategyQ stockStrategyanyclassStrategynewtypeStrategy viaStrategy Data.TypeabletypeOf7typeOf6typeOf5typeOf4typeOf3typeOf2typeOf1 rnfTypeReptypeRepFingerprint typeRepTyCon typeRepArgs splitTyConAppmkFunTy funResultTygcast2gcast1gcasteqTcast showsTypeReptypeReptypeOfTypeReprnfTyContyConFingerprint tyConName tyConModule tyConPackage Data.ProxyProxyData.Type.Equality:~:Refl:~~:HReflghc-boot-th-8.10.2GHC.LanguageExtensions.Type ExtensionOverlappingInstancesUndecidableInstancesIncoherentInstancesUndecidableSuperClassesMonomorphismRestriction MonoPatBindsMonoLocalBindsRelaxedPolyRecExtendedDefaultRulesForeignFunctionInterfaceUnliftedFFITypesInterruptibleFFICApiFFIGHCForeignImportPrim JavaScriptFFIParallelArraysArrowsTemplateHaskellTemplateHaskellQuotes QuasiQuotesImplicitParamsImplicitPreludeScopedTypeVariablesAllowAmbiguousTypes UnboxedTuples UnboxedSumsUnliftedNewtypes BangPatterns TypeFamiliesTypeFamilyDependencies TypeInTypeOverloadedStringsOverloadedLists NumDecimalsDisambiguateRecordFieldsRecordWildCards RecordPuns ViewPatternsGADTs GADTSyntaxNPlusKPatternsDoAndIfThenElseBlockArgumentsRebindableSyntaxConstraintKinds PolyKinds DataKinds InstanceSigs ApplicativeDoStandaloneDerivingDeriveDataTypeableAutoDeriveTypeable DeriveFunctorDeriveTraversableDeriveFoldable DeriveGenericDefaultSignaturesDeriveAnyClass DeriveLiftDerivingStrategies DerivingViaTypeSynonymInstancesFlexibleContextsFlexibleInstancesConstrainedClassMethodsMultiParamTypeClassesNullaryTypeClassesFunctionalDependenciesExistentialQuantification MagicHashEmptyDataDeclsKindSignaturesRoleAnnotationsParallelListCompTransformListCompMonadComprehensionsGeneralizedNewtypeDeriving RecursiveDoPostfixOperators TupleSections PatternGuardsLiberalTypeSynonyms RankNTypesImpredicativeTypes TypeOperatorsExplicitNamespacesPackageImportsExplicitForAllAlternativeLayoutRule!AlternativeLayoutRuleTransitionalDatatypeContextsNondecreasingIndentation RelaxedLayoutTraditionalRecordSyntax LambdaCase MultiWayIfBinaryLiteralsNegativeLiteralsHexFloatLiteralsDuplicateRecordFieldsOverloadedLabels EmptyCasePatternSynonymsPartialTypeSignaturesNamedWildCardsStaticPointersTypeApplications StrictDataMonadFailDesugaringEmptyDataDerivingNumericUnderscoresQuantifiedConstraints StarIsTypeImportQualifiedPostCUSKsStandaloneKindSignatures UnicodeSyntaxStrictCppLanguage.Haskell.TH.Lib unboxedTupEtupEmkBytesstandaloneDerivWithStrategyD derivClausetyVarSigkindSignoSig constraintKstarKkindedTVsigTforallTforallCtySynEqnclosedTypeFamilyDopenTypeFamilyD dataFamilyD newtypeInstD dataInstD pragRuleDclassDnewtypeDdataDtySynD thisModuleappsE varStrictType strictTypeunpacked notStrictisStrictequalPclassPparensTuInfixTstandaloneDerivD pragLineD instanceDstringE arithSeqElam1EuInfixEparensEdynpatGnormalG fromThenToRfromToR fromThenRfromRparensPuInfixP bytesPrimLInfoQTExpQTyLitQCxtQBodyQGuardQRangeQSourceStrictnessQSourceUnpackednessQBangQ StrictTypeQVarStrictTypeQ PatSynDirQ PatSynArgsQFamilyResultSigQLanguage.Haskell.TH.Ppr pprParendTypepprPatpprLitpprExppprintPprpprppr_list defaultFixity maxPrecedenceunboxedSumTypeNameunboxedSumDataNameunboxedTupleTypeNameunboxedTupleDataName tupleTypeName tupleDataName nameSpace namePackage nameModulenameBase extsEnabled isExtEnabledrunIOlocation isInstancereifyConStrictness reifyModulereifyAnnotations reifyRolesreifyInstances reifyType reifyFixityreifylookupValueNamelookupTypeNamerecover reportWarning reportErrorreportrunQ NameSpaceLocloc_end loc_start loc_module loc_filename loc_packageInfoTyVarIVarIPatSynIDataConI PrimTyConIFamilyITyConIClassIClassOpI ModuleInfo ParentNameSumAltSumArityArityUnlifted InstanceDecFixityFixityDirectionInfixNInfixLInfixRLit CharPrimL BytesPrimL StringPrimL DoublePrimL FloatPrimL WordPrimLIntPrimL RationalLIntegerLCharLStringLBodyGuardedBNormalBGuardNormalGPatGStmtRecSParSNoBindSBindSLetSRange FromThenToRFromToRFromR FromThenR DerivClause DerivStrategy ViaStrategyNewtypeStrategy StockStrategyAnyclassStrategy PatSynTypeTypeFamilyHeadTySynEqnForeignImportFExportFCallconv JavaScriptCApiCCallStdCallSafety InterruptibleUnsafeSafePragma CompletePLinePAnnPRulePSpecialiseInstPInlineP SpecialisePInline InlinableNoInline RuleMatchConLikeFunLikePhases BeforePhase AllPhases FromPhaseRuleBndrRuleVar TypedRuleVar AnnTargetValueAnnotationModuleAnnotationTypeAnnotationCxtSourceUnpackednessNoSourceUnpackedness SourceUnpackSourceNoUnpackSourceStrictnessNoSourceStrictness SourceLazy SourceStrictDecidedStrictness DecidedUnpack DecidedLazy DecidedStrictConRecGadtCGadtCForallCInfixCNormalCRecCBang PatSynDir ExplBidirUnidir ImplBidir PatSynArgs RecordPatSyn PrefixPatSyn InfixPatSyn TyVarBndrPlainTVKindedTVFamilyResultSigTyVarSigNoSigKindSigTyLitNumTyLitStrTyLitRoleInferRPhantomRNominalRRepresentationalR AnnLookupAnnLookupModule AnnLookupNameversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName versionInfo mhVersion ghcVersionnow