compdata-dags 0.2 → 0.2.1
raw patch · 9 files changed
+29/−11 lines, 9 filesdep ~compdataPVP: major bump suggested
API removals or changes: PVP suggests a major version bump
Dependency ranges changed: compdata
API changes (from Hackage documentation)
- Data.Comp.Dag: instance (ShowF f, Functor f) => Show (Dag f)
- Data.Comp.Dag: instance Exception CyclicException
- Data.Comp.Dag: instance Show CyclicException
- Data.Comp.Dag: instance Typeable CyclicException
+ Data.Comp.AG: (&) :: Mapping m k => m v -> m v -> m v
+ Data.Comp.AG: (>*<) :: (p :< c, q :< c, Functor f) => Inh f c p -> Inh f c q -> Inh f c (p, q)
+ Data.Comp.AG: (|*|) :: (p :< c, q :< c) => Syn f c p -> Syn f c q -> Syn f c (p, q)
+ Data.Comp.AG: (|->) :: Mapping m k => k -> v -> m v
+ Data.Comp.AG: Numbered :: Int -> a -> Numbered a
+ Data.Comp.AG: above :: (?above :: q, p :< q) => p
+ Data.Comp.AG: below :: (?below :: child -> q, p :< q) => child -> p
+ Data.Comp.AG: class Functor m => Mapping (m :: * -> *) k | m -> k
+ Data.Comp.AG: class (Functor t, Foldable t) => Traversable (t :: * -> *)
+ Data.Comp.AG: data NumMap k v
+ Data.Comp.AG: data Numbered a
+ Data.Comp.AG: empty :: Mapping m k => m v
+ Data.Comp.AG: findWithDefault :: Mapping m k => a -> k -> m a -> a
+ Data.Comp.AG: lookupNumMap :: () => a -> Int -> NumMap t a -> a
+ Data.Comp.AG: lookupNumMap' :: () => Int -> NumMap t a -> Maybe a
+ Data.Comp.AG: number :: Traversable f => f a -> f Numbered a
+ Data.Comp.AG: pr :: p :< q => q -> p
+ Data.Comp.AG: prodInh :: (p :< c, q :< c) => Inh f c p -> Inh f c q -> Inh f c (p, q)
+ Data.Comp.AG: prodMap :: Mapping m k => v1 -> v2 -> m v1 -> m v2 -> m (v1, v2)
+ Data.Comp.AG: prodMapWith :: Mapping m k => v1 -> v2 -> v -> v1 -> v2 -> m v1 -> m v2 -> m v
+ Data.Comp.AG: prodSyn :: (p :< c, q :< c) => Syn f c p -> Syn f c q -> Syn f c (p, q)
+ Data.Comp.AG: type (:<) f g = Proj ComprEmb Elem f g f g
+ Data.Comp.AG: type Inh f p q = (q :< p) => Inh' f p q
+ Data.Comp.AG: type Syn f p q = (q :< p) => Syn' f p q
+ Data.Comp.AG: type Rewrite f q g = forall a. (?below :: a -> q, ?above :: q) => f a -> Context g a
+ Data.Comp.AG: unNumbered :: () => Numbered a -> a
+ Data.Comp.Dag: instance (Data.Comp.Derive.Show.ShowF f, GHC.Base.Functor f) => GHC.Show.Show (Data.Comp.Dag.Internal.Dag f)
+ Data.Comp.Dag: instance GHC.Exception.Exception Data.Comp.Dag.CyclicException
+ Data.Comp.Dag: instance GHC.Show.Show Data.Comp.Dag.CyclicException
+ Data.Comp.Dag.AG: (&) :: Mapping m k => m v -> m v -> m v
+ Data.Comp.Dag.AG: (>*<) :: (p :< c, q :< c, Functor f) => Inh f c p -> Inh f c q -> Inh f c (p, q)
+ Data.Comp.Dag.AG: (|*|) :: (p :< c, q :< c) => Syn f c p -> Syn f c q -> Syn f c (p, q)
+ Data.Comp.Dag.AG: (|->) :: Mapping m k => k -> v -> m v
+ Data.Comp.Dag.AG: Numbered :: Int -> a -> Numbered a
+ Data.Comp.Dag.AG: above :: (?above :: q, p :< q) => p
+ Data.Comp.Dag.AG: below :: (?below :: child -> q, p :< q) => child -> p
+ Data.Comp.Dag.AG: class Functor m => Mapping (m :: * -> *) k | m -> k
+ Data.Comp.Dag.AG: class (Functor t, Foldable t) => Traversable (t :: * -> *)
+ Data.Comp.Dag.AG: data NumMap k v
+ Data.Comp.Dag.AG: data Numbered a
+ Data.Comp.Dag.AG: empty :: Mapping m k => m v
+ Data.Comp.Dag.AG: findWithDefault :: Mapping m k => a -> k -> m a -> a
+ Data.Comp.Dag.AG: lookupNumMap :: () => a -> Int -> NumMap t a -> a
+ Data.Comp.Dag.AG: lookupNumMap' :: () => Int -> NumMap t a -> Maybe a
+ Data.Comp.Dag.AG: number :: Traversable f => f a -> f Numbered a
+ Data.Comp.Dag.AG: pr :: p :< q => q -> p
+ Data.Comp.Dag.AG: prodInh :: (p :< c, q :< c) => Inh f c p -> Inh f c q -> Inh f c (p, q)
+ Data.Comp.Dag.AG: prodMap :: Mapping m k => v1 -> v2 -> m v1 -> m v2 -> m (v1, v2)
+ Data.Comp.Dag.AG: prodMapWith :: Mapping m k => v1 -> v2 -> v -> v1 -> v2 -> m v1 -> m v2 -> m v
+ Data.Comp.Dag.AG: prodSyn :: (p :< c, q :< c) => Syn f c p -> Syn f c q -> Syn f c (p, q)
+ Data.Comp.Dag.AG: type (:<) f g = Proj ComprEmb Elem f g f g
+ Data.Comp.Dag.AG: type Inh f p q = (q :< p) => Inh' f p q
+ Data.Comp.Dag.AG: type Syn f p q = (q :< p) => Syn' f p q
+ Data.Comp.Dag.AG: type Rewrite f q g = forall a. (?below :: a -> q, ?above :: q) => f a -> Context g a
+ Data.Comp.Dag.AG: unNumbered :: () => Numbered a -> a
+ Data.Comp.Dag.PAG: (&) :: Mapping m k => m v -> m v -> m v
+ Data.Comp.Dag.PAG: (:*:) :: f a -> g a -> (:*:)
+ Data.Comp.Dag.PAG: (>*<) :: (p :< c, q :< c, Functor p, Functor q) => Inh f c p g -> Inh f c q g -> Inh f c (p :*: q) g
+ Data.Comp.Dag.PAG: (|*|) :: (p :< c, q :< c) => Syn f c p g -> Syn f c q g -> Syn f c (p :*: q) g
+ Data.Comp.Dag.PAG: (|->) :: Mapping m k => k -> v -> m v
+ Data.Comp.Dag.PAG: Numbered :: Int -> a -> Numbered a
+ Data.Comp.Dag.PAG: above :: (?above :: q a, p :< q) => p a
+ Data.Comp.Dag.PAG: below :: (?below :: child -> q a, p :< q) => child -> p a
+ Data.Comp.Dag.PAG: class Functor m => Mapping (m :: * -> *) k | m -> k
+ Data.Comp.Dag.PAG: class (Functor t, Foldable t) => Traversable (t :: * -> *)
+ Data.Comp.Dag.PAG: data NumMap k v
+ Data.Comp.Dag.PAG: data Numbered a
+ Data.Comp.Dag.PAG: data (:*:) (f :: k -> *) (g :: k -> *) (a :: k) :: forall k. () => k -> * -> k -> * -> k -> *
+ Data.Comp.Dag.PAG: empty :: Mapping m k => m v
+ Data.Comp.Dag.PAG: ffst :: () => f :*: g a -> f a
+ Data.Comp.Dag.PAG: findWithDefault :: Mapping m k => a -> k -> m a -> a
+ Data.Comp.Dag.PAG: fsnd :: () => f :*: g a -> g a
+ Data.Comp.Dag.PAG: lookupNumMap :: () => a -> Int -> NumMap t a -> a
+ Data.Comp.Dag.PAG: lookupNumMap' :: () => Int -> NumMap t a -> Maybe a
+ Data.Comp.Dag.PAG: number :: Traversable f => f a -> f Numbered a
+ Data.Comp.Dag.PAG: pr :: p :< q => q a -> p a
+ Data.Comp.Dag.PAG: prodInh :: (p :< c, q :< c, Functor p, Functor q) => Inh f c p g -> Inh f c q g -> Inh f c (p :*: q) g
+ Data.Comp.Dag.PAG: prodMap :: Mapping m k => v1 -> v2 -> m v1 -> m v2 -> m (v1, v2)
+ Data.Comp.Dag.PAG: prodMapWith :: Mapping m k => v1 -> v2 -> v -> v1 -> v2 -> m v1 -> m v2 -> m v
+ Data.Comp.Dag.PAG: prodSyn :: (p :< c, q :< c) => Syn f c p g -> Syn f c q g -> Syn f c (p :*: q) g
+ Data.Comp.Dag.PAG: type (:<) (f :: * -> *) (g :: * -> *) = Proj ComprEmb Elem f g f g
+ Data.Comp.Dag.PAG: type Inh f p q g = (q :< p) => Inh' f p q g
+ Data.Comp.Dag.PAG: type Syn f p q g = (q :< p) => Syn' f p q g
+ Data.Comp.Dag.PAG: type Syn' f p q g = forall child a. (?below :: child -> p a, ?above :: p a) => f child -> q (Context g a)
+ Data.Comp.Dag.PAG: unNumbered :: () => Numbered a -> a
+ Data.Comp.PAG: (&) :: Mapping m k => m v -> m v -> m v
+ Data.Comp.PAG: (:*:) :: f a -> g a -> (:*:)
+ Data.Comp.PAG: (>*<) :: (p :< c, q :< c, Functor p, Functor q) => Inh f c p g -> Inh f c q g -> Inh f c (p :*: q) g
+ Data.Comp.PAG: (|*|) :: (p :< c, q :< c) => Syn f c p g -> Syn f c q g -> Syn f c (p :*: q) g
+ Data.Comp.PAG: (|->) :: Mapping m k => k -> v -> m v
+ Data.Comp.PAG: Numbered :: Int -> a -> Numbered a
+ Data.Comp.PAG: above :: (?above :: q a, p :< q) => p a
+ Data.Comp.PAG: below :: (?below :: child -> q a, p :< q) => child -> p a
+ Data.Comp.PAG: class Functor m => Mapping (m :: * -> *) k | m -> k
+ Data.Comp.PAG: class (Functor t, Foldable t) => Traversable (t :: * -> *)
+ Data.Comp.PAG: data NumMap k v
+ Data.Comp.PAG: data Numbered a
+ Data.Comp.PAG: data (:*:) (f :: k -> *) (g :: k -> *) (a :: k) :: forall k. () => k -> * -> k -> * -> k -> *
+ Data.Comp.PAG: empty :: Mapping m k => m v
+ Data.Comp.PAG: ffst :: () => f :*: g a -> f a
+ Data.Comp.PAG: findWithDefault :: Mapping m k => a -> k -> m a -> a
+ Data.Comp.PAG: fsnd :: () => f :*: g a -> g a
+ Data.Comp.PAG: lookupNumMap :: () => a -> Int -> NumMap t a -> a
+ Data.Comp.PAG: lookupNumMap' :: () => Int -> NumMap t a -> Maybe a
+ Data.Comp.PAG: number :: Traversable f => f a -> f Numbered a
+ Data.Comp.PAG: pr :: p :< q => q a -> p a
+ Data.Comp.PAG: prodInh :: (p :< c, q :< c, Functor p, Functor q) => Inh f c p g -> Inh f c q g -> Inh f c (p :*: q) g
+ Data.Comp.PAG: prodMap :: Mapping m k => v1 -> v2 -> m v1 -> m v2 -> m (v1, v2)
+ Data.Comp.PAG: prodMapWith :: Mapping m k => v1 -> v2 -> v -> v1 -> v2 -> m v1 -> m v2 -> m v
+ Data.Comp.PAG: prodSyn :: (p :< c, q :< c) => Syn f c p g -> Syn f c q g -> Syn f c (p :*: q) g
+ Data.Comp.PAG: type (:<) (f :: * -> *) (g :: * -> *) = Proj ComprEmb Elem f g f g
+ Data.Comp.PAG: type Inh f p q g = (q :< p) => Inh' f p q g
+ Data.Comp.PAG: type Syn f p q g = (q :< p) => Syn' f p q g
+ Data.Comp.PAG: type Syn' f p q g = forall child a. (?below :: child -> p a, ?above :: p a) => f child -> q (Context g a)
+ Data.Comp.PAG: unNumbered :: () => Numbered a -> a
- Data.Comp.AG: runAG :: Traversable f => Syn' f (u, d) u -> Inh' f (u, d) d -> (u -> d) -> Term f -> u
+ Data.Comp.AG: runAG :: forall f u d. Traversable f => Syn' f (u, d) u -> Inh' f (u, d) d -> (u -> d) -> Term f -> u
- Data.Comp.AG: runRewrite :: (Traversable f, Functor g) => Syn' f (u, d) u -> Inh' f (u, d) d -> Rewrite f (u, d) g -> (u -> d) -> Term f -> (u, Term g)
+ Data.Comp.AG: runRewrite :: forall f g u d. (Traversable f, Functor g) => Syn' f (u, d) u -> Inh' f (u, d) d -> Rewrite f (u, d) g -> (u -> d) -> Term f -> (u, Term g)
- Data.Comp.Dag: bisim :: (EqF f, Functor f, Foldable f) => Dag f -> Dag f -> Bool
+ Data.Comp.Dag: bisim :: forall f. (EqF f, Functor f, Foldable f) => Dag f -> Dag f -> Bool
- Data.Comp.Dag: unravel :: Functor f => Dag f -> Term f
+ Data.Comp.Dag: unravel :: forall f. Functor f => Dag f -> Term f
- Data.Comp.Dag.AG: runAG :: Traversable f => (d -> d -> d) -> Syn' f (u, d) u -> Inh' f (u, d) d -> (u -> d) -> Dag f -> u
+ Data.Comp.Dag.AG: runAG :: forall f d u. Traversable f => (d -> d -> d) -> Syn' f (u, d) u -> Inh' f (u, d) d -> (u -> d) -> Dag f -> u
- Data.Comp.Dag.AG: runRewrite :: (Traversable f, Traversable g) => (d -> d -> d) -> Syn' f (u, d) u -> Inh' f (u, d) d -> Rewrite f (u, d) g -> (u -> d) -> Dag f -> (u, Dag g)
+ Data.Comp.Dag.AG: runRewrite :: forall f g d u. (Traversable f, Traversable g) => (d -> d -> d) -> Syn' f (u, d) u -> Inh' f (u, d) d -> Rewrite f (u, d) g -> (u -> d) -> Dag f -> (u, Dag g)
- Data.Comp.Dag.PAG: runPAG :: (Traversable f, Traversable d, Traversable g, Traversable u) => (forall a. d a -> d a -> d a) -> Syn' f (u :*: d) u g -> Inh' f (u :*: d) d g -> (forall a. u a -> d (Context g a)) -> Dag f -> u (Dag g)
+ Data.Comp.Dag.PAG: runPAG :: forall f d u g. (Traversable f, Traversable d, Traversable g, Traversable u) => (forall a. d a -> d a -> d a) -> Syn' f (u :*: d) u g -> Inh' f (u :*: d) d g -> (forall a. u a -> d (Context g a)) -> Dag f -> u (Dag g)
- Data.Comp.PAG: runPAG :: (Traversable f, Functor g, Functor d, Functor u) => Syn' f (u :*: d) u g -> Inh' f (u :*: d) d g -> (forall a. u a -> d (Context g a)) -> Term f -> u (Term g)
+ Data.Comp.PAG: runPAG :: forall f u d g. (Traversable f, Functor g, Functor d, Functor u) => Syn' f (u :*: d) u g -> Inh' f (u :*: d) d g -> (forall a. u a -> d (Context g a)) -> Term f -> u (Term g)
Files
- compdata-dags.cabal +21/−5
- examples/Examples/LeavesBelow.hs +1/−1
- examples/Examples/Repmin.hs +1/−1
- examples/Examples/RepminPAG.hs +1/−0
- src/Data/Comp/AG/Internal.hs +1/−0
- src/Data/Comp/Dag.hs +0/−1
- src/Data/Comp/Dag/AG.hs +2/−2
- src/Data/Comp/Dag/PAG.hs +1/−1
- src/Data/Comp/PAG/Internal.hs +1/−0
compdata-dags.cabal view
@@ -1,5 +1,5 @@ Name: compdata-dags-Version: 0.2+Version: 0.2.1 Synopsis: Compositional Data Types on DAGs Description: This library implements recursion schemes on directed acyclic@@ -12,7 +12,7 @@ License: BSD3 License-file: LICENSE Author: Patrick Bahr, Emil Axelsson-Maintainer: paba@di.ku.dk+Maintainer: paba@itu.dk Build-Type: Simple Cabal-Version: >=1.9.2 bug-reports: https://github.com/pa-ba/compdata-dags/issues@@ -34,7 +34,7 @@ Other-Modules: Data.Comp.Dag.Internal Data.Comp.AG.Internal Data.Comp.PAG.Internal- Build-Depends: base >= 4.7, base < 5, compdata == 0.10.*, unordered-containers, + Build-Depends: base >= 4.7, base < 5, compdata >= 0.10, unordered-containers, mtl, containers, vector hs-source-dirs: src ghc-options: -W@@ -44,10 +44,26 @@ Type: exitcode-stdio-1.0 Main-is: RunTests.hs hs-source-dirs: tests examples src- Build-Depends: base >= 4.7, base < 5, compdata == 0.10.*, unordered-containers, + Build-Depends: base >= 4.7, base < 5, compdata >= 0.10, unordered-containers, mtl, containers, vector, test-framework-hunit, HUnit, test-framework, QuickCheck >= 2 && < 2.8, test-framework-quickcheck2 >= 0.3-+ Other-Modules: Data.Comp.AG+ Data.Comp.AG.Internal+ Data.Comp.Dag+ Data.Comp.Dag.AG+ Data.Comp.Dag.Internal+ Data.Comp.Dag.PAG+ Data.Comp.PAG+ Data.Comp.PAG.Internal+ Examples.LeavesBelow+ Examples.Repmin+ Examples.RepminPAG+ Examples.TypeInference+ Examples.Types+ Examples.Circuit+ Test.Dag+ Test.Examples+ Test.Utils source-repository head type: git
examples/Examples/LeavesBelow.hs view
@@ -1,6 +1,6 @@ {-# LANGUAGE TypeOperators #-} {-# LANGUAGE ImplicitParams #-}-+{-# LANGUAGE FlexibleContexts #-} module Examples.LeavesBelow where
examples/Examples/Repmin.hs view
@@ -1,6 +1,6 @@ {-# LANGUAGE TypeOperators #-} {-# LANGUAGE ImplicitParams #-}-+{-# LANGUAGE FlexibleContexts #-} module Examples.Repmin where
examples/Examples/RepminPAG.hs view
@@ -3,6 +3,7 @@ {-# LANGUAGE DeriveFunctor #-} {-# LANGUAGE DeriveFoldable #-} {-# LANGUAGE DeriveTraversable #-}+{-# LANGUAGE FlexibleContexts #-} -- This is an implementation of repmin as a PAG. The use of a PAG -- allows us to implement repmin such that the result of repmin is a
src/Data/Comp/AG/Internal.hs view
@@ -2,6 +2,7 @@ {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE Rank2Types #-} {-# LANGUAGE TypeOperators #-}+{-# LANGUAGE FlexibleContexts #-} -------------------------------------------------------------------------------- -- |
src/Data/Comp/Dag.hs view
@@ -30,7 +30,6 @@ , strongIso ) where -import Control.Applicative import Control.Exception.Base import Control.Monad.State import Data.Comp.Dag.Internal
src/Data/Comp/Dag/AG.hs view
@@ -84,7 +84,6 @@ let d' = lookupNumMap d i m u' <- runF d' s -- recurse return (Numbered i (u',d'))- writeSTRef count 0 -- re-initialize counter result <- Traversable.mapM run' t return u -- recurses through the tree structure@@ -101,6 +100,7 @@ runF d (Term t) = run d t -- This function is applied to each edge iter (n, t) = do+ writeSTRef count 0 -- re-initialize counter u <- run (fromJust $ dmapFin Vec.! n) t MVec.unsafeWrite umap n u -- first apply to the root@@ -143,6 +143,7 @@ let -- This function is applied to each edge iter (node,s) = do let d = fromJust $ dmapFin Vec.! node+ writeSTRef count 0 (u,t) <- run d s MVec.unsafeWrite umap node u MVec.unsafeWrite allEdges node t@@ -161,7 +162,6 @@ let d' = lookupNumMap d i m (u',t) <- runF d' s return (Numbered i ((u',d'), t))- writeSTRef count 0 result <- Traversable.mapM run' t let t' = join $ fmap (snd . unNumbered) $ explicit rewr (u,d) (fst . unNumbered) result return (u, t')
src/Data/Comp/Dag/PAG.hs view
@@ -87,6 +87,7 @@ let -- This function is applied to each edge iter (node,s) = do let d = fromJust $ dmapFin Vec.! node+ writeSTRef count 0 u <- run d s MVec.unsafeWrite umap node u -- Runs the AG on an edge with the given input inherited@@ -111,7 +112,6 @@ Just d' -> d' u' <- runF d' s return (Numbered i (u' :*: d'))- writeSTRef count 0 result <- Traversable.mapM run' t return u -- recurses through the tree structure
src/Data/Comp/PAG/Internal.hs view
@@ -2,6 +2,7 @@ {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE Rank2Types #-} {-# LANGUAGE TypeOperators #-}+{-# LANGUAGE FlexibleContexts #-} -------------------------------------------------------------------------------- -- |