packages feed

functor-combo 0.0.6 → 0.0.7

raw patch · 4 files changed

+20/−5 lines, 4 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

- FunctorCombo.NonstrictMemo: instance (Functor (STrie a)) => Functor (ListSTrie a)
- FunctorCombo.NonstrictMemo: instance (Functor (STrie k)) => Functor (Trie k)
- FunctorCombo.NonstrictMemo: instance (HasTrie (g (f a))) => HasTrie ((:.) g f a)
- FunctorCombo.NonstrictMemo: instance (HasTrie a) => HasTrie (Id a)
- FunctorCombo.NonstrictMemo: instance (HasTrie a) => HasTrie [a]
- FunctorCombo.NonstrictMemo: instance (HasTrie x) => HasTrie (Const x a)
- FunctorCombo.StrictMemo: instance (Functor (Trie a)) => Functor (ListTrie a)
- FunctorCombo.StrictMemo: instance (Functor (Trie a)) => Functor (TreeTrie a)
- FunctorCombo.StrictMemo: instance (HasTrie (PF (Tree a) (Tree a) :->: v)) => HasTrie (TreeTrie a v)
- FunctorCombo.StrictMemo: instance (HasTrie (PF [a] [a] :->: v)) => HasTrie (ListTrie a v)
- FunctorCombo.StrictMemo: instance (HasTrie (g (f a))) => HasTrie ((:.) g f a)
- FunctorCombo.StrictMemo: instance (HasTrie a) => HasTrie (Id a)
- FunctorCombo.StrictMemo: instance (HasTrie x) => HasTrie (Const x a)
+ FunctorCombo.NonstrictMemo: instance Functor (STrie a) => Functor (ListSTrie a)
+ FunctorCombo.NonstrictMemo: instance Functor (STrie k) => Functor (Trie k)
+ FunctorCombo.NonstrictMemo: instance HasTrie (g (f a)) => HasTrie ((:.) g f a)
+ FunctorCombo.NonstrictMemo: instance HasTrie a => HasTrie (Id a)
+ FunctorCombo.NonstrictMemo: instance HasTrie a => HasTrie [a]
+ FunctorCombo.NonstrictMemo: instance HasTrie x => HasTrie (Const x a)
+ FunctorCombo.StrictMemo: instance Functor (Trie a) => Functor (ListTrie a)
+ FunctorCombo.StrictMemo: instance Functor (Trie a) => Functor (TreeTrie a)
+ FunctorCombo.StrictMemo: instance HasTrie (PF (Tree a) (Tree a) :->: v) => HasTrie (TreeTrie a v)
+ FunctorCombo.StrictMemo: instance HasTrie (PF [a] [a] :->: v) => HasTrie (ListTrie a v)
+ FunctorCombo.StrictMemo: instance HasTrie (g (f a)) => HasTrie ((:.) g f a)
+ FunctorCombo.StrictMemo: instance HasTrie a => HasTrie (Id a)
+ FunctorCombo.StrictMemo: instance HasTrie x => HasTrie (Const x a)
- FunctorCombo.DHoley: class (Functor f) => Holey f where { type family Der f :: * -> *; }
+ FunctorCombo.DHoley: class Functor f => Holey f where type family Der f :: * -> *
- FunctorCombo.DHoley: extract :: (Holey f) => f a -> f (Loc f a)
+ FunctorCombo.DHoley: extract :: Holey f => f a -> f (Loc f a)
- FunctorCombo.DHoley: fill :: (Holey f) => Loc f a -> f a
+ FunctorCombo.DHoley: fill :: Holey f => Loc f a -> f a
- FunctorCombo.DHoley: fillC :: (Holey f) => Der f a -> a -> f a
+ FunctorCombo.DHoley: fillC :: Holey f => Der f a -> a -> f a
- FunctorCombo.Functor: (~>) :: (a' -> a) -> (b -> b') -> (a -> b) -> a' -> b'
+ FunctorCombo.Functor: (~>) :: Category --> => --> a' a -> --> b b' -> --> a b -> --> a' b'
- FunctorCombo.Functor: newtype (:.) g :: (* -> *) f :: (* -> *) a :: (* -> *) -> (* -> *) -> * -> *
+ FunctorCombo.Functor: newtype (:.) (g :: * -> *) (f :: * -> *) a :: (* -> *) -> (* -> *) -> * -> *
- FunctorCombo.Holey: class (Functor f) => Holey f
+ FunctorCombo.Holey: class Functor f => Holey f
- FunctorCombo.Holey: extract :: (Holey f) => f a -> f (Loc f a)
+ FunctorCombo.Holey: extract :: Holey f => f a -> f (Loc f a)
- FunctorCombo.Holey: fill :: (Holey f) => Loc f a -> f a
+ FunctorCombo.Holey: fill :: Holey f => Loc f a -> f a
- FunctorCombo.Holey: fillC :: (Holey f) => Der f a -> a -> f a
+ FunctorCombo.Holey: fillC :: Holey f => Der f a -> a -> f a
- FunctorCombo.NonstrictMemo: class (Functor (STrie (k))) => HasTrie k where { type family STrie k :: * -> *; }
+ FunctorCombo.NonstrictMemo: class Functor (STrie (k)) => HasTrie k where type family STrie k :: * -> *
- FunctorCombo.NonstrictMemo: memo :: (HasLub (v)) => (HasTrie k) => Unop (k -> v)
+ FunctorCombo.NonstrictMemo: memo :: HasLub (v) => HasTrie k => Unop (k -> v)
- FunctorCombo.NonstrictMemo: memo2 :: (HasLub (a)) => (HasTrie s, HasTrie t) => Unop (s -> t -> a)
+ FunctorCombo.NonstrictMemo: memo2 :: HasLub (a) => (HasTrie s, HasTrie t) => Unop (s -> t -> a)
- FunctorCombo.NonstrictMemo: memo3 :: (HasLub (a)) => (HasTrie r, HasTrie s, HasTrie t) => Unop (r -> s -> t -> a)
+ FunctorCombo.NonstrictMemo: memo3 :: HasLub (a) => (HasTrie r, HasTrie s, HasTrie t) => Unop (r -> s -> t -> a)
- FunctorCombo.NonstrictMemo: sTrie :: (HasTrie k) => (k -> v) -> (k :-> v)
+ FunctorCombo.NonstrictMemo: sTrie :: HasTrie k => (k -> v) -> (k :-> v)
- FunctorCombo.Regular: class (Functor (PF t)) => Regular t where { type family PF t :: * -> *; }
+ FunctorCombo.Regular: class Functor (PF t) => Regular t where type family PF t :: * -> *
- FunctorCombo.Regular: unwrap :: (Regular t) => t -> PF t t
+ FunctorCombo.Regular: unwrap :: Regular t => t -> PF t t
- FunctorCombo.Regular: wrap :: (Regular t) => PF t t -> t
+ FunctorCombo.Regular: wrap :: Regular t => PF t t -> t
- FunctorCombo.StrictMemo: class HasTrie k where { type family Trie k :: * -> *; }
+ FunctorCombo.StrictMemo: class HasTrie k where type family Trie k :: * -> *
- FunctorCombo.StrictMemo: enumerate :: (HasTrie k) => (k :->: v) -> [(k, v)]
+ FunctorCombo.StrictMemo: enumerate :: HasTrie k => (k :->: v) -> [(k, v)]
- FunctorCombo.StrictMemo: memo :: (HasTrie k) => Unop (k -> v)
+ FunctorCombo.StrictMemo: memo :: HasTrie k => Unop (k -> v)
- FunctorCombo.StrictMemo: trie :: (HasTrie k) => (k -> v) -> (k :->: v)
+ FunctorCombo.StrictMemo: trie :: HasTrie k => (k -> v) -> (k :->: v)
- FunctorCombo.StrictMemo: untrie :: (HasTrie k) => (k :->: v) -> (k -> v)
+ FunctorCombo.StrictMemo: untrie :: HasTrie k => (k :->: v) -> (k -> v)
- FunctorCombo.ZipperFix: down :: (Holey f) => Zipper f -> f (Zipper f)
+ FunctorCombo.ZipperFix: down :: Holey f => Zipper f -> f (Zipper f)
- FunctorCombo.ZipperFix: up :: (Holey f) => Zipper f -> Zipper f
+ FunctorCombo.ZipperFix: up :: Holey f => Zipper f -> Zipper f
- FunctorCombo.ZipperFix: up' :: (Holey f) => Zipper f -> Maybe (Zipper f)
+ FunctorCombo.ZipperFix: up' :: Holey f => Zipper f -> Maybe (Zipper f)

Files

functor-combo.cabal view
@@ -1,5 +1,5 @@ Name:                functor-combo-Version:             0.0.6+Version:             0.0.7 Cabal-Version:       >= 1.2 Synopsis:            Functor combinators with tries & zippers Category:            Data
src/FunctorCombo/DHoley.hs view
@@ -111,7 +111,7 @@  -- type instance Der (g :.  f) = Der g :. f  :*:  Der f -+{- lassoc :: (p,(q,r)) -> ((p,q),r) lassoc    (p,(q,r)) =  ((p,q),r) @@ -126,6 +126,21 @@  tweak2 :: Functor f => (dg (f a), f (df a, a)) -> f (((dg :. f) :*: df) a, a) tweak2 = (fmap.first) chainRule . tweak1+-}++-- Sjoerd Visscher wrote <http://conal.net/blog/posts/another-angle-on-zippers/#comment-51328>:++-- At first it was a bit disappointing that extract is so complicated for+-- functor composition, but I played a bit with the code and tweak2 can be+-- simplified (if I didn’t make a mistake) to:++-- tweak2 (dgfa, fl) = (fmap.first) (O dgfa :*:) fl++-- It’s interesting that (tweak2 . second extract) is very much like down!+-- Probably because Fix f is like repeated functor composition of f.++tweak2 :: Functor f => (dg (f a), f (df a, a)) -> f (((dg :. f) :*: df) a, a)+tweak2 (dgfa, fl) = (fmap.first) (O dgfa :*:) fl  -- And more specifically, --
src/FunctorCombo/ZipperFix.hs view
@@ -87,7 +87,7 @@ -}  down :: Holey f => Zipper f -> f (Zipper f)-down (ds', t) = fmap (first (:ds')) (extract (unFix t))+down (ds', t) = (fmap.first) (:ds') (extract (unFix t))  -- down (ds', t) = fmap (\ (d,t') -> (d:ds',t')) (extract (unFix t)) @@ -104,7 +104,7 @@  extract (unFix t) :: f (Der f (Fix f), Fix f) -fmap (\ (d,t') -> (d:ds',t')) (extract (unFix t))+(fmap.first) (:ds') (extract (unFix t))   :: ([Der f (Fix f)], Fix f)   :: (Context f, Fix f)   :: Zipper f
src/FunctorCombo/ZipperReg.hs view
@@ -58,7 +58,7 @@ up' l          = Just (up l)  down :: (Regular t, Holey (PF t)) => Zipper t -> PF t (Zipper t)-down (ds', t) = fmap (first (:ds')) (extract (unwrap t))+down (ds', t) = (fmap.first) (:ds') (extract (unwrap t))  {-