packages feed

compdata 0.5.1 → 0.5.2

raw patch · 14 files changed

+28/−29 lines, 14 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

- Data.Comp.Annotation: project' :: (RemA s s', :<: s f) => Cxt h f a -> Maybe (s' (Cxt h f a))
+ Data.Comp.Annotation: project' :: (RemA f g, f :<: f1) => Cxt h f1 a -> Maybe (g (Cxt h f1 a))
- Data.Comp.Arbitrary: class ArbitraryF f
+ Data.Comp.Arbitrary: class ArbitraryF f where arbitraryF' = [(1, arbitraryF)] arbitraryF = frequency arbitraryF' shrinkF _ = []
- Data.Comp.Automata: (<*>) :: (:< p c, :< q c) => DUpState f c p -> DUpState f c q -> DUpState f c (p, q)
+ Data.Comp.Automata: (<*>) :: (p :< c, q :< c) => DUpState f c p -> DUpState f c q -> DUpState f c (p, q)
- Data.Comp.Automata: (>*<) :: (:< p c, :< q c, Functor f) => DDownState f c p -> DDownState f c q -> DDownState f c (p, q)
+ Data.Comp.Automata: (>*<) :: (p :< c, q :< c, Functor f) => DDownState f c p -> DDownState f c q -> DDownState f c (p, q)
- Data.Comp.Automata: above :: (?above :: q, :< p q) => p
+ Data.Comp.Automata: above :: (?above :: q, p :< q) => p
- Data.Comp.Automata: below :: (?below :: a -> q, :< p q) => a -> p
+ Data.Comp.Automata: below :: (?below :: a -> q, p :< q) => a -> p
- Data.Comp.Automata: prodDDownState :: (:< p c, :< q c) => DDownState f c p -> DDownState f c q -> DDownState f c (p, q)
+ Data.Comp.Automata: prodDDownState :: (p :< c, q :< c) => DDownState f c p -> DDownState f c q -> DDownState f c (p, q)
- Data.Comp.Automata: prodDUpState :: (:< p c, :< q c) => DUpState f c p -> DUpState f c q -> DUpState f c (p, q)
+ Data.Comp.Automata: prodDUpState :: (p :< c, q :< c) => DUpState f c p -> DUpState f c q -> DUpState f c (p, q)
- Data.Comp.Automata: type DDownState f p q = forall i. (Ord i, ?below :: i -> p, ?above :: p, :< q p) => f i -> Map i q
+ Data.Comp.Automata: type DDownState f p q = forall i. (Ord i, ?below :: i -> p, ?above :: p, q :< p) => f i -> Map i q
- Data.Comp.Decompose: class (HasVars f v, Functor f, Foldable f) => Decompose f v
+ Data.Comp.Decompose: class (HasVars f v, Functor f, Foldable f) => Decompose f v where decomp t = case isVar t of { Just v -> Var v Nothing -> Fun sym args where sym = fmap (const ()) t args = arguments t }
- Data.Comp.Derive: class ArbitraryF f
+ Data.Comp.Derive: class ArbitraryF f where arbitraryF' = [(1, arbitraryF)] arbitraryF = frequency arbitraryF' shrinkF _ = []
- Data.Comp.Derive: class Foldable t :: (* -> *)
+ Data.Comp.Derive: class Foldable (t :: * -> *)
- Data.Comp.Derive: class Functor f :: (* -> *)
+ Data.Comp.Derive: class Functor (f :: * -> *)
- Data.Comp.Derive: class (Functor t, Foldable t) => Traversable t :: (* -> *)
+ Data.Comp.Derive: class (Functor t, Foldable t) => Traversable (t :: * -> *)
- Data.Comp.Derive: haskellStrict :: (Monad m, HaskellStrict f, :<: f g) => f (TermT m g) -> TermT m g
+ Data.Comp.Derive: haskellStrict :: (Monad m, HaskellStrict f, f :<: g) => f (TermT m g) -> TermT m g
- Data.Comp.Derive: haskellStrict' :: (Monad m, HaskellStrict f, :<: f g) => f (TermT m g) -> TermT m g
+ Data.Comp.Derive: haskellStrict' :: (Monad m, HaskellStrict f, f :<: g) => f (TermT m g) -> TermT m g
- Data.Comp.Desugar: class (Functor f, Functor g) => Desugar f g
+ Data.Comp.Desugar: class (Functor f, Functor g) => Desugar f g where desugHom = desugHom' . fmap Hole desugHom' x = appCxt (desugHom x)
- Data.Comp.Generic: subterms' :: (Foldable f, :<: g f) => Term f -> [g (Term f)]
+ Data.Comp.Generic: subterms' :: (Foldable f, g :<: f) => Term f -> [g (Term f)]
- Data.Comp.Multi.Algebra: type SigFun f g = forall a. f a :-> g a
+ Data.Comp.Multi.Algebra: type SigFun f g = forall (a :: * -> *). f a :-> g a
- Data.Comp.Multi.Algebra: type SigFunM m f g = forall a. NatM m (f a) (g a)
+ Data.Comp.Multi.Algebra: type SigFunM m f g = forall (a :: * -> *). NatM m (f a) (g a)
- Data.Comp.Multi.Annotation: class DistAnn s :: ((* -> *) -> * -> *) p s' | s' -> s, s' -> p
+ Data.Comp.Multi.Annotation: class DistAnn (s :: (* -> *) -> * -> *) p s' | s' -> s, s' -> p
- Data.Comp.Multi.Annotation: class RemA s :: ((* -> *) -> * -> *) s' | s -> s'
+ Data.Comp.Multi.Annotation: class RemA (s :: (* -> *) -> * -> *) s' | s -> s'
- Data.Comp.Multi.Annotation: data (:&:) f a g :: (* -> *) e
+ Data.Comp.Multi.Annotation: data (:&:) f a (g :: * -> *) e
- Data.Comp.Multi.Annotation: project' :: (RemA s s', :<: s f) => Cxt h f a i -> Maybe (s' (Cxt h f a) i)
+ Data.Comp.Multi.Annotation: project' :: (RemA s s', s :<: f) => Cxt h f a i -> Maybe (s' (Cxt h f a) i)
- Data.Comp.Multi.Derive: class HFunctor h => HFoldable h
+ Data.Comp.Multi.Derive: class HFunctor h => HFoldable h where hfold = hfoldMap unK hfoldMap f = hfoldr (mappend . f) mempty hfoldr f z t = appEndo (hfoldMap (Endo . f) t) z hfoldl f z t = appEndo (getDual (hfoldMap (Dual . Endo . flip f) t)) z hfoldr1 f xs = fromMaybe (error "hfoldr1: empty structure") (hfoldr mf Nothing xs) where mf :: K a :=> (Maybe a -> Maybe a) mf (K x) Nothing = Just x mf (K x) (Just y) = Just (f x y) hfoldl1 f xs = fromMaybe (error "hfoldl1: empty structure") (hfoldl mf Nothing xs) where mf :: Maybe a -> K a :=> Maybe a mf Nothing (K y) = Just y mf (Just x) (K y) = Just (f x y)
- Data.Comp.Multi.Derive: class ShowHF f
+ Data.Comp.Multi.Derive: class ShowHF f where showHF = K . showHF' showHF' = unK . showHF
- Data.Comp.Multi.Desugar: class (HFunctor f, HFunctor g) => Desugar f g
+ Data.Comp.Multi.Desugar: class (HFunctor f, HFunctor g) => Desugar f g where desugHom = desugHom' . hfmap Hole desugHom' x = appCxt (desugHom x)
- Data.Comp.Multi.Generic: subs' :: (HFoldable f, :<: g f) => Term f :=> [A (g (Term f))]
+ Data.Comp.Multi.Generic: subs' :: (HFoldable f, g :<: f) => Term f :=> [A (g (Term f))]
- Data.Comp.Multi.Generic: subterms' :: (HFoldable f, :<: g f) => Term f :=> [A (g (Term f))]
+ Data.Comp.Multi.Generic: subterms' :: (HFoldable f, g :<: f) => Term f :=> [A (g (Term f))]
- Data.Comp.Multi.HFoldable: class HFunctor h => HFoldable h
+ Data.Comp.Multi.HFoldable: class HFunctor h => HFoldable h where hfold = hfoldMap unK hfoldMap f = hfoldr (mappend . f) mempty hfoldr f z t = appEndo (hfoldMap (Endo . f) t) z hfoldl f z t = appEndo (getDual (hfoldMap (Dual . Endo . flip f) t)) z hfoldr1 f xs = fromMaybe (error "hfoldr1: empty structure") (hfoldr mf Nothing xs) where mf :: K a :=> (Maybe a -> Maybe a) mf (K x) Nothing = Just x mf (K x) (Just y) = Just (f x y) hfoldl1 f xs = fromMaybe (error "hfoldl1: empty structure") (hfoldl mf Nothing xs) where mf :: Maybe a -> K a :=> Maybe a mf Nothing (K y) = Just y mf (Just x) (K y) = Just (f x y)
- Data.Comp.Multi.Ops: class :<: sub :: ((* -> *) -> * -> *) sup
+ Data.Comp.Multi.Ops: class :<: (sub :: (* -> *) -> * -> *) sup
- Data.Comp.Multi.Ops: class DistAnn s :: ((* -> *) -> * -> *) p s' | s' -> s, s' -> p
+ Data.Comp.Multi.Ops: class DistAnn (s :: (* -> *) -> * -> *) p s' | s' -> s, s' -> p
- Data.Comp.Multi.Ops: class RemA s :: ((* -> *) -> * -> *) s' | s -> s'
+ Data.Comp.Multi.Ops: class RemA (s :: (* -> *) -> * -> *) s' | s -> s'
- Data.Comp.Multi.Ops: data (:&:) f a g :: (* -> *) e
+ Data.Comp.Multi.Ops: data (:&:) f a (g :: * -> *) e
- Data.Comp.Multi.Show: class ShowHF f
+ Data.Comp.Multi.Show: class ShowHF f where showHF = K . showHF' showHF' = unK . showHF
- Data.Comp.Multi.Sum: class :<: sub :: ((* -> *) -> * -> *) sup
+ Data.Comp.Multi.Sum: class :<: (sub :: (* -> *) -> * -> *) sup
- Data.Comp.Multi.Sum: data (:+:) f g h :: (* -> *) e
+ Data.Comp.Multi.Sum: data (:+:) f g (h :: * -> *) e
- Data.Comp.Multi.Sum: deepInject :: (HFunctor g, :<: g f) => CxtFun g f
+ Data.Comp.Multi.Sum: deepInject :: (HFunctor g, g :<: f) => CxtFun g f
- Data.Comp.Multi.Sum: deepProject :: (HTraversable g, :<: g f) => CxtFunM Maybe f g
+ Data.Comp.Multi.Sum: deepProject :: (HTraversable g, g :<: f) => CxtFunM Maybe f g
- Data.Comp.Multi.Sum: inject :: :<: g f => g (Cxt h f a) :-> Cxt h f a
+ Data.Comp.Multi.Sum: inject :: g :<: f => g (Cxt h f a) :-> Cxt h f a
- Data.Comp.Multi.Sum: injectConst :: (HFunctor g, :<: g f) => Const g :-> Cxt h f a
+ Data.Comp.Multi.Sum: injectConst :: (HFunctor g, g :<: f) => Const g :-> Cxt h f a
- Data.Comp.Multi.Sum: injectConst2 :: (HFunctor f1, HFunctor f2, HFunctor g, :<: f1 g, :<: f2 g) => Const (f1 :+: f2) :-> Cxt h g a
+ Data.Comp.Multi.Sum: injectConst2 :: (HFunctor f1, HFunctor f2, HFunctor g, f1 :<: g, f2 :<: g) => Const (f1 :+: f2) :-> Cxt h g a
- Data.Comp.Multi.Sum: injectConst3 :: (HFunctor f1, HFunctor f2, HFunctor f3, HFunctor g, :<: f1 g, :<: f2 g, :<: f3 g) => Const (f1 :+: (f2 :+: f3)) :-> Cxt h g a
+ Data.Comp.Multi.Sum: injectConst3 :: (HFunctor f1, HFunctor f2, HFunctor f3, HFunctor g, f1 :<: g, f2 :<: g, f3 :<: g) => Const (f1 :+: (f2 :+: f3)) :-> Cxt h g a
- Data.Comp.Multi.Sum: injectCxt :: (HFunctor g, :<: g f) => Cxt h' g (Cxt h f a) :-> Cxt h f a
+ Data.Comp.Multi.Sum: injectCxt :: (HFunctor g, g :<: f) => Cxt h' g (Cxt h f a) :-> Cxt h f a
- Data.Comp.Multi.Sum: liftCxt :: (HFunctor f, :<: g f) => g a :-> Context f a
+ Data.Comp.Multi.Sum: liftCxt :: (HFunctor f, g :<: f) => g a :-> Context f a
- Data.Comp.Multi.Sum: project :: :<: g f => NatM Maybe (Cxt h f a) (g (Cxt h f a))
+ Data.Comp.Multi.Sum: project :: g :<: f => NatM Maybe (Cxt h f a) (g (Cxt h f a))
- Data.Comp.Multi.Sum: projectConst :: (HFunctor g, :<: g f) => NatM Maybe (Cxt h f a) (Const g)
+ Data.Comp.Multi.Sum: projectConst :: (HFunctor g, g :<: f) => NatM Maybe (Cxt h f a) (Const g)
- Data.Comp.Multi.Sum: substHoles :: (HFunctor f, HFunctor g, :<: f g) => (v :-> Cxt h g a) -> Cxt h' f v :-> Cxt h g a
+ Data.Comp.Multi.Sum: substHoles :: (HFunctor f, HFunctor g, f :<: g) => (v :-> Cxt h g a) -> Cxt h' f v :-> Cxt h g a
- Data.Comp.Multi.Term: type Const f :: ((* -> *) -> * -> *) = f (K ())
+ Data.Comp.Multi.Term: type Const (f :: (* -> *) -> * -> *) = f (K ())
- Data.Comp.Multi.Variables: class HasVars f :: ((* -> *) -> * -> *) v
+ Data.Comp.Multi.Variables: class HasVars (f :: (* -> *) -> * -> *) v where isVar _ = Nothing bindsVars _ = []
- Data.Comp.MultiParam.Algebra: newtype Compose f :: (* -> *) g :: (* -> *) a :: (* -> *) -> (* -> *) -> * -> *
+ Data.Comp.MultiParam.Algebra: newtype Compose (f :: * -> *) (g :: * -> *) a :: (* -> *) -> (* -> *) -> * -> *
- Data.Comp.MultiParam.Algebra: type SigFun f g = forall a b. f a b :-> g a b
+ Data.Comp.MultiParam.Algebra: type SigFun f g = forall (a :: * -> *) (b :: * -> *). f a b :-> g a b
- Data.Comp.MultiParam.Algebra: type SigFunM m f g = forall a b. NatM m (f a b) (g a b)
+ Data.Comp.MultiParam.Algebra: type SigFunM m f g = forall (a :: * -> *) (b :: * -> *). NatM m (f a b) (g a b)
- Data.Comp.MultiParam.Annotation: class DistAnn s :: ((* -> *) -> (* -> *) -> * -> *) p s' | s' -> s, s' -> p
+ Data.Comp.MultiParam.Annotation: class DistAnn (s :: (* -> *) -> (* -> *) -> * -> *) p s' | s' -> s, s' -> p
- Data.Comp.MultiParam.Annotation: class RemA s :: ((* -> *) -> (* -> *) -> * -> *) s' | s -> s'
+ Data.Comp.MultiParam.Annotation: class RemA (s :: (* -> *) -> (* -> *) -> * -> *) s' | s -> s'
- Data.Comp.MultiParam.Annotation: project' :: (RemA s s', :<: s f) => Cxt h f a b i -> Maybe (s' a (Cxt h f a b) i)
+ Data.Comp.MultiParam.Annotation: project' :: (RemA s s', s :<: f) => Cxt h f a b i -> Maybe (s' a (Cxt h f a b) i)
- Data.Comp.MultiParam.Desugar: class (HDifunctor f, HDifunctor g) => Desugar f g
+ Data.Comp.MultiParam.Desugar: class (HDifunctor f, HDifunctor g) => Desugar f g where desugHom = desugHom' . hfmap Hole desugHom' x = appCxt (desugHom x)
- Data.Comp.MultiParam.Ops: class :<: sub :: ((* -> *) -> (* -> *) -> * -> *) sup
+ Data.Comp.MultiParam.Ops: class :<: (sub :: (* -> *) -> (* -> *) -> * -> *) sup
- Data.Comp.MultiParam.Ops: class DistAnn s :: ((* -> *) -> (* -> *) -> * -> *) p s' | s' -> s, s' -> p
+ Data.Comp.MultiParam.Ops: class DistAnn (s :: (* -> *) -> (* -> *) -> * -> *) p s' | s' -> s, s' -> p
- Data.Comp.MultiParam.Ops: class RemA s :: ((* -> *) -> (* -> *) -> * -> *) s' | s -> s'
+ Data.Comp.MultiParam.Ops: class RemA (s :: (* -> *) -> (* -> *) -> * -> *) s' | s -> s'
- Data.Comp.MultiParam.Ops: data (:&:) f p a :: (* -> *) b :: (* -> *) i
+ Data.Comp.MultiParam.Ops: data (:&:) f p (a :: * -> *) (b :: * -> *) i
- Data.Comp.MultiParam.Sum: class :<: sub :: ((* -> *) -> (* -> *) -> * -> *) sup
+ Data.Comp.MultiParam.Sum: class :<: (sub :: (* -> *) -> (* -> *) -> * -> *) sup
- Data.Comp.MultiParam.Sum: data (:+:) f g a :: (* -> *) b :: (* -> *) i
+ Data.Comp.MultiParam.Sum: data (:+:) f g (a :: * -> *) (b :: * -> *) i
- Data.Comp.MultiParam.Sum: deepInject :: (HDifunctor g, :<: g f) => CxtFun g f
+ Data.Comp.MultiParam.Sum: deepInject :: (HDifunctor g, g :<: f) => CxtFun g f
- Data.Comp.MultiParam.Sum: deepProject :: (HDitraversable g, :<: g f) => Term f i -> Maybe (Term g i)
+ Data.Comp.MultiParam.Sum: deepProject :: (HDitraversable g, g :<: f) => Term f i -> Maybe (Term g i)
- Data.Comp.MultiParam.Sum: inject :: :<: g f => g a (Cxt h f a b) :-> Cxt h f a b
+ Data.Comp.MultiParam.Sum: inject :: g :<: f => g a (Cxt h f a b) :-> Cxt h f a b
- Data.Comp.MultiParam.Sum: injectCxt :: (HDifunctor g, :<: g f) => Cxt h g a (Cxt h f a b) :-> Cxt h f a b
+ Data.Comp.MultiParam.Sum: injectCxt :: (HDifunctor g, g :<: f) => Cxt h g a (Cxt h f a b) :-> Cxt h f a b
- Data.Comp.MultiParam.Sum: liftCxt :: (HDifunctor f, :<: g f) => g a b :-> Cxt Hole f a b
+ Data.Comp.MultiParam.Sum: liftCxt :: (HDifunctor f, g :<: f) => g a b :-> Cxt Hole f a b
- Data.Comp.MultiParam.Sum: project :: :<: g f => NatM Maybe (Cxt h f a b) (g a (Cxt h f a b))
+ Data.Comp.MultiParam.Sum: project :: g :<: f => NatM Maybe (Cxt h f a b) (g a (Cxt h f a b))
- Data.Comp.Number: class (Functor t, Foldable t) => Traversable t :: (* -> *)
+ Data.Comp.Number: class (Functor t, Foldable t) => Traversable (t :: * -> *)
- Data.Comp.Param.Annotation: project' :: (RemA s s', :<: s f) => Cxt h f a b -> Maybe (s' a (Cxt h f a b))
+ Data.Comp.Param.Annotation: project' :: (RemA s s', s :<: f) => Cxt h f a b -> Maybe (s' a (Cxt h f a b))
- Data.Comp.Param.Derive: class Difunctor f => Ditraversable f
+ Data.Comp.Param.Derive: class Difunctor f => Ditraversable f where dimapM f = disequence . fmap f disequence = dimapM id
- Data.Comp.Param.Desugar: class (Difunctor f, Difunctor g) => Desugar f g
+ Data.Comp.Param.Desugar: class (Difunctor f, Difunctor g) => Desugar f g where desugHom = desugHom' . fmap Hole desugHom' x = appCxt (desugHom x)
- Data.Comp.Param.Ditraversable: class Difunctor f => Ditraversable f
+ Data.Comp.Param.Ditraversable: class Difunctor f => Ditraversable f where dimapM f = disequence . fmap f disequence = dimapM id
- Data.Comp.Param.Sum: deepInject :: (Difunctor g, :<: g f) => Term g -> Term f
+ Data.Comp.Param.Sum: deepInject :: (Difunctor g, g :<: f) => Term g -> Term f
- Data.Comp.Param.Sum: deepProject :: (Ditraversable g, :<: g f) => Term f -> Maybe (Term g)
+ Data.Comp.Param.Sum: deepProject :: (Ditraversable g, g :<: f) => Term f -> Maybe (Term g)
- Data.Comp.Param.Sum: inject :: :<: g f => g a (Cxt h f a b) -> Cxt h f a b
+ Data.Comp.Param.Sum: inject :: g :<: f => g a (Cxt h f a b) -> Cxt h f a b
- Data.Comp.Param.Sum: inject' :: (Difunctor g, :<: g f) => g (Cxt h f a b) (Cxt h f a b) -> Cxt h f a b
+ Data.Comp.Param.Sum: inject' :: (Difunctor g, g :<: f) => g (Cxt h f a b) (Cxt h f a b) -> Cxt h f a b
- Data.Comp.Param.Sum: injectCxt :: (Difunctor g, :<: g f) => Cxt h g a (Cxt h f a b) -> Cxt h f a b
+ Data.Comp.Param.Sum: injectCxt :: (Difunctor g, g :<: f) => Cxt h g a (Cxt h f a b) -> Cxt h f a b
- Data.Comp.Param.Sum: liftCxt :: (Difunctor f, :<: g f) => g a b -> Cxt Hole f a b
+ Data.Comp.Param.Sum: liftCxt :: (Difunctor f, g :<: f) => g a b -> Cxt Hole f a b
- Data.Comp.Param.Sum: project :: :<: g f => Cxt h f a b -> Maybe (g a (Cxt h f a b))
+ Data.Comp.Param.Sum: project :: g :<: f => Cxt h f a b -> Maybe (g a (Cxt h f a b))
- Data.Comp.Param.Thunk: evalStrict :: (Ditraversable g, Monad m, :<: g f) => (g (TrmT m f a) (f a (TrmT m f a)) -> TrmT m f a) -> g (TrmT m f a) (TrmT m f a) -> TrmT m f a
+ Data.Comp.Param.Thunk: evalStrict :: (Ditraversable g, Monad m, g :<: f) => (g (TrmT m f a) (f a (TrmT m f a)) -> TrmT m f a) -> g (TrmT m f a) (TrmT m f a) -> TrmT m f a
- Data.Comp.Param.Thunk: nfPr :: (Monad m, Ditraversable g, :<: g f) => TrmT m f a -> m (Trm g a)
+ Data.Comp.Param.Thunk: nfPr :: (Monad m, Ditraversable g, g :<: f) => TrmT m f a -> m (Trm g a)
- Data.Comp.Param.Thunk: nfTPr :: (ParamFunctor m, Monad m, Ditraversable g, :<: g f) => TermT m f -> m (Term g)
+ Data.Comp.Param.Thunk: nfTPr :: (ParamFunctor m, Monad m, Ditraversable g, g :<: f) => TermT m f -> m (Term g)
- Data.Comp.Param.Thunk: strict :: (:<: f g, Ditraversable f, Monad m) => f a (TrmT m g a) -> TrmT m g a
+ Data.Comp.Param.Thunk: strict :: (f :<: g, Ditraversable f, Monad m) => f a (TrmT m g a) -> TrmT m g a
- Data.Comp.Param.Thunk: strict' :: (:<: f g, Ditraversable f, Monad m) => f (TrmT m g a) (TrmT m g a) -> TrmT m g a
+ Data.Comp.Param.Thunk: strict' :: (f :<: g, Ditraversable f, Monad m) => f (TrmT m g a) (TrmT m g a) -> TrmT m g a
- Data.Comp.Param.Thunk: thunk :: :<: (Thunk m) f => m (Cxt h f a b) -> Cxt h f a b
+ Data.Comp.Param.Thunk: thunk :: Thunk m :<: f => m (Cxt h f a b) -> Cxt h f a b
- Data.Comp.Param.Thunk: whnfPr :: (Monad m, :<: g f) => TrmT m f a -> m (g a (TrmT m f a))
+ Data.Comp.Param.Thunk: whnfPr :: (Monad m, g :<: f) => TrmT m f a -> m (g a (TrmT m f a))
- Data.Comp.Sum: deepInject :: (Functor g, :<: g f) => CxtFun g f
+ Data.Comp.Sum: deepInject :: (Functor g, g :<: f) => CxtFun g f
- Data.Comp.Sum: deepProject :: (Traversable g, :<: g f) => CxtFunM Maybe f g
+ Data.Comp.Sum: deepProject :: (Traversable g, g :<: f) => CxtFunM Maybe f g
- Data.Comp.Sum: inject :: :<: g f => g (Cxt h f a) -> Cxt h f a
+ Data.Comp.Sum: inject :: g :<: f => g (Cxt h f a) -> Cxt h f a
- Data.Comp.Sum: injectConst :: (Functor g, :<: g f) => Const g -> Cxt h f a
+ Data.Comp.Sum: injectConst :: (Functor g, g :<: f) => Const g -> Cxt h f a
- Data.Comp.Sum: injectConst2 :: (Functor f1, Functor f2, Functor g, :<: f1 g, :<: f2 g) => Const (f1 :+: f2) -> Cxt h g a
+ Data.Comp.Sum: injectConst2 :: (Functor f1, Functor f2, Functor g, f1 :<: g, f2 :<: g) => Const (f1 :+: f2) -> Cxt h g a
- Data.Comp.Sum: injectConst3 :: (Functor f1, Functor f2, Functor f3, Functor g, :<: f1 g, :<: f2 g, :<: f3 g) => Const (f1 :+: (f2 :+: f3)) -> Cxt h g a
+ Data.Comp.Sum: injectConst3 :: (Functor f1, Functor f2, Functor f3, Functor g, f1 :<: g, f2 :<: g, f3 :<: g) => Const (f1 :+: (f2 :+: f3)) -> Cxt h g a
- Data.Comp.Sum: injectCxt :: (Functor g, :<: g f) => Cxt h' g (Cxt h f a) -> Cxt h f a
+ Data.Comp.Sum: injectCxt :: (Functor g, g :<: f) => Cxt h' g (Cxt h f a) -> Cxt h f a
- Data.Comp.Sum: liftCxt :: (Functor f, :<: g f) => g a -> Context f a
+ Data.Comp.Sum: liftCxt :: (Functor f, g :<: f) => g a -> Context f a
- Data.Comp.Sum: project :: :<: g f => Cxt h f a -> Maybe (g (Cxt h f a))
+ Data.Comp.Sum: project :: g :<: f => Cxt h f a -> Maybe (g (Cxt h f a))
- Data.Comp.Sum: projectConst :: (Functor g, :<: g f) => Cxt h f a -> Maybe (Const g)
+ Data.Comp.Sum: projectConst :: (Functor g, g :<: f) => Cxt h f a -> Maybe (Const g)
- Data.Comp.Sum: substHoles :: (Functor f, Functor g, :<: f g) => Cxt h' f v -> (v -> Cxt h g a) -> Cxt h g a
+ Data.Comp.Sum: substHoles :: (Functor f, Functor g, f :<: g) => Cxt h' f v -> (v -> Cxt h g a) -> Cxt h g a
- Data.Comp.Sum: substHoles' :: (Functor f, Functor g, :<: f g, Ord v) => Cxt h' f v -> Map v (Cxt h g a) -> Cxt h g a
+ Data.Comp.Sum: substHoles' :: (Functor f, Functor g, f :<: g, Ord v) => Cxt h' f v -> Map v (Cxt h g a) -> Cxt h g a
- Data.Comp.Thunk: nfPr :: (Monad m, Traversable g, :<: g f) => TermT m f -> m (Term g)
+ Data.Comp.Thunk: nfPr :: (Monad m, Traversable g, g :<: f) => TermT m f -> m (Term g)
- Data.Comp.Thunk: strict :: (:<: f g, Traversable f, Monad m) => f (TermT m g) -> TermT m g
+ Data.Comp.Thunk: strict :: (f :<: g, Traversable f, Monad m) => f (TermT m g) -> TermT m g
- Data.Comp.Thunk: strictAt :: (:<: f g, Traversable f, Monad m) => Pos f -> f (TermT m g) -> TermT m g
+ Data.Comp.Thunk: strictAt :: (f :<: g, Traversable f, Monad m) => Pos f -> f (TermT m g) -> TermT m g
- Data.Comp.Thunk: thunk :: :<: m f => m (Cxt h f a) -> Cxt h f a
+ Data.Comp.Thunk: thunk :: m :<: f => m (Cxt h f a) -> Cxt h f a
- Data.Comp.Thunk: whnfPr :: (Monad m, :<: g f) => TermT m f -> m (g (TermT m f))
+ Data.Comp.Thunk: whnfPr :: (Monad m, g :<: f) => TermT m f -> m (g (TermT m f))
- Data.Comp.Variables: class HasVars f v
+ Data.Comp.Variables: class HasVars f v where isVar _ = Nothing bindsVars _ = []

Files

compdata.cabal view
@@ -1,5 +1,5 @@ Name:			compdata-Version:		0.5.1+Version:		0.5.2 Synopsis:            	Compositional Data Types Description:
examples/Examples/Param/Lambda.hs view
@@ -92,7 +92,7 @@                              _                               -> e1 `iPlus` e2  -- * Call-by-value evaluation-data Monad m => Sem m = Fun (Sem m -> m (Sem m)) | Int Int+data Sem m = Fun (Sem m -> m (Sem m)) | Int Int  class Monad m => Eval f m where   evalAlg :: Alg f (m (Sem m))
src/Data/Comp/Annotation.hs view
@@ -1,5 +1,5 @@ {-# LANGUAGE TypeOperators, MultiParamTypeClasses, FlexibleInstances,-  UndecidableInstances, RankNTypes, GADTs #-}+  UndecidableInstances, RankNTypes, GADTs, ScopedTypeVariables #-} -------------------------------------------------------------------------------- -- | -- Module      :  Data.Comp.Annotation@@ -104,5 +104,5 @@ with an annotation which is then ignored. -} -- bug in type checker? below is the inferred type, however, the type checker -- rejects it.--- project' :: (RemA f g, f :<: f1) => Cxt h f1 a -> Maybe (g (Cxt h f1 a))-project' v = liftM remA $ project v+project' :: forall f g f1 a h . (RemA f g, f :<: f1) => Cxt h f1 a -> Maybe (g (Cxt h f1 a))+project' v = liftM remA (project v :: Maybe (f (Cxt h f1 a)))
src/Data/Comp/Automata.hs view
@@ -1,4 +1,4 @@-{-# LANGUAGE RankNTypes, FlexibleContexts, ImplicitParams, GADTs #-}+{-# LANGUAGE RankNTypes, FlexibleContexts, ImplicitParams, GADTs, TypeOperators #-} -------------------------------------------------------------------------------- -- | -- Module      :  Data.Comp.Automata
src/Data/Comp/Derive/HaskellStrict.hs view
@@ -1,4 +1,4 @@-{-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TemplateHaskell, TypeOperators, CPP #-} -------------------------------------------------------------------------------- -- | -- Module      :  Data.Comp.Derive.HaskellStrict@@ -76,6 +76,9 @@       where isFarg fArg (constr, args) = (constr, map (containsStr fArg) args)             containsStr _ (NotStrict,_) = []             containsStr fArg (IsStrict,ty) = ty `containsType'` fArg+#if __GLASGOW_HASKELL__ > 702+            containsStr fArg (Unpacked,ty) = ty `containsType'` fArg+#endif             filterVar _ nonFarg [] x  = nonFarg x             filterVar farg _ [depth] x = farg depth x             filterVar _ _ _ _ = error "functor variable occurring twice in argument type"
src/Data/Comp/Derive/Show.hs view
@@ -45,6 +45,7 @@   return [InstanceD preCond classType [showFDecl]]       where showFClauses fArg = map (genShowFClause fArg)             filterFarg fArg ty x = (fArg == ty, varE x)+            mkShow :: (Bool, ExpQ) -> ExpQ             mkShow (isFArg, var)                 | isFArg = var                 | otherwise = [| show $var |]
src/Data/Comp/Desugar.hs view
@@ -1,5 +1,5 @@ {-# LANGUAGE TemplateHaskell, MultiParamTypeClasses, FlexibleInstances,-  UndecidableInstances, OverlappingInstances #-}+  UndecidableInstances, OverlappingInstances, TypeOperators #-} -------------------------------------------------------------------------------- -- | -- Module      :  Data.Comp.Desugar
src/Data/Comp/Generic.hs view
@@ -1,4 +1,4 @@-{-# LANGUAGE GADTs, ScopedTypeVariables #-}+{-# LANGUAGE GADTs, ScopedTypeVariables, TypeOperators #-}  -------------------------------------------------------------------------------- -- |
src/Data/Comp/Multi/Algebra.hs view
@@ -1,5 +1,5 @@ {-# LANGUAGE GADTs, RankNTypes, TypeOperators, ScopedTypeVariables, -  FlexibleContexts #-}+  FlexibleContexts, KindSignatures #-} -------------------------------------------------------------------------------- -- | -- Module      :  Data.Comp.Multi.Algebra@@ -160,7 +160,7 @@   -- | This type represents uniform signature function specification.-type SigFun f g = forall a. f a :-> g a+type SigFun f g = forall (a :: * -> *). f a :-> g a  -- | This type represents context function. type CxtFun f g = forall h . SigFun (Cxt h f) (Cxt h g)@@ -225,7 +225,7 @@ hom f = simpCxt . f  -- | This type represents monadic signature functions.-type SigFunM m f g = forall a. NatM m (f a) (g a)+type SigFunM m f g = forall (a :: * -> *) . NatM m (f a) (g a)   -- | This type represents monadic context function.
src/Data/Comp/Multi/Annotation.hs view
@@ -1,5 +1,5 @@ {-# LANGUAGE TypeOperators, MultiParamTypeClasses,-  FlexibleInstances, UndecidableInstances, RankNTypes, GADTs #-}+  FlexibleInstances, UndecidableInstances, RankNTypes, GADTs, ScopedTypeVariables #-} -------------------------------------------------------------------------------- -- | -- Module      :  Data.Comp.Multi.Annotation@@ -71,7 +71,5 @@  -- | This function is similar to 'project' but applies to signatures -- with an annotation which is then ignored.---- project' :: (RemA s s',s :<: f) =>---      NatM Maybe (Cxt h f a) (s' (Cxt h f a))-project' v = liftM remA $ project v+project' :: forall s s' f h a i . (RemA s s', s :<: f) => Cxt h f a i -> Maybe (s' (Cxt h f a) i)+project' v = liftM remA (project v :: Maybe (s (Cxt h f a) i))
src/Data/Comp/MultiParam/Algebra.hs view
@@ -1,5 +1,5 @@ {-# LANGUAGE GADTs, RankNTypes, ScopedTypeVariables, TypeOperators,-  FlexibleContexts, CPP #-}+  FlexibleContexts, CPP, KindSignatures #-} -------------------------------------------------------------------------------- -- | -- Module      :  Data.Comp.MultiParam.Algebra@@ -153,7 +153,7 @@           run (Var x) = return x  {-| This type represents a signature function. -}-type SigFun f g = forall a b. f a b :-> g a b+type SigFun f g = forall (a :: * -> *) (b :: * -> *) . f a b :-> g a b  {-| This type represents a context function. -} type CxtFun f g = forall h. SigFun (Cxt h f) (Cxt h g)@@ -215,7 +215,7 @@ hom f = simpCxt . f  {-| This type represents a monadic signature function. -}-type SigFunM m f g = forall a b. NatM m (f a b) (g a b)+type SigFunM m f g = forall (a :: * -> *) (b :: * -> *) . NatM m (f a b) (g a b)  {-| This type represents a monadic context function. -} type CxtFunM m f g = forall h . SigFunM m (Cxt h f) (Cxt h g)
src/Data/Comp/MultiParam/Annotation.hs view
@@ -76,7 +76,5 @@  {-| This function is similar to 'project' but applies to signatures   with an annotation which is then ignored. -}--- bug in type checker? below is the inferred type, however, the type checker--- rejects it.--- project' :: (RemA f g, f :<: f1) => Cxt h f1 a -> Maybe (g (Cxt h f1 a))-project' v = liftM remA $ project v+project' :: forall s s' f a b i h . (RemA s s', s :<: f) =>  Cxt h f a b i -> Maybe (s' a (Cxt h f a b) i)+project' v = liftM remA (project v :: Maybe (s a (Cxt h f a b) i))
src/Data/Comp/Param/Annotation.hs view
@@ -74,7 +74,6 @@  {-| This function is similar to 'project' but applies to signatures with an annotation which is then ignored. -}--- bug in type checker? below is the inferred type, however, the type checker--- rejects it.--- project' :: (RemA f g, f :<: f1) => Cxt h f1 a -> Maybe (g (Cxt h f1 a))-project' v = liftM remA $ project v+project' :: forall s s' f h a b .  (RemA s s', s :<: f) => +            Cxt h f a b -> Maybe (s' a (Cxt h f a b))+project' v = liftM remA (project v :: Maybe (s a (Cxt h f a b)))
src/Data/Comp/Param/Desugar.hs view
@@ -1,5 +1,5 @@ {-# LANGUAGE TemplateHaskell, MultiParamTypeClasses, FlexibleInstances,-  UndecidableInstances, OverlappingInstances, Rank2Types #-}+  UndecidableInstances, OverlappingInstances, Rank2Types, TypeOperators #-} -------------------------------------------------------------------------------- -- | -- Module      :  Data.Comp.Param.Desugar