h$yR      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~(c) 2021 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela None  code-conjure+Checks if all elements of a list are equal. code-conjure+Counts the number of occurrences on a list. code-conjureNubs using a given field. code-conjureEquivalent to  nub . sort but running in  O(n log n). code-conjureZips  values leaving trailing values. '> mzip ["ab","cd"] ["ef"] ["abef","cd"] code-conjure*Group values using a given field selector. code-conjureWARNING: uses ' and should only be used for debugging! > idIO print 10 10 10 code-conjure)Applies a function to the head of a list. code-conjure(Return sets of values based on the list.&The values in the list must me unique. code-conjureLike & but allows providing a default value. code-conjureLists choices of values. code-conjure/Lists choices of values that follow a property. code-conjureA variation of foldr that only uses "zero" when the list is empty (c) 2021 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela None&: code-conjureO(n)". Compares the simplicity of two s. An expression e1 is strictly simpler than another expression e2 if the first of the following conditions to distingish between them is: e1 is smaller in size/length than e2 , e.g.: x + y < x + (y + z);or, e1$ has less variable occurrences than e2,or, e1# has fewer distinct constants than e2 , e.g.:  1 + 1 < 0 + 1.9They're otherwise considered of equal complexity, e.g.: x + y and y + z. 9> (xx -+- yy) `compareComplexity` (xx -+- (yy -+- zz)) LT 0> (xx -+- yy) `compareComplexity` (xx -+- xx) EQ 1> (xx -+- xx) `compareComplexity` (one -+- xx) GT 5> (one -+- one) `compareComplexity` (zero -+- one) LT 0> (xx -+- yy) `compareComplexity` (yy -+- zz) EQ 6> (zero -+- one) `compareComplexity` (one -+- zero) EQ code-conjure/Makes the function in an application a variable code-conjureExpands recursive calls on an expression until the given size limit is reached. )> recursexpr 6 (ff xx) (ff xx) f x :: Int > recursexpr 6 (ff xx) (one -+- ff xx) 1 + (1 + (1 + (1 + f x))) :: Int > recursexpr 6 (ff xx) (if' pp one (xx -*- ff xx)) (if p then 1 else x * (if p then 1 else x * f x)) :: Int > recursexpr 6 (ff xx) (if' pp one (xx -*- ff (gg xx))) (if p then 1 else x * (if p then 1 else g x * f (g (g x)))) :: Int code-conjureChecks if the given recursive call apparently terminates. The first argument indicates the functional variable indicating the recursive call. (> apparentlyTerminates ffE (ff xx) False 5> apparentlyTerminates ffE (if' pp zero (ff xx)) True7This function only allows recursion in the else clause: 6> apparentlyTerminates ffE (if' pp (ff xx) zero) False apparentlyTerminates ffE (if' (odd' (ff xx)) zero zero) False code-conjureChecks if the given functional expression may refrain from evaluating its next argument. +> mayNotEvaluateArgument (plus :$ xx) False *> mayNotEvaluateArgument (andE :$ pp) TrueThis returns false for non-funcional value even if it involves an application which may not evaluate its argument. 1> mayNotEvaluateArgument (andE :$ pp :$ qq) False;This currently works by checking if the function is an if,  or . code-conjureCreates an if  of the type of the given proxy. :> ifFor (undefined :: Int) if :: Bool -> Int -> Int -> Int > ifFor (undefined :: String) if :: Bool -> [Char] -> [Char] -> [Char]You need to provide this as part of your building blocks on the primitives if you want recursive functions to be considered and produced. code-conjure0Application cross-product between lists of Exprs code-conjure#Lists terminal values in BFS order.(cf. , , ) code-conjureLists holes in BFS order.(cf. , , ) code-conjureFills holes in BFS order.(cf. , , ) code-conjureLike % but always works regardless of type.Warning: just like ), this may produce ill-typed expressions. 6> zero $$** zero Just (0 0 :: ill-typed # Int $ Int #)Together with , this function is unused but is useful when experiment with the source to see the effect of type-corrected on pruning the search space.(cf. , ) code-conjureLike & but relaxed to work on correct kinds. > ordE $$|< zero Just (ord 0 :: ill-typed # Char -> Int $ Int #) > zero $$|< zero NothingWarning: just like ), this may produce ill-typed expressions.Together with , this function is unused but is useful when experiment with the source to see the effect of type-corrected on pruning the search space.(cf. , ) code-conjure:Lists all distinct holes that are possible with the given s. > possibleHoles [zero, one, plus] [_ :: Int,_ :: Int -> Int,_ :: Int -> Int -> Int] > possibleHoles [ae, ordE] [_ :: Char,_ :: Int,_ :: Char -> Int] code-conjureEnumerate applications between values of the given list of primitives and of the given expressions's type. Arguments: an  whose type we are interested in a filtering function, returning  for the expressions to keep7a list of primitives to be used in building expression.Result:> a potentially infinite list of list of enumerated expressions>The enumeration here is type-directed for performance reasons. code-conjure$Given an expression whose holes are all of the same type and an enumeration of s of this same type, enumerate all possible fillings of the original expression with the s in the enumeration. code-conjure Evaluates an  to a regular Haskell value using the given recursive definition and maximum number of recursive calls. If there's a type mismatch, this function returns .(cf. , ) code-conjure Evaluates an  to a regular Haskell value using the given recursive definition and maximum number of recursive calls. If there's a type mismatch, this function returns the given default value.(cf. ,  ) code-conjure useMatches [xx,yy] [xx,yy] = [[(xx,xx), (yy,yy)]] useMatches [xx,yy] [yy,xx] = [[(xx,xx), (yy,yy)]] useMatches [yy,xx] [xx,yy] = [[(yy,yy), (xx,xx)]] useMatches [xx,yy] [xx,xx] = [] useMatches [xx,yy] [abs' xx, abs' yy] = [[(xx,abs' xx), (yy, abs' yy)]] useMatches [xx-:-xxs, yy-:-yys] [abs' xx, abs' yy] = [(xx-:-xxs, abs' xx), (yy-:-yys, abs' yy)] code-conjure0Turns all variables of an expression into holes. !> rehole (xx -+- yy) _ + _ :: Int  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~(c) 2021 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela None90  code-conjure"A single binding in a definition (). code-conjure Int) (=-) = (,) infixr 0 =- sumDefn :: Defn sumDefn = [ sum' nil =- zero , sum' (xx -:- xxs) =- xx -+- (sumV :$ xxs) ] where sum' e = sumV :$ e code-conjurePretty-prints a  as a : > putStr $ showDefn sumDefn sum [] = 0 sum (x:xs) = x + sum xs code-conjure Evaluates an  to a  value using the given 1 as definition when a recursive call is found. Arguments: 4a function that deeply reencodes an expression (cf. )+the maximum number of recursive evaluationsa & to be used when evaluating the given an  to be evaluatedThis function cannot be used to evaluate a functional value for the given 5 and can only be used when occurrences of the given  are fully applied.%The function the deeply reencodes an 0 can be defined using functionality present in Conjure.Conjurable>. Here's a quick-and-dirty version that is able to reencode s, s and their lists: exprExpr :: Expr -> Expr exprExpr = conjureExpress (undefined :: Bool -> [Bool] -> Int -> [Int] -> ())?The maximum number of recursive evaluations counts in two ways: the maximum number of entries in the recursive-evaluation memo table;the maximum number of terminal values considered (but in this case the limit is multiplied by the _size_ of the given .These could be divided into two separate parameters but then there would be an extra _dial_ to care about...(cf. , , ) code-conjure Evaluates an  expression into $ a regular Haskell value using a  definition when it is found. If there's a type-mismatch, this function returns .This function requires a -deep-reencoding function and a limit to the number of recursive evaluations.(cf. , , ) code-conjure Evaluates an 4 expression into a regular Haskell value using a  definition when it is found in the given expression. If there's a type-mismatch, this function return a default value.This function requires a -deep-reencoding function and a limit to the number of recursive evaluations.(cf. , , devl') code-conjureLike # but only works for when the given & definition has no case breakdowns./In other words, this only works when the given  is a singleton list whose first value of the only element is a simple application without constructors. code-conjure Evaluates an 4 expression into a regular Haskell value using a  definition when it is found in the given expression. If there's a type-mismatch, this raises an error.This function requires a -deep-reencoding function and a limit to the number of recursive evaluations.(cf. ,  , deval') code-conjure%Returns whether the given definition .  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ (c) 2021 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela NoneT code-conjure Class of  types. Functions are  if all their arguments are ,  and able.For atomic types that are , instances are defined as: >instance Conjurable Atomic where conjureTiers = reifyTiersFor atomic types that are both  and , instances are defined as: instance Conjurable Atomic where conjureTiers = reifyTiers conjureEquality = reifyEquality3For types with subtypes, instances are defined as: instance Conjurable Composite where conjureTiers = reifyTiers conjureEquality = reifyEquality conjureSubTypes x = conjureType y . conjureType z . conjureType w where (Composite ... y ... z ... w ...) = xAbove x, y, z and w are just proxies. The Proxy. type was avoided for backwards compatibility.Please see the source code of Conjure.Conjurable for more examples.(cf. , , ) code-conjureReturns  the  function encoded as an  when available or  otherwise.Use  when defining this. code-conjureReturns   of values encoded as s when possible or  otherwise.Use  when defining this. code-conjure%Returns an if-function encoded as an . code-conjure#Returns a top-level case breakdown. code-conjure0Returns the (recursive) size of the given value. code-conjureReturns a function that deeply reencodes an expression when possible. ( when not available.)Use  when defining this. code-conjure)A reification over a collection of types.4Represented as a transformation of a list to a list. code-conjure4Single reification of some functions over a type as s.This is a sixtuple, in order: a hole encoded as an ;the  function encoded as an  when available;& of enumerated test values encoded as s when available;*infinite list of potential variable names;.boolean indicating whether the type is atomic;the  function encoded as an . code-conjure$To be used in the implementation of . instance ... => Conjurable where ... conjureSubTypes x = conjureType (field1 x) . conjureType (field2 x) . ... . conjureType (fieldN x) ... code-conjure Conjures a  for a  type.&This is used in the implementation of . code-conjureConjures a list of  for a  type, its subtypes and .'This is used in the implementation of , , , , , , , etc. code-conjureReifies equality  in a  type instance.)This is to be used in the definition of  of  typeclass instances: instance ... => Conjurable where ... conjureEquality = reifyEquality ... code-conjure1Reifies equality to be used in a conjurable type.)This is to be used in the definition of  of  typeclass instances: instance ... => Conjurable where ... conjureTiers = reifyTiers ... code-conjure Reifies the  function in a  type instance.)This is to be used in the definition of  of  typeclass instances. instance ... => Conjurable where ... conjureExpress = reifyExpress ... code-conjure$Computes a list of holes encoded as  s from a  functional value.(cf.  ) code-conjureComputes a function that makes an equation between two expressions. code-conjureGiven a  functional value, computes a function that checks whether two -s are equal up to a given number of tests. code-conjureCompute  of values encoded as s of the type of the given . code-conjure*Checks if an unary function encoded as an  is a deconstructor.(cf. ) code-conjure,Checks if an expression is a deconstruction.There should be a single  in the expression. The result does not increase the size for at least half the time.>The result decreases in size for at least a third of the time.(cf. ) code-conjure*Compute candidate deconstructions from an .'This is used in the implementation of   and   followed by . code-conjure Checks if an  is of an unbreakable type. code-conjure Evaluates a + into a regular Haskell value returning  when there's a type mismatch.The integer argument indicates the limit of recursive evaluations. code-conjure Evaluates a  into a regular Haskell value returning the given default value when there's a type mismatch.The integer argument indicates the limit of recursive evaluations. code-conjure Evaluates a  into a regular Haskell value raising an error there's a type mismatch.The integer argument indicates the limit of recursive evaluations. code-conjure7Computes a complete application for the given function. ,> conjureApplication "not" not not p :: Bool > conjureApplication "+" ((+) :: Int -> Int -> Int) x + y :: Int(cf. ) code-conjureComputes a complete application for a variable of the same type of the given function. /> conjureVarApplication "not" not not p :: Bool > conjureVarApplication "+" ((+) :: Int -> Int -> Int) x + y :: Int(cf. ) code-conjure:Computes tiers of sets of patterns for the given function. > conjurePats [zero] "f" (undefined :: Int -> Int) [[[f x :: Int]],[[f 0 :: Int,f x :: Int]]],,(c) 2021 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela NoneY code-conjure9A primtive expression (paired with instance reification). code-conjure8Provides a primitive value to Conjure. To be used on  instances. (cf. ) code-conjureProvides a primitive value to Conjure. To be used on values that are not ) instances such as functions. (cf. ) code-conjure8Provides an if condition bound to the given return type. code-conjure$Computes a list of holes encoded as s from a list of s.)This function mirrors functionality from . code-conjure%Computes a function that equates two s from a list of s.)This function mirrors functionality from . code-conjureGiven a list of 2s, computes a function that checks whether two -s are equal up to a given number of tests. code-conjureGiven a list of 's, returns a function that given an  will return tiers of test  values.This is used in .(c) 2021 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela None#$n: code-conjureArguments to be passed to  or  . See  for the defaults. code-conjure)maximum number of tests to each candidate code-conjure maximum size of candidate bodies code-conjure?maximum number of recursive evaluations when testing candidates code-conjure!maximum size of equation operands code-conjure4maximum number of tests to search for defined values code-conjure'maximum size of deconstructions (e.g.: _ - 1) code-conjure0require recursive calls to deconstruct arguments code-conjure5use pattern matching to create (recursive) candidates code-conjure3show theory discovered by Speculate used in pruning code-conjure unique-modulo-testing candidates code-conjure;Conjures an implementation of a partially defined function.Takes a  with the name of a function, a partially-defined function from a conjurable type, and a list of building blocks encoded as s.For example, given: square :: Int -> Int square 0 = 0 square 1 = 1 square 2 = 4 primitives :: [Prim] primitives = [ pr (0::Int) , pr (1::Int) , prim "+" ((+) :: Int -> Int -> Int) , prim "*" ((*) :: Int -> Int -> Int) ](The conjure function does the following: > conjure "square" square primitives square :: Int -> Int -- pruning with 14/25 rules -- testing 3 combinations of argument values -- looking through 3 candidates of size 1 -- looking through 3 candidates of size 2 -- looking through 5 candidates of size 3 square x = x * x$The primitives list is defined with  and . code-conjure9Conjures an implementation from a function specification.This function works like  but instead of receiving a partial definition it receives a boolean filter / property about the function.For example, given: squareSpec :: (Int -> Int) -> Bool squareSpec square = square 0 == 0 && square 1 == 1 && square 2 == 4Then: > conjureFromSpec "square" squareSpec primitives square :: Int -> Int -- pruning with 14/25 rules -- looking through 3 candidates of size 1 -- looking through 4 candidates of size 2 -- looking through 9 candidates of size 3 square x = x * xThis allows users to specify QuickCheck-style properties, here is an example using LeanCheck: import Test.LeanCheck (holds, exists) squarePropertySpec :: (Int -> Int) -> Bool squarePropertySpec square = and [ holds n $ \x -> square x >= x , holds n $ \x -> square x >= 0 , exists n $ \x -> square x > x ] where n = 60 code-conjureSynthesizes an implementation from both a partial definition and a function specification.This works like the functions  and  combined. code-conjureLike  but allows setting the maximum size of considered expressions instead of the default value of 12. /conjureWithMaxSize 10 "function" function [...] code-conjureDefault arguments to conjure. 60 testsfunctions of up to 12 symbols9maximum of one recursive call allowed in candidate bodies)maximum evaluation of up to 60 recursions#pruning with equations up to size 5=search for defined applications for up to 100000 combinations0require recursive calls to deconstruct arguments%don't show the theory used in pruning,do not make candidates unique module testing code-conjureLike $ but allows setting options through /. 8conjureWith args{maxSize = 11} "function" function [...] code-conjureLike $ but allows setting options through /. ?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~(c) 2019-2021 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela Nonex code-conjure Derives an  instance for the given type .This function needs the TemplateHaskell extension.If , , , 7, ... are not in scope, this will derive them as well.&For now, this function only derives ,  and  and does not derive ,  and . These will be added in future versions. If you plan to use features that depend on these functionalities, please define your instances manually. code-conjureSame as 4 but does not warn when instance already exists ( is preferable).&For now, this function only derives ,  and  and does not derive ,  and . These will be added in future versions. If you plan to use features that depend on these functionalities, please define your instances manually. code-conjure Derives a  instance for a given type 3 cascading derivation of type arguments as well.&For now, this function only derives ,  and  and does not derive ,  and . These will be added in future versions. If you plan to use features that depend on these functionalities, please define your instances manually. (c) 2021 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela Nonex22 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~    )code-conjure-0.5.2-LfCXT3EtyThBEyzKaZZPZ4 Conjure.ExprConjure.EngineConjure.Conjurable Conjure.Utils Conjure.Defn Conjure.PrimConjure.Conjurable.Derive devaluatedevalcjHolescandidateDefnsCcandidateExprsConjure#express-1.0.8-I8jW3dTTzJZz0OlDpoBPIData.Express.Fixtures-...-enumFromThenTo'-... enumFromThen'-..- enumFromTo'-.. enumFrom'map'mapE-.-compose-%-product'sum'or'and'qqsppsbs_sixtuple quintuple quadrupletriplecommapair-|-justjustBooljustInt nothingBool nothingIntnothingcompare'if'-<--<=--/=--$-elem'insert'sort'init'length'null'tail'head'-++- appendInt-:-unitconsCharconsBoolconsIntconsnilCharnilBoolnilInt emptyStringnilzzsyysxxsis_ordEord' lineBreakspacezeezeddeeceebeeaeccsddcccs_c_even'odd'signumEsignum'absEabs'negateEnegate'const'idStringidBoolsidIntsidCharidBoolidIntidEid'remErem'quotEquot'modEmod'divEdiv'minustimes-*-plus-+-ooEooquestion-?-hhEhhggEggffEffminusTwominusOnetwelveeleventennineeightsevensixfivefourthreetwoonezeronnmmllii'kkjjiixx'zzyyxxi_-||--&&-not'implies-==>-orEandEnotEtruefalsepp'rrqqppb_Data.Express.CanonfastMostSpecificVariationfastMostGeneralVariationfastCanonicalVariationsmostSpecificCanonicalVariationmostGeneralCanonicalVariationcanonicalVariations isCanonicalcanonicalization canonicalizeisCanonicalWithcanonicalizationWithcanonicalizeWithData.Express.InstancespreludeNameInstances findValidApp validApps listVarsWith lookupNames lookupNamemkComparisonLEmkComparisonLT mkEquation mkComparisonisEqOrdisOrdisEqisEqOrdTisOrdTisEqTlookupComparison mkNameWithmkNamemkOrdLessEqualmkOrdmkEq reifyName reifyEqOrdreifyOrdreifyEqData.Express.Express.DerivederiveExpressCascadingderiveExpressIfNeeded deriveExpressData.Express.ExpressexprExpressData.Express.Foldunfoldfold unfoldTriofoldTrio unfoldPairfoldPairfoldAppData.Express.HolefilllistVarsAsTypeOflistVars isCompletehasHolenubHolesholesisHolehole holeAsTypeOf varAsTypeOfData.Express.Map renameVarsBy////- mapSubexprs mapConstsmapVars mapValuesData.Express.Match isSubexprOf hasInstanceOf encompasses isInstanceOf matchWithmatchData.Express.CoreheightdepthsizearitynubVarsvars nubConstsconsts nubValuesvalues nubSubexprssubexprsisAppisValueisVarisConstisGroundhasVar unfoldAppcompareQuicklycompareLexicographicallycompareComplexityshowExpr showPrecExpr showOpExpr toDynamicevlevalevaluateisFun isWellTyped isIllTypedmtypetyptypvar$$valvalue:$ValueExprData.Express.Utils.TypeableboolTyData.Express.Name.DerivederiveNameCascadingderiveNameIfNeeded deriveNameData.Express.NamenamesnameNameData.Express.Utils.StringvariableNamesFromTemplate'leancheck-0.9.10-8h9G6xmR1toBCesz0EouenTest.LeanCheck.Utils.TypesABCDEF'speculate-0.4.14-Hm7hxaIVMNSD6q9WXnukGjTest.Speculate.EnginetheoryFromAtomsTest.Speculate.Reason doubleCheckprintThyinvalid closureLimit canReduceTo equationsrulesThyTest.Speculate.Expr.Ground groundBindsgroundsallEqualcountnubOnnubSortmzipgroupOnidIOmapHeadsetsheadOrchoices choicesThatfoldr0compareSimplicityfunToVar recursexprapparentlyTerminatesmayNotEvaluateArgumentifFor>$$< valuesBFSholesBFSfillBFS$$**$$|< possibleHolesenumerateAppsForenumerateFillings revaluatereval useMatchesrehole $fExpressF $fExpressE $fExpressD $fExpressC $fExpressB $fExpressABndnDefnshowDefntoDynamicWithDefn devalFastdevldefnApparentlyTerminates ConjurableconjureArgumentHolesconjureEquality conjureTiersconjureSubTypes conjureIf conjureCasesconjureArgumentCases conjureSizeconjureExpressconjureEvaluate Reification Reification1 conjureTypeconjureReification1conjureReification reifyEquality reifyTiers reifyExpress conjureHolesconjureMkEquationconjureDynamicEqconjureAreEqualconjureTiersForconjureIsDeconstructorconjureIsDeconstructioncandidateDeconstructionsFromconjureIsUnbreakable cevaluatecevalcevlconjureApplicationconjureVarApplication conjurePats$fNameF$fNameE$fNameD$fNameC$fNameB$fNameA$fConjurable(,,,,,,)$fConjurable(,,,,,)$fConjurable(,,,,)$fConjurable(,,,) $fConjurableF $fConjurableE $fConjurableD $fConjurableC $fConjurableB $fConjurableA$fConjurableComplex$fConjurableRatio$fConjurableWord64$fConjurableWord32$fConjurableWord16$fConjurableWord8$fConjurableWord$fConjurableInt64$fConjurableInt32$fConjurableInt16$fConjurableInt8$fConjurableDouble$fConjurableFloat$fConjurableOrdering$fConjurable->$fConjurableEither$fConjurableMaybe$fConjurable(,,)$fConjurable(,)$fConjurable[]$fConjurableChar$fConjurableInteger$fConjurableInt$fConjurableBool$fConjurable()Primprprimprif cjMkEquation cjAreEqual cjTiersForArgsmaxTestsmaxSizemaxEvalRecursionsmaxEquationSizemaxSearchTestsmaxDeconstructionSizerequireDescent usePatterns showTheoryuniqueCandidatesconjureconjureFromSpecconjure0conjureWithMaxSizeargs conjureWithconjureFromSpecWith conjure0WithconjpureconjpureFromSpec conjpure0 conjpureWithconjpureFromSpecWith conjpure0With conjureTheoryconjureTheoryWithcandidateDefnscandidateDefns1deriveConjurablederiveConjurableIfNeededderiveConjurableCascadingbaseGHC.BaseMonoid GHC.IO.UnsafeunsafePerformIOGHC.Listhead++filterzip Data.Tuplefstsndmap$Data.Typeable.InternalTypeable Data.Foldableelemminimummaximumfoldr1productsumfoldl1foldl'nullfoldlfoldrlength<>mconcatmemptymappend GHC.MaybeMaybeNothingJustghc-prim GHC.TypesTyCon Data.ListisSubsequenceOfData.Traversable mapAccumR mapAccumL Data.TypeabletypeOf7typeOf6typeOf5typeOf4typeOf3typeOf2typeOf1 rnfTypeReptypeRepFingerprint typeRepTyCon typeRepArgs splitTyConAppmkFunTy funResultTygcast2gcast1gcasteqTcast showsTypeReptypeReptypeOfTypeReprnfTyContyConFingerprint tyConName tyConModule tyConPackagefindnotElem minimumBy maximumByallanyorand concatMapconcat Data.MonoidFirstgetFirstLastgetLastApgetApData.Semigroup.InternalDualgetDualEndoappEndoAllgetAllAnygetAnySumgetSumProduct getProductAltgetAlt Data.OldListunwordswordsunlineslinesunfoldrsortOnsortBysort permutations subsequencestailsinitsgroupBygroupdeleteFirstsByunzip7unzip6unzip5unzip4zipWith7zipWith6zipWith5zipWith4zip7zip6zip5zip4genericReplicate genericIndexgenericSplitAt genericDrop genericTake genericLengthinsertByinsert partition transpose intercalate intersperse intersectBy intersectunionByunion\\deleteBydeletenubBynub isInfixOf isSuffixOf isPrefixOf findIndices findIndex elemIndices elemIndex stripPrefix dropWhileEnd Data.ProxyProxyData.Type.Equality:~:Refl:~~:HReflunzip3unzipzipWith3zipWithzip3!!lookupreversebreakspansplitAtdroptake dropWhile takeWhilecycle replicaterepeatiterate'iteratescanr1scanrscanl'scanl1scanlfoldl1'initlasttailuncons Data.MaybemapMaybe catMaybes listToMaybe maybeToList fromMaybefromJust isNothingisJustmaybe Data.Function&onfixswapuncurrycurryflip.constid GHC.Classes&&||TrueString Data.DynamicDynamicBoolIntTest.LeanCheck.CoreListableGHC.ShowShowEq==tiersconjureNamesFortemplate-haskellLanguage.Haskell.TH.Syntax Test.LeanCheck.Utils.TypeBinding-:->:->>:->>>: