packages feed

compdata 0.10.1 → 0.11

raw patch · 7 files changed

+22/−15 lines, 7 filesdep ~basedep ~containersdep ~deepseqPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: base, containers, deepseq, derive, mtl, template-haskell, th-expand-syns, transformers, tree-view

API changes (from Hackage documentation)

- Data.Comp.Derive: class Functor (f :: * -> *)
- Data.Comp.Derive: makeFunctor :: Name -> Q [Dec]
- Data.Comp.Multi.Term: Hole :: a i -> Cxt Hole f a i
- Data.Comp.Multi.Term: Term :: f (Cxt h f a) i -> Cxt h f a i
- Data.Comp.Ops: instance forall (k :: BOX) (f :: k -> *) (s :: k -> *) p (s' :: k -> *). Data.Comp.Ops.DistAnn s p s' => Data.Comp.Ops.DistAnn (f Data.Comp.Ops.:+: s) p ((f Data.Comp.Ops.:&: p) Data.Comp.Ops.:+: s')
- Data.Comp.Ops: instance forall (k :: BOX) (f :: k -> *) p (s :: k -> *) (s' :: k -> *). Data.Comp.Ops.RemA s s' => Data.Comp.Ops.RemA ((f Data.Comp.Ops.:&: p) Data.Comp.Ops.:+: s) (f Data.Comp.Ops.:+: s')
- Data.Comp.Ops: instance forall (k :: BOX) (f :: k -> *) p. Data.Comp.Ops.DistAnn f p (f Data.Comp.Ops.:&: p)
- Data.Comp.Ops: instance forall (k :: BOX) (f :: k -> *) p. Data.Comp.Ops.RemA (f Data.Comp.Ops.:&: p) f
- Data.Comp.Term: Hole :: a -> Cxt Hole f a
- Data.Comp.Term: Term :: f (Cxt h f a) -> Cxt h f a
+ Data.Comp.Multi.Term: [Hole] :: a i -> Cxt Hole f a i
+ Data.Comp.Multi.Term: [Term] :: f (Cxt h f a) i -> Cxt h f a i
+ Data.Comp.Ops: instance forall k (f :: k -> *) p. Data.Comp.Ops.DistAnn f p (f Data.Comp.Ops.:&: p)
+ Data.Comp.Ops: instance forall k (f :: k -> *) p. Data.Comp.Ops.RemA (f Data.Comp.Ops.:&: p) f
+ Data.Comp.Ops: instance forall k (s :: k -> *) (s' :: k -> *) (f :: k -> *) p. Data.Comp.Ops.RemA s s' => Data.Comp.Ops.RemA ((f Data.Comp.Ops.:&: p) Data.Comp.Ops.:+: s) (f Data.Comp.Ops.:+: s')
+ Data.Comp.Ops: instance forall k (s :: k -> *) p (s' :: k -> *) (f :: k -> *). Data.Comp.Ops.DistAnn s p s' => Data.Comp.Ops.DistAnn (f Data.Comp.Ops.:+: s) p ((f Data.Comp.Ops.:&: p) Data.Comp.Ops.:+: s')
+ Data.Comp.Term: [Hole] :: a -> Cxt Hole f a
+ Data.Comp.Term: [Term] :: f (Cxt h f a) -> Cxt h f a
+ Data.Comp.Thunk: infixl 1 #>>
- Data.Comp.Algebra: ana :: Functor f => Coalg f a -> a -> Term f
+ Data.Comp.Algebra: ana :: forall a f. Functor f => Coalg f a -> a -> Term f
- Data.Comp.Algebra: ana' :: Functor f => Coalg f a -> a -> Term f
+ Data.Comp.Algebra: ana' :: forall a f. Functor f => Coalg f a -> a -> Term f
- Data.Comp.Algebra: anaM :: (Traversable f, Monad m) => CoalgM m f a -> a -> m (Term f)
+ Data.Comp.Algebra: anaM :: forall a m f. (Traversable f, Monad m) => CoalgM m f a -> a -> m (Term f)
- Data.Comp.Algebra: appHom :: (Functor f, Functor g) => Hom f g -> CxtFun f g
+ Data.Comp.Algebra: appHom :: forall f g. (Functor f, Functor g) => Hom f g -> CxtFun f g
- Data.Comp.Algebra: appHom' :: (Functor g) => Hom f g -> CxtFun f g
+ Data.Comp.Algebra: appHom' :: forall f g. (Functor g) => Hom f g -> CxtFun f g
- Data.Comp.Algebra: appHomM :: (Traversable f, Functor g, Monad m) => HomM m f g -> CxtFunM m f g
+ Data.Comp.Algebra: appHomM :: forall f g m. (Traversable f, Functor g, Monad m) => HomM m f g -> CxtFunM m f g
- Data.Comp.Algebra: appHomM' :: (Traversable g, Monad m) => HomM m f g -> CxtFunM m f g
+ Data.Comp.Algebra: appHomM' :: forall f g m. (Traversable g, Monad m) => HomM m f g -> CxtFunM m f g
- Data.Comp.Algebra: appSigFunMD :: (Traversable f, Functor g, Monad m) => SigFunMD m f g -> CxtFunM m f g
+ Data.Comp.Algebra: appSigFunMD :: forall f g m. (Traversable f, Functor g, Monad m) => SigFunMD m f g -> CxtFunM m f g
- Data.Comp.Algebra: cata :: (Functor f) => Alg f a -> Term f -> a
+ Data.Comp.Algebra: cata :: forall f a. (Functor f) => Alg f a -> Term f -> a
- Data.Comp.Algebra: cataM :: (Traversable f, Monad m) => AlgM m f a -> Term f -> m a
+ Data.Comp.Algebra: cataM :: forall f m a. (Traversable f, Monad m) => AlgM m f a -> Term f -> m a
- Data.Comp.Algebra: cataM' :: (Traversable f, Monad m) => AlgM m f a -> Cxt h f a -> m a
+ Data.Comp.Algebra: cataM' :: forall h f a m. (Traversable f, Monad m) => AlgM m f a -> Cxt h f a -> m a
- Data.Comp.Algebra: free :: (Functor f) => Alg f b -> (a -> b) -> Cxt h f a -> b
+ Data.Comp.Algebra: free :: forall f h a b. (Functor f) => Alg f b -> (a -> b) -> Cxt h f a -> b
- Data.Comp.Algebra: freeM :: (Traversable f, Monad m) => AlgM m f b -> (a -> m b) -> Cxt h f a -> m b
+ Data.Comp.Algebra: freeM :: forall h f a m b. (Traversable f, Monad m) => AlgM m f b -> (a -> m b) -> Cxt h f a -> m b
- Data.Comp.Algebra: futu :: Functor f => CVCoalg f a -> a -> Term f
+ Data.Comp.Algebra: futu :: forall f a. Functor f => CVCoalg f a -> a -> Term f
- Data.Comp.Algebra: futu' :: Functor f => CVCoalg' f a -> a -> Term f
+ Data.Comp.Algebra: futu' :: forall f a. Functor f => CVCoalg' f a -> a -> Term f
- Data.Comp.Algebra: futuM :: (Traversable f, Monad m) => CVCoalgM m f a -> a -> m (Term f)
+ Data.Comp.Algebra: futuM :: forall f a m. (Traversable f, Monad m) => CVCoalgM m f a -> a -> m (Term f)
- Data.Comp.Algebra: homMD :: (Traversable f, Functor g, Monad m) => HomMD m f g -> CxtFunM m f g
+ Data.Comp.Algebra: homMD :: forall f g m. (Traversable f, Functor g, Monad m) => HomMD m f g -> CxtFunM m f g
- Data.Comp.Derive.Utils: DataInfo :: Cxt -> Name -> [TyVarBndr] -> [Con] -> [Name] -> DataInfo
+ Data.Comp.Derive.Utils: DataInfo :: Cxt -> Name -> [TyVarBndr] -> [Con] -> Cxt -> DataInfo
- Data.Comp.Generic: subterms :: Foldable f => Term f -> [Term f]
+ Data.Comp.Generic: subterms :: forall f. Foldable f => Term f -> [Term f]
- Data.Comp.Generic: subterms' :: (Foldable f, g :<: f) => Term f -> [g (Term f)]
+ Data.Comp.Generic: subterms' :: forall f g. (Foldable f, g :<: f) => Term f -> [g (Term f)]
- Data.Comp.Multi.Algebra: ana :: HFunctor f => Coalg f a -> a :-> Term f
+ Data.Comp.Multi.Algebra: ana :: forall f a. HFunctor f => Coalg f a -> a :-> Term f
- Data.Comp.Multi.Algebra: anaM :: (HTraversable f, Monad m) => CoalgM m f a -> NatM m a (Term f)
+ Data.Comp.Multi.Algebra: anaM :: forall a m f. (HTraversable f, Monad m) => CoalgM m f a -> NatM m a (Term f)
- Data.Comp.Multi.Algebra: apo :: (HFunctor f) => RCoalg f a -> a :-> Term f
+ Data.Comp.Multi.Algebra: apo :: forall f a. (HFunctor f) => RCoalg f a -> a :-> Term f
- Data.Comp.Multi.Algebra: apoM :: (HTraversable f, Monad m) => RCoalgM m f a -> NatM m a (Term f)
+ Data.Comp.Multi.Algebra: apoM :: forall f m a. (HTraversable f, Monad m) => RCoalgM m f a -> NatM m a (Term f)
- Data.Comp.Multi.Algebra: appHom :: (HFunctor f, HFunctor g) => Hom f g -> CxtFun f g
+ Data.Comp.Multi.Algebra: appHom :: forall f g. (HFunctor f, HFunctor g) => Hom f g -> CxtFun f g
- Data.Comp.Multi.Algebra: appHom' :: (HFunctor g) => Hom f g -> CxtFun f g
+ Data.Comp.Multi.Algebra: appHom' :: forall f g. (HFunctor g) => Hom f g -> CxtFun f g
- Data.Comp.Multi.Algebra: appHomM :: (HTraversable f, HFunctor g, Monad m) => HomM m f g -> CxtFunM m f g
+ Data.Comp.Multi.Algebra: appHomM :: forall f g m. (HTraversable f, HFunctor g, Monad m) => HomM m f g -> CxtFunM m f g
- Data.Comp.Multi.Algebra: appHomM' :: (HTraversable g, Monad m) => HomM m f g -> CxtFunM m f g
+ Data.Comp.Multi.Algebra: appHomM' :: forall f g m. (HTraversable g, Monad m) => HomM m f g -> CxtFunM m f g
- Data.Comp.Multi.Algebra: appSigFun :: (HFunctor f) => SigFun f g -> CxtFun f g
+ Data.Comp.Multi.Algebra: appSigFun :: forall f g. (HFunctor f) => SigFun f g -> CxtFun f g
- Data.Comp.Multi.Algebra: appSigFun' :: (HFunctor g) => SigFun f g -> CxtFun f g
+ Data.Comp.Multi.Algebra: appSigFun' :: forall f g. (HFunctor g) => SigFun f g -> CxtFun f g
- Data.Comp.Multi.Algebra: appSigFunM :: (HTraversable f, Monad m) => SigFunM m f g -> CxtFunM m f g
+ Data.Comp.Multi.Algebra: appSigFunM :: forall f g m. (HTraversable f, Monad m) => SigFunM m f g -> CxtFunM m f g
- Data.Comp.Multi.Algebra: appSigFunM' :: (HTraversable g, Monad m) => SigFunM m f g -> CxtFunM m f g
+ Data.Comp.Multi.Algebra: appSigFunM' :: forall f g m. (HTraversable g, Monad m) => SigFunM m f g -> CxtFunM m f g
- Data.Comp.Multi.Algebra: cata :: HFunctor f => Alg f a -> Term f :-> a
+ Data.Comp.Multi.Algebra: cata :: forall f a. HFunctor f => Alg f a -> Term f :-> a
- Data.Comp.Multi.Algebra: cataM :: (HTraversable f, Monad m) => AlgM m f a -> NatM m (Term f) a
+ Data.Comp.Multi.Algebra: cataM :: forall f m a. (HTraversable f, Monad m) => AlgM m f a -> NatM m (Term f) a
- Data.Comp.Multi.Algebra: cataM' :: (Monad m, HTraversable f) => AlgM m f a -> NatM m (Cxt h f a) a
+ Data.Comp.Multi.Algebra: cataM' :: forall m h a f. (Monad m, HTraversable f) => AlgM m f a -> NatM m (Cxt h f a) a
- Data.Comp.Multi.Algebra: free :: (HFunctor f) => Alg f b -> (a :-> b) -> Cxt h f a :-> b
+ Data.Comp.Multi.Algebra: free :: forall f h a b. (HFunctor f) => Alg f b -> (a :-> b) -> Cxt h f a :-> b
- Data.Comp.Multi.Algebra: freeM :: (HTraversable f, Monad m) => AlgM m f b -> NatM m a b -> NatM m (Cxt h f a) b
+ Data.Comp.Multi.Algebra: freeM :: forall f m h a b. (HTraversable f, Monad m) => AlgM m f b -> NatM m a b -> NatM m (Cxt h f a) b
- Data.Comp.Multi.Algebra: futu :: HFunctor f => CVCoalg f a -> a :-> Term f
+ Data.Comp.Multi.Algebra: futu :: forall f a. HFunctor f => CVCoalg f a -> a :-> Term f
- Data.Comp.Multi.Algebra: futuM :: (HTraversable f, Monad m) => CVCoalgM m f a -> NatM m a (Term f)
+ Data.Comp.Multi.Algebra: futuM :: forall f a m. (HTraversable f, Monad m) => CVCoalgM m f a -> NatM m a (Term f)
- Data.Comp.Multi.Algebra: liftMAlg :: (Monad m, HTraversable f) => Alg f I -> Alg f m
+ Data.Comp.Multi.Algebra: liftMAlg :: forall m f. (Monad m, HTraversable f) => Alg f I -> Alg f m
- Data.Comp.Multi.Algebra: para :: (HFunctor f) => RAlg f a -> Term f :-> a
+ Data.Comp.Multi.Algebra: para :: forall f a. (HFunctor f) => RAlg f a -> Term f :-> a
- Data.Comp.Multi.Algebra: paraM :: (HTraversable f, Monad m) => RAlgM m f a -> NatM m (Term f) a
+ Data.Comp.Multi.Algebra: paraM :: forall f m a. (HTraversable f, Monad m) => RAlgM m f a -> NatM m (Term f) a
- Data.Comp.Multi.Generic: subterms :: HFoldable f => Term f :=> [E (Term f)]
+ Data.Comp.Multi.Generic: subterms :: forall f. HFoldable f => Term f :=> [E (Term f)]
- Data.Comp.Multi.Generic: subterms' :: (HFoldable f, g :<: f) => Term f :=> [E (g (Term f))]
+ Data.Comp.Multi.Generic: subterms' :: forall f g. (HFoldable f, g :<: f) => Term f :=> [E (g (Term f))]
- Data.Comp.Multi.Generic: transform :: (HFunctor f) => (Term f :-> Term f) -> Term f :-> Term f
+ Data.Comp.Multi.Generic: transform :: forall f. (HFunctor f) => (Term f :-> Term f) -> Term f :-> Term f
- Data.Comp.Multi.Generic: transformM :: (HTraversable f, Monad m) => NatM m (Term f) (Term f) -> NatM m (Term f) (Term f)
+ Data.Comp.Multi.Generic: transformM :: forall f m. (HTraversable f, Monad m) => NatM m (Term f) (Term f) -> NatM m (Term f) (Term f)
- Data.Comp.Multi.HFoldable: hfoldl1 :: HFoldable h => (a -> a -> a) -> h (K a) :=> a
+ Data.Comp.Multi.HFoldable: hfoldl1 :: forall a. HFoldable h => (a -> a -> a) -> h (K a) :=> a
- Data.Comp.Multi.HFoldable: hfoldr1 :: HFoldable h => (a -> a -> a) -> h (K a) :=> a
+ Data.Comp.Multi.HFoldable: hfoldr1 :: forall a. HFoldable h => (a -> a -> a) -> h (K a) :=> a
- Data.Comp.Multi.Ops: inj :: (f :<: g) => f a :-> g a
+ Data.Comp.Multi.Ops: inj :: forall f g a. (f :<: g) => f a :-> g a
- Data.Comp.Multi.Ops: proj :: (f :<: g) => NatM Maybe (g a) (f a)
+ Data.Comp.Multi.Ops: proj :: forall f g a. (f :<: g) => NatM Maybe (g a) (f a)
- Data.Comp.Multi.Projection: pr :: (p :< q) => q a -> p a
+ Data.Comp.Multi.Projection: pr :: forall p q a. (p :< q) => q a -> p a
- Data.Comp.Multi.Sum: inj :: (f :<: g) => f a :-> g a
+ Data.Comp.Multi.Sum: inj :: forall f g a. (f :<: g) => f a :-> g a
- Data.Comp.Multi.Sum: proj :: (f :<: g) => NatM Maybe (g a) (f a)
+ Data.Comp.Multi.Sum: proj :: forall f g a. (f :<: g) => NatM Maybe (g a) (f a)
- Data.Comp.Multi.Variables: getBoundVars :: (HasVars f v, HTraversable f) => f a i -> f (a :*: K (Set v)) i
+ Data.Comp.Multi.Variables: getBoundVars :: forall f a v i. (HasVars f v, HTraversable f) => f a i -> f (a :*: K (Set v)) i
- Data.Comp.Multi.Variables: varsToHoles :: (HTraversable f, HasVars f v, Ord v) => Term f :-> Context f (K v)
+ Data.Comp.Multi.Variables: varsToHoles :: forall f v. (HTraversable f, HasVars f v, Ord v) => Term f :-> Context f (K v)
- Data.Comp.Ops: inj :: (f :<: g) => f a -> g a
+ Data.Comp.Ops: inj :: forall f g a. (f :<: g) => f a -> g a
- Data.Comp.Ops: proj :: (f :<: g) => g a -> Maybe (f a)
+ Data.Comp.Ops: proj :: forall f g a. (f :<: g) => g a -> Maybe (f a)
- Data.Comp.Projection: pr :: (p :< q) => q -> p
+ Data.Comp.Projection: pr :: forall p q. (p :< q) => q -> p
- Data.Comp.Sum: inj :: (f :<: g) => f a -> g a
+ Data.Comp.Sum: inj :: forall f g a. (f :<: g) => f a -> g a
- Data.Comp.Sum: proj :: (f :<: g) => g a -> Maybe (f a)
+ Data.Comp.Sum: proj :: forall f g a. (f :<: g) => g a -> Maybe (f a)
- Data.Comp.Thunk: cataTM :: (Traversable f, Monad m) => AlgM m f a -> TermT m f -> m a
+ Data.Comp.Thunk: cataTM :: forall m f a. (Traversable f, Monad m) => AlgM m f a -> TermT m f -> m a

Files

compdata.cabal view
@@ -1,5 +1,5 @@ Name:			compdata-Version:		0.10.1+Version:		0.11 Synopsis:            	Compositional Data Types Description: @@ -188,7 +188,7 @@                         Data.Comp.Multi.Derive.SmartAConstructors    Build-Depends:	base >= 4.7, base < 5, template-haskell, containers, mtl >= 2.2.1, QuickCheck >= 2 && < 2.9, derive,-                        deepseq, th-expand-syns, transformers, tree-view+                        deepseq, th-expand-syns, transformers, tree-view >= 0.5   Extensions:           FlexibleContexts   hs-source-dirs:	src   ghc-options:          -W
examples/Examples/Common.hs view
@@ -1,5 +1,6 @@ {-# LANGUAGE TemplateHaskell, TypeOperators #-} {-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE DeriveFunctor #-} -------------------------------------------------------------------------------- -- | -- Module      :  Examples.Common@@ -22,12 +23,14 @@  -- Signature for values and operators data Value a = Const Int | Pair a a+  deriving Functor data Op a    = Add a a | Mult a a | Fst a | Snd a+  deriving Functor  -- Signature for the simple expression language type Sig = Op :+: Value  -- Derive boilerplate code using Template Haskell-$(derive [makeFunctor, makeTraversable, makeFoldable,+$(derive [makeTraversable, makeFoldable,           makeEqF, makeShowF, smartConstructors, smartAConstructors]          [''Value, ''Op])
examples/Examples/Desugar.hs view
@@ -1,6 +1,7 @@ {-# LANGUAGE TemplateHaskell, TypeOperators, MultiParamTypeClasses,   FlexibleInstances, FlexibleContexts, UndecidableInstances,   OverlappingInstances, ConstraintKinds #-}+{-# LANGUAGE DeriveFunctor #-} -------------------------------------------------------------------------------- -- | -- Module      :  Examples.Desugar@@ -31,6 +32,7 @@  -- Signature for syntactic sugar data Sugar a = Neg a | Swap a+  deriving Functor  -- Source position information (line number, column number) data Pos = Pos Int Int@@ -47,7 +49,7 @@ type SigP' = Sugar :&: Pos :+: Op :&: Pos :+: Value :&: Pos  -- Derive boilerplate code using Template Haskell-$(derive [makeFunctor, makeTraversable, makeFoldable,+$(derive [makeTraversable, makeFoldable,           makeEqF, makeShowF, makeOrdF, smartConstructors, smartAConstructors]          [''Sugar])
src/Data/Comp/Derive.hs view
@@ -25,9 +25,6 @@      module Data.Comp.Derive.Equality,      -- ** OrdF      module Data.Comp.Derive.Ordering,-     -- ** Functor-     Functor,-     makeFunctor,      -- ** Foldable      module Data.Comp.Derive.Foldable,      -- ** Traversable@@ -66,11 +63,6 @@  import qualified Data.Derive.All as A import qualified Data.DeriveTH as D--{-| Derive an instance of 'Functor' for a type constructor of any first-order-  kind taking at least one argument. -}-makeFunctor :: Name -> Q [Dec]-makeFunctor = D.derive A.makeFunctor  {-| Derive an instance of 'NFData' for a type constructor. -} makeNFData :: Name -> Q [Dec]
src/Data/Comp/Render.hs view
@@ -29,6 +29,8 @@  -- | Write a term to an HTML file with foldable nodes writeHtmlTerm :: Render f => FilePath -> Term f -> IO ()-writeHtmlTerm file = writeHtmlTree file . fmap (\n -> NodeInfo n "") . stringTree+writeHtmlTerm file+    = writeHtmlTree Nothing file+    . fmap (\n -> NodeInfo InitiallyExpanded n "") . stringTree  $(derive [liftSum] [''Render])
testsuite/tests/Data/Comp/Variables_Test.hs view
@@ -1,5 +1,6 @@ {-# LANGUAGE TemplateHaskell, TypeSynonymInstances, FlexibleInstances, MultiParamTypeClasses,    TypeOperators, FlexibleContexts, ConstraintKinds #-}+{-# LANGUAGE DeriveFunctor #-}  module Data.Comp.Variables_Test where @@ -29,13 +30,17 @@ data Val e = Abs Var e            | Var Var            | Int Int+  deriving Functor  data Op e = App e e           | Plus e e+  deriving Functor  data Let e = Let Var e e+  deriving Functor  data LetRec e = LetRec Var e e+  deriving Functor  type Sig = Op :+: Val @@ -43,7 +48,7 @@  type SigRec = LetRec :+: Sig -$(derive [makeFunctor, makeTraversable, makeFoldable,+$(derive [makeTraversable, makeFoldable,           makeEqF, makeShowF, smartConstructors]          [''Op, ''Val, ''Let, ''LetRec])
testsuite/tests/Test/Utils.hs view
@@ -1,4 +1,5 @@ {-# LANGUAGE TemplateHaskell, TypeOperators, FlexibleContexts, FlexibleInstances, ConstraintKinds #-}+{-# LANGUAGE DeriveFunctor #-}  module Test.Utils where @@ -12,11 +13,13 @@               | UnNode l e               | BinNode e l e               | TerNode l e e e+              deriving Functor  data Pair a e = Pair a e+  deriving Functor  $(derive-  [makeFunctor, makeFoldable, makeShowF, makeEqF, makeArbitraryF]+  [makeFoldable, makeShowF, makeEqF, makeArbitraryF]   [''Tree, ''Pair])  $(derive