WNDi      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgh(c) 2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>Safeijkijkijk5(c) 2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>Safe$  !"#$$  !"#$$  !"#$$  !"#$(c) 2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None lm%no&'()*+,pqrstuvwxyz{|}~%&'()*+,%&'()+,* lm%no&'()*+,(c) 2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>NoneUsage: ins "x" (undefined :: Type)lgeneralizes an expression by making it less defined, starting with smaller changes, then bigger changes:1: change constant to variable 1.1: if a variable of the constant type exists, use it 1.2: if not, introduce new variable 2: change a variable to a new variableAThe above is the ideal, but let's start with a simpler algorithm:1: change constant to holeI0List matches of lists of expressions if possible S[0,1] `matchList` [x,y] = Just [x=0, y=1] [0,1+2] `matchList` [x,y+y] = Nothing=-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXpqrstuvwxyz{|}~      !"#$%&'()*+,%&'()*+,-./0123456789:;<=>?@ABCDEFG-./0213456789:;<=>?@ABCDEFGHIJKL"789:<=>;3456./012?@AGCDEFLIJ-.BHK0-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWX(c) 2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>NoneZ Derives a 7 instance for a given type H.Consider the following Stack datatype: (data Stack a = Stack a (Stack a) | EmptyWriting deriveGeneralizable ''Stack(will automatically derive the following 7 instance: ^instance Generalizable a => Generalizable (Stack a) where tiers = cons2 Stack \/ cons0 Empty Needs the TemplateHaskell extension.[Same as Z4 but does not warn when instance already exists (Z is preferable).\ Derives a 7 instance for a given type H3 cascading derivation of type arguments as well.IgGiven a type name, return the number of arguments taken by that type. Examples in partially broken TH: arity ''Int === Q 0 arity ''Int->Int === Q 0 arity ''Maybe === Q 1 arity ''Either === Q 2 arity ''Int-> === Q 1ZThis works for Data's and Newtype's and it is useful when generating typeclass instances.JKLZ[\MNOPQRSTUVWXYIZ[\]^_`abZ[\Z[\JKLZ[\MNOPQRSTUVWXYIZ[\]^_`ab(c) 2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>Noned&Checks a property printing results on stdout > check $ \xs -> sort (sort xs) == sort (xs::[Int]) +++ OK, passed 360 tests. > check $ \xs ys -> xs `union` ys == ys `union` (xs::[Int]) *** Failed! Falsifiable (after 4 tests): [] [0,0] Generalization: [] (x:x:xs)e(Check a property printing results on stdout and returning c on success.JThere is no option to silence this function: for silence, you should use  .defg`abcdehijklmn`abcdede`abcdefg`abcdehijklmn(c) 2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>Nonehpqrstuvwxyz{|}~      !"#$%&'()*+,%&'()*+,-./0123456789:;<=>?@ABCDEFG-./0213456789:;<=>?@ABCDEFGHIJKLh (c) 2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>Nonep  !"#$qrstuvwxyz{|}~      !"#$%&'()*+,%&'()*+,-./0123456789:;<=>?@ABCDEFG-./0213456789:;<=>?@ABCDEFGHIJKLZ[\`abcdeo    !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwwxyz{|}~}}}}}}}}}}~}~}~}~}~}~}~}~}~}~}~}~}~}~}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}                           !  "  #  $  %  &  '  (  )  *  +  ,  -  .  /  0  1  2  3  4  5 67 68 69 6: 6; 6< 6= 6> 6?  @  A    B  C DE DF DG DH DI DJ DK DL DM DN DO DP DQ DR DS DT DU DV DW DX DY DZ D[ D\ D] D^ D_`abcddefghijklmnopqrstuvwxvyz{|}~(extrapolate-0.0.1-2wYKH5BMoPO8Pd7HyWYvQwTest.Extrapolate.CoreTest.Extrapolate.TypeBindingTest.Extrapolate.ExprsTest.Extrapolate.DeriveTest.Extrapolate.IOTest.Extrapolate.BasicTest.Extrapolate.UtilsTestLean.CheckholdsTest.Extrapolate+++ argTypes0 argTypes1 argTypes2 argTypes3 argTypes4 argTypes5 argTypes6 argTypes7 argTypes8 argTypes9 argTypes10 argTypes11 argTypes12argTys1argTys2 argTy1of1 argTy1of2 argTy2of2 argTy1of3 argTy2of3 argTy3of3 argTy1of4 argTy2of4 argTy3of4 argTy4of4 argTy1of5 argTy2of5 argTy3of5 argTy4of5 argTy5of5 argTy1of6 argTy2of6 argTy3of6 argTy4of6 argTy5of6 argTy6of6canonicalizeWithgroundsgroundsAndBinds vassignmentsvarsisAssignmentTestfoldunfoldTestableoptions WithOptionWithpropertyoptionOptionMaxTestsExtraInstancesMaxConditionSize Generalizableexpruseful instancesnameOfthistheseusefunsmaxTestsextraInstancesmaxConditionSizeresultscounterExampleGensgeneralizationsCEgeneralizationsCECgeneralizationsCountscounterExampleGenareInstancesOf matchList newMatches expressionsTconditionalGeneralization$fTestable(->)$fTestableBool$fTestableWithOption$fGeneralizable[]$fGeneralizable(,,)$fGeneralizable(,)$fGeneralizableMaybe$fGeneralizableChar$fGeneralizableInteger$fGeneralizableInt$fGeneralizableBool$fGeneralizable() $fShowOptionderiveGeneralizablederiveGeneralizableIfNeededderiveGeneralizableCascading$fEqBla$fOrdBla $fShowBlafor withInstanceswithBackgroundwithConditionSizecheck checkResult $fEqResult $fShowResult$fGeneralizableRatio nubMergeBy nubMergeOnnubMerge MarkerTypecanonicalizeWith1unrepeatedToHole1baseData.Typeable.InternalTypeRep&speculate-0.2.5-Kko6VPD22un4tab108GNkdTest.Speculate.Expr.MatchBindsTest.Speculate.Expr.Instance InstancesInstanceTest.Speculate.Expr.CoreExprVarConstant:$Test.Speculate.Utils.TypeablemkEqnTyboolTyunify unificationsubrenameBy matchWithmatch2match isInstanceOfisCanonInstanceOf hasInstanceOfhasCanonInstanceOffill assigningassigntiersEpreludeInstancesordWithordnamesnameltE listableWithlistableleEisOrdEisOrd isListableisEqOrdEisEqOrdisEqEisEq instanceTypefindInfoeqWitheqOrdeqEeqdefNamesTest.Speculate.Expr.Ground trueRatio trueBindstrue lessOrEquallessinequal groundBindsgroundAndBindsfalseequal condEqualM condEqualTest.Speculate.Expr.EquateuselessEquationusefulImplicationusefulEquationusefulConditionalEquation unImplication unEquationunConditionalEquationunConditionalComparison unComparison phonyEquation isEquation implicationequationconditionalEquationconditionalComparisonLTconditionalComparisonLE comparisonLT comparisonLEvarunrepeatedVars unfoldApp typeCorrecttyp subexprsVsubexprs showsPrecExpr showsOpExpr showPrecExpr showOpExprshowExpr showConstant lexicompareBy lexicomparelengthEisSubisConstantNamed isAssignmentholesholeOfTyholehasVarfalseEevaluateevaletypeqExprCommutingdepthE countVarscountVarconstsconstantcompareComplexityThencompareComplexityatomicConstantsarity$$Test.Speculate.Expr.Canon canonicalize canonicalWithinsgeneralizations1 resultiers$-| tinstancesOptions getBackgroundgeneralizations productWithcounterExamplescounterExampleisCounterExample countPasses expressionsTTweakestConditionisCounterExampleUnderisVar&leancheck-0.6.3-AjCDFvE22s2JnuKqsb5srhTest.LeanCheck.CoreListablelisttiersTest.LeanCheck.TierssetsOfsetConsproductsproductMaybeWith product3With normalizeT noDupListsOf noDupListCons listsOfLengthlistsOfdeleteTbagsOfbagConsTest.LeanCheck.DerivederiveListableCascadingderiveListabletoTierstiersFractionalsuchThatresetmapT listIntegralfilterTdelaycons5cons4cons3cons2cons1cons0concatT concatMapT\\//\/><==>+|Test.LeanCheck.BasicofWeightcons9cons8cons7cons6cons12cons11cons10 addWeight witnesseswitnessfailsexists Test.LeanCheck.Utils.TypeBindingunduint4uint3uint2uint1stringnatmaybintegerint4int3int2int1intfloateithdoublecharbool>-->>>:->>:>->>:->:>->:-:>-:template-haskellLanguage.Haskell.TH.SyntaxName typeArityBlaBlederiveGeneralizableXreallyDeriveGeneralizableletintypeConstructorsArgNames lookupValN"reallyDeriveGeneralizableCascading typeConArgstypeConArgsThattypeConCascadingArgsThat normalizeTypenormalizeTypeUnitsisntInstanceOftypeConstructors isTypeSynonymtypeSynonymType|=>| mergeIFnsmergeIwhereI nubMergesghc-prim GHC.TypesTrueResultOK Falsified Exception resultsIOresultIO showResultshowCECshowCEGshowCEprettify