extrapolate 0.3.1 → 0.3.2
raw patch · 3 files changed
+20/−6 lines, 3 filesdep ~leancheckdep ~speculatePVP: major bump suggested
API removals or changes: PVP suggests a major version bump
Dependency ranges changed: leancheck, speculate
API changes (from Hackage documentation)
+ Test.Extrapolate: (+|) :: () => [a] -> [a] -> [a]
+ Test.Extrapolate: (==>) :: Bool -> Bool -> Bool
+ Test.Extrapolate: (><) :: () => [[a]] -> [[b]] -> [[(a, b)]]
+ Test.Extrapolate: (\/) :: () => [[a]] -> [[a]] -> [[a]]
+ Test.Extrapolate: (\\//) :: () => [[a]] -> [[a]] -> [[a]]
+ Test.Extrapolate: addWeight :: () => [[a]] -> Int -> [[a]]
+ Test.Extrapolate: bagCons :: Listable a => [a] -> b -> [[b]]
+ Test.Extrapolate: bagsOf :: () => [[a]] -> [[[a]]]
+ Test.Extrapolate: class Listable a
+ Test.Extrapolate: concatMapT :: () => a -> [[b]] -> [[a]] -> [[b]]
+ Test.Extrapolate: concatT :: () => [[[[a]]]] -> [[a]]
+ Test.Extrapolate: cons0 :: () => a -> [[a]]
+ Test.Extrapolate: cons1 :: Listable a => a -> b -> [[b]]
+ Test.Extrapolate: cons10 :: (Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g, Listable h, Listable i, Listable j) => a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> [[k]]
+ Test.Extrapolate: cons11 :: (Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g, Listable h, Listable i, Listable j, Listable k) => a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> [[l]]
+ Test.Extrapolate: cons12 :: (Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g, Listable h, Listable i, Listable j, Listable k, Listable l) => a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> [[m]]
+ Test.Extrapolate: cons2 :: (Listable a, Listable b) => a -> b -> c -> [[c]]
+ Test.Extrapolate: cons3 :: (Listable a, Listable b, Listable c) => a -> b -> c -> d -> [[d]]
+ Test.Extrapolate: cons4 :: (Listable a, Listable b, Listable c, Listable d) => a -> b -> c -> d -> e -> [[e]]
+ Test.Extrapolate: cons5 :: (Listable a, Listable b, Listable c, Listable d, Listable e) => a -> b -> c -> d -> e -> f -> [[f]]
+ Test.Extrapolate: cons6 :: (Listable a, Listable b, Listable c, Listable d, Listable e, Listable f) => a -> b -> c -> d -> e -> f -> g -> [[g]]
+ Test.Extrapolate: cons7 :: (Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g) => a -> b -> c -> d -> e -> f -> g -> h -> [[h]]
+ Test.Extrapolate: cons8 :: (Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g, Listable h) => a -> b -> c -> d -> e -> f -> g -> h -> i -> [[i]]
+ Test.Extrapolate: cons9 :: (Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g, Listable h, Listable i) => a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> [[j]]
+ Test.Extrapolate: delay :: () => [[a]] -> [[a]]
+ Test.Extrapolate: deleteT :: Eq a => a -> [[a]] -> [[a]]
+ Test.Extrapolate: deriveListable :: Name -> DecsQ
+ Test.Extrapolate: deriveListableCascading :: Name -> DecsQ
+ Test.Extrapolate: exists :: Testable a => Int -> a -> Bool
+ Test.Extrapolate: fails :: Testable a => Int -> a -> Bool
+ Test.Extrapolate: filterT :: () => a -> Bool -> [[a]] -> [[a]]
+ Test.Extrapolate: holds :: Testable a => Int -> a -> Bool
+ Test.Extrapolate: infixr 0 ==>
+ Test.Extrapolate: infixr 5 +|
+ Test.Extrapolate: infixr 7 \/
+ Test.Extrapolate: infixr 8 ><
+ Test.Extrapolate: list :: Listable a => [a]
+ Test.Extrapolate: listIntegral :: (Enum a, Num a) => [a]
+ Test.Extrapolate: listsOf :: () => [[a]] -> [[[a]]]
+ Test.Extrapolate: listsOfLength :: () => Int -> [[a]] -> [[[a]]]
+ Test.Extrapolate: mapCons :: (Listable a, Listable b) => [(a, b)] -> c -> [[c]]
+ Test.Extrapolate: mapT :: () => a -> b -> [[a]] -> [[b]]
+ Test.Extrapolate: noDupListCons :: Listable a => [a] -> b -> [[b]]
+ Test.Extrapolate: noDupListsOf :: () => [[a]] -> [[[a]]]
+ Test.Extrapolate: normalizeT :: () => [[a]] -> [[a]]
+ Test.Extrapolate: ofWeight :: () => [[a]] -> Int -> [[a]]
+ Test.Extrapolate: product3With :: () => a -> b -> c -> d -> [[a]] -> [[b]] -> [[c]] -> [[d]]
+ Test.Extrapolate: productMaybeWith :: () => a -> b -> Maybe c -> [[a]] -> [[b]] -> [[c]]
+ Test.Extrapolate: products :: () => [[[a]]] -> [[[a]]]
+ Test.Extrapolate: reset :: () => [[a]] -> [[a]]
+ Test.Extrapolate: setCons :: Listable a => [a] -> b -> [[b]]
+ Test.Extrapolate: setsOf :: () => [[a]] -> [[[a]]]
+ Test.Extrapolate: suchThat :: () => [[a]] -> a -> Bool -> [[a]]
+ Test.Extrapolate: tiers :: Listable a => [[a]]
+ Test.Extrapolate: tiersFractional :: Fractional a => [[a]]
+ Test.Extrapolate: toTiers :: () => [a] -> [[a]]
+ Test.Extrapolate: witness :: Testable a => Int -> a -> Maybe [String]
+ Test.Extrapolate: witnesses :: Testable a => Int -> a -> [[String]]
+ Test.Extrapolate.Core: (+|) :: () => [a] -> [a] -> [a]
+ Test.Extrapolate.Core: (==>) :: Bool -> Bool -> Bool
+ Test.Extrapolate.Core: (><) :: () => [[a]] -> [[b]] -> [[(a, b)]]
+ Test.Extrapolate.Core: (\/) :: () => [[a]] -> [[a]] -> [[a]]
+ Test.Extrapolate.Core: (\\//) :: () => [[a]] -> [[a]] -> [[a]]
+ Test.Extrapolate.Core: addWeight :: () => [[a]] -> Int -> [[a]]
+ Test.Extrapolate.Core: bagCons :: Listable a => [a] -> b -> [[b]]
+ Test.Extrapolate.Core: bagsOf :: () => [[a]] -> [[[a]]]
+ Test.Extrapolate.Core: class Listable a
+ Test.Extrapolate.Core: concatMapT :: () => a -> [[b]] -> [[a]] -> [[b]]
+ Test.Extrapolate.Core: concatT :: () => [[[[a]]]] -> [[a]]
+ Test.Extrapolate.Core: cons0 :: () => a -> [[a]]
+ Test.Extrapolate.Core: cons1 :: Listable a => a -> b -> [[b]]
+ Test.Extrapolate.Core: cons10 :: (Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g, Listable h, Listable i, Listable j) => a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> [[k]]
+ Test.Extrapolate.Core: cons11 :: (Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g, Listable h, Listable i, Listable j, Listable k) => a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> [[l]]
+ Test.Extrapolate.Core: cons12 :: (Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g, Listable h, Listable i, Listable j, Listable k, Listable l) => a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> [[m]]
+ Test.Extrapolate.Core: cons2 :: (Listable a, Listable b) => a -> b -> c -> [[c]]
+ Test.Extrapolate.Core: cons3 :: (Listable a, Listable b, Listable c) => a -> b -> c -> d -> [[d]]
+ Test.Extrapolate.Core: cons4 :: (Listable a, Listable b, Listable c, Listable d) => a -> b -> c -> d -> e -> [[e]]
+ Test.Extrapolate.Core: cons5 :: (Listable a, Listable b, Listable c, Listable d, Listable e) => a -> b -> c -> d -> e -> f -> [[f]]
+ Test.Extrapolate.Core: cons6 :: (Listable a, Listable b, Listable c, Listable d, Listable e, Listable f) => a -> b -> c -> d -> e -> f -> g -> [[g]]
+ Test.Extrapolate.Core: cons7 :: (Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g) => a -> b -> c -> d -> e -> f -> g -> h -> [[h]]
+ Test.Extrapolate.Core: cons8 :: (Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g, Listable h) => a -> b -> c -> d -> e -> f -> g -> h -> i -> [[i]]
+ Test.Extrapolate.Core: cons9 :: (Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g, Listable h, Listable i) => a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> [[j]]
+ Test.Extrapolate.Core: delay :: () => [[a]] -> [[a]]
+ Test.Extrapolate.Core: deleteT :: Eq a => a -> [[a]] -> [[a]]
+ Test.Extrapolate.Core: deriveListable :: Name -> DecsQ
+ Test.Extrapolate.Core: deriveListableCascading :: Name -> DecsQ
+ Test.Extrapolate.Core: exists :: Testable a => Int -> a -> Bool
+ Test.Extrapolate.Core: fails :: Testable a => Int -> a -> Bool
+ Test.Extrapolate.Core: filterT :: () => a -> Bool -> [[a]] -> [[a]]
+ Test.Extrapolate.Core: holds :: Testable a => Int -> a -> Bool
+ Test.Extrapolate.Core: infixr 0 ==>
+ Test.Extrapolate.Core: infixr 7 \/
+ Test.Extrapolate.Core: infixr 8 ><
+ Test.Extrapolate.Core: list :: Listable a => [a]
+ Test.Extrapolate.Core: listIntegral :: (Enum a, Num a) => [a]
+ Test.Extrapolate.Core: listsOf :: () => [[a]] -> [[[a]]]
+ Test.Extrapolate.Core: listsOfLength :: () => Int -> [[a]] -> [[[a]]]
+ Test.Extrapolate.Core: mapCons :: (Listable a, Listable b) => [(a, b)] -> c -> [[c]]
+ Test.Extrapolate.Core: mapT :: () => a -> b -> [[a]] -> [[b]]
+ Test.Extrapolate.Core: noDupListCons :: Listable a => [a] -> b -> [[b]]
+ Test.Extrapolate.Core: noDupListsOf :: () => [[a]] -> [[[a]]]
+ Test.Extrapolate.Core: normalizeT :: () => [[a]] -> [[a]]
+ Test.Extrapolate.Core: ofWeight :: () => [[a]] -> Int -> [[a]]
+ Test.Extrapolate.Core: product3With :: () => a -> b -> c -> d -> [[a]] -> [[b]] -> [[c]] -> [[d]]
+ Test.Extrapolate.Core: productMaybeWith :: () => a -> b -> Maybe c -> [[a]] -> [[b]] -> [[c]]
+ Test.Extrapolate.Core: products :: () => [[[a]]] -> [[[a]]]
+ Test.Extrapolate.Core: reset :: () => [[a]] -> [[a]]
+ Test.Extrapolate.Core: setCons :: Listable a => [a] -> b -> [[b]]
+ Test.Extrapolate.Core: setsOf :: () => [[a]] -> [[[a]]]
+ Test.Extrapolate.Core: suchThat :: () => [[a]] -> a -> Bool -> [[a]]
+ Test.Extrapolate.Core: tiers :: Listable a => [[a]]
+ Test.Extrapolate.Core: tiersFractional :: Fractional a => [[a]]
+ Test.Extrapolate.Core: toTiers :: () => [a] -> [[a]]
+ Test.Extrapolate.Core: witness :: Testable a => Int -> a -> Maybe [String]
+ Test.Extrapolate.Core: witnesses :: Testable a => Int -> a -> [[String]]
+ Test.Extrapolate.Exprs: ($$) :: Expr -> Expr -> Maybe Expr
+ Test.Extrapolate.Exprs: (:$) :: Expr -> Expr -> Expr
+ Test.Extrapolate.Exprs: Constant :: String -> Dynamic -> Expr
+ Test.Extrapolate.Exprs: Instance :: String -> TypeRep -> [Expr] -> Instance
+ Test.Extrapolate.Exprs: Var :: String -> TypeRep -> Expr
+ Test.Extrapolate.Exprs: arity :: Expr -> Int
+ Test.Extrapolate.Exprs: assign :: String -> Expr -> Expr -> Expr
+ Test.Extrapolate.Exprs: assigning :: Expr -> Binds -> Expr
+ Test.Extrapolate.Exprs: atomicConstants :: Expr -> [Expr]
+ Test.Extrapolate.Exprs: boolTy :: TypeRep
+ Test.Extrapolate.Exprs: canonicalWith :: Instances -> Expr -> Bool
+ Test.Extrapolate.Exprs: canonicalize :: Expr -> Expr
+ Test.Extrapolate.Exprs: compareComplexity :: Expr -> Expr -> Ordering
+ Test.Extrapolate.Exprs: compareComplexityThen :: Expr -> Expr -> Ordering -> Expr -> Expr -> Ordering
+ Test.Extrapolate.Exprs: comparisonLE :: Instances -> Expr -> Expr -> Maybe Expr
+ Test.Extrapolate.Exprs: comparisonLT :: Instances -> Expr -> Expr -> Maybe Expr
+ Test.Extrapolate.Exprs: condEqual :: Instances -> Int -> Expr -> Expr -> Expr -> Bool
+ Test.Extrapolate.Exprs: condEqualM :: Instances -> Int -> Int -> Expr -> Expr -> Expr -> Bool
+ Test.Extrapolate.Exprs: conditionalComparisonLE :: Instances -> Expr -> Expr -> Expr -> Maybe Expr
+ Test.Extrapolate.Exprs: conditionalComparisonLT :: Instances -> Expr -> Expr -> Expr -> Maybe Expr
+ Test.Extrapolate.Exprs: conditionalEquation :: Instances -> Expr -> Expr -> Expr -> Maybe Expr
+ Test.Extrapolate.Exprs: constant :: Typeable a => String -> a -> Expr
+ Test.Extrapolate.Exprs: consts :: Expr -> [Expr]
+ Test.Extrapolate.Exprs: countHoles :: TypeRep -> Expr -> Int
+ Test.Extrapolate.Exprs: countVar :: TypeRep -> String -> Expr -> Int
+ Test.Extrapolate.Exprs: countVars :: Expr -> [(TypeRep, String, Int)]
+ Test.Extrapolate.Exprs: data Expr
+ Test.Extrapolate.Exprs: data Instance
+ Test.Extrapolate.Exprs: defNames :: [String]
+ Test.Extrapolate.Exprs: depthE :: Expr -> Int
+ Test.Extrapolate.Exprs: eq :: (Typeable a, Eq a) => a -> Instances
+ Test.Extrapolate.Exprs: eqE :: Instances -> TypeRep -> Maybe Expr
+ Test.Extrapolate.Exprs: eqExprCommuting :: [Expr] -> Expr -> Expr -> Bool
+ Test.Extrapolate.Exprs: eqOrd :: (Typeable a, Eq a, Ord a) => a -> Instances
+ Test.Extrapolate.Exprs: eqWith :: (Typeable a, Eq a) => a -> a -> Bool -> Instances
+ Test.Extrapolate.Exprs: equal :: Instances -> Int -> Expr -> Expr -> Bool
+ Test.Extrapolate.Exprs: equation :: Instances -> Expr -> Expr -> Maybe Expr
+ Test.Extrapolate.Exprs: etyp :: Expr -> Either Expr TypeRep
+ Test.Extrapolate.Exprs: eval :: Typeable a => a -> Expr -> a
+ Test.Extrapolate.Exprs: evaluate :: Typeable a => Expr -> Maybe a
+ Test.Extrapolate.Exprs: false :: Instances -> Int -> Expr -> Bool
+ Test.Extrapolate.Exprs: falseE :: Expr
+ Test.Extrapolate.Exprs: fill :: Expr -> [Expr] -> Expr
+ Test.Extrapolate.Exprs: findInfo :: () => Instance -> Maybe a -> Instances -> Maybe a
+ Test.Extrapolate.Exprs: groundAndBinds :: Instances -> Expr -> [(Binds, Expr)]
+ Test.Extrapolate.Exprs: groundBinds :: Instances -> Expr -> [Binds]
+ Test.Extrapolate.Exprs: hasCanonInstanceOf :: Expr -> Expr -> Bool
+ Test.Extrapolate.Exprs: hasInstanceOf :: Expr -> Expr -> Bool
+ Test.Extrapolate.Exprs: hasVar :: Expr -> Bool
+ Test.Extrapolate.Exprs: hole :: (Listable a, Typeable a) => a -> Expr
+ Test.Extrapolate.Exprs: holeOfTy :: TypeRep -> Expr
+ Test.Extrapolate.Exprs: holes :: Expr -> [TypeRep]
+ Test.Extrapolate.Exprs: implication :: Expr -> Expr -> Maybe Expr
+ Test.Extrapolate.Exprs: inequal :: Instances -> Int -> Expr -> Expr -> Bool
+ Test.Extrapolate.Exprs: inequality :: Instances -> Expr -> Expr -> Maybe Expr
+ Test.Extrapolate.Exprs: instanceType :: Instance -> TypeRep
+ Test.Extrapolate.Exprs: iqE :: Instances -> TypeRep -> Maybe Expr
+ Test.Extrapolate.Exprs: isAssignment :: Expr -> Bool
+ Test.Extrapolate.Exprs: isCanonInstanceOf :: Expr -> Expr -> Bool
+ Test.Extrapolate.Exprs: isConstantNamed :: Expr -> String -> Bool
+ Test.Extrapolate.Exprs: isEq :: Instances -> TypeRep -> Bool
+ Test.Extrapolate.Exprs: isEqE :: Instances -> Expr -> Bool
+ Test.Extrapolate.Exprs: isEqOrd :: Instances -> TypeRep -> Bool
+ Test.Extrapolate.Exprs: isEqOrdE :: Instances -> Expr -> Bool
+ Test.Extrapolate.Exprs: isEquation :: Expr -> Bool
+ Test.Extrapolate.Exprs: isInstanceOf :: Expr -> Expr -> Bool
+ Test.Extrapolate.Exprs: isListable :: Instances -> TypeRep -> Bool
+ Test.Extrapolate.Exprs: isOrd :: Instances -> TypeRep -> Bool
+ Test.Extrapolate.Exprs: isOrdE :: Instances -> Expr -> Bool
+ Test.Extrapolate.Exprs: isSub :: Expr -> Expr -> Bool
+ Test.Extrapolate.Exprs: isTuple :: Expr -> Bool
+ Test.Extrapolate.Exprs: leE :: Instances -> TypeRep -> Maybe Expr
+ Test.Extrapolate.Exprs: lengthE :: Expr -> Int
+ Test.Extrapolate.Exprs: less :: Instances -> Int -> Expr -> Expr -> Bool
+ Test.Extrapolate.Exprs: lessOrEqual :: Instances -> Int -> Expr -> Expr -> Bool
+ Test.Extrapolate.Exprs: lexicompare :: Expr -> Expr -> Ordering
+ Test.Extrapolate.Exprs: lexicompareBy :: Expr -> Expr -> Ordering -> Expr -> Expr -> Ordering
+ Test.Extrapolate.Exprs: listable :: (Typeable a, Show a, Listable a) => a -> Instances
+ Test.Extrapolate.Exprs: listableWith :: (Typeable a, Show a) => [[a]] -> Instances
+ Test.Extrapolate.Exprs: ltE :: Instances -> TypeRep -> Maybe Expr
+ Test.Extrapolate.Exprs: match :: Expr -> Expr -> Maybe Binds
+ Test.Extrapolate.Exprs: match2 :: (Expr, Expr) -> (Expr, Expr) -> Maybe Binds
+ Test.Extrapolate.Exprs: matchWith :: Binds -> Expr -> Expr -> Maybe Binds
+ Test.Extrapolate.Exprs: mkEqnTy :: TypeRep -> TypeRep
+ Test.Extrapolate.Exprs: names :: Instances -> TypeRep -> [String]
+ Test.Extrapolate.Exprs: ord :: (Typeable a, Ord a) => a -> Instances
+ Test.Extrapolate.Exprs: ordWith :: (Typeable a, Ord a) => a -> a -> Bool -> Instances
+ Test.Extrapolate.Exprs: phonyEquation :: Expr -> Expr -> Expr
+ Test.Extrapolate.Exprs: preludeInstances :: Instances
+ Test.Extrapolate.Exprs: renameBy :: String -> String -> Expr -> Expr
+ Test.Extrapolate.Exprs: showConstant :: (Typeable a, Show a) => a -> Expr
+ Test.Extrapolate.Exprs: showExpr :: Expr -> String
+ Test.Extrapolate.Exprs: showOpExpr :: String -> Expr -> String
+ Test.Extrapolate.Exprs: showPrecExpr :: Int -> Expr -> String
+ Test.Extrapolate.Exprs: showsOpExpr :: String -> Expr -> String -> String
+ Test.Extrapolate.Exprs: showsPrecExpr :: Int -> Expr -> String -> String
+ Test.Extrapolate.Exprs: sub :: Expr -> Expr -> Expr -> Expr
+ Test.Extrapolate.Exprs: subexprs :: Expr -> [Expr]
+ Test.Extrapolate.Exprs: subexprsV :: Expr -> [Expr]
+ Test.Extrapolate.Exprs: tiersE :: Instances -> TypeRep -> [[Expr]]
+ Test.Extrapolate.Exprs: true :: Instances -> Int -> Expr -> Bool
+ Test.Extrapolate.Exprs: trueBinds :: Instances -> Int -> Expr -> [Binds]
+ Test.Extrapolate.Exprs: trueRatio :: Instances -> Int -> Expr -> Ratio Int
+ Test.Extrapolate.Exprs: typ :: Expr -> TypeRep
+ Test.Extrapolate.Exprs: type Binds = [(String, Expr)]
+ Test.Extrapolate.Exprs: type Instances = [Instance]
+ Test.Extrapolate.Exprs: type TypeRep = SomeTypeRep
+ Test.Extrapolate.Exprs: typeCorrect :: Expr -> Bool
+ Test.Extrapolate.Exprs: unComparison :: Expr -> (Expr, Expr)
+ Test.Extrapolate.Exprs: unConditionalComparison :: Expr -> (Expr, Expr, Expr)
+ Test.Extrapolate.Exprs: unConditionalEquation :: Expr -> (Expr, Expr, Expr)
+ Test.Extrapolate.Exprs: unEquation :: Expr -> (Expr, Expr)
+ Test.Extrapolate.Exprs: unImplication :: Expr -> (Expr, Expr)
+ Test.Extrapolate.Exprs: unfoldApp :: Expr -> [Expr]
+ Test.Extrapolate.Exprs: unfoldTuple :: Expr -> [Expr]
+ Test.Extrapolate.Exprs: unification :: Expr -> Expr -> Maybe Binds
+ Test.Extrapolate.Exprs: unify :: Expr -> Expr -> Maybe Expr
+ Test.Extrapolate.Exprs: unrepeatedVars :: Expr -> Bool
+ Test.Extrapolate.Exprs: usefulConditionalEquation :: Expr -> Bool
+ Test.Extrapolate.Exprs: usefulEquation :: Expr -> Bool
+ Test.Extrapolate.Exprs: usefulImplication :: Expr -> Bool
+ Test.Extrapolate.Exprs: uselessEquation :: Expr -> Bool
+ Test.Extrapolate.Exprs: var :: (Listable a, Typeable a) => String -> a -> Expr
- Test.Extrapolate: constant :: Typeable * a => String -> a -> Expr
+ Test.Extrapolate: constant :: Typeable a => String -> a -> Expr
- Test.Extrapolate: data Expr :: *
+ Test.Extrapolate: data Expr
- Test.Extrapolate: showConstant :: (Typeable * a, Show a) => a -> Expr
+ Test.Extrapolate: showConstant :: (Typeable a, Show a) => a -> Expr
Files
- README.md +2/−0
- TODO.md +12/−0
- extrapolate.cabal +6/−6
README.md view
@@ -126,6 +126,7 @@ Extrapolate was accepted for presentation at [IFL 2017], see the pre-symposium proceedings [paper about Extrapolate](https://matela.com.br/paper/extrapolate.pdf).+Extrapolate is also subject to a chapter in a [PhD Thesis (2017)]. [extrapolate-on-hackage]: https://hackage.haskell.org/package/extrapolate [Extrapolate from Hackage]: https://hackage.haskell.org/package/extrapolate@@ -144,6 +145,7 @@ [IFL 2017]: http://iflconference.org/ [SmartCheck]: https://github.com/leepike/SmartCheck [Lazy SmallCheck 2012]: https://github.com/UoYCS-plasma/lazysmallcheck2012+[PhD Thesis (2017)]: https://matela.com.br/paper/rudy-phd-thesis-2017.pdf [build-status]: https://travis-ci.org/rudymatela/extrapolate.svg?branch=master [build-log]: https://travis-ci.org/rudymatela/extrapolate
TODO.md view
@@ -3,6 +3,8 @@ A non-exhaustive list of things TO DO for Extrapolate. +WARNING: This TO DO list is outdated.+ * `deriveGeneralizable` should `deriveListableIfNeeded`. examples@@ -37,6 +39,16 @@ feature -------++* `deriveGeneralizableAtomic`: derive a generalizable value treating it as+ atomic, as I did with the Map on the XMonad example. To be used on datatypes+ with data invariants.++* `deriveGeneralizableFromTo`: derive a generalizable value using a bijection+ passed as parameter so that a data invariant is not broken. Example:++ deriveGeneralizable ''Map fromList toList.+ * `background-exclusion`: add a mechanism to exclude functions from the background.
extrapolate.cabal view
@@ -1,5 +1,5 @@ name: extrapolate-version: 0.3.1+version: 0.3.2 synopsis: generalize counter-examples of test properties description: Extrapolate is a tool able to provide generalized counter-examples of test@@ -18,11 +18,11 @@ maintainer: Rudy Matela <rudy@matela.com.br> category: Testing build-type: Simple-cabal-version: >=1.18+cabal-version: 1.18 extra-doc-files: README.md , TODO.md-tested-with: GHC==8.2, GHC==8.0, GHC==7.10, GHC==7.8+tested-with: GHC==8.4, GHC==8.2, GHC==8.0, GHC==7.10, GHC==7.8 source-repository head type: git@@ -31,7 +31,7 @@ source-repository this type: git location: https://github.com/rudymatela/extrapolate- tag: v0.3.1+ tag: v0.3.2 library exposed-modules: Test.Extrapolate@@ -45,9 +45,9 @@ , Test.Extrapolate.New other-extensions: TemplateHaskell, CPP build-depends: base >= 4 && < 5- , leancheck >= 0.7+ , leancheck >= 0.7.2 , template-haskell- , speculate >= 0.3.2+ , speculate >= 0.3.4 hs-source-dirs: src default-language: Haskell2010