pandora 0.2.1 → 0.2.2

raw patch · 29 files changed

+558/−226 lines, 29 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• CHANGELOG.md +18/−1
• Pandora/Core/Functor.hs +14/−5
• Pandora/Core/Transformation.hs +2/−0
• Pandora/Paradigm/Basis/Conclusion.hs +31/−25
• Pandora/Paradigm/Basis/Continuation.hs +6/−6
• Pandora/Paradigm/Basis/Free.hs +4/−0
• Pandora/Paradigm/Basis/Maybe.hs +31/−25
• Pandora/Paradigm/Basis/Twister.hs +2/−2
• Pandora/Paradigm/Basis/Yoneda.hs +8/−4
• Pandora/Paradigm/Controlflow/Joint.hs +1/−0
• Pandora/Paradigm/Controlflow/Joint/Adaptable.hs +148/−0
• Pandora/Paradigm/Controlflow/Joint/Transformer.hs +47/−10
• Pandora/Paradigm/Inventory.hs +3/−2
• Pandora/Paradigm/Inventory/Accumulator.hs +61/−0
• Pandora/Paradigm/Inventory/Environment.hs +62/−0
• Pandora/Paradigm/Inventory/Environmental.hs +0/−34
• Pandora/Paradigm/Inventory/Optics.hs +9/−7
• Pandora/Paradigm/Inventory/State.hs +83/−0
• Pandora/Paradigm/Inventory/Stateful.hs +0/−82
• Pandora/Paradigm/Structure/Cartesian.hs +1/−2
• Pandora/Paradigm/Structure/Specific/Graph.hs +1/−1
• Pandora/Paradigm/Structure/Specific/Stack.hs +1/−1
• Pandora/Pattern/Functor/Covariant.hs +2/−2
• Pandora/Pattern/Functor/Distributive.hs +10/−10
• Pandora/Pattern/Functor/Extractable.hs +2/−1
• Pandora/Pattern/Functor/Pointable.hs +2/−1
• Pandora/Pattern/Functor/Representable.hs +2/−1
• Pandora/Pattern/Functor/Traversable.hs +1/−1
• pandora.cabal +6/−3

@@ -95,7 +95,7 @@ * Remove `a` parameter from `Layout` to be able to use natural transformations in methods * Return `filter` method to `Stack` data structure * Rename `unwrap` to `untwist` method in `Twister` module-* Rename `composition` to `unwrap` and `Outline` to `Primary` in `Composition` typeclass+* Rename `composition` to `unwrap` and `Outline` to `Primary` in `Composition` type class * Rename `equip` to `wrap` and `Layout` to `Schema` in `Transformer` typeclass * Make `Composition` a superclass for `Transformer` typeclass * Move all `Junction` modules to `Pattern` submodule except `Kan`@@ -125,3 +125,20 @@ * Create `:#` type synonymous for `Tagged` datatype * Remove `untag` in favor of `extract` method * Rename `Tagged` constructor of `Tagged` to `Tag`++# 0.2.2+* Change types of `lay` and `wrap` methods of `Transformer` class+* Define `Adaptable` type class for fitting effects in schemas+* Define `Failable` and `failure` for adaptable `Conclusion`+* Define `Optional` and `nothing` for adaptable `Maybe`+* Rename `Stateful` to `State`, `get` to `current`, `put` to `replace`+* Define `Stateful` adaptable constraint and adapt `get`, `modify` and `put`+* Rename `Environmental` to `Environment`+* Make `env` adaptable effect and remove `local`+* Define `Accumulator` effect and it's adaptable `gather` method+* Define `|->` (Coalgebra) and `<-|` (Algebra) type synonyms+* Remove `oblige` in favor of `Liftable` instance of `Continuation`+* Remove `environmentally` in favor of `Interpreted` instance for `Environment`+* Remove `statefully` in favor of `Interpreted` instance for `State`++# 0.2.3

@@ -1,17 +1,26 @@ module Pandora.Core.Functor where +infixr 0 :=, <-|, |->+infixr 1 .:, :.+infixr 2 ::|:., ::|.:, ::|::+ data Variant = Co | Contra -infixr 1 :.+-- | Parameter application+type (:=) t a = t a++-- | Functors composition type (:.) t u a = t (u a) -infixr 1 .:+-- | Flipped functors composition type (.:) t u a = u (t a) -infixr 0 :=-type (:=) t a = t a+-- | Coalgebra's type operator+type (|->) a t = a -> t a -infixr 2 ::|:., ::|.:, ::|::+-- | Algebra's type operator+type (<-|) a t = t a -> a+ type (::|:.) p a b = p (p a b) b type (::|.:) p a b = p a (p a b) type (::|::) p a b = p (p a b) (p a b)

@@ -2,6 +2,8 @@  import Pandora.Pattern.Functor.Covariant (Covariant) +infixr 0 ~>+ type Natural t u = forall a . (Covariant t, Covariant u) => t a -> u a  type (~>) t u = Natural t u

@@ -1,9 +1,10 @@-module Pandora.Paradigm.Basis.Conclusion (Conclusion (..), conclusion, fail) where+module Pandora.Paradigm.Basis.Conclusion (Conclusion (..), Failable, conclusion, fail, failure) where  import Pandora.Core.Functor (Variant (Co)) import Pandora.Core.Morphism ((.)) import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))-import Pandora.Paradigm.Controlflow.Joint.Transformer (Transformer (Schema, lay, wrap))+import Pandora.Paradigm.Controlflow.Joint.Transformer (Transformer (Schema, lay, wrap), (:>)(T))+import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt)) import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>))) import Pandora.Pattern.Functor.Pointable (Pointable (point))@@ -44,29 +45,6 @@  instance Monad (Conclusion e) where -instance Interpreted (Conclusion e) where-	type Primary (Conclusion e) a = Conclusion e a-	unwrap x = x--instance Transformer (Conclusion e) where-	type Schema (Conclusion e) u = UT 'Co 'Co (Conclusion e) u-	lay x = UT $ Success <$> x-	wrap x = UT . point $ x--instance Covariant u => Covariant (UT 'Co 'Co (Conclusion e) u) where-	f <$> UT x = UT $ f <$$> x--instance Applicative u => Applicative (UT 'Co 'Co (Conclusion e) u) where-	UT f <*> UT x = UT $ apply <$> f <*> x--instance Pointable u => Pointable (UT 'Co 'Co (Conclusion e) u) where-	point = UT . point . point--instance (Pointable u, Bindable u) => Bindable (UT 'Co 'Co (Conclusion e) u) where-	UT x >>= f = UT $ x >>= conclusion (point . Failure) (unwrap . f)--instance Monad u => Monad (UT 'Co 'Co (Conclusion e) u) where- instance (Setoid e, Setoid a) => Setoid (Conclusion e a) where 	Success x == Success y = x == y 	Failure x == Failure y = x == y@@ -91,3 +69,31 @@ fail :: (e -> r) -> Conclusion e a -> Conclusion r a fail f (Failure x) = Failure $ f x fail _ (Success y) = Success y++instance Interpreted (Conclusion e) where+	type Primary (Conclusion e) a = Conclusion e a+	unwrap x = x++instance Transformer (Conclusion e) where+	type Schema (Conclusion e) u = UT 'Co 'Co (Conclusion e) u+	lay x = T . UT $ Success <$> x+	wrap x = T . UT . point $ x++type Failable e = Adaptable (Conclusion e)++instance Covariant u => Covariant (UT 'Co 'Co (Conclusion e) u) where+	f <$> UT x = UT $ f <$$> x++instance Applicative u => Applicative (UT 'Co 'Co (Conclusion e) u) where+	UT f <*> UT x = UT $ apply <$> f <*> x++instance Pointable u => Pointable (UT 'Co 'Co (Conclusion e) u) where+	point = UT . point . point++instance (Pointable u, Bindable u) => Bindable (UT 'Co 'Co (Conclusion e) u) where+	UT x >>= f = UT $ x >>= conclusion (point . Failure) (unwrap . f)++instance Monad u => Monad (UT 'Co 'Co (Conclusion e) u) where++failure :: (Covariant t, Failable e t) => e -> t a+failure = adapt . Failure

@@ -1,4 +1,4 @@-module Pandora.Paradigm.Basis.Continuation (Continuation (..), oblige, cwcc, reset, shift) where+module Pandora.Paradigm.Basis.Continuation (Continuation (..), cwcc, reset, shift) where  import Pandora.Core.Functor (type (:.), type (:=), type (::|:.)) import Pandora.Core.Morphism ((.), (!), (%))@@ -7,6 +7,7 @@ import Pandora.Pattern.Functor.Applicative (Applicative ((<*>))) import Pandora.Pattern.Functor.Bindable (Bindable ((>>=))) import Pandora.Pattern.Functor.Monad (Monad)+import Pandora.Pattern.Functor.Liftable (Liftable (lift)) import Pandora.Pattern.Functor.Divariant (($))  newtype Continuation r t a = Continuation { continue :: (->) ::|:. a :. t := r }@@ -25,17 +26,16 @@  instance Monad t => Monad (Continuation r t) where --- | Make any bindable action continue-oblige :: Bindable t => t a -> Continuation r t a-oblige x = Continuation (x >>=)+instance (forall u . Bindable u) => Liftable (Continuation r) where+	lift = Continuation . (>>=)  -- | Call with current continuation cwcc :: ((a -> Continuation r t b) -> Continuation r t a) -> Continuation r t a cwcc f = Continuation $ \g -> continue % g . f $ Continuation . (!) . g  -- | Delimit the continuation of any 'shift'-reset :: (Bindable t, Pointable t) => Continuation r t r -> Continuation s t r-reset = oblige . continue % point+reset :: (forall u . Bindable u, Bindable t, Pointable t) => Continuation r t r -> Continuation s t r+reset = lift . continue % point  -- | Capture the continuation up to the nearest enclosing 'reset' and pass it shift :: Pointable t => ((a -> t r) -> Continuation r t r) -> Continuation r t a

@@ -8,6 +8,7 @@ import Pandora.Pattern.Functor.Applicative (Applicative ((<*>))) import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>))) import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))+import Pandora.Pattern.Functor.Liftable (Liftable (lift)) import Pandora.Pattern.Functor.Divariant (($))  data Free t a = Pure a | Impure (t :. Free t := a)@@ -39,3 +40,6 @@ instance Traversable t => Traversable (Free t) where 	Pure x ->> f = Pure <$> f x 	Impure xs ->> f = Impure <$> xs ->>> f++instance Liftable Free where+	lift x = Impure $ Pure <$> x

@@ -1,9 +1,10 @@-module Pandora.Paradigm.Basis.Maybe (Maybe (..), maybe) where+module Pandora.Paradigm.Basis.Maybe (Maybe (..), Optional, maybe, nothing) where  import Pandora.Core.Functor (Variant (Co)) import Pandora.Core.Morphism ((.)) import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))-import Pandora.Paradigm.Controlflow.Joint.Transformer (Transformer (Schema, lay, wrap))+import Pandora.Paradigm.Controlflow.Joint.Transformer (Transformer (Schema, lay, wrap), (:>)(T))+import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt)) import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>))) import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))@@ -51,29 +52,6 @@  instance Monad Maybe where -instance Interpreted Maybe where-	type Primary Maybe a = Maybe a-	unwrap x = x--instance Transformer Maybe where-	type Schema Maybe u = UT 'Co 'Co Maybe u-	lay x = UT $ Just <$> x-	wrap x = UT . point $ x--instance Covariant u => Covariant (UT 'Co 'Co Maybe u) where-	f <$> UT x = UT $ f <$$> x--instance Applicative u => Applicative (UT 'Co 'Co Maybe u) where-	UT f <*> UT x = UT $ apply <$> f <*> x--instance Pointable u => Pointable (UT 'Co 'Co Maybe u) where-	point = UT . point . point--instance (Pointable u, Bindable u) => Bindable (UT 'Co 'Co Maybe u) where-	UT x >>= f = UT $ x >>= maybe (point Nothing) (unwrap . f)--instance Monad u => Monad (UT 'Co 'Co Maybe u) where- instance Setoid a => Setoid (Maybe a) where 	Just x == Just y = x == y 	Nothing == Nothing = True@@ -108,3 +86,31 @@ maybe :: b -> (a -> b) -> Maybe a -> b maybe x _ Nothing = x maybe _ f (Just y) = f y++instance Interpreted Maybe where+	type Primary Maybe a = Maybe a+	unwrap x = x++instance Transformer Maybe where+	type Schema Maybe u = UT 'Co 'Co Maybe u+	lay x = T . UT $ Just <$> x+	wrap x = T. UT . point $ x++type Optional = Adaptable Maybe++instance Covariant u => Covariant (UT 'Co 'Co Maybe u) where+	f <$> UT x = UT $ f <$$> x++instance Applicative u => Applicative (UT 'Co 'Co Maybe u) where+	UT f <*> UT x = UT $ apply <$> f <*> x++instance Pointable u => Pointable (UT 'Co 'Co Maybe u) where+	point = UT . point . point++instance (Pointable u, Bindable u) => Bindable (UT 'Co 'Co Maybe u) where+	UT x >>= f = UT $ x >>= maybe (point Nothing) (unwrap . f)++instance Monad u => Monad (UT 'Co 'Co Maybe u) where++nothing :: (Covariant t, Optional t) => t a+nothing = adapt Nothing

@@ -1,6 +1,6 @@ module Pandora.Paradigm.Basis.Twister (Twister (..), untwist, coiterate, section) where -import Pandora.Core.Functor (type (:.), type (:=))+import Pandora.Core.Functor (type (:.), type (:=), type (|->)) import Pandora.Core.Transformation (type (~>)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>), comap)) import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))@@ -59,7 +59,7 @@ untwist :: Twister t a -> (t :. Twister t) a untwist (_ :< xs) = xs -coiterate :: Covariant t => (a -> t a) -> a -> Twister t a+coiterate :: Covariant t => a |-> t -> a -> Twister t a coiterate coalgebra x = x :< (coiterate coalgebra <$> coalgebra x)  section :: Comonad t => t ~> Twister t

@@ -1,13 +1,14 @@ module Pandora.Paradigm.Basis.Yoneda (Yoneda (..)) where  import Pandora.Core.Morphism ((.), (!), identity)-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), comap))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>))) import Pandora.Pattern.Functor.Alternative (Alternative ((<+>))) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>))) import Pandora.Pattern.Functor.Avoidable (Avoidable (empty)) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Adjoint (Adjoint (phi, psi))+import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))+import Pandora.Pattern.Functor.Liftable (Liftable (lift)) import Pandora.Pattern.Functor.Divariant (($))  newtype Yoneda t a = Yoneda@@ -31,6 +32,9 @@ instance Extractable t => Extractable (Yoneda t) where 	extract (Yoneda f) = extract $ f identity +instance Liftable Yoneda where+	lift x = Yoneda (\f -> f <$> x)+ instance (Extractable t, Pointable t, Extractable u, Pointable u) => Adjoint (Yoneda t) (Yoneda u) where-	phi f = point . f . point-	psi f = extract . extract . comap f+	x -| f = point . f . point $ x+	x |- g = extract . extract $ g <$> x

@@ -3,3 +3,4 @@ import Pandora.Paradigm.Controlflow.Joint.Schemes as Exports import Pandora.Paradigm.Controlflow.Joint.Transformer as Exports import Pandora.Paradigm.Controlflow.Joint.Interpreted as Exports+import Pandora.Paradigm.Controlflow.Joint.Adaptable as Exports

@@ -0,0 +1,148 @@+module Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (..)) where++import Pandora.Core.Morphism (identity, (.))+import Pandora.Core.Transformation (type (~>))+import Pandora.Pattern.Functor.Covariant (Covariant)+import Pandora.Pattern.Functor.Pointable (Pointable)+import Pandora.Paradigm.Controlflow.Joint.Transformer (Transformer (Schema, lay, wrap), (:>))++class Adaptable eff schema where+	{-# MINIMAL adapt #-}+	adapt :: eff ~> schema++type Layable t u = (Transformer t, Covariant u)+type Wrappable t u = (Transformer t, Pointable u)++instance Adaptable t t where+	adapt = identity++instance Layable t u => Adaptable u (t :> u) where+	adapt = lay++instance Wrappable t u => Adaptable t (t :> u) where+	adapt = wrap++instance+	( Layable t (Schema u v)+	, Wrappable u v+	) => Adaptable u (t :> u :> v) where+	adapt = lay . wrap++instance+	( Layable t (Schema u v)+	, Layable u v+	) => Adaptable v (t :> u :> v) where+	adapt = lay . lay++instance+	( Layable t (Schema u (v :> w))+	, Layable u (Schema v w)+	, Wrappable v w+	) => Adaptable v (t :> u :> v :> w) where+	adapt = lay . lay . wrap++instance+	( Layable t (Schema u v)+	, Layable t (Schema u (v :> w))+	, Layable u (Schema v w)+	, Layable v w+	) => Adaptable w (t :> u :> v :> w) where+	adapt = lay . lay . lay++instance (Layable t (Schema u (v :> w :> x))+	, Layable u (Schema v (w :> x))+	, Layable v (Schema w x)+	, Layable w x+	) => Adaptable x (t :> u :> v :> w :> x) where+	adapt = lay . lay . lay . lay++instance (Layable t (Schema u (v :> w :> x))+	, Layable u (Schema v (w :> x))+	, Layable v (Schema w x)+	, Wrappable w x+	) => Adaptable w (t :> u :> v :> w :> x) where+	adapt = lay . lay . lay . wrap++instance+	( Layable t (Schema u (v :> w :> x :> y))+	, Layable u (Schema v (w :> x :> y))+	, Layable v (Schema w (x :> y))+	, Layable w (Schema x y)+	, Layable x y+	) => Adaptable y (t :> u :> v :> w :> x :> y) where+	adapt = lay . lay . lay . lay . lay++instance+	( Layable t (Schema u (v :> w :> x :> y))+	, Layable u (Schema v (w :> x :> y))+	, Layable v (Schema w (x :> y))+	, Layable w (Schema x y)+	, Wrappable x y+	) => Adaptable x (t :> u :> v :> w :> x :> y) where+	adapt = lay . lay . lay . lay . wrap++instance+	( Layable t (Schema u (v :> w :> x :> y :> z))+	, Layable u (Schema v (w :> x :> y :> z))+	, Layable v (Schema w (x :> y :> z))+	, Layable w (Schema x (y :> z))+	, Layable x (Schema y z)+	, Layable y z+	) => Adaptable z (t :> u :> v :> w :> x :> y :> z) where+	adapt = lay . lay . lay . lay . lay . lay++instance+	( Layable t (Schema u (v :> w :> x :> y :> z))+	, Layable u (Schema v (w :> x :> y :> z))+	, Layable v (Schema w (x :> y :> z))+	, Layable w (Schema x (y :> z))+	, Layable x (Schema y z)+	, Wrappable y z+	) => Adaptable y (t :> u :> v :> w :> x :> y :> z) where+	adapt = lay . lay . lay . lay . lay . wrap++instance+	( Layable t (Schema u (v :> w :> x :> y :> z :> f))+	, Layable u (Schema v (w :> x :> y :> z :> f))+	, Layable v (Schema w (x :> y :> z :> f))+	, Layable w (Schema x (y :> z :> f))+	, Layable x (Schema y (z :> f))+	, Layable y (Schema z f)+	, Layable z f+	) => Adaptable f (t :> u :> v :> w :> x :> y :> z :> f) where+	adapt = lay . lay . lay . lay . lay . lay . lay++instance+	( Layable t (Schema u (v :> w :> x :> y :> z :> f))+	, Layable u (Schema v (w :> x :> y :> z :> f))+	, Layable v (Schema w (x :> y :> z :> f))+	, Layable w (Schema x (y :> z :> f))+	, Layable x (Schema y (z :> f))+	, Layable y (Schema z f)+	, Wrappable z f+	) => Adaptable z (t :> u :> v :> w :> x :> y :> z :> f) where+	adapt = lay . lay . lay . lay . lay . lay . wrap++instance+	( Layable t (Schema u (v :> w :> x :> y :> z :> f :> h))+	, Layable u (Schema v (w :> x :> y :> z :> f :> h))+	, Layable v (Schema w (x :> y :> z :> f :> h))+	, Layable w (Schema x (y :> z :> f :> h))+	, Layable x (Schema y (z :> f :> h))+	, Layable y (Schema z (f :> h))+	, Layable z (Schema f h)+	, Layable f h+	) => Adaptable h (t :> u :> v :> w :> x :> y :> z :> f :> h) where+	adapt = lay . lay . lay . lay . lay . lay . lay . lay++instance+	( Layable t (Schema u (v :> w :> x :> y :> z :> f :> h))+	, Layable u (Schema v (w :> x :> y :> z :> f :> h))+	, Layable v (Schema w (x :> y :> z :> f :> h))+	, Layable w (Schema x (y :> z :> f :> h))+	, Layable x (Schema y (z :> f :> h))+	, Layable y (Schema z (f :> h))+	, Layable z (Schema f h)+	, Wrappable f h+	) => Adaptable f (t :> u :> v :> w :> x :> y :> z :> f :> h) where+	adapt = lay . lay . lay . lay . lay . lay . lay . wrap

@@ -1,18 +1,55 @@-module Pandora.Paradigm.Controlflow.Joint.Transformer (Transformer (..), type (:>)) where+module Pandora.Paradigm.Controlflow.Joint.Transformer (Transformer (..), (:>) (..)) where +import Pandora.Core.Morphism ((.)) import Pandora.Core.Transformation (type (~>))-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted)-import Pandora.Pattern.Functor.Covariant (Covariant)-import Pandora.Pattern.Functor.Pointable (Pointable)+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Extractable (Extractable (extract))+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))+import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))+import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))+import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))+import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))+import Pandora.Pattern.Functor.Divariant (($))  class Interpreted t => Transformer t where 	{-# MINIMAL lay, wrap #-} 	type Schema (t :: * -> *) (u :: * -> *) = (r :: * -> *) | r -> t u-	lay :: Covariant u => u ~> Schema t u-	wrap :: Pointable u => t ~> Schema t u---- infixr 1 :>--- type (:>) t u a = Transformer t => Schema t u a+	lay :: Covariant u => u ~> t :> u+	wrap :: Pointable u => t ~> t :> u  infixr 3 :>-newtype (:>) t u a = T { trans :: Transformer t => Schema t u a }+newtype (:>) t u a = T { trans :: Schema t u a }++instance Covariant (Schema t u) => Covariant (t :> u) where+	f <$> T x = T $ f <$> x++instance Pointable (Schema t u) => Pointable (t :> u) where+	point = T . point++instance Extractable (Schema t u) => Extractable (t :> u) where+	extract = extract . trans++instance Applicative (Schema t u) => Applicative (t :> u) where+	T f <*> T x = T $ f <*> x++instance Alternative (Schema t u) => Alternative (t :> u) where+	T x <+> T y = T $ x <+> y++instance Traversable (Schema t u) => Traversable (t :> u) where+	T x ->> f = T <$> x ->> f++instance Distributive (Schema t u) => Distributive (t :> u) where+	x >>- f = T $ x >>- trans . f++instance Bindable (Schema t u) => Bindable (t :> u) where+	T x >>= f = T $ x >>= trans . f++instance Extendable (Schema t u) => Extendable (t :> u) where+	T x =>> f = T $ x =>> f . T++instance (Interpreted (Schema t u), Transformer t) => Interpreted (t :> u) where+	type Primary (t :> u) a = Primary (Schema t u) a+	unwrap (T x) = unwrap x

@@ -2,5 +2,6 @@  import Pandora.Paradigm.Inventory.Optics as Exports import Pandora.Paradigm.Inventory.Storage as Exports-import Pandora.Paradigm.Inventory.Stateful as Exports-import Pandora.Paradigm.Inventory.Environmental as Exports+import Pandora.Paradigm.Inventory.State as Exports+import Pandora.Paradigm.Inventory.Environment as Exports+import Pandora.Paradigm.Inventory.Accumulator as Exports

@@ -0,0 +1,61 @@+{-# OPTIONS_GHC -fno-warn-orphans #-}++module Pandora.Paradigm.Inventory.Accumulator (Accumulator (..), Accumulated, gather) where++import Pandora.Core.Functor (Variant (Co))+import Pandora.Core.Morphism ((.))+import Pandora.Paradigm.Basis.Product (Product ((:*:)), type (:*:))+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))+import Pandora.Paradigm.Controlflow.Joint.Transformer (Transformer (Schema, lay, wrap), (:>) (T))+import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))+import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))+import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))+import Pandora.Pattern.Functor.Divariant (($))+import Pandora.Pattern.Object.Monoid (Monoid (zero))+import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))++newtype Accumulator e a = Accumulator (e :*: a)++instance Covariant (Accumulator e) where+	f <$> Accumulator x = Accumulator $ f <$> x++instance Semigroup e => Applicative (Accumulator e) where+	f <*> v = Accumulator $ k (unwrap f) (unwrap v) where+		k ~(e :*: g) ~(e' :*: w) = e + e' :*: g w++instance Monoid e => Pointable (Accumulator e) where+	point = Accumulator . (zero :*:)++instance Semigroup e => Bindable (Accumulator e) where+	Accumulator (e :*: x) >>= f = let (e' :*: b) = unwrap $ f x in+		Accumulator $ e + e':*: b++instance Interpreted (Accumulator e) where+	type Primary (Accumulator e) a = e :*: a+	unwrap (Accumulator x) = x++instance Monoid e => Transformer (Accumulator e) where+	type Schema (Accumulator e) u = UT 'Co 'Co ((:*:) e) u+	lay x = T . UT $ (zero :*:) <$> x+	wrap = T . UT . point . unwrap++type Accumulated e t = Adaptable (Accumulator e) t++instance Covariant u => Covariant (UT 'Co 'Co ((:*:) e) u) where+	f <$> UT x = UT $ f <$$> x++instance (Semigroup e, Applicative u) => Applicative (UT 'Co 'Co ((:*:) e) u) where+	UT f <*> UT x = UT $ k <$> f <*> x where+		k ~(u :*: g) ~(v :*: y) = u + v :*: g y++instance (Pointable u, Monoid e) => Pointable (UT 'Co 'Co ((:*:) e) u) where+	point = UT . point . (zero :*:)++instance (Semigroup e, Pointable u, Bindable u) => Bindable (UT 'Co 'Co ((:*:) e) u) where+	UT x >>= f = UT $ x >>= \(acc :*: v) -> (\(acc' :*: y) -> (acc + acc' :*: y)) <$> unwrap (f v)++gather :: (Covariant t, Accumulated e t) => e -> t ()+gather x = adapt . Accumulator $ x :*: ()

@@ -0,0 +1,62 @@+{-# OPTIONS_GHC -fno-warn-orphans #-}++module Pandora.Paradigm.Inventory.Environment (Environment (..), Configured, env) where++import Pandora.Core.Functor (Variant (Co))+import Pandora.Core.Morphism (identity, (.), (!), (%))+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))+import Pandora.Paradigm.Controlflow.Joint.Transformer (Transformer (Schema, lay, wrap), (:>) (T))+import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))+import Pandora.Paradigm.Controlflow.Joint.Schemes.TU (TU (TU))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))+import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))+import Pandora.Pattern.Functor.Monad (Monad)+import Pandora.Pattern.Functor.Divariant (($))++newtype Environment e a = Environment (e -> a)++instance Covariant (Environment e) where+	f <$> Environment x = Environment $ f . x++instance Pointable (Environment e) where+	point x = Environment (x !)++instance Applicative (Environment e) where+	f <*> x = Environment $ \e -> unwrap f e $ unwrap x e++instance Distributive (Environment e) where+	g >>- f = Environment $ g >>- (unwrap <$> f)++instance Bindable (Environment e) where+	Environment x >>= f = Environment $ \e -> unwrap % e . f . x $ e++instance Monad (Environment e) where++instance Interpreted (Environment e) where+	type Primary (Environment e) a = (->) e a+	unwrap (Environment x) = x++instance Transformer (Environment e) where+	type Schema (Environment e) u = TU 'Co 'Co ((->) e) u+	lay = T . TU . (!)+	wrap x = T. TU $ point <$> unwrap x++type Configured e = Adaptable (Environment e)++instance Covariant u => Covariant (TU 'Co 'Co ((->) e) u) where+	f <$> TU x = TU $ \r -> f <$> x r++instance (Covariant u, Pointable u) => Pointable (TU 'Co 'Co ((->) e) u) where+	point = TU . point . point++instance Applicative u => Applicative (TU 'Co 'Co ((->) e) u) where+	TU f <*> TU x = TU $ \r -> f r <*> x r++instance Bindable u => Bindable (TU 'Co 'Co ((->) e) u) where+	TU x >>= f = TU $ \e -> x e >>= ($ e) . unwrap . f++env :: (Covariant t, Configured e t) => t e+env = adapt $ Environment identity

@@ -1,34 +0,0 @@-module Pandora.Paradigm.Inventory.Environmental (Environmental (..), env, local) where--import Pandora.Core.Morphism (identity, (.), (!))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))-import Pandora.Pattern.Functor.Monad (Monad)-import Pandora.Pattern.Functor.Divariant (($))--newtype Environmental e a = Environmental (e -> a)--environmentally :: e -> Environmental e a -> a-environmentally e (Environmental f) = f e--instance Covariant (Environmental e) where-	f <$> Environmental x = Environmental $ f . x--instance Pointable (Environmental e) where-	point x = Environmental (x !)--instance Applicative (Environmental e) where-	f <*> x = Environmental $ \e -> environmentally e f $ environmentally e x--instance Bindable (Environmental e) where-	Environmental x >>= f = Environmental $ \e -> environmentally e . f . x $ e--instance Monad (Environmental e) where--env :: Environmental e e-env = Environmental identity--local :: (e -> e) -> Environmental e a -> Environmental e a-local f (Environmental x) = Environmental $ x . f

@@ -1,18 +1,20 @@-module Pandora.Paradigm.Inventory.Optics-	(Lens, type (:-.), (|>), view, set, over, (^.), (.~), (%~)) where+{-# OPTIONS_GHC -fno-warn-orphans #-} -import Pandora.Core.Morphism ((.), (!))+module Pandora.Paradigm.Inventory.Optics (Lens, type (:-.), (|>), view, set, over, (^.), (.~), (%~)) where++import Pandora.Core.Morphism ((.), (!), (%)) import Pandora.Paradigm.Basis.Product (Product ((:*:)))-import Pandora.Paradigm.Inventory.Stateful (Stateful (Stateful), statefully)+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (unwrap))+import Pandora.Paradigm.Inventory.State (State (State)) import Pandora.Paradigm.Inventory.Storage (Storage (Storage), access, position, retrofit) import Pandora.Pattern.Functor.Covariant (Covariant ((<$))) import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-))) import Pandora.Pattern.Functor.Divariant (($)) -instance Adjoint (Storage s) (Stateful s) where-	v -| f = Stateful $ \s -> (:*:) s . f . Storage $ s :*: (v !)-	Storage (s :*: f) |- g = extract . statefully s . g $ f s+instance Adjoint (Storage s) (State s) where+	v -| f = State $ \s -> (:*:) s . f . Storage $ s :*: (v !)+	Storage (s :*: f) |- g = extract . unwrap % s . g $ f s  infixr 0 :-. type (:-.) src tgt = Lens src tgt

@@ -0,0 +1,83 @@+{-# OPTIONS_GHC -fno-warn-orphans #-}++module Pandora.Paradigm.Inventory.State (State (..), Stateful, current, modify, replace, fold, find) where++import Pandora.Core.Functor (Variant (Co), type (:.), type (:=))+import Pandora.Core.Morphism ((.), (%))+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))+import Pandora.Paradigm.Controlflow.Joint.Transformer (Transformer (Schema, lay, wrap), (:>) (T))+import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))+import Pandora.Paradigm.Controlflow.Joint.Schemes.TUV (TUV (TUV))+import Pandora.Paradigm.Basis.Predicate (Predicate (predicate))+import Pandora.Paradigm.Basis.Product (Product ((:*:)), type (:*:), attached, delta, uncurry)+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), ($>), (<$$>)))+import Pandora.Pattern.Functor.Extractable (Extractable (extract))+import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))+import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (*>)))+import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))+import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))+import Pandora.Pattern.Functor.Monad (Monad)+import Pandora.Pattern.Functor.Divariant (($))+import Pandora.Pattern.Object.Setoid (bool)++newtype State s a = State ((->) s :. (:*:) s := a)++instance Covariant (State s) where+	f <$> State x = State $ \old -> f <$> x old++instance Applicative (State s) where+	State f <*> State x = State $ \old ->+		let latest = attached . x $ old in+			latest :*: (extract (f old) . extract . x $ old)++instance Pointable (State s) where+	point x = State $ \s -> s :*: x++instance Bindable (State s) where+	State x >>= f = State $ \old ->+		uncurry (unwrap %) $ f <$> x old++instance Monad (State s) where++fold :: Traversable t => s -> (a -> s -> s) -> t a -> s+fold start op struct = extract . unwrap @(State _) % start $+	struct ->> modify . op $> () *> current++find :: (Pointable u, Avoidable u, Alternative u, Traversable t) => Predicate a -> t a -> u a+find p struct = fold empty (\x s -> (<+>) s . bool empty (point x) . predicate p $ x) struct++instance Interpreted (State s) where+	type Primary (State s) a = (->) s :. (:*:) s := a+	unwrap (State x) = x++instance Transformer (State s) where+	type Schema (State s) u = TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)+	lay x = T . TUV $ \s -> (s :*:) <$> x+	wrap x = T . TUV $ point <$> unwrap x++type Stateful s = Adaptable (State s)++instance Covariant u => Covariant (TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)) where+	f <$> TUV x = TUV $ \old -> f <$$> x old++instance Bindable u => Applicative (TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)) where+	TUV f <*> TUV x = TUV $ \old -> f old >>= \(new :*: g) -> g <$$> x new++instance Pointable u => Pointable (TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)) where+	point x = TUV $ \s -> point $ s :*: x++instance Bindable u => Bindable (TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)) where+	TUV x >>= f = TUV $ \old -> x old >>= \(new :*: y) -> ($ new) . unwrap . f $ y++instance Monad u => Monad (TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)) where++current :: (Covariant t, Stateful s t) => t s+current = adapt $ State delta++modify :: (Covariant t, Stateful s t) => (s -> s) -> t ()+modify f = adapt $ State $ \s -> f s :*: ()++replace :: (Covariant t, Stateful s t) => s -> t ()+replace s = adapt $ State $ \_ -> s :*: ()

@@ -1,82 +0,0 @@-module Pandora.Paradigm.Inventory.Stateful-	(Stateful (..), statefully, get, modify, put, fold, find) where--import Pandora.Core.Functor (Variant (Co), type (:.), type (:=))-import Pandora.Core.Morphism ((.))-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))-import Pandora.Paradigm.Controlflow.Joint.Transformer (Transformer (Schema, lay, wrap))-import Pandora.Paradigm.Controlflow.Joint.Schemes.TUV (TUV (TUV))-import Pandora.Paradigm.Basis.Predicate (Predicate (predicate))-import Pandora.Paradigm.Basis.Product (Product ((:*:)), type (:*:), attached, delta, uncurry)-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), ($>), (<$$>)))-import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (*>)))-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))-import Pandora.Pattern.Functor.Monad (Monad)-import Pandora.Pattern.Functor.Divariant (($))-import Pandora.Pattern.Object.Setoid (bool)--newtype Stateful s a = Stateful ((->) s :. (:*:) s := a)--statefully :: s -> Stateful s a -> s :*: a-statefully initial (Stateful state) = state initial--instance Covariant (Stateful s) where-	f <$> Stateful x = Stateful $ \old -> f <$> x old--instance Applicative (Stateful s) where-	Stateful f <*> Stateful x = Stateful $ \old ->-		let latest = attached . x $ old in-			latest :*: (extract (f old) . extract . x $ old)--instance Pointable (Stateful s) where-	point x = Stateful $ \s -> s :*: x--instance Bindable (Stateful s) where-	Stateful x >>= f = Stateful $ \old ->-		uncurry statefully $ f <$> x old--instance Monad (Stateful s) where--get :: Stateful s s-get = Stateful delta--modify :: (s -> s) -> Stateful s ()-modify f = Stateful $ \s -> f s :*: ()--put :: s -> Stateful s ()-put s = Stateful $ \_ -> s :*: ()--fold :: Traversable t => s -> (a -> s -> s) -> t a -> s-fold start op struct = extract . statefully start $-	struct ->> modify . op $> () *> get--find :: (Pointable u, Avoidable u, Alternative u, Traversable t) => Predicate a -> t a -> u a-find p struct = fold empty (\x s -> (<+>) s . bool empty (point x) . predicate p $ x) struct--instance Interpreted (Stateful s) where-	type Primary (Stateful s) a = (->) s :. (:*:) s := a-	unwrap (Stateful x) = x--instance Transformer (Stateful s) where-	type Schema (Stateful s) u = TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)-	lay x = TUV $ \s -> (s :*:) <$> x-	wrap x = TUV $ point <$> unwrap x--instance Covariant u => Covariant (TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)) where-	f <$> TUV x = TUV $ \old -> f <$$> x old--instance Bindable u => Applicative (TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)) where-	TUV f <*> TUV x = TUV $ \old -> f old >>= \(new :*: g) -> g <$$> x new--instance Pointable u => Pointable (TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)) where-	point x = TUV $ \s -> point $ s :*: x--instance Bindable u => Bindable (TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)) where-	TUV x >>= f = TUV $ \old -> x old >>= \(new :*: y) -> ($ new) . unwrap . f $ y--instance Monad u => Monad (TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)) where

@@ -1,8 +1,7 @@-module Pandora.Paradigm.Structure.Cartesian (Cartesian) where+module Pandora.Paradigm.Structure.Cartesian (Cartesian (..)) where  import Pandora.Paradigm.Basis.Product (type (:*:))  class Cartesian (t :: * -> *) where 	{-# MINIMAL (-:*:-) #-} 	(-:*:-) :: t a -> t b -> t (a :*: b)-	cartesian :: t a -> t b -> t (a :*: b)

@@ -5,7 +5,7 @@ import Pandora.Core.Morphism ((.)) import Pandora.Paradigm.Basis.Edges (Edges (Empty, Overlay)) import Pandora.Paradigm.Basis.Twister (Twister ((:<)))-import Pandora.Paradigm.Inventory.Stateful (fold)+import Pandora.Paradigm.Inventory.State (fold) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>))) import Pandora.Pattern.Functor.Divariant (($)) import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))

@@ -6,7 +6,7 @@ import Pandora.Paradigm.Basis.Maybe (Maybe (Just, Nothing)) import Pandora.Paradigm.Basis.Predicate (Predicate (Predicate)) import Pandora.Paradigm.Basis.Twister (Twister ((:<)), untwist)-import Pandora.Paradigm.Inventory.Stateful (fold)+import Pandora.Paradigm.Inventory.State (fold) import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>))) import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))

@@ -1,6 +1,6 @@ module Pandora.Pattern.Functor.Covariant (Covariant (..)) where -import Pandora.Core.Functor (type (:.), type (:=))+import Pandora.Core.Functor (type (:.), type (:=), type (<-|)) import Pandora.Core.Morphism (fix, (.), (!), (%))  infixl 4 <$>, <$, $>@@ -29,7 +29,7 @@ 	void :: t a -> t () 	void x = () <$ x 	-- | Computing a value from a structure of values-	loeb :: t (t a -> a) -> t a+	loeb :: t (a <-| t) -> t a 	loeb tt = fix (\f -> (\g -> g f) <$> tt) 	-- | Flipped infix version of 'comap' 	(<&>) :: t a -> (a -> b) -> t b

@@ -14,27 +14,27 @@  infixl 5 >>-, >>>-, >>>>-, >>>>>- -class Covariant u => Distributive u where+class Covariant t => Distributive t where 	{-# MINIMAL (>>-) #-} 	-- | Infix and flipped version of 'collect'-	(>>-) :: Covariant t => t a -> (a -> u b) -> u :. t := b+	(>>-) :: Covariant u => u a -> (a -> t b) -> t :. u := b  	-- | Prefix version of '>>-'-	collect :: Covariant t => (a -> u b) -> t a -> u :. t := b+	collect :: Covariant u => (a -> t b) -> u a -> t :. u := b 	collect f t = t >>- f 	-- | The dual of 'sequence'-	distribute :: Covariant t => t :. u := a -> u :. t := a+	distribute :: Covariant u => u :. t := a -> t :. u := a 	distribute t = t >>- identity  	-- | Infix versions of `collect` with various nesting levels-	(>>>-) :: (Covariant t, Covariant v)-		=> t :. v := a -> (a -> u b) -> u :. t :. v := b+	(>>>-) :: (Covariant u, Covariant v)+		=> u :. v := a -> (a -> t b) -> t :. u :. v := b 	x >>>- f = (collect . collect) f x-	(>>>>-) :: (Covariant t, Covariant v, Covariant w)-		=> t :. v :. w := a -> (a -> u b) -> u :. t :. v :. w := b+	(>>>>-) :: (Covariant u, Covariant v, Covariant w)+		=> u :. v :. w := a -> (a -> t b) -> t :. u :. v :. w := b 	x >>>>- f = (collect . collect . collect) f x-	(>>>>>-) :: (Covariant t, Covariant v, Covariant w, Covariant j)-		=> t :. v :. w :. j := a -> (a -> u b) -> u :. t :. v :. w :. j := b+	(>>>>>-) :: (Covariant u, Covariant v, Covariant w, Covariant j)+		=> u :. v :. w :. j := a -> (a -> t b) -> t :. u :. v :. w :. j := b 	x >>>>>- f = (collect . collect . collect . collect) f x  instance Distributive ((->) e) where

@@ -1,6 +1,7 @@ module Pandora.Pattern.Functor.Extractable (Extractable (..)) where +import Pandora.Core.Functor (type (<-|)) import Pandora.Pattern.Functor.Covariant (Covariant)  class Covariant t => Extractable t where-	extract :: t a -> a+	extract :: a <-| t

@@ -1,10 +1,11 @@ module Pandora.Pattern.Functor.Pointable (Pointable (..)) where +import Pandora.Core.Functor (type (|->)) import Pandora.Core.Morphism ((!)) import Pandora.Pattern.Functor.Covariant (Covariant)  class Covariant t => Pointable t where-	point :: a -> t a+	point :: a |-> t  instance Pointable ((->) e) where 	point = (!)

@@ -1,5 +1,6 @@ module Pandora.Pattern.Functor.Representable (Representable (..)) where +import Pandora.Core.Functor (type (<-|)) import Pandora.Core.Morphism (identity, (%)) import Pandora.Pattern.Functor.Pointable (Pointable) @@ -15,7 +16,7 @@ 	{-# MINIMAL (<#>), tabulate #-} 	type Representation t :: * 	-- | Infix and flipped version of 'index'-	(<#>) :: Representation t -> t a -> a+	(<#>) :: Representation t -> a <-| t 	-- Build with a function which describes value 	tabulate :: (Representation t -> a) -> t a 	-- | Prefix and flipped version of '<#>'

@@ -28,7 +28,7 @@ 	traverse :: (Pointable u, Applicative u) => (a -> u b) -> t a -> u :. t := b 	traverse f t = t ->> f 	-- | The dual of 'distribute'-	sequence :: (Pointable u, Applicative u) => (t :. u) a -> u :. t := a+	sequence :: (Pointable u, Applicative u) => t :. u := a -> u :. t := a 	sequence t = t ->> identity  	-- | Infix versions of `traverse` with various nesting levels

@@ -1,5 +1,5 @@ name:                pandora-version:             0.2.1+version:             0.2.2 synopsis:            A box of patterns and paradigms description:         Humble attempt to define a library for problem solving based on math abstractions. homepage:            https://github.com/iokasimov/pandora@@ -55,6 +55,7 @@     Pandora.Paradigm.Controlflow.Joint     Pandora.Paradigm.Controlflow.Joint.Interpreted     Pandora.Paradigm.Controlflow.Joint.Transformer+    Pandora.Paradigm.Controlflow.Joint.Adaptable     Pandora.Paradigm.Controlflow.Joint.Schemes     Pandora.Paradigm.Controlflow.Joint.Schemes.TU     Pandora.Paradigm.Controlflow.Joint.Schemes.TUV@@ -65,9 +66,10 @@     Pandora.Paradigm.Controlflow.Pipeline     -- Tools for datastructures     Pandora.Paradigm.Inventory-    Pandora.Paradigm.Inventory.Environmental+    Pandora.Paradigm.Inventory.Accumulator+    Pandora.Paradigm.Inventory.Environment     Pandora.Paradigm.Inventory.Optics-    Pandora.Paradigm.Inventory.Stateful+    Pandora.Paradigm.Inventory.State     Pandora.Paradigm.Inventory.Storage     -- Tree-based datastructures     Pandora.Paradigm.Structure@@ -117,5 +119,6 @@     FlexibleContexts, FlexibleInstances, KindSignatures, LiberalTypeSynonyms     MultiParamTypeClasses, NoImplicitPrelude, PackageImports, PolyKinds, RankNTypes     ScopedTypeVariables, TypeApplications, TypeFamilies, TypeFamilyDependencies, TypeOperators+    UndecidableInstances   default-language: Haskell2010   ghc-options: -Wall -fno-warn-tabs