pandora 0.2.2 → 0.2.3

raw patch · 44 files changed

+501/−344 lines, 44 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• CHANGELOG.md +12/−0
• Pandora/Core/Functor.hs +0/−2
• Pandora/Core/Morphism.hs +1/−10
• Pandora/Paradigm/Basis/Conclusion.hs +16/−14
• Pandora/Paradigm/Basis/Continuation.hs +2/−1
• Pandora/Paradigm/Basis/Endo.hs +1/−1
• Pandora/Paradigm/Basis/Identity.hs +1/−1
• Pandora/Paradigm/Basis/Jack.hs +1/−1
• Pandora/Paradigm/Basis/Kan.hs +1/−1
• Pandora/Paradigm/Basis/Maybe.hs +14/−13
• Pandora/Paradigm/Basis/Predicate.hs +2/−1
• Pandora/Paradigm/Basis/Tagged.hs +1/−1
• Pandora/Paradigm/Basis/Twister.hs +22/−20
• Pandora/Paradigm/Basis/Yoneda.hs +2/−1
• Pandora/Paradigm/Controlflow/Joint.hs +1/−0
• Pandora/Paradigm/Controlflow/Joint/Adaptable.hs +86/−66
• Pandora/Paradigm/Controlflow/Joint/Schematic.hs +3/−0
• Pandora/Paradigm/Controlflow/Joint/Transformer.hs +7/−52
• Pandora/Paradigm/Controlflow/Joint/Transformer/Comonadic.hs +58/−0
• Pandora/Paradigm/Controlflow/Joint/Transformer/Monadic.hs +58/−0
• Pandora/Paradigm/Controlflow/Observable.hs +1/−1
• Pandora/Paradigm/Inventory.hs +1/−1
• Pandora/Paradigm/Inventory/Accumulator.hs +14/−12
• Pandora/Paradigm/Inventory/Environment.hs +14/−12
• Pandora/Paradigm/Inventory/Optics.hs +7/−6
• Pandora/Paradigm/Inventory/State.hs +24/−20
• Pandora/Paradigm/Inventory/Storage.hs +0/−33
• Pandora/Paradigm/Inventory/Store.hs +61/−0
• Pandora/Paradigm/Structure/Specific/Binary.hs +11/−5
• Pandora/Paradigm/Structure/Specific/Graph.hs +14/−17
• Pandora/Paradigm/Structure/Specific/Stack.hs +24/−27
• Pandora/Pattern.hs +1/−1
• Pandora/Pattern/Category.hs +11/−0
• Pandora/Pattern/Functor/Adjoint.hs +1/−1
• Pandora/Pattern/Functor/Applicative.hs +1/−1
• Pandora/Pattern/Functor/Bindable.hs +2/−1
• Pandora/Pattern/Functor/Contravariant.hs +2/−1
• Pandora/Pattern/Functor/Covariant.hs +2/−1
• Pandora/Pattern/Functor/Distributive.hs +2/−2
• Pandora/Pattern/Functor/Divariant.hs +7/−11
• Pandora/Pattern/Functor/Extendable.hs +2/−1
• Pandora/Pattern/Functor/Representable.hs +2/−1
• Pandora/Pattern/Functor/Traversable.hs +1/−1
• pandora.cabal +7/−3

@@ -142,3 +142,15 @@ * Remove `statefully` in favor of `Interpreted` instance for `State`  # 0.2.3+* Define `Category` type class with `identity` and `.` methods+* Change `>->` signature: `a -> b` to `v a d` and `c -> d` to `v c d`+* Extract `Schema` from `Transformer` type class as `Schematic` type family+* Rename `Transformer` type class to `Monadic`+* Define `Comonadic` type class for comonad transformers+* Define `Transformer` umbrella module and type family+* Rename `:<` data constructor to `Twister` to not confuse it with comonad transformer type operator+* Use `UT` joint scheme for `Stack` and `Graph` data structures+* Remove `Variant` type in favor of `Covariant` and `Contravariant` constraints in joint schemes+* Add `Covariant` constraint on schema parameter in `Adaptable` type class+* Rename `Storage` type to `Store`+* Define `Interpreted`, `Schematic` and `Comonadic` instances for `Store` type

@@ -4,8 +4,6 @@ infixr 1 .:, :. infixr 2 ::|:., ::|.:, ::|:: -data Variant = Co | Contra- -- | Parameter application type (:=) t a = t a 

@@ -1,20 +1,11 @@-module Pandora.Core.Morphism (identity, fix, (.), (&), (!), (%)) where+module Pandora.Core.Morphism (fix, (&), (!), (%)) where -infixr 8 . infixl 1 & infixr 2 ! infixr 9 % -{-# INLINE identity #-}-identity :: a -> a-identity x = x- fix :: (a -> a) -> a fix f = let x = f x in x--{-# INLINE (.) #-}-(.) :: (b -> c) -> (a -> b) -> a -> c-f . g = \x -> f (g x)  {-# INLINE (&) #-} (&) :: a -> (a -> b) -> b

@@ -1,9 +1,10 @@ module Pandora.Paradigm.Basis.Conclusion (Conclusion (..), Failable, conclusion, fail, failure) where -import Pandora.Core.Functor (Variant (Co))-import Pandora.Core.Morphism ((.))+import Pandora.Core.Transformation (type (~>))+import Pandora.Pattern.Category ((.)) 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.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))+import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic) import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt)) import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))@@ -66,7 +67,7 @@ conclusion f _ (Failure x) = f x conclusion _ s (Success x) = s x -fail :: (e -> r) -> Conclusion e a -> Conclusion r a+fail :: (e -> r) -> Conclusion e ~> Conclusion r fail f (Failure x) = Failure $ f x fail _ (Success y) = Success y @@ -74,26 +75,27 @@ 	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 instance Schematic Monad (Conclusion e) u = UT Covariant Covariant (Conclusion e) u +instance Monadic (Conclusion e) where+	lay x = TM . UT $ Success <$> x+	wrap x = TM . UT . point $ x+ type Failable e = Adaptable (Conclusion e) -instance Covariant u => Covariant (UT 'Co 'Co (Conclusion e) u) where+instance Covariant u => Covariant (UT Covariant Covariant (Conclusion e) u) where 	f <$> UT x = UT $ f <$$> x -instance Applicative u => Applicative (UT 'Co 'Co (Conclusion e) u) where+instance Applicative u => Applicative (UT Covariant Covariant (Conclusion e) u) where 	UT f <*> UT x = UT $ apply <$> f <*> x -instance Pointable u => Pointable (UT 'Co 'Co (Conclusion e) u) where+instance Pointable u => Pointable (UT Covariant Covariant (Conclusion e) u) where 	point = UT . point . point -instance (Pointable u, Bindable u) => Bindable (UT 'Co 'Co (Conclusion e) u) where+instance (Pointable u, Bindable u) => Bindable (UT Covariant Covariant (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 Monad u => Monad (UT Covariant Covariant (Conclusion e) u) where -failure :: (Covariant t, Failable e t) => e -> t a+failure :: Failable e t => e -> t a failure = adapt . Failure

@@ -1,7 +1,8 @@ module Pandora.Paradigm.Basis.Continuation (Continuation (..), cwcc, reset, shift) where  import Pandora.Core.Functor (type (:.), type (:=), type (::|:.))-import Pandora.Core.Morphism ((.), (!), (%))+import Pandora.Core.Morphism ((!), (%))+import Pandora.Pattern.Category ((.)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>))) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))

@@ -1,6 +1,6 @@ module Pandora.Paradigm.Basis.Endo (Endo (..)) where -import Pandora.Core.Morphism ((.), identity)+import Pandora.Pattern.Category (identity, (.)) import Pandora.Pattern.Functor.Invariant (Invariant (invmap)) import Pandora.Pattern.Object.Semigroup (Semigroup ((+))) import Pandora.Pattern.Object.Monoid (Monoid (zero))

@@ -1,6 +1,6 @@ module Pandora.Paradigm.Basis.Identity (Identity (..)) where -import Pandora.Core.Morphism ((.))+import Pandora.Pattern.Category ((.)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), comap)) import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Pointable (Pointable (point))

@@ -1,6 +1,6 @@ module Pandora.Paradigm.Basis.Jack (Jack (..), jack) where -import Pandora.Core.Morphism ((.))+import Pandora.Pattern.Category ((.)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), comap) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Extractable (Extractable (extract))

@@ -1,6 +1,6 @@ module Pandora.Paradigm.Basis.Kan (Lan (..), Ran (..)) where -import Pandora.Core.Morphism ((.))+import Pandora.Pattern.Category ((.)) import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<))) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>))) import Pandora.Pattern.Functor.Divariant (($))

@@ -1,11 +1,11 @@ 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), (:>)(T))+import Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))+import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic) import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt)) import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))+import Pandora.Pattern.Category ((.)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>))) import Pandora.Pattern.Functor.Avoidable (Avoidable (empty)) import Pandora.Pattern.Functor.Pointable (Pointable (point))@@ -87,30 +87,31 @@ maybe x _ Nothing = x maybe _ f (Just y) = f y +type instance Schematic Monad Maybe u = UT Covariant Covariant Maybe u+ 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+instance Monadic Maybe where+	lay x = TM . UT $ Just <$> x+	wrap x = TM . UT . point $ x  type Optional = Adaptable Maybe -instance Covariant u => Covariant (UT 'Co 'Co Maybe u) where+instance Covariant u => Covariant (UT Covariant Covariant Maybe u) where 	f <$> UT x = UT $ f <$$> x -instance Applicative u => Applicative (UT 'Co 'Co Maybe u) where+instance Applicative u => Applicative (UT Covariant Covariant Maybe u) where 	UT f <*> UT x = UT $ apply <$> f <*> x -instance Pointable u => Pointable (UT 'Co 'Co Maybe u) where+instance Pointable u => Pointable (UT Covariant Covariant Maybe u) where 	point = UT . point . point -instance (Pointable u, Bindable u) => Bindable (UT 'Co 'Co Maybe u) where+instance (Pointable u, Bindable u) => Bindable (UT Covariant Covariant Maybe u) where 	UT x >>= f = UT $ x >>= maybe (point Nothing) (unwrap . f) -instance Monad u => Monad (UT 'Co 'Co Maybe u) where+instance Monad u => Monad (UT Covariant Covariant Maybe u) where -nothing :: (Covariant t, Optional t) => t a+nothing :: Optional t => t a nothing = adapt Nothing

@@ -1,6 +1,7 @@ module Pandora.Paradigm.Basis.Predicate (Predicate (..)) where -import Pandora.Core.Morphism ((.), (!))+import Pandora.Core.Morphism ((!))+import Pandora.Pattern.Category ((.)) import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<))) import Pandora.Pattern.Functor.Determinable (Determinable (determine)) import Pandora.Pattern.Functor.Divariant (($))

@@ -1,6 +1,6 @@ module Pandora.Paradigm.Basis.Tagged (Tagged (..), retag, tagself, type (:#)) where -import Pandora.Core.Morphism ((.))+import Pandora.Pattern.Category ((.)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>))) import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Pointable (Pointable (point))

@@ -2,65 +2,67 @@  import Pandora.Core.Functor (type (:.), type (:=), type (|->)) import Pandora.Core.Transformation (type (~>))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>), comap))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>))) 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.Alternative (Alternative ((<+>)))-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (<**>))) import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>))) import Pandora.Pattern.Functor.Bindable (Bindable ((>>=))) import Pandora.Pattern.Functor.Extendable (Extendable ((=>>), extend)) import Pandora.Pattern.Functor.Monad (Monad) import Pandora.Pattern.Functor.Comonad (Comonad)+import Pandora.Pattern.Functor.Lowerable (Lowerable (lower))+import Pandora.Pattern.Functor.Divariant (($)) import Pandora.Pattern.Object.Setoid (Setoid ((==)), (&&)) import Pandora.Pattern.Object.Semigroup (Semigroup ((+))) import Pandora.Pattern.Object.Monoid (Monoid (zero)) -infixr 5 :<--data Twister t a = a :< (t :. Twister t := a)+data Twister t a = Twister a (t :. Twister t := a)  instance Covariant t => Covariant (Twister t) where-	f <$> (x :< xs) = f x :< (f <$$> xs)+	f <$> Twister x xs = Twister (f x) $ f <$$> xs  instance Avoidable t => Pointable (Twister t) where-	point x = x :< empty+	point x = Twister x empty  instance Covariant t => Extractable (Twister t) where-	extract (x :< _) = x+	extract (Twister x _) = x  instance Applicative t => Applicative (Twister t) where-	(f :< fs) <*> (x :< xs) = f x :< ((<*>) <$> fs <*> xs)+	Twister f fs <*> Twister x xs = Twister (f x) $ fs <**> xs  instance Traversable t => Traversable (Twister t) where-	(x :< xs) ->> f = (:<) <$> f x <*> xs ->>> f+	Twister x xs ->> f = Twister <$> f x <*> xs ->>> f  instance Alternative t => Bindable (Twister t) where-	(x :< xs) >>= f = case f x of-		y :< ys -> y :< (ys <+> comap (>>= f) xs)+	Twister x xs >>= f = case f x of Twister y ys -> Twister y $ ys <+> (>>= f) <$> xs  instance Covariant t => Extendable (Twister t) where-	x =>> f = f x :< (extend f <$> untwist x)+	x =>> f = Twister (f x) $ extend f <$> untwist x  instance (Avoidable t, Alternative t) => Monad (Twister t) where  instance Covariant t => Comonad (Twister t) where +instance Lowerable Twister where+	lower (Twister _ xs) = extract <$> xs+ instance (Setoid a, forall b . Setoid b => Setoid (t b)) => Setoid (Twister t a) where-	(x :< xs) == (y :< ys) = x == y && xs == ys+	Twister x xs == Twister y ys = x == y && xs == ys  instance (Semigroup a, forall b . Semigroup b => Semigroup (t b)) => Semigroup (Twister t a) where-	(x :< xs) + (y :< ys) = (x + y) :< (xs + ys)+	Twister x xs + Twister y ys = Twister (x + y) $ xs + ys  instance (Monoid a, forall b . Semigroup b => Monoid (t b)) => Monoid (Twister t a) where-	zero = zero :< zero+	zero = Twister zero zero  untwist :: Twister t a -> (t :. Twister t) a-untwist (_ :< xs) = xs+untwist (Twister _ xs) = xs -coiterate :: Covariant t => a |-> t -> a -> Twister t a-coiterate coalgebra x = x :< (coiterate coalgebra <$> coalgebra x)+coiterate :: Covariant t => a |-> t -> a |-> Twister t+coiterate coalgebra x = Twister x $ coiterate coalgebra <$> coalgebra x  section :: Comonad t => t ~> Twister t-section as = extract as :< extend section as+section as = Twister (extract as) $ extend section as

@@ -1,6 +1,7 @@ module Pandora.Paradigm.Basis.Yoneda (Yoneda (..)) where -import Pandora.Core.Morphism ((.), (!), identity)+import Pandora.Core.Morphism ((!))+import Pandora.Pattern.Category (identity, (.)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>))) import Pandora.Pattern.Functor.Alternative (Alternative ((<+>))) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))

@@ -1,6 +1,7 @@ module Pandora.Paradigm.Controlflow.Joint (module Exports) where  import Pandora.Paradigm.Controlflow.Joint.Schemes as Exports+import Pandora.Paradigm.Controlflow.Joint.Schematic 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

@@ -1,148 +1,168 @@+{-# LANGUAGE UndecidableInstances #-}+ module Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (..)) where -import Pandora.Core.Morphism (identity, (.)) import Pandora.Core.Transformation (type (~>))+import Pandora.Pattern.Category (identity, (.)) import Pandora.Pattern.Functor.Covariant (Covariant) import Pandora.Pattern.Functor.Pointable (Pointable)-import Pandora.Paradigm.Controlflow.Joint.Transformer (Transformer (Schema, lay, wrap), (:>))+import Pandora.Pattern.Functor.Monad (Monad)+import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)+import Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic (Monadic (lay, wrap), (:>)) -class Adaptable eff schema where+class Covariant u => Adaptable t u where 	{-# MINIMAL adapt #-}-	adapt :: eff ~> schema+	adapt :: t ~> u -type Layable t u = (Transformer t, Covariant u)-type Wrappable t u = (Transformer t, Pointable u)+type Layable t u = (Monadic t, Covariant u)+type Wrappable t u = (Monadic t, Pointable u) -instance Adaptable t t where+instance Covariant t => Adaptable t t where 	adapt = identity -instance Layable t u => Adaptable u (t :> u) where+instance (Covariant (t :> u), Layable t u) => Adaptable u (t :> u) where 	adapt = lay -instance Wrappable t u => Adaptable t (t :> u) where+instance (Covariant (t :> u), Wrappable t u) => Adaptable t (t :> u) where 	adapt = wrap  instance-	( Layable t (Schema u v)+	( Covariant (t :> u :> v)+	, Layable t (Schematic Monad u v) 	, Wrappable u v 	) => Adaptable u (t :> u :> v) where 	adapt = lay . wrap  instance-	( Layable t (Schema u v)+	( Covariant (t :> u :> v)+	, Layable t (Schematic Monad 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)+	( Covariant (t :> u :> v :> w)+	, Layable t (Schematic Monad u (v :> w))+	, Layable u (Schematic Monad 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)+	( Covariant (t :> u :> v :> w)+	, Layable t (Schematic Monad u v)+	, Layable t (Schematic Monad u (v :> w))+	, Layable u (Schematic Monad 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)+instance+	( Covariant (t :> u :> v :> w :> x)+	, Layable t (Schematic Monad u (v :> w :> x))+	, Layable u (Schematic Monad v (w :> x))+	, Layable v (Schematic Monad 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)+instance+	( Covariant (t :> u :> v :> w :> x)+	, Layable t (Schematic Monad u (v :> w :> x))+	, Layable u (Schematic Monad v (w :> x))+	, Layable v (Schematic Monad 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)+	( Covariant (t :> u :> v :> w :> x :> y)+	, Layable t (Schematic Monad u (v :> w :> x :> y))+	, Layable u (Schematic Monad v (w :> x :> y))+	, Layable v (Schematic Monad w (x :> y))+	, Layable w (Schematic Monad 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)+	( Covariant (t :> u :> v :> w :> x :> y)+	, Layable t (Schematic Monad u (v :> w :> x :> y))+	, Layable u (Schematic Monad v (w :> x :> y))+	, Layable v (Schematic Monad w (x :> y))+	, Layable w (Schematic Monad 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)+	( Covariant (t :> u :> v :> w :> x :> y :> z)+	, Layable t (Schematic Monad u (v :> w :> x :> y :> z))+	, Layable u (Schematic Monad v (w :> x :> y :> z))+	, Layable v (Schematic Monad w (x :> y :> z))+	, Layable w (Schematic Monad x (y :> z))+	, Layable x (Schematic Monad 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)+	( Covariant (t :> u :> v :> w :> x :> y :> z)+	, Layable t (Schematic Monad u (v :> w :> x :> y :> z))+	, Layable u (Schematic Monad v (w :> x :> y :> z))+	, Layable v (Schematic Monad w (x :> y :> z))+	, Layable w (Schematic Monad x (y :> z))+	, Layable x (Schematic Monad 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)+	( Covariant (t :> u :> v :> w :> x :> y :> z :> f)+	, Layable t (Schematic Monad u (v :> w :> x :> y :> z :> f))+	, Layable u (Schematic Monad v (w :> x :> y :> z :> f))+	, Layable v (Schematic Monad w (x :> y :> z :> f))+	, Layable w (Schematic Monad x (y :> z :> f))+	, Layable x (Schematic Monad y (z :> f))+	, Layable y (Schematic Monad 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)+	( Covariant (t :> u :> v :> w :> x :> y :> z :> f)+	, Layable t (Schematic Monad u (v :> w :> x :> y :> z :> f))+	, Layable u (Schematic Monad v (w :> x :> y :> z :> f))+	, Layable v (Schematic Monad w (x :> y :> z :> f))+	, Layable w (Schematic Monad x (y :> z :> f))+	, Layable x (Schematic Monad y (z :> f))+	, Layable y (Schematic Monad 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)+	( Covariant (t :> u :> v :> w :> x :> y :> z :> f :> h)+	, Layable t (Schematic Monad u (v :> w :> x :> y :> z :> f :> h))+	, Layable u (Schematic Monad v (w :> x :> y :> z :> f :> h))+	, Layable v (Schematic Monad w (x :> y :> z :> f :> h))+	, Layable w (Schematic Monad x (y :> z :> f :> h))+	, Layable x (Schematic Monad y (z :> f :> h))+	, Layable y (Schematic Monad z (f :> h))+	, Layable z (Schematic Monad 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)+	( Covariant (t :> u :> v :> w :> x :> y :> z :> f :> h)+	, Layable t (Schematic Monad u (v :> w :> x :> y :> z :> f :> h))+	, Layable u (Schematic Monad v (w :> x :> y :> z :> f :> h))+	, Layable v (Schematic Monad w (x :> y :> z :> f :> h))+	, Layable w (Schematic Monad x (y :> z :> f :> h))+	, Layable x (Schematic Monad y (z :> f :> h))+	, Layable y (Schematic Monad z (f :> h))+	, Layable z (Schematic Monad 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

@@ -0,0 +1,3 @@+module Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic) where++type family Schematic (c :: (* -> *) -> k) (t :: * -> *) (u :: * -> *) = (r :: * -> *) | r -> t u

@@ -1,55 +1,10 @@-module Pandora.Paradigm.Controlflow.Joint.Transformer (Transformer (..), (:>) (..)) where--import Pandora.Core.Morphism ((.))-import Pandora.Core.Transformation (type (~>))-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 ~> t :> u-	wrap :: Pointable u => t ~> t :> u--infixr 3 :>-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+module Pandora.Paradigm.Controlflow.Joint.Transformer (module Exports, Transformer) where -instance Bindable (Schema t u) => Bindable (t :> u) where-	T x >>= f = T $ x >>= trans . f+import Pandora.Paradigm.Controlflow.Joint.Transformer.Comonadic as Exports+import Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic as Exports -instance Extendable (Schema t u) => Extendable (t :> u) where-	T x =>> f = T $ x =>> f . T+import Pandora.Pattern.Functor (Monad, Comonad) -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+type family Transformer c t where+	Transformer Monad t = Monadic t+	Transformer Comonad t = Comonadic t

@@ -0,0 +1,58 @@+{-# LANGUAGE UndecidableInstances #-}++module Pandora.Paradigm.Controlflow.Joint.Transformer.Comonadic (Comonadic (..), (:<) (..)) where++import Pandora.Core.Transformation (type (~>))+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))+import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)+import Pandora.Pattern.Category ((.))+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.Comonad (Comonad)+import Pandora.Pattern.Functor.Divariant (($))++class Interpreted t => Comonadic t where+	{-# MINIMAL flick, bring #-}+	flick :: Covariant u => t :< u ~> u+	bring :: Extractable u => t :< u ~> t++infixr 3 :<+newtype (:<) t u a = TC { tc :: Schematic Comonad t u a }++instance Covariant (Schematic Comonad t u) => Covariant (t :< u) where+	f <$> TC x = TC $ f <$> x++instance Pointable (Schematic Comonad t u) => Pointable (t :< u) where+	point = TC . point++instance Extractable (Schematic Comonad t u) => Extractable (t :< u) where+	extract = extract . tc++instance Applicative (Schematic Comonad t u) => Applicative (t :< u) where+	TC f <*> TC x = TC $ f <*> x++instance Alternative (Schematic Comonad t u) => Alternative (t :< u) where+	TC x <+> TC y = TC $ x <+> y++instance Traversable (Schematic Comonad t u) => Traversable (t :< u) where+	TC x ->> f = TC <$> x ->> f++instance Distributive (Schematic Comonad t u) => Distributive (t :< u) where+	x >>- f = TC $ x >>- tc . f++instance Bindable (Schematic Comonad t u) => Bindable (t :< u) where+	TC x >>= f = TC $ x >>= tc . f++instance Extendable (Schematic Comonad t u) => Extendable (t :< u) where+	TC x =>> f = TC $ x =>> f . TC++instance (Interpreted (Schematic Comonad t u)) => Interpreted (t :< u) where+	type Primary (t :< u) a = Primary (Schematic Comonad t u) a+	unwrap (TC x) = unwrap x

@@ -0,0 +1,58 @@+{-# LANGUAGE UndecidableInstances #-}++module Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic (Monadic (..), (:>) (..)) where++import Pandora.Core.Transformation (type (~>))+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))+import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)+import Pandora.Pattern.Category ((.))+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.Monad (Monad)+import Pandora.Pattern.Functor.Divariant (($))++class Interpreted t => Monadic t where+	{-# MINIMAL lay, wrap #-}+	lay :: Covariant u => u ~> t :> u+	wrap :: Pointable u => t ~> t :> u++infixr 3 :>+newtype (:>) t u a = TM { tm :: Schematic Monad t u a }++instance Covariant (Schematic Monad t u) => Covariant (t :> u) where+	f <$> TM x = TM $ f <$> x++instance Pointable (Schematic Monad t u) => Pointable (t :> u) where+	point = TM . point++instance Extractable (Schematic Monad t u) => Extractable (t :> u) where+	extract = extract . tm++instance Applicative (Schematic Monad t u) => Applicative (t :> u) where+	TM f <*> TM x = TM $ f <*> x++instance Alternative (Schematic Monad t u) => Alternative (t :> u) where+	TM x <+> TM y = TM $ x <+> y++instance Traversable (Schematic Monad t u) => Traversable (t :> u) where+	TM x ->> f = TM <$> x ->> f++instance Distributive (Schematic Monad t u) => Distributive (t :> u) where+	x >>- f = TM $ x >>- tm . f++instance Bindable (Schematic Monad t u) => Bindable (t :> u) where+	TM x >>= f = TM $ x >>= tm . f++instance Extendable (Schematic Monad t u) => Extendable (t :> u) where+	TM x =>> f = TM $ x =>> f . TM++instance (Interpreted (Schematic Monad t u)) => Interpreted (t :> u) where+	type Primary (t :> u) a = Primary (Schematic Monad t u) a+	unwrap (TM x) = unwrap x

@@ -1,7 +1,7 @@ module Pandora.Paradigm.Controlflow.Observable (Observable, observe, 	notify, follow, subscribe, watch, (.:~.), (.:~*), (*:~.), (*:~*)) where -import Pandora.Core.Morphism ((.))+import Pandora.Pattern.Category ((.)) import Pandora.Paradigm.Basis.Continuation (Continuation (Continuation, continue)) import Pandora.Pattern.Functor.Applicative (Applicative (forever)) import Pandora.Pattern.Functor.Divariant (($))

@@ -1,7 +1,7 @@ module Pandora.Paradigm.Inventory (module Exports) where  import Pandora.Paradigm.Inventory.Optics as Exports-import Pandora.Paradigm.Inventory.Storage as Exports+import Pandora.Paradigm.Inventory.Store as Exports import Pandora.Paradigm.Inventory.State as Exports import Pandora.Paradigm.Inventory.Environment as Exports import Pandora.Paradigm.Inventory.Accumulator as Exports

@@ -2,18 +2,19 @@  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.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))+import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic) import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt)) import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))+import Pandora.Pattern.Category ((.)) 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.Functor.Monad (Monad) import Pandora.Pattern.Object.Monoid (Monoid (zero)) import Pandora.Pattern.Object.Semigroup (Semigroup ((+))) @@ -33,29 +34,30 @@ 	Accumulator (e :*: x) >>= f = let (e' :*: b) = unwrap $ f x in 		Accumulator $ e + e':*: b +type instance Schematic Monad (Accumulator e) u = UT Covariant Covariant ((:*:) e) u+ 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+instance Monoid e => Monadic (Accumulator e) where+	lay x = TM . UT $ (zero :*:) <$> x+	wrap = TM . UT . point . unwrap  type Accumulated e t = Adaptable (Accumulator e) t -instance Covariant u => Covariant (UT 'Co 'Co ((:*:) e) u) where+instance Covariant u => Covariant (UT Covariant Covariant ((:*:) e) u) where 	f <$> UT x = UT $ f <$$> x -instance (Semigroup e, Applicative u) => Applicative (UT 'Co 'Co ((:*:) e) u) where+instance (Semigroup e, Applicative u) => Applicative (UT Covariant Covariant ((:*:) 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+instance (Pointable u, Monoid e) => Pointable (UT Covariant Covariant ((:*:) e) u) where 	point = UT . point . (zero :*:) -instance (Semigroup e, Pointable u, Bindable u) => Bindable (UT 'Co 'Co ((:*:) e) u) where+instance (Semigroup e, Pointable u, Bindable u) => Bindable (UT Covariant Covariant ((:*:) 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 :: Accumulated e t => e -> t () gather x = adapt . Accumulator $ x :*: ()

@@ -2,12 +2,13 @@  module Pandora.Paradigm.Inventory.Environment (Environment (..), Configured, env) where -import Pandora.Core.Functor (Variant (Co))-import Pandora.Core.Morphism (identity, (.), (!), (%))+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.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))+import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic) import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt)) import Pandora.Paradigm.Controlflow.Joint.Schemes.TU (TU (TU))+import Pandora.Pattern.Category (identity, (.)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>))) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))@@ -35,28 +36,29 @@  instance Monad (Environment e) where +type instance Schematic Monad (Environment e) u = TU Covariant Covariant ((->) e) u+ 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+instance Monadic (Environment e) where+	lay = TM . TU . (!)+	wrap x = TM. TU $ point <$> unwrap x  type Configured e = Adaptable (Environment e) -instance Covariant u => Covariant (TU 'Co 'Co ((->) e) u) where+instance Covariant u => Covariant (TU Covariant Covariant ((->) e) u) where 	f <$> TU x = TU $ \r -> f <$> x r -instance (Covariant u, Pointable u) => Pointable (TU 'Co 'Co ((->) e) u) where+instance (Covariant u, Pointable u) => Pointable (TU Covariant Covariant ((->) e) u) where 	point = TU . point . point -instance Applicative u => Applicative (TU 'Co 'Co ((->) e) u) where+instance Applicative u => Applicative (TU Covariant Covariant ((->) e) u) where 	TU f <*> TU x = TU $ \r -> f r <*> x r -instance Bindable u => Bindable (TU 'Co 'Co ((->) e) u) where+instance Bindable u => Bindable (TU Covariant Covariant ((->) e) u) where 	TU x >>= f = TU $ \e -> x e >>= ($ e) . unwrap . f -env :: (Covariant t, Configured e t) => t e+env :: Configured e t => t e env = adapt $ Environment identity

@@ -2,24 +2,25 @@  module Pandora.Paradigm.Inventory.Optics (Lens, type (:-.), (|>), view, set, over, (^.), (.~), (%~)) where -import Pandora.Core.Morphism ((.), (!), (%))+import Pandora.Core.Morphism ((!), (%)) import Pandora.Paradigm.Basis.Product (Product ((:*:))) 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.Paradigm.Inventory.Store (Store (Store), access, position, retrofit)+import Pandora.Pattern.Category ((.)) 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) (State s) where-	v -| f = State $ \s -> (:*:) s . f . Storage $ s :*: (v !)-	Storage (s :*: f) |- g = extract . unwrap % s . g $ f s+instance Adjoint (Store s) (State s) where+	v -| f = State $ \s -> (:*:) s . f . Store $ s :*: (v !)+	Store (s :*: f) |- g = extract . unwrap % s . g $ f s  infixr 0 :-. type (:-.) src tgt = Lens src tgt -type Lens src tgt = src -> Storage tgt src+type Lens src tgt = src -> Store tgt src  -- | Lens composition infix operator (|>) :: Lens src btw -> Lens btw tgt -> Lens src tgt

@@ -2,14 +2,9 @@  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.Core.Functor (type (:.), type (:=))+import Pandora.Core.Morphism ((%))+import Pandora.Pattern.Category ((.)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), ($>), (<$$>))) import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))@@ -21,6 +16,13 @@ import Pandora.Pattern.Functor.Monad (Monad) import Pandora.Pattern.Functor.Divariant (($)) import Pandora.Pattern.Object.Setoid (bool)+import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))+import Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))+import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)+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)  newtype State s a = State ((->) s :. (:*:) s := a) @@ -52,32 +54,34 @@ 	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 instance Schematic Monad (State s) u =+	TUV Covariant Covariant Covariant ((->) s) u ((:*:) s) +instance Monadic (State s) where+	lay x = TM . TUV $ \s -> (s :*:) <$> x+	wrap x = TM . TUV $ point <$> unwrap x+ type Stateful s = Adaptable (State s) -instance Covariant u => Covariant (TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)) where+instance Covariant u => Covariant (TUV Covariant Covariant Covariant ((->) s) u ((:*:) s)) where 	f <$> TUV x = TUV $ \old -> f <$$> x old -instance Bindable u => Applicative (TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)) where+instance Bindable u => Applicative (TUV Covariant Covariant Covariant ((->) 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+instance Pointable u => Pointable (TUV Covariant Covariant Covariant ((->) s) u ((:*:) s)) where 	point x = TUV $ \s -> point $ s :*: x -instance Bindable u => Bindable (TUV 'Co 'Co 'Co ((->) s) u ((:*:) s)) where+instance Bindable u => Bindable (TUV Covariant Covariant Covariant ((->) 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+instance Monad u => Monad (TUV Covariant Covariant Covariant ((->) s) u ((:*:) s)) where -current :: (Covariant t, Stateful s t) => t s+current :: Stateful s t => t s current = adapt $ State delta -modify :: (Covariant t, Stateful s t) => (s -> s) -> t ()+modify :: Stateful s t => (s -> s) -> t () modify f = adapt $ State $ \s -> f s :*: () -replace :: (Covariant t, Stateful s t) => s -> t ()+replace :: Stateful s t => s -> t () replace s = adapt $ State $ \_ -> s :*: ()

@@ -1,33 +0,0 @@-module Pandora.Paradigm.Inventory.Storage (Storage (..), position, access, retrofit) where--import Pandora.Core.Functor (type (:.), type (:=))-import Pandora.Core.Morphism ((.), (%))-import Pandora.Paradigm.Basis.Product (Product ((:*:)), type (:*:))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))-import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))-import Pandora.Pattern.Functor.Comonad (Comonad)-import Pandora.Pattern.Functor.Divariant (($))--newtype Storage p a = Storage { stored :: (:*:) p :. (->) p := a }--instance Covariant (Storage p) where-	g <$> Storage (p :*: f) = Storage . (:*:) p $ (g .) f--instance Extractable (Storage p) where-	extract (Storage (p :*: f)) = f p--instance Extendable (Storage p) where-	Storage (old :*: f) =>> g = Storage . (:*:) old-		$ \new -> g . Storage $ new :*: f--instance Comonad (Storage p) where--position :: Storage p a -> p-position (Storage (p :*: _)) = p--access :: p -> Storage p a -> a-access p = extract % p . stored--retrofit :: (p -> p) -> Storage p a -> Storage p a-retrofit g (Storage (p :*: f)) = Storage $ g p :*: f

@@ -0,0 +1,61 @@+{-# OPTIONS_GHC -fno-warn-orphans #-}++module Pandora.Paradigm.Inventory.Store (Store (..), position, access, retrofit) where++import Pandora.Core.Functor (type (:.), type (:=), type (<-|))+import Pandora.Core.Morphism ((%))+import Pandora.Core.Transformation (type (~>))+import Pandora.Pattern.Category ((.))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))+import Pandora.Pattern.Functor.Extractable (Extractable (extract))+import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))+import Pandora.Pattern.Functor.Comonad (Comonad)+import Pandora.Pattern.Functor.Divariant (($))+import Pandora.Paradigm.Basis.Product (Product ((:*:)), type (:*:))+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))+import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)+import Pandora.Paradigm.Controlflow.Joint.Schemes.TUV (TUV (TUV))+import Pandora.Paradigm.Controlflow.Joint.Transformer.Comonadic (Comonadic (flick, bring), (:<) (TC))++newtype Store p a = Store ((:*:) p :. (->) p := a)++instance Covariant (Store p) where+	f <$> Store (p :*: x) = Store . (:*:) p $ f <$> x++instance Extractable (Store p) where+	extract (Store (p :*: f)) = f p++instance Extendable (Store p) where+	Store (old :*: x) =>> f = Store . (:*:) old+		$ \new -> f <$> Store $ new :*: x++instance Comonad (Store p) where++instance Interpreted (Store p) where+	type Primary (Store p) a = (:*:) p :. (->) p := a+	unwrap (Store x) = x++type instance Schematic Comonad (Store p) u =+	TUV Covariant Covariant Covariant ((:*:) p) u ((->) p)++instance Comonadic (Store p) where+	flick (TC (TUV (p :*: f))) = ($ p) <$> f+	bring (TC (TUV (p :*: f))) = Store $ p :*: extract f++instance Covariant u => Covariant (TUV Covariant Covariant Covariant ((:*:) p) u ((->) p)) where+	f <$> TUV (p :*: x) = TUV . (:*:) p $ f <$$> x++instance Extractable u => Extractable (TUV Covariant Covariant Covariant ((:*:) p) u ((->) p)) where+	extract (TUV (p :*: x)) = extract x p++instance Extendable u => Extendable (TUV Covariant Covariant Covariant ((:*:) p) u ((->) p)) where+	TUV (old :*: x) =>> f = TUV . (:*:) old $ x =>> (\x' new -> f . TUV . (:*:) new $ x')++position :: Store p a -> p+position (Store (p :*: _)) = p++access :: p -> a <-| Store p+access p = extract % p . unwrap++retrofit :: (p -> p) -> Store p ~> Store p+retrofit g (Store (p :*: f)) = Store $ g p :*: f

@@ -2,13 +2,19 @@  import Pandora.Core.Morphism ((&)) import Pandora.Paradigm.Basis.Wye (Wye (End, Left, Right, Both))-import Pandora.Paradigm.Basis.Twister (Twister ((:<)))+import Pandora.Paradigm.Basis.Twister (Twister (Twister))+import Pandora.Pattern.Category ((.))+import Pandora.Pattern.Functor.Divariant (($)) import Pandora.Pattern.Object.Chain (Chain ((<=>)), order)  type Binary = Twister Wye  insert :: Chain a => a -> Binary a -> Binary a-insert x (y :< End) = x <=> y & order (y :< Right (x :< End)) (y :< Right (x :< End)) (y :< Left (x :< End))-insert x (y :< Left ls) = x <=> y & order (y :< Both ls (x :< End)) (y :< Both ls (x :< End)) (y :< Left (insert x ls))-insert x (y :< Right rs) = x <=> y & order (y :< Right (insert x rs)) (y :< Right (insert x rs)) (y :< Both (x :< End) rs)-insert x (y :< Both ls rs) = x <=> y & order (y :< Both ls (insert x rs)) (y :< Both ls (insert x rs)) (y :< Both (insert x ls) rs)+insert x (Twister y End) = x <=> y & order (Twister y . Right $ Twister x End)+	(Twister y . Right $ Twister x End) (Twister y . Left $ Twister x End)+insert x (Twister y (Left ls)) = x <=> y & order (Twister y . Both ls $ Twister x End)+	(Twister y $ Both ls $ Twister x End) (Twister y . Left $ insert x ls)+insert x (Twister y (Right rs)) = x <=> y & order (Twister y . Right $ insert x rs)+	(Twister y $ Right (insert x rs)) (Twister y $ Both (Twister x End) rs)+insert x (Twister y (Both ls rs)) = x <=> y & order (Twister y . Both ls $ insert x rs)+	(Twister y . Both ls $ insert x rs) (Twister y $ Both (insert x ls) rs)

@@ -1,29 +1,26 @@+{-# OPTIONS_GHC -fno-warn-orphans #-}+ module Pandora.Paradigm.Structure.Specific.Graph (Graph, loose) where -import Pandora.Core.Functor (type (:.), type (:=)) import Pandora.Core.Transformation (type (~>))-import Pandora.Core.Morphism ((.))-import Pandora.Paradigm.Basis.Edges (Edges (Empty, Overlay))-import Pandora.Paradigm.Basis.Twister (Twister ((:<)))-import Pandora.Paradigm.Inventory.State (fold)+import Pandora.Pattern.Category ((.)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>))) import Pandora.Pattern.Functor.Divariant (($)) import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))---- | Acyclic graph structure without loops-newtype Graph a = Graph (Edges :. Twister Edges := a)+import Pandora.Paradigm.Basis.Edges (Edges (Empty, Overlay))+import Pandora.Paradigm.Basis.Twister (Twister (Twister))+import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))+import Pandora.Paradigm.Inventory.State (fold) -instance Covariant Graph where-	f <$> Graph stack = Graph $ f <$$> stack+-- | Directed acyclic graph structure+type Graph = UT Covariant Covariant (Twister Edges) Edges -instance Traversable Graph where-	Graph stack ->> f = Graph <$> stack ->>> f+instance Covariant (UT Covariant Covariant (Twister Edges) Edges) where+	f <$> UT g = UT $ f <$$> g -instance Interpreted Graph where-	type Primary Graph a = Edges :. Twister Edges := a-	unwrap (Graph stack) = stack+instance Traversable (UT Covariant Covariant (Twister Edges) Edges) where+	UT g ->> f = UT <$> g ->>> f  -- | Transform any traversable structure into all loose edges graph loose :: Traversable t => t ~> Graph-loose = Graph . fold Empty (\x -> Overlay . (:<) x)+loose = UT . fold Empty (\x -> Overlay . Twister x)

@@ -1,13 +1,14 @@+{-# OPTIONS_GHC -fno-warn-orphans #-}+ module Pandora.Paradigm.Structure.Specific.Stack (Stack, push, top, pop, filter, linearize) where -import Pandora.Core.Functor (type (:.), type (:=))-import Pandora.Core.Morphism ((.)) import Pandora.Core.Transformation (type (~>)) 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.Basis.Twister (Twister (Twister), untwist) import Pandora.Paradigm.Inventory.State (fold)-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))+import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))+import Pandora.Pattern.Category ((.)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>))) import Pandora.Pattern.Functor.Alternative (Alternative ((<+>))) import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))@@ -20,43 +21,39 @@ import Pandora.Pattern.Object.Setoid ((?))  -- | Linear data structure that serves as a collection of elements-newtype Stack a = Stack (Maybe :. Twister Maybe := a)--instance Covariant Stack where-	f <$> Stack stack = Stack $ f <$$> stack+type Stack = UT Covariant Covariant (Twister Maybe) Maybe -instance Pointable Stack where-	point x = Stack . Just $ x :< Nothing+instance Covariant (UT Covariant Covariant (Twister Maybe) Maybe) where+	f <$> UT stack = UT $ f <$$> stack -instance Alternative Stack where-	Stack stack <+> Stack stack' = Stack $ stack <+> stack'+instance Pointable (UT Covariant Covariant (Twister Maybe) Maybe) where+	point = UT . Just . point -instance Avoidable Stack where-	empty = Stack Nothing+instance Alternative (UT Covariant Covariant (Twister Maybe) Maybe) where+	UT x <+> UT y = UT $ x <+> y -instance Applicative Stack where-	Stack f <*> Stack x = Stack $ f <**> x+instance Avoidable (UT Covariant Covariant (Twister Maybe) Maybe) where+	empty = UT Nothing -instance Traversable Stack where-	Stack stack ->> f = Stack <$> stack ->>> f+instance Applicative (UT Covariant Covariant (Twister Maybe) Maybe) where+	UT f <*> UT x = UT $ f <**> x -instance Interpreted Stack where-	type Primary Stack a = Maybe :. Twister Maybe := a-	unwrap (Stack stack) = stack+instance Traversable (UT Covariant Covariant (Twister Maybe) Maybe) where+	UT stack ->> f = UT <$> stack ->>> f  push :: a -> Stack a -> Stack a-push x (Stack stack) = Stack $ ((:<) x . Just <$> stack) <+> (point . point) x+push x (UT stack) = UT $ (Twister x . Just <$> stack) <+> (point . point) x  top :: Stack ~> Maybe-top (Stack stack) = extract <$> stack+top (UT stack) = extract <$> stack  pop :: Stack ~> Stack-pop (Stack stack) = Stack $ stack >>= untwist+pop (UT stack) = UT $ stack >>= untwist  filter :: Predicate a -> Stack a -> Stack a-filter (Predicate p) = Stack . fold empty-	(\now new -> p now ? Just (now :< new) $ new)+filter (Predicate p) = UT . fold empty+	(\now new -> p now ? Just (Twister now new) $ new)  -- | Transform any traversable structure into a stack linearize :: Traversable t => t ~> Stack-linearize = Stack . fold Nothing (\x -> Just . (:<) x)+linearize = UT . fold Nothing (\x -> Just . Twister x)

@@ -1,5 +1,5 @@ module Pandora.Pattern (module Exports) where  import Pandora.Pattern.Object as Exports-import Pandora.Paradigm.Controlflow.Joint as Exports import Pandora.Pattern.Functor as Exports+import Pandora.Pattern.Category as Exports

@@ -0,0 +1,11 @@+module Pandora.Pattern.Category (Category (..)) where++infixr 8 .++class Category (m :: * -> * -> *) where+	identity :: m a a+	(.) :: m b c -> m a b -> m a c++instance Category (->) where+	identity x = x+	f . g = \x -> f (g x)

@@ -1,7 +1,7 @@ module Pandora.Pattern.Functor.Adjoint (Adjoint (..), type (-|)) where  import Pandora.Core.Functor (type (:.), type (:=))-import Pandora.Core.Morphism (identity)+import Pandora.Pattern.Category (identity) import Pandora.Pattern.Functor.Covariant (Covariant)  type (-|) = Adjoint

@@ -1,7 +1,7 @@ module Pandora.Pattern.Functor.Applicative (Applicative (..)) where  import Pandora.Core.Functor (type (:.), type (:=))-import Pandora.Core.Morphism (identity)+import Pandora.Pattern.Category (identity) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$)))  infixl 4 <*>, <*, *>

@@ -1,7 +1,8 @@ module Pandora.Pattern.Functor.Bindable (Bindable (..)) where  import Pandora.Core.Functor (type (:.), type (:=))-import Pandora.Core.Morphism ((%), identity)+import Pandora.Core.Morphism ((%))+import Pandora.Pattern.Category (identity) import Pandora.Pattern.Functor.Covariant (Covariant)  infixl 1 >>=

@@ -1,7 +1,8 @@ module Pandora.Pattern.Functor.Contravariant (Contravariant (..)) where  import Pandora.Core.Functor (type (:.), type (:=))-import Pandora.Core.Morphism ((.), (!), (%))+import Pandora.Core.Morphism ((!), (%))+import Pandora.Pattern.Category ((.))  infixl 4 >$<, $<, >$ 

@@ -1,7 +1,8 @@ module Pandora.Pattern.Functor.Covariant (Covariant (..)) where  import Pandora.Core.Functor (type (:.), type (:=), type (<-|))-import Pandora.Core.Morphism (fix, (.), (!), (%))+import Pandora.Core.Morphism (fix, (!), (%))+import Pandora.Pattern.Category ((.))  infixl 4 <$>, <$, $> 

@@ -1,9 +1,9 @@ module Pandora.Pattern.Functor.Distributive (Distributive (..)) where  import Pandora.Core.Functor (type (:.), type (:=))-import Pandora.Core.Morphism (identity, (.), (%))+import Pandora.Core.Morphism ((%)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))-+import Pandora.Pattern.Category (identity, (.)) {- | > Let f :: Distributive g => (a -> g b) 

@@ -1,8 +1,6 @@ module Pandora.Pattern.Functor.Divariant (Divariant (..)) where -import Pandora.Pattern.Functor.Covariant (Covariant)--import Pandora.Core.Morphism ((.))+import Pandora.Pattern.Category ((.))  infixl 4 >-> infixr 0 $@@ -13,16 +11,14 @@ > * Interpreted: dimap (f . g) (h . i) ≡ dimap g h . dimap f i -} -class (forall a . Covariant (t a)) => Divariant (t :: * -> * -> *) where+class Divariant (v :: * -> * -> *) where 	{-# MINIMAL (>->) #-}-	-- | Infix version of 'comap'-	(>->) :: (a -> b) -> (c -> d) -> t b c -> t a d-+	(>->) :: v a b -> v c d -> v b c -> v a d 	-- | Prefix version of '>->'-	dimap :: (a -> b) -> (c -> d) -> t b c -> t a d-	dimap f g x = (f >-> g) x--	($) :: t a b -> t a b+	dimap :: v a b -> v c d -> v b c -> v a d+	dimap f g x = f >-> g $ x+	-- Generalized function application+	($) :: v a b -> v a b 	($) f = f  instance Divariant ((->)) where

@@ -1,7 +1,8 @@ module Pandora.Pattern.Functor.Extendable (Extendable (..)) where  import Pandora.Core.Functor (type (:.), type (:=))-import Pandora.Core.Morphism ((.), (%), identity)+import Pandora.Core.Morphism ((%))+import Pandora.Pattern.Category (identity, (.)) import Pandora.Pattern.Functor.Covariant (Covariant)  infixl 1 =>>

@@ -1,7 +1,8 @@ module Pandora.Pattern.Functor.Representable (Representable (..)) where  import Pandora.Core.Functor (type (<-|))-import Pandora.Core.Morphism (identity, (%))+import Pandora.Core.Morphism ((%))+import Pandora.Pattern.Category (identity) import Pandora.Pattern.Functor.Pointable (Pointable)  {- |

@@ -1,7 +1,7 @@ module Pandora.Pattern.Functor.Traversable (Traversable (..)) where  import Pandora.Core.Functor (type (:.), type (:=))-import Pandora.Core.Morphism (identity, (.))+import Pandora.Pattern.Category (identity, (.)) import Pandora.Pattern.Functor.Covariant (Covariant) import Pandora.Pattern.Functor.Applicative (Applicative) import Pandora.Pattern.Functor.Pointable (Pointable)

@@ -1,5 +1,5 @@ name:                pandora-version:             0.2.2+version:             0.2.3 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,9 @@     Pandora.Paradigm.Controlflow.Joint     Pandora.Paradigm.Controlflow.Joint.Interpreted     Pandora.Paradigm.Controlflow.Joint.Transformer+    Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic+    Pandora.Paradigm.Controlflow.Joint.Transformer.Comonadic+    Pandora.Paradigm.Controlflow.Joint.Schematic     Pandora.Paradigm.Controlflow.Joint.Adaptable     Pandora.Paradigm.Controlflow.Joint.Schemes     Pandora.Paradigm.Controlflow.Joint.Schemes.TU@@ -70,7 +73,7 @@     Pandora.Paradigm.Inventory.Environment     Pandora.Paradigm.Inventory.Optics     Pandora.Paradigm.Inventory.State-    Pandora.Paradigm.Inventory.Storage+    Pandora.Paradigm.Inventory.Store     -- Tree-based datastructures     Pandora.Paradigm.Structure     Pandora.Paradigm.Structure.Cartesian@@ -81,6 +84,8 @@     Pandora.Paradigm.Structure.Specific.Binary      Pandora.Pattern+    -- Category typeclass+    Pandora.Pattern.Category     -- Functor typeclassess     Pandora.Pattern.Functor     Pandora.Pattern.Functor.Adjoint@@ -119,6 +124,5 @@     FlexibleContexts, FlexibleInstances, KindSignatures, LiberalTypeSynonyms     MultiParamTypeClasses, NoImplicitPrelude, PackageImports, PolyKinds, RankNTypes     ScopedTypeVariables, TypeApplications, TypeFamilies, TypeFamilyDependencies, TypeOperators-    UndecidableInstances   default-language: Haskell2010   ghc-options: -Wall -fno-warn-tabs