pandora 0.2.3 → 0.2.4

raw patch · 41 files changed

+490/−110 lines, 41 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• CHANGELOG.md +15/−0
• Pandora/Core.hs +0/−1
• Pandora/Core/Functor.hs +4/−1
• Pandora/Core/Transformation.hs +0/−9
• Pandora/Paradigm/Basis.hs +1/−1
• Pandora/Paradigm/Basis/Conclusion.hs +8/−4
• Pandora/Paradigm/Basis/Constant.hs +4/−0
• Pandora/Paradigm/Basis/Fix.hs +14/−1
• Pandora/Paradigm/Basis/Jet.hs +1/−1
• Pandora/Paradigm/Basis/Maybe.hs +3/−3
• Pandora/Paradigm/Basis/Product.hs +5/−1
• Pandora/Paradigm/Basis/Tagged.hs +4/−0
• Pandora/Paradigm/Basis/Twister.hs +1/−2
• Pandora/Paradigm/Basis/Validation.hs +29/−1
• Pandora/Paradigm/Controlflow.hs +1/−0
• Pandora/Paradigm/Controlflow/Joint/Adaptable.hs +154/−2
• Pandora/Paradigm/Controlflow/Joint/Interpreted.hs +2/−2
• Pandora/Paradigm/Controlflow/Joint/Schemes/TU.hs +2/−2
• Pandora/Paradigm/Controlflow/Joint/Schemes/TUV.hs +2/−2
• Pandora/Paradigm/Controlflow/Joint/Schemes/TUVW.hs +2/−2
• Pandora/Paradigm/Controlflow/Joint/Schemes/UT.hs +2/−2
• Pandora/Paradigm/Controlflow/Joint/Schemes/UTU.hs +2/−2
• Pandora/Paradigm/Controlflow/Joint/Transformer/Comonadic.hs +3/−3
• Pandora/Paradigm/Controlflow/Joint/Transformer/Monadic.hs +3/−3
• Pandora/Paradigm/Inventory.hs +2/−0
• Pandora/Paradigm/Inventory/Accumulator.hs +6/−6
• Pandora/Paradigm/Inventory/Environment.hs +13/−13
• Pandora/Paradigm/Inventory/Equipment.hs +48/−0
• Pandora/Paradigm/Inventory/Imprint.hs +57/−0
• Pandora/Paradigm/Inventory/Optics.hs +12/−6
• Pandora/Paradigm/Inventory/State.hs +6/−6
• Pandora/Paradigm/Inventory/Store.hs +12/−10
• Pandora/Paradigm/Structure/Nonempty.hs +3/−0
• Pandora/Paradigm/Structure/Specific/Graph.hs +3/−3
• Pandora/Paradigm/Structure/Specific/Stack.hs +36/−16
• Pandora/Pattern/Functor.hs +1/−0
• Pandora/Pattern/Functor/Bivariant.hs +18/−0
• Pandora/Pattern/Functor/Extractable.hs +4/−0
• Pandora/Pattern/Functor/Liftable.hs +1/−1
• Pandora/Pattern/Functor/Lowerable.hs +1/−1
• pandora.cabal +5/−3

@@ -154,3 +154,18 @@ * Add `Covariant` constraint on schema parameter in `Adaptable` type class * Rename `Storage` type to `Store` * Define `Interpreted`, `Schematic` and `Comonadic` instances for `Store` type++# 0.2.4+* Remove `Pandora.Core.Transformation` module and move `~>` to `Functor` module+* Define `Adaptable` instances for comonad transformer schemes+* Make `position` and `access` methods of `Store` adaptable+* Rename `unwrap` method of `Interpreted` type class to `run`+* Define `Bivariant` functor type class+* Define `zoom` optical operator - apply lens within some part of `State`+* Make `top` method of `Stack` data structure a lens+* Make `zoom` method of `Optics` adaptable for bigger state+* Define `Traced` for adaptable `Environment` comonad+* Define `cata`, `ana` and `hylo` methods of `Fix`+* Define `Equipment` datatype to use `Comonad` `Product` transformer+* Define adaptable `retrieve` method of `Equipment`+* Extract `Imprint` from `Environment` module

@@ -1,5 +1,4 @@ module Pandora.Core (module Exports) where -import Pandora.Core.Transformation as Exports import Pandora.Core.Morphism as Exports import Pandora.Core.Functor as Exports

@@ -1,6 +1,6 @@ module Pandora.Core.Functor where -infixr 0 :=, <-|, |->+infixr 0 :=, <-|, |->, ~> infixr 1 .:, :. infixr 2 ::|:., ::|.:, ::|:: @@ -18,6 +18,9 @@  -- | Algebra's type operator type (<-|) a t = t a -> a++-- | Natural transformation+type (~>) t u = forall a . t a -> u a  type (::|:.) p a b = p (p a b) b type (::|.:) p a b = p a (p a b)

@@ -1,9 +0,0 @@-module Pandora.Core.Transformation (Natural, type (~>)) where--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

@@ -22,7 +22,7 @@ import Pandora.Paradigm.Basis.Identity as Exports  import Pandora.Core.Morphism ((!))-import Pandora.Core.Transformation (type (~>))+import Pandora.Core.Functor (type (~>))  note :: e -> Maybe ~> Conclusion e note x = maybe (Failure x) Success

@@ -1,8 +1,8 @@ module Pandora.Paradigm.Basis.Conclusion (Conclusion (..), Failable, conclusion, fail, failure) where -import Pandora.Core.Transformation (type (~>))+import Pandora.Core.Functor (type (~>)) import Pandora.Pattern.Category ((.))-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run)) 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))@@ -14,6 +14,7 @@ import Pandora.Pattern.Functor.Traversable (Traversable ((->>))) import Pandora.Pattern.Functor.Bindable (Bindable ((>>=))) import Pandora.Pattern.Functor.Monad (Monad)+import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->))) import Pandora.Pattern.Functor.Divariant (($)) import Pandora.Pattern.Object.Setoid (Setoid ((==)), Boolean (False)) import Pandora.Pattern.Object.Chain (Chain ((<=>)), Ordering (Less, Greater))@@ -46,6 +47,9 @@  instance Monad (Conclusion e) where +instance Bivariant Conclusion where+    f <-> g = conclusion (Failure . f) (Success . g)+ instance (Setoid e, Setoid a) => Setoid (Conclusion e a) where 	Success x == Success y = x == y 	Failure x == Failure y = x == y@@ -73,7 +77,7 @@  instance Interpreted (Conclusion e) where 	type Primary (Conclusion e) a = Conclusion e a-	unwrap x = x+	run x = x  type instance Schematic Monad (Conclusion e) u = UT Covariant Covariant (Conclusion e) u @@ -93,7 +97,7 @@ 	point = UT . point . point  instance (Pointable u, Bindable u) => Bindable (UT Covariant Covariant (Conclusion e) u) where-	UT x >>= f = UT $ x >>= conclusion (point . Failure) (unwrap . f)+	UT x >>= f = UT $ x >>= conclusion (point . Failure) (run . f)  instance Monad u => Monad (UT Covariant Covariant (Conclusion e) u) where 

@@ -5,6 +5,7 @@ import Pandora.Pattern.Functor.Invariant (Invariant (invmap)) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))+import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->))) import Pandora.Pattern.Functor.Divariant (($)) import Pandora.Pattern.Object.Setoid (Setoid ((==))) import Pandora.Pattern.Object.Chain (Chain ((<=>)))@@ -28,6 +29,9 @@  instance Traversable (Constant a) where 	Constant x ->> _ = point (Constant x)++instance Bivariant Constant where+	f <-> _ = \(Constant x) -> Constant $ f x  instance Setoid a => Setoid (Constant a b) where 	Constant x == Constant y = x == y

@@ -1,3 +1,16 @@-module Pandora.Paradigm.Basis.Fix (Fix (..)) where+module Pandora.Paradigm.Basis.Fix (Fix (..), cata, ana, hylo) where +import Pandora.Core.Functor (type (<-|), type (|->))+import Pandora.Pattern.Category ((.))+import Pandora.Pattern.Functor.Covariant (Covariant (comap))+ newtype Fix t = Fix { unfix :: t (Fix t) }++cata :: Covariant t => (a <-| t) -> Fix t -> a+cata f = f . comap (cata f) . unfix++ana :: Covariant t => (a |-> t) -> a -> Fix t+ana f = Fix . comap (ana f) . f++hylo :: Covariant t => (b <-| t) -> (a |-> t) -> (a -> b)+hylo phi psi = cata phi . ana psi

@@ -17,7 +17,7 @@ instance Traversable t => Traversable (Jet t) where 	a :- as ->> f = (:-) <$> f a <*> as ->>> f -instance (forall t' . Avoidable t') => Pointable (Jet t) where+instance (forall u . Avoidable u) => Pointable (Jet t) where 	point x = x :- empty  instance Covariant t => Extractable (Jet t) where

@@ -1,6 +1,6 @@ module Pandora.Paradigm.Basis.Maybe (Maybe (..), Optional, maybe, nothing) where -import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run)) 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))@@ -91,7 +91,7 @@  instance Interpreted Maybe where 	type Primary Maybe a = Maybe a-	unwrap x = x+	run x = x  instance Monadic Maybe where 	lay x = TM . UT $ Just <$> x@@ -109,7 +109,7 @@ 	point = UT . point . point  instance (Pointable u, Bindable u) => Bindable (UT Covariant Covariant Maybe u) where-	UT x >>= f = UT $ x >>= maybe (point Nothing) (unwrap . f)+	UT x >>= f = UT $ x >>= maybe (point Nothing) (run . f)  instance Monad u => Monad (UT Covariant Covariant Maybe u) where 

@@ -7,6 +7,8 @@ import Pandora.Pattern.Functor.Extendable (Extendable ((=>>))) import Pandora.Pattern.Functor.Comonad (Comonad) import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))+import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))+import Pandora.Pattern.Functor.Divariant (($)) import Pandora.Pattern.Object.Setoid (Setoid ((==)), (&&)) import Pandora.Pattern.Object.Semigroup (Semigroup ((+))) import Pandora.Pattern.Object.Monoid (Monoid (zero))@@ -14,7 +16,6 @@ import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/))) import Pandora.Pattern.Object.Lattice (Lattice) import Pandora.Pattern.Object.Group (Group (inverse))-import Pandora.Pattern.Functor.Divariant (($))  infixr 1 :*: @@ -39,6 +40,9 @@ instance Adjoint (Product a) ((->) a) where 	x -| f = \y -> f $ y :*: x 	(y :*: x) |- f = f x y++instance Bivariant Product where+	f <-> g = \(x :*: y) -> f x :*: g y  instance (Setoid a, Setoid b) => Setoid (Product a b) where 	(x :*: y) == (x' :*: y') = x == x' && y == y'

@@ -11,6 +11,7 @@ import Pandora.Pattern.Functor.Extendable (Extendable ((=>>))) import Pandora.Pattern.Functor.Monad (Monad) import Pandora.Pattern.Functor.Comonad (Comonad)+import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->))) import Pandora.Pattern.Functor.Divariant (($)) import Pandora.Pattern.Object.Setoid (Setoid ((==))) import Pandora.Pattern.Object.Chain (Chain ((<=>)))@@ -53,6 +54,9 @@ 	x =>> f = Tag . f $ x  instance Comonad (Tagged tag)++instance Bivariant Tagged where+	_ <-> g = \(Tag x) -> Tag $ g x  instance Setoid a => Setoid (Tagged tag a) where 	Tag x == Tag y = x == y

@@ -1,7 +1,6 @@ module Pandora.Paradigm.Basis.Twister (Twister (..), untwist, coiterate, section) where -import Pandora.Core.Functor (type (:.), type (:=), type (|->))-import Pandora.Core.Transformation (type (~>))+import Pandora.Core.Functor (type (:.), type (:=), type (|->), type (~>)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>))) import Pandora.Pattern.Functor.Avoidable (Avoidable (empty)) import Pandora.Pattern.Functor.Pointable (Pointable (point))

@@ -1,11 +1,15 @@ module Pandora.Paradigm.Basis.Validation (Validation (..)) where +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.Alternative (Alternative ((<+>))) import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))+import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->))) import Pandora.Pattern.Functor.Divariant (($))+import Pandora.Pattern.Object.Setoid (Setoid ((==)), Boolean (False))+import Pandora.Pattern.Object.Chain (Chain ((<=>)), Ordering (Less, Greater)) import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))  data Validation e a = Flaws e | Validated a@@ -20,7 +24,7 @@ instance Semigroup e => Applicative (Validation e) where 	Flaws e <*> Flaws e' = Flaws $ e + e' 	Flaws e <*> Validated _ = Flaws e-	Validated _ <*> Flaws e2 = Flaws e2+	Validated _ <*> Flaws e' = Flaws e' 	Validated f <*> Validated x = Validated $ f x  instance Alternative (Validation e) where@@ -30,3 +34,27 @@ instance Traversable (Validation e) where 	Validated x ->> f = Validated <$> f x 	Flaws e ->> _ = point $ Flaws e++instance Bivariant Validation where+    f <-> g = validation (Flaws . f) (Validated . g)++instance (Setoid e, Setoid a) => Setoid (Validation e a) where+	Validated x == Validated y = x == y+	Flaws x == Flaws y = x == y+	_ == _ = False++instance (Chain e, Chain a) => Chain (Validation e a) where+	Validated x <=> Validated y = x <=> y+	Flaws x <=> Flaws y = x <=> y+	Flaws _ <=> Validated _ = Less+	Validated _ <=> Flaws _ = Greater++instance (Semigroup e, Semigroup a) => Semigroup (Validation e a) where+	Validated x + Validated y = Validated $ x + y+	Flaws x + Flaws y = Flaws $ x + y+	Flaws _ + Validated y = Validated y+	Validated x + Flaws _ = Validated x++validation :: (e -> r) -> (a -> r) -> Validation e a -> r+validation f _ (Flaws x) = f x+validation _ s (Validated x) = s x

@@ -2,3 +2,4 @@  import Pandora.Paradigm.Controlflow.Pipeline as Exports import Pandora.Paradigm.Controlflow.Observable as Exports+import Pandora.Paradigm.Controlflow.Joint as Exports

@@ -2,20 +2,25 @@  module Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (..)) where -import Pandora.Core.Transformation (type (~>))+import Pandora.Core.Functor (type (~>)) import Pandora.Pattern.Category (identity, (.)) import Pandora.Pattern.Functor.Covariant (Covariant) import Pandora.Pattern.Functor.Pointable (Pointable)+import Pandora.Pattern.Functor.Extractable (Extractable)+import Pandora.Pattern.Functor.Comonad (Comonad) import Pandora.Pattern.Functor.Monad (Monad) import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic) import Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic (Monadic (lay, wrap), (:>))+import Pandora.Paradigm.Controlflow.Joint.Transformer.Comonadic (Comonadic (flick, bring), (:<)) -class Covariant u => Adaptable t u where+class Adaptable t u where 	{-# MINIMAL adapt #-} 	adapt :: t ~> u  type Layable t u = (Monadic t, Covariant u) type Wrappable t u = (Monadic t, Pointable u)+type Flickable t u = (Comonadic t, Covariant u)+type Bringable t u = (Comonadic t, Extractable u)  instance Covariant t => Adaptable t t where 	adapt = identity@@ -26,6 +31,12 @@ instance (Covariant (t :> u), Wrappable t u) => Adaptable t (t :> u) where 	adapt = wrap +instance (Covariant (t :> u), Flickable t u) => Adaptable (t :< u) u where+	adapt = flick++instance (Covariant (t :< u), Bringable t u) => Adaptable (t :< u) t where+	adapt = bring+ instance 	( Covariant (t :> u :> v) 	, Layable t (Schematic Monad u v)@@ -41,6 +52,20 @@ 	adapt = lay . lay  instance+	( Covariant (t :< u :< v)+	, Flickable t (Schematic Comonad u v)+	, Bringable u v+	) => Adaptable (t :< u :< v) u where+	adapt = bring . flick++instance+	( Covariant (t :< u :< v)+	, Flickable t (Schematic Comonad u v)+	, Flickable u v+	) => Adaptable (t :< u :< v) v where+	adapt = flick . flick++instance 	( Covariant (t :> u :> v :> w) 	, Layable t (Schematic Monad u (v :> w)) 	, Layable u (Schematic Monad v w)@@ -58,6 +83,23 @@ 	adapt = lay . lay . lay  instance+	( Covariant (t :< u :< v :< w)+	, Flickable t (Schematic Comonad u (v :< w))+	, Flickable u (Schematic Comonad v w)+	, Bringable v w+	) => Adaptable (t :< u :< v :< w) v where+	adapt = bring . flick . flick++instance+	( Covariant (t :< u :< v :< w)+	, Flickable t (Schematic Comonad u v)+	, Flickable t (Schematic Comonad u (v :< w))+	, Flickable u (Schematic Comonad v w)+	, Flickable v w+	) => Adaptable (t :< u :< v :< w) w where+	adapt = flick . flick . flick++instance 	( Covariant (t :> u :> v :> w :> x) 	, Layable t (Schematic Monad u (v :> w :> x)) 	, Layable u (Schematic Monad v (w :> x))@@ -76,6 +118,24 @@ 	adapt = lay . lay . lay . wrap  instance+	( Covariant (t :< u :< v :< w :< x)+	, Flickable t (Schematic Comonad u (v :< w :< x))+	, Flickable u (Schematic Comonad v (w :< x))+	, Flickable v (Schematic Comonad w x)+	, Flickable w x+	) => Adaptable (t :< u :< v :< w :< x) x where+	adapt = flick . flick . flick . flick++instance+	( Covariant (t :< u :< v :< w :< x)+	, Flickable t (Schematic Comonad u (v :< w :< x))+	, Flickable u (Schematic Comonad v (w :< x))+	, Flickable v (Schematic Comonad w x)+	, Bringable w x+	) => Adaptable (t :< u :< v :< w :< x) w where+	adapt = bring . flick . flick . flick++instance 	( Covariant (t :> u :> v :> w :> x :> y) 	, Layable t (Schematic Monad u (v :> w :> x :> y)) 	, Layable u (Schematic Monad v (w :> x :> y))@@ -96,6 +156,26 @@ 	adapt = lay . lay . lay . lay . wrap  instance+	( Covariant (t :< u :< v :< w :< x :< y)+	, Flickable t (Schematic Comonad u (v :< w :< x :< y))+	, Flickable u (Schematic Comonad v (w :< x :< y))+	, Flickable v (Schematic Comonad w (x :< y))+	, Flickable w (Schematic Comonad x y)+	, Flickable x y+	) => Adaptable (t :< u :< v :< w :< x :< y) y where+	adapt = flick . flick . flick . flick . flick++instance+	( Covariant (t :< u :< v :< w :< x :< y)+	, Flickable t (Schematic Comonad u (v :< w :< x :< y))+	, Flickable u (Schematic Comonad v (w :< x :< y))+	, Flickable v (Schematic Comonad w (x :< y))+	, Flickable w (Schematic Comonad x y)+	, Bringable x y+	) => Adaptable (t :< u :< v :< w :< x :< y) x where+	adapt = bring . flick . flick . flick . flick++instance 	( 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))@@ -118,6 +198,28 @@ 	adapt = lay . lay . lay . lay . lay . wrap  instance+	( Covariant (t :< u :< v :< w :< x :< y :< z)+	, Flickable t (Schematic Comonad u (v :< w :< x :< y :< z))+	, Flickable u (Schematic Comonad v (w :< x :< y :< z))+	, Flickable v (Schematic Comonad w (x :< y :< z))+	, Flickable w (Schematic Comonad x (y :< z))+	, Flickable x (Schematic Comonad y z)+	, Flickable y z+	) => Adaptable (t :< u :< v :< w :< x :< y :< z) z where+	adapt = flick . flick . flick . flick . flick . flick++instance+	( Covariant (t :< u :< v :< w :< x :< y :< z)+	, Flickable t (Schematic Comonad u (v :< w :< x :< y :< z))+	, Flickable u (Schematic Comonad v (w :< x :< y :< z))+	, Flickable v (Schematic Comonad w (x :< y :< z))+	, Flickable w (Schematic Comonad x (y :< z))+	, Flickable x (Schematic Comonad y z)+	, Bringable y z+	) => Adaptable (t :< u :< v :< w :< x :< y :< z) y where+	adapt = bring . flick . flick . flick . flick . flick++instance 	( 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))@@ -142,6 +244,30 @@ 	adapt = lay . lay . lay . lay . lay . lay . wrap  instance+	( Covariant (t :< u :< v :< w :< x :< y :< z :< f)+	, Flickable t (Schematic Comonad u (v :< w :< x :< y :< z :< f))+	, Flickable u (Schematic Comonad v (w :< x :< y :< z :< f))+	, Flickable v (Schematic Comonad w (x :< y :< z :< f))+	, Flickable w (Schematic Comonad x (y :< z :< f))+	, Flickable x (Schematic Comonad y (z :< f))+	, Flickable y (Schematic Comonad z f)+	, Flickable z f+	) => Adaptable (t :< u :< v :< w :< x :< y :< z :< f) f where+	adapt = flick . flick . flick . flick . flick . flick . flick++instance+	( Covariant (t :< u :< v :< w :< x :< y :< z :< f)+	, Flickable t (Schematic Comonad u (v :< w :< x :< y :< z :< f))+	, Flickable u (Schematic Comonad v (w :< x :< y :< z :< f))+	, Flickable v (Schematic Comonad w (x :< y :< z :< f))+	, Flickable w (Schematic Comonad x (y :< z :< f))+	, Flickable x (Schematic Comonad y (z :< f))+	, Flickable y (Schematic Comonad z f)+	, Bringable z f+	) => Adaptable (t :< u :< v :< w :< x :< y :< z :< f) z where+	adapt = bring . flick . flick . flick . flick . flick . flick++instance 	( 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))@@ -166,3 +292,29 @@ 	, Wrappable f h 	) => Adaptable f (t :> u :> v :> w :> x :> y :> z :> f :> h) where 	adapt = lay . lay . lay . lay . lay . lay . lay . wrap++instance+	( Covariant (t :< u :< v :< w :< x :< y :< z :< f :< h)+	, Flickable t (Schematic Comonad u (v :< w :< x :< y :< z :< f :< h))+	, Flickable u (Schematic Comonad v (w :< x :< y :< z :< f :< h))+	, Flickable v (Schematic Comonad w (x :< y :< z :< f :< h))+	, Flickable w (Schematic Comonad x (y :< z :< f :< h))+	, Flickable x (Schematic Comonad y (z :< f :< h))+	, Flickable y (Schematic Comonad z (f :< h))+	, Flickable z (Schematic Comonad f h)+	, Flickable f h+	) => Adaptable (t :< u :< v :< w :< x :< y :< z :< f :< h) h where+	adapt = flick . flick . flick . flick . flick . flick . flick . flick++instance+	( Covariant (t :< u :< v :< w :< x :< y :< z :< f :< h)+	, Flickable t (Schematic Comonad u (v :< w :< x :< y :< z :< f :< h))+	, Flickable u (Schematic Comonad v (w :< x :< y :< z :< f :< h))+	, Flickable v (Schematic Comonad w (x :< y :< z :< f :< h))+	, Flickable w (Schematic Comonad x (y :< z :< f :< h))+	, Flickable x (Schematic Comonad y (z :< f :< h))+	, Flickable y (Schematic Comonad z (f :< h))+	, Flickable z (Schematic Comonad f h)+	, Bringable f h+	) => Adaptable (t :< u :< v :< w :< x :< y :< z :< f :< h) f where+	adapt = bring . flick . flick . flick . flick . flick . flick . flick

@@ -1,6 +1,6 @@ module Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (..)) where  class Interpreted t where-	{-# MINIMAL unwrap #-}+	{-# MINIMAL run #-} 	type Primary t a :: *-	unwrap :: t a -> Primary t a+	run :: t a -> Primary t a

@@ -1,10 +1,10 @@ module Pandora.Paradigm.Controlflow.Joint.Schemes.TU (TU (..)) where  import Pandora.Core.Functor (type (:.), type (:=))-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))  newtype TU ct cu t u a = TU (t :. u := a)  instance Interpreted (TU ct cu t u) where 	type Primary (TU ct cu t u) a = t :. u := a-	unwrap (TU x) = x+	run (TU x) = x

@@ -1,10 +1,10 @@ module Pandora.Paradigm.Controlflow.Joint.Schemes.TUV (TUV (..)) where  import Pandora.Core.Functor (type (:.), type (:=))-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))  newtype TUV ct cu cv t u v a = TUV (t :. u :. v := a)  instance Interpreted (TUV ct cu cv t u v) where 	type Primary (TUV ct cu cv t u v) a = t :. u :. v := a-	unwrap (TUV x) = x+	run (TUV x) = x

@@ -1,10 +1,10 @@ module Pandora.Paradigm.Controlflow.Joint.Schemes.TUVW (TUVW (..)) where  import Pandora.Core.Functor (type (:.), type (:=))-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))  newtype TUVW ct cu cv cw t u v w a = TUVW (t :. u :. v :. w := a)  instance Interpreted (TUVW ct cu cv cw t u v w) where 	type Primary (TUVW ct cu cv cw t u v w) a = t :. u :. v :. w := a-	unwrap (TUVW x) = x+	run (TUVW x) = x

@@ -1,10 +1,10 @@ module Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (..)) where  import Pandora.Core.Functor (type (:.), type (:=))-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))  newtype UT ct cu t u a = UT (u :. t := a)  instance Interpreted (UT ct cu t u) where 	type Primary (UT ct cu t u) a = u :. t := a-	unwrap (UT x) = x+	run (UT x) = x

@@ -1,10 +1,10 @@ module Pandora.Paradigm.Controlflow.Joint.Schemes.UTU (UTU (..)) where  import Pandora.Core.Functor (type (:.), type (:=))-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))  newtype UTU ct cu t u a = UTU (u :. t u := a)  instance Interpreted (UTU ct cu t u) where 	type Primary (UTU ct cu t u) a = u :. t u := a-	unwrap (UTU x) = x+	run (UTU x) = x

@@ -2,8 +2,8 @@  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.Core.Functor (type (~>))+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run)) import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic) import Pandora.Pattern.Category ((.)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))@@ -55,4 +55,4 @@  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+	run (TC x) = run x

@@ -2,8 +2,8 @@  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.Core.Functor (type (~>))+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run)) import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic) import Pandora.Pattern.Category ((.)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))@@ -55,4 +55,4 @@  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+	run (TM x) = run x

@@ -3,5 +3,7 @@ import Pandora.Paradigm.Inventory.Optics as Exports import Pandora.Paradigm.Inventory.Store as Exports import Pandora.Paradigm.Inventory.State as Exports+import Pandora.Paradigm.Inventory.Imprint as Exports+import Pandora.Paradigm.Inventory.Equipment as Exports import Pandora.Paradigm.Inventory.Environment as Exports import Pandora.Paradigm.Inventory.Accumulator as Exports

@@ -3,7 +3,7 @@ module Pandora.Paradigm.Inventory.Accumulator (Accumulator (..), Accumulated, gather) where  import Pandora.Paradigm.Basis.Product (Product ((:*:)), type (:*:))-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run)) 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))@@ -24,25 +24,25 @@ 	f <$> Accumulator x = Accumulator $ f <$> x  instance Semigroup e => Applicative (Accumulator e) where-	f <*> v = Accumulator $ k (unwrap f) (unwrap v) where+	f <*> v = Accumulator $ k (run f) (run 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 :*: x) >>= f = let (e' :*: b) = run $ 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+	run (Accumulator x) = x  instance Monoid e => Monadic (Accumulator e) where 	lay x = TM . UT $ (zero :*:) <$> x-	wrap = TM . UT . point . unwrap+	wrap = TM . UT . point . run  type Accumulated e t = Adaptable (Accumulator e) t @@ -57,7 +57,7 @@ 	point = UT . point . (zero :*:)  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)+	UT x >>= f = UT $ x >>= \(acc :*: v) -> (\(acc' :*: y) -> (acc + acc' :*: y)) <$> run (f v)  gather :: Accumulated e t => e -> t () gather x = adapt . Accumulator $ x :*: ()

@@ -3,15 +3,15 @@ module Pandora.Paradigm.Inventory.Environment (Environment (..), Configured, env) where  import Pandora.Core.Morphism ((!), (%))-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run)) 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.Covariant (Covariant ((<$>), (<$$>))) import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (<**>))) import Pandora.Pattern.Functor.Distributive (Distributive ((>>-))) import Pandora.Pattern.Functor.Bindable (Bindable ((>>=))) import Pandora.Pattern.Functor.Monad (Monad)@@ -26,39 +26,39 @@ 	point x = Environment (x !)  instance Applicative (Environment e) where-	f <*> x = Environment $ \e -> unwrap f e $ unwrap x e+	f <*> x = Environment $ \e -> run f e $ run x e  instance Distributive (Environment e) where-	g >>- f = Environment $ g >>- (unwrap <$> f)+	g >>- f = Environment $ g >>- (run <$> f)  instance Bindable (Environment e) where-	Environment x >>= f = Environment $ \e -> unwrap % e . f . x $ e+	Environment x >>= f = Environment $ \e -> run % e . f . x $ e  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+	run (Environment x) = x +type instance Schematic Monad (Environment e) u = TU Covariant Covariant ((->) e) u+ instance Monadic (Environment e) where 	lay = TM . TU . (!)-	wrap x = TM. TU $ point <$> unwrap x+	wrap x = TM . TU $ point <$> run x  type Configured e = Adaptable (Environment e)  instance Covariant u => Covariant (TU Covariant Covariant ((->) e) u) where-	f <$> TU x = TU $ \r -> f <$> x r+	f <$> TU x = TU $ f <$$> x  instance (Covariant u, Pointable u) => Pointable (TU Covariant Covariant ((->) e) u) where 	point = TU . point . point  instance Applicative u => Applicative (TU Covariant Covariant ((->) e) u) where-	TU f <*> TU x = TU $ \r -> f r <*> x r+	TU f <*> TU x = TU $ f <**> x  instance Bindable u => Bindable (TU Covariant Covariant ((->) e) u) where-	TU x >>= f = TU $ \e -> x e >>= ($ e) . unwrap . f+	TU x >>= f = TU $ \e -> x e >>= ($ e) . run . f  env :: Configured e t => t e env = adapt $ Environment identity

@@ -0,0 +1,48 @@+{-# OPTIONS_GHC -fno-warn-orphans #-}++module Pandora.Paradigm.Inventory.Equipment (Equipment (..), retrieve) where++import Pandora.Paradigm.Basis.Product (Product ((:*:)), type (:*:), attached)+import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))+import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)+import Pandora.Paradigm.Controlflow.Joint.Schemes.TU (TU (TU))+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 (($))++newtype Equipment e a = Equipment (e :*: a)++instance Covariant (Equipment e) where+	f <$> Equipment x = Equipment $ f <$> x++instance Extractable (Equipment e) where+	extract = extract . run++instance Extendable (Equipment e) where+	Equipment (e :*: x) =>> f = Equipment . (:*:) e . f . Equipment $ e :*: x++type instance Schematic Comonad (Equipment e) u = TU Covariant Covariant ((:*:) e) u++instance Interpreted (Equipment e) where+	type Primary (Equipment e) a = e :*: a+	run (Equipment x) = x++type Equipped e t = Adaptable t (Equipment e)++instance Covariant u => Covariant (TU Covariant Covariant ((:*:) e) u) where+	f <$> TU x = TU $ f <$$> x++instance Extractable u => Extractable (TU Covariant Covariant ((:*:) e) u) where+	extract (TU x) = extract . extract $ x++instance Extendable u => Extendable (TU Covariant Covariant ((:*:) e) u) where+	TU (e :*: x) =>> f = TU . (:*:) e $ x =>> f . TU . (:*:) e++instance Comonad (Equipment e) where++retrieve :: Equipped e t => t a -> e+retrieve = attached . run @(Equipment _) . adapt

@@ -0,0 +1,57 @@+{-# OPTIONS_GHC -fno-warn-orphans #-}++module Pandora.Paradigm.Inventory.Imprint (Imprint (..), Traceable) where++import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))+import Pandora.Paradigm.Controlflow.Joint.Transformer.Comonadic (Comonadic (flick, bring), (:<) (TC))+import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)+import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable)+import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))+import Pandora.Pattern.Category ((.))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))+import Pandora.Pattern.Functor.Extractable (Extractable (extract))+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (<**>)))+import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))+import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))+import Pandora.Pattern.Functor.Comonad (Comonad)+import Pandora.Pattern.Functor.Divariant (($))+import Pandora.Pattern.Object.Monoid (Monoid (zero))+import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))++newtype Imprint e a = Imprint (e -> a)++instance Covariant (Imprint e) where+	f <$> Imprint x = Imprint $ f . x++instance Distributive (Imprint e) where+	g >>- f = Imprint $ g >>- (run <$> f)++instance Monoid e => Extractable (Imprint e) where+	extract (Imprint x) = x zero++instance Semigroup e => Extendable (Imprint e) where+	Imprint x =>> f = Imprint $ \e -> f $ Imprint $ x . (e +)++instance Interpreted (Imprint e) where+	type Primary (Imprint e) a = (->) e a+	run (Imprint x) = x++type instance Schematic Comonad (Imprint e) u = UT Covariant Covariant ((->) e) u++instance Monoid e => Comonadic (Imprint e) where+	flick (TC (UT x)) = extract <$> x+	bring (TC (UT x)) = Imprint . extract $ x++instance Covariant u => Covariant (UT Covariant Covariant ((->) e) u) where+	f <$> UT x = UT $ f <$$> x++instance Applicative u => Applicative (UT Covariant Covariant ((->) e) u) where+	UT f <*> UT x = UT $ f <**> x++instance (Monoid e, Extractable u) => Extractable (UT Covariant Covariant ((->) e) u) where+	extract (UT x) = extract . extract $ x++instance (Semigroup e, Extendable u) => Extendable (UT Covariant Covariant ((->) e) u) where+	UT x =>> f = UT $ x =>> (\x' e -> f . UT . (<$>) (. (e +)) $ x')++type Traceable e t = Adaptable t (Imprint e)

@@ -1,26 +1,29 @@ {-# OPTIONS_GHC -fno-warn-orphans #-} -module Pandora.Paradigm.Inventory.Optics (Lens, type (:-.), (|>), view, set, over, (^.), (.~), (%~)) where+module Pandora.Paradigm.Inventory.Optics (Lens, type (:-.), (|>), view, set, over, zoom, (^.), (.~), (%~)) where +import Pandora.Core.Functor (type (|->)) 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.Controlflow.Joint.Adaptable (adapt)+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (run))+import Pandora.Paradigm.Inventory.State (State (State), Stateful) import Pandora.Paradigm.Inventory.Store (Store (Store), access, position, retrofit)-import Pandora.Pattern.Category ((.))+import Pandora.Pattern.Category (identity, (.)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$))) import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-))) import Pandora.Pattern.Functor.Divariant (($))+import Pandora.Pattern.Functor.Bivariant ((<->))  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+	Store (s :*: f) |- g = extract . run % s . g $ f s  infixr 0 :-. type (:-.) src tgt = Lens src tgt -type Lens src tgt = src -> Store tgt src+type Lens src tgt = src |-> Store tgt  -- | Lens composition infix operator (|>) :: Lens src btw -> Lens btw tgt -> Lens src tgt@@ -49,3 +52,6 @@ -- | Infix version of `over` (%~) :: Lens src tgt -> (tgt -> tgt) -> src -> src lens %~ f = over lens f++zoom :: Stateful bg t => Lens bg ls -> State ls a -> t a+zoom lens (State f) = adapt . State $ (\(Store (p :*: g)) -> (g <-> identity) . f $ p) . lens

@@ -17,7 +17,7 @@ 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.Interpreted (Interpreted (Primary, run)) 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))@@ -39,12 +39,12 @@  instance Bindable (State s) where 	State x >>= f = State $ \old ->-		uncurry (unwrap %) $ f <$> x old+		uncurry (run %) $ 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 $+fold start op struct = extract . run @(State _) % start $ 	struct ->> modify . op $> () *> current  find :: (Pointable u, Avoidable u, Alternative u, Traversable t) => Predicate a -> t a -> u a@@ -52,14 +52,14 @@  instance Interpreted (State s) where 	type Primary (State s) a = (->) s :. (:*:) s := a-	unwrap (State x) = x+	run (State x) = 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+	wrap x = TM . TUV $ point <$> run x  type Stateful s = Adaptable (State s) @@ -73,7 +73,7 @@ 	point x = TUV $ \s -> point $ s :*: x  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+	TUV x >>= f = TUV $ \old -> x old >>= \(new :*: y) -> ($ new) . run . f $ y  instance Monad u => Monad (TUV Covariant Covariant Covariant ((->) s) u ((:*:) s)) where 

@@ -1,18 +1,18 @@ {-# OPTIONS_GHC -fno-warn-orphans #-} -module Pandora.Paradigm.Inventory.Store (Store (..), position, access, retrofit) where+module Pandora.Paradigm.Inventory.Store (Store (..), Storable, position, access, retrofit) where -import Pandora.Core.Functor (type (:.), type (:=), type (<-|))+import Pandora.Core.Functor (type (:.), 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.Basis.Product (Product ((:*:)), type (:*:), attached)+import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run)) 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))@@ -33,7 +33,7 @@  instance Interpreted (Store p) where 	type Primary (Store p) a = (:*:) p :. (->) p := a-	unwrap (Store x) = x+	run (Store x) = x  type instance Schematic Comonad (Store p) u = 	TUV Covariant Covariant Covariant ((:*:) p) u ((->) p)@@ -42,6 +42,8 @@ 	flick (TC (TUV (p :*: f))) = ($ p) <$> f 	bring (TC (TUV (p :*: f))) = Store $ p :*: extract f +type Storable s x = Adaptable x (Store s)+ instance Covariant u => Covariant (TUV Covariant Covariant Covariant ((:*:) p) u ((->) p)) where 	f <$> TUV (p :*: x) = TUV . (:*:) p $ f <$$> x @@ -51,11 +53,11 @@ 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+position :: Storable s t => t a -> s+position = attached . run @(Store _) . adapt -access :: p -> a <-| Store p-access p = extract % p . unwrap+access :: Storable s t => s -> a <-| t+access p = extract % p . run @(Store _) . adapt  retrofit :: (p -> p) -> Store p ~> Store p retrofit g (Store (p :*: f)) = Store $ g p :*: f

@@ -1,9 +1,12 @@ module Pandora.Paradigm.Structure.Nonempty (Nonempty) where  import Pandora.Paradigm.Basis.Maybe (Maybe)+import Pandora.Paradigm.Basis.Edges (Edges) import Pandora.Paradigm.Basis.Twister (Twister) import Pandora.Paradigm.Structure.Specific.Stack (Stack)+import Pandora.Paradigm.Structure.Specific.Graph (Graph)  -- | Type synonymous for at least one element data structure type family Nonempty (structure :: * -> *) where 	Nonempty Stack = Twister Maybe+	Nonempty Graph = Twister Edges

@@ -2,7 +2,7 @@  module Pandora.Paradigm.Structure.Specific.Graph (Graph, loose) where -import Pandora.Core.Transformation (type (~>))+import Pandora.Core.Functor (type (~>)) import Pandora.Pattern.Category ((.)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>))) import Pandora.Pattern.Functor.Divariant (($))@@ -15,10 +15,10 @@ -- | Directed acyclic graph structure type Graph = UT Covariant Covariant (Twister Edges) Edges -instance Covariant (UT Covariant Covariant (Twister Edges) Edges) where+instance Covariant Graph where 	f <$> UT g = UT $ f <$$> g -instance Traversable (UT Covariant Covariant (Twister Edges) Edges) where+instance Traversable Graph where 	UT g ->> f = UT <$> g ->>> f  -- | Transform any traversable structure into all loose edges graph

@@ -2,12 +2,8 @@  module Pandora.Paradigm.Structure.Specific.Stack (Stack, push, top, pop, filter, linearize) where -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 (Twister), untwist)-import Pandora.Paradigm.Inventory.State (fold)-import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))+import Pandora.Core.Functor (type (~>))+import Pandora.Core.Morphism ((&)) import Pandora.Pattern.Category ((.)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>))) import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))@@ -18,34 +14,58 @@ import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>))) import Pandora.Pattern.Functor.Bindable (Bindable ((>>=))) import Pandora.Pattern.Functor.Divariant (($))-import Pandora.Pattern.Object.Setoid ((?))+import Pandora.Pattern.Object.Setoid (Setoid ((==)), (?))+import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))+import Pandora.Pattern.Object.Monoid (Monoid (zero))+import Pandora.Paradigm.Basis.Maybe (Maybe (Just, Nothing))+import Pandora.Paradigm.Basis.Predicate (Predicate (Predicate))+import Pandora.Paradigm.Basis.Product (Product ((:*:)))+import Pandora.Paradigm.Basis.Twister (Twister (Twister), untwist)+import Pandora.Paradigm.Inventory.State (fold)+import Pandora.Paradigm.Inventory.Store (Store (Store))+import Pandora.Paradigm.Inventory.Optics (type (:-.))+import Pandora.Paradigm.Controlflow.Joint.Interpreted (run)+import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))  -- | Linear data structure that serves as a collection of elements type Stack = UT Covariant Covariant (Twister Maybe) Maybe -instance Covariant (UT Covariant Covariant (Twister Maybe) Maybe) where+instance Covariant Stack where 	f <$> UT stack = UT $ f <$$> stack -instance Pointable (UT Covariant Covariant (Twister Maybe) Maybe) where+instance Pointable Stack where 	point = UT . Just . point -instance Alternative (UT Covariant Covariant (Twister Maybe) Maybe) where+instance Alternative Stack where 	UT x <+> UT y = UT $ x <+> y -instance Avoidable (UT Covariant Covariant (Twister Maybe) Maybe) where+instance Avoidable Stack where 	empty = UT Nothing -instance Applicative (UT Covariant Covariant (Twister Maybe) Maybe) where+instance Applicative Stack where 	UT f <*> UT x = UT $ f <**> x -instance Traversable (UT Covariant Covariant (Twister Maybe) Maybe) where+instance Traversable Stack where 	UT stack ->> f = UT <$> stack ->>> f +instance Setoid a => Setoid (Stack a) where+	UT ls == UT rs = ls == rs++instance Semigroup (Stack a) where+	UT Nothing + UT ys = UT ys+	UT (Just (Twister x xs)) + UT ys = UT . Just . Twister x . run+		$ UT @Covariant @Covariant xs + UT @Covariant @Covariant ys++instance Monoid (Stack a) where+	zero = UT Nothing++top :: Stack a :-. Maybe a+top stack = Store $ (:*:) (extract <$> run stack) $ \case+    Just x -> stack & pop & push x+    Nothing -> pop stack+ push :: a -> Stack a -> Stack a push x (UT stack) = UT $ (Twister x . Just <$> stack) <+> (point . point) x--top :: Stack ~> Maybe-top (UT stack) = extract <$> stack  pop :: Stack ~> Stack pop (UT stack) = UT $ stack >>= untwist

@@ -1,5 +1,6 @@ module Pandora.Pattern.Functor (module Exports) where +import Pandora.Pattern.Functor.Bivariant as Exports import Pandora.Pattern.Functor.Divariant as Exports import Pandora.Pattern.Functor.Lowerable as Exports import Pandora.Pattern.Functor.Liftable as Exports

@@ -0,0 +1,18 @@+module Pandora.Pattern.Functor.Bivariant (Bivariant (..)) where++import Pandora.Pattern.Functor.Divariant (($))++infixl 4 <->++{- |+> When providing a new instance, you should ensure it satisfies the two laws:+> * Identity: bimap identity identity ≡ identity+> * Parametricity: bimap  (f . g) (h . i) ≡ bimap f h . bimap g i+-}++class Bivariant (v :: * -> * -> *) where+	{-# MINIMAL (<->) #-}+	(<->) :: (a -> b) -> (c -> d) -> v a c -> v b d+	-- | Prefix version of '<->'+	bimap :: (a -> b) -> (c -> d) -> v a c -> v b d+	bimap f g x = f <-> g $ x

@@ -2,6 +2,10 @@  import Pandora.Core.Functor (type (<-|)) import Pandora.Pattern.Functor.Covariant (Covariant)+import Pandora.Pattern.Object.Monoid (Monoid (zero))  class Covariant t => Extractable t where 	extract :: a <-| t++instance Monoid e => Extractable ((->) e) where+	extract f = f zero

@@ -1,6 +1,6 @@ module Pandora.Pattern.Functor.Liftable (Liftable (..)) where -import Pandora.Core.Transformation (type (~>))+import Pandora.Core.Functor (type (~>)) import Pandora.Pattern.Functor.Covariant (Covariant)  class Liftable t where

@@ -1,6 +1,6 @@ module Pandora.Pattern.Functor.Lowerable (Lowerable (..)) where -import Pandora.Core.Transformation (type (~>))+import Pandora.Core.Functor (type (~>)) import Pandora.Pattern.Functor.Covariant (Covariant)  class Lowerable t where

@@ -1,5 +1,5 @@ name:                pandora-version:             0.2.3+version:             0.2.4 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@@ -23,7 +23,6 @@     Pandora.Core     Pandora.Core.Functor     Pandora.Core.Morphism-    Pandora.Core.Transformation      Pandora.Paradigm     -- Basic constructions@@ -71,6 +70,8 @@     Pandora.Paradigm.Inventory     Pandora.Paradigm.Inventory.Accumulator     Pandora.Paradigm.Inventory.Environment+    Pandora.Paradigm.Inventory.Equipment+    Pandora.Paradigm.Inventory.Imprint     Pandora.Paradigm.Inventory.Optics     Pandora.Paradigm.Inventory.State     Pandora.Paradigm.Inventory.Store@@ -108,6 +109,7 @@     Pandora.Pattern.Functor.Representable     Pandora.Pattern.Functor.Traversable     Pandora.Pattern.Functor.Divariant+    Pandora.Pattern.Functor.Bivariant     -- Typeclassess about object internals     Pandora.Pattern.Object     Pandora.Pattern.Object.Chain@@ -121,7 +123,7 @@     Pandora.Pattern.Object.Setoid   default-extensions:     DataKinds, ConstraintKinds, ExistentialQuantification, GADTs, QuantifiedConstraints-    FlexibleContexts, FlexibleInstances, KindSignatures, LiberalTypeSynonyms+    FlexibleContexts, FlexibleInstances, KindSignatures, LiberalTypeSynonyms, LambdaCase     MultiParamTypeClasses, NoImplicitPrelude, PackageImports, PolyKinds, RankNTypes     ScopedTypeVariables, TypeApplications, TypeFamilies, TypeFamilyDependencies, TypeOperators   default-language: Haskell2010