pandora 0.3.0 → 0.3.1

raw patch · 30 files changed

+377/−304 lines, 30 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• CHANGELOG.md +10/−0
• Pandora/Paradigm.hs +1/−0
• Pandora/Paradigm/Controlflow/Effect.hs +0/−2
• Pandora/Paradigm/Controlflow/Effect/Adaptable.hs +211/−164
• Pandora/Paradigm/Controlflow/Effect/Interpreted.hs +3/−1
• Pandora/Paradigm/Controlflow/Effect/Schematic.hs +0/−3
• Pandora/Paradigm/Controlflow/Effect/Transformer/Comonadic.hs +10/−4
• Pandora/Paradigm/Controlflow/Effect/Transformer/Monadic.hs +10/−4
• Pandora/Paradigm/Inventory.hs +9/−4
• Pandora/Paradigm/Inventory/Accumulator.hs +3/−5
• Pandora/Paradigm/Inventory/Environment.hs +3/−5
• Pandora/Paradigm/Inventory/Equipment.hs +3/−5
• Pandora/Paradigm/Inventory/Imprint.hs +3/−5
• Pandora/Paradigm/Inventory/Optics.hs +1/−7
• Pandora/Paradigm/Inventory/State.hs +9/−24
• Pandora/Paradigm/Inventory/Store.hs +7/−15
• Pandora/Paradigm/Primary/Functor.hs +10/−0
• Pandora/Paradigm/Primary/Functor/Conclusion.hs +3/−5
• Pandora/Paradigm/Primary/Functor/Maybe.hs +4/−5
• Pandora/Paradigm/Primary/Functor/Product.hs +24/−29
• Pandora/Paradigm/Primary/Transformer/Continuation.hs +2/−1
• Pandora/Paradigm/Schemes/TU.hs +4/−1
• Pandora/Paradigm/Schemes/TUT.hs +5/−6
• Pandora/Paradigm/Schemes/UT.hs +4/−2
• Pandora/Paradigm/Structure.hs +15/−0
• Pandora/Paradigm/Structure/Interface.hs +3/−0
• Pandora/Paradigm/Structure/Interface/Set.hs +7/−0
• Pandora/Paradigm/Structure/Stack.hs +8/−3
• Pandora/Pattern/Functor/Monad.hs +1/−1
• pandora.cabal +4/−3

@@ -259,3 +259,13 @@ * Define experimental methods: `<*+>`, `<**+>`, `<***+>` * Rename Bindable method `>>=$` to `<>>=` * Move `Comprehension` wrapper from `Construction` to `Structure.Ability` module++# 0.3.1+* Define `Set` interface for data structures with `member` method+* Move `zoom` function to `Inventory` module+* Move `Adjoint` instance for `(:*:)` and `(->)` to `Paradigm.Primary.Functor` module+* Remove `Schematic` module and move `Schematic` type family to `Interpreted` module+* Change arity of `Schematic` type family+* Remove `lay` method of `Monadic` type class, use `lift` instead+* Remove `flick` method of `Comonadic` type class, use `lower` instead+* Change `lift` constraint: from `Covariant` to `Traversable`

@@ -4,3 +4,4 @@ import Pandora.Paradigm.Inventory as Exports import Pandora.Paradigm.Controlflow as Exports import Pandora.Paradigm.Primary as Exports+import Pandora.Paradigm.Schemes as Exports

@@ -1,7 +1,5 @@ module Pandora.Paradigm.Controlflow.Effect (module Exports) where -import Pandora.Paradigm.Schemes as Exports-import Pandora.Paradigm.Controlflow.Effect.Schematic as Exports import Pandora.Paradigm.Controlflow.Effect.Transformer as Exports import Pandora.Paradigm.Controlflow.Effect.Interpreted as Exports import Pandora.Paradigm.Controlflow.Effect.Adaptable as Exports

@@ -7,313 +7,360 @@ import Pandora.Pattern.Functor.Covariant (Covariant) import Pandora.Pattern.Functor.Pointable (Pointable) import Pandora.Pattern.Functor.Extractable (Extractable)+import Pandora.Pattern.Functor.Traversable (Traversable) import Pandora.Pattern.Functor.Comonad (Comonad) import Pandora.Pattern.Functor.Monad (Monad)-import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic)-import Pandora.Paradigm.Controlflow.Effect.Transformer (Transformer, lay, wrap, flick, bring, (:>), (:<))+import Pandora.Pattern.Transformer (Liftable (lift), Lowerable (lower), Hoistable (hoist))+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic)+import Pandora.Paradigm.Controlflow.Effect.Transformer (Transformer, wrap, bring, (:>), (:<))  class Adaptable t u where 	{-# MINIMAL adapt #-} 	adapt :: t ~> u -type Layable t u = (Transformer Monad t, Covariant u)+type Lifting t u = (Transformer Monad t, Liftable (Schematic Monad t), Traversable u)+type Lowering t u = (Transformer Comonad t, Lowerable (Schematic Comonad t), Covariant u) type Wrappable t u = (Transformer Monad t, Pointable u)-type Flickable t u = (Transformer Comonad t, Covariant u) type Bringable t u = (Transformer Comonad t, Extractable u)  instance Covariant t => Adaptable t t where 	adapt = identity -instance (Covariant (t :> u), Layable t u) => Adaptable u (t :> u) where-	adapt = lay+instance (Covariant (t :> u), Lifting t u) => Adaptable u (t :> u) where+	adapt = lift  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), Lowering t u) => Adaptable (t :< u) u where+	adapt = lower  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)+	, Liftable (Schematic Monad t)+	, Traversable (Schematic Monad u v) 	, Wrappable u v 	) => Adaptable u (t :> u :> v) where-	adapt = lay . wrap+	adapt = lift . wrap  instance 	( Covariant (t :> u :> v)-	, Layable t (Schematic Monad u v)-	, Layable u v+	, Lifting t (Schematic Monad u v)+	, Lifting u v 	) => Adaptable v (t :> u :> v) where-	adapt = lay . lay+	adapt = lift . lift  instance 	( Covariant (t :< u :< v)-	, Flickable t (Schematic Comonad u v)+	, Lowering t (Schematic Comonad u v) 	, Bringable u v 	) => Adaptable (t :< u :< v) u where-	adapt = bring . flick+	adapt = bring . lower  instance 	( Covariant (t :< u :< v)-	, Flickable t (Schematic Comonad u v)-	, Flickable u v+	, Lowering t (Schematic Comonad u v)+	, Lowering u v 	) => Adaptable (t :< u :< v) v where-	adapt = flick . flick+	adapt = lower . lower  instance 	( Covariant (t :> u :> v :> w)-	, Layable t (Schematic Monad u (v :> w))-	, Layable u (Schematic Monad v w)+	, Liftable (Schematic Monad t)+	, Lifting t (Schematic Monad u (v :> w))+	, Lifting u (Schematic Monad v w) 	, Wrappable v w 	) => Adaptable v (t :> u :> v :> w) where-	adapt = lay . lay . wrap+	adapt = lift . lift . wrap  instance 	( 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+	, Lifting t (Schematic Monad u v)+	, Lifting t (Schematic Monad u (v :> w))+	, Lifting u (Schematic Monad v w)+	, Lifting v w 	) => Adaptable w (t :> u :> v :> w) where-	adapt = lay . lay . lay+	adapt = lift . lift . lift  instance 	( Covariant (t :< u :< v :< w)-	, Flickable t (Schematic Comonad u (v :< w))-	, Flickable u (Schematic Comonad v w)+	, Lowering t (Schematic Comonad u (v :< w))+	, Lowering u (Schematic Comonad v w) 	, Bringable v w 	) => Adaptable (t :< u :< v :< w) v where-	adapt = bring . flick . flick+	adapt = bring . lower . lower  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+	, Lowering t (Schematic Comonad u v)+	, Lowering t (Schematic Comonad u (v :< w))+	, Lowering u (Schematic Comonad v w)+	, Lowering v w 	) => Adaptable (t :< u :< v :< w) w where-	adapt = flick . flick . flick+	adapt = lower . lower . lower  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+	, Lifting t (Schematic Monad u (v :> w :> x))+	, Lifting u (Schematic Monad v (w :> x))+	, Lifting v (Schematic Monad w x)+	, Lifting w x 	) => Adaptable x (t :> u :> v :> w :> x) where-	adapt = lay . lay . lay . lay+	adapt = lift . lift . lift . lift  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)+	, Lifting t (Schematic Monad u (v :> w :> x))+	, Lifting u (Schematic Monad v (w :> x))+	, Lifting v (Schematic Monad w x) 	, Wrappable w x 	) => Adaptable w (t :> u :> v :> w :> x) where-	adapt = lay . lay . lay . wrap+	adapt = lift . lift . lift . 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+	, Lowering t (Schematic Comonad u (v :< w :< x))+	, Lowering u (Schematic Comonad v (w :< x))+	, Lowering v (Schematic Comonad w x)+	, Lowering w x 	) => Adaptable (t :< u :< v :< w :< x) x where-	adapt = flick . flick . flick . flick+	adapt = lower . lower . lower . lower  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)+	, Lowering t (Schematic Comonad u (v :< w :< x))+	, Lowering u (Schematic Comonad v (w :< x))+	, Lowering v (Schematic Comonad w x) 	, Bringable w x 	) => Adaptable (t :< u :< v :< w :< x) w where-	adapt = bring . flick . flick . flick+	adapt = bring . lower . lower . lower  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))-	, Layable v (Schematic Monad w (x :> y))-	, Layable w (Schematic Monad x y)-	, Layable x y+	, Lifting t (Schematic Monad u (v :> w :> x :> y))+	, Lifting u (Schematic Monad v (w :> x :> y))+	, Lifting v (Schematic Monad w (x :> y))+	, Lifting w (Schematic Monad x y)+	, Lifting x y 	) => Adaptable y (t :> u :> v :> w :> x :> y) where-	adapt = lay . lay . lay . lay . lay+	adapt = lift . lift . lift . lift . lift  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))-	, Layable v (Schematic Monad w (x :> y))-	, Layable w (Schematic Monad x y)+	, Lifting t (Schematic Monad u (v :> w :> x :> y))+	, Lifting u (Schematic Monad v (w :> x :> y))+	, Lifting v (Schematic Monad w (x :> y))+	, Lifting w (Schematic Monad x y) 	, Wrappable x y 	) => Adaptable x (t :> u :> v :> w :> x :> y) where-	adapt = lay . lay . lay . lay . wrap+	adapt = lift . lift . lift . lift . 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+	, Lowering t (Schematic Comonad u (v :< w :< x :< y))+	, Lowering u (Schematic Comonad v (w :< x :< y))+	, Lowering v (Schematic Comonad w (x :< y))+	, Lowering w (Schematic Comonad x y)+	, Lowering x y 	) => Adaptable (t :< u :< v :< w :< x :< y) y where-	adapt = flick . flick . flick . flick . flick+	adapt = lower . lower . lower . lower . lower  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)+	, Lowering t (Schematic Comonad u (v :< w :< x :< y))+	, Lowering u (Schematic Comonad v (w :< x :< y))+	, Lowering v (Schematic Comonad w (x :< y))+	, Lowering w (Schematic Comonad x y) 	, Bringable x y 	) => Adaptable (t :< u :< v :< w :< x :< y) x where-	adapt = bring . flick . flick . flick . flick+	adapt = bring . lower . lower . lower . lower  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))-	, Layable v (Schematic Monad w (x :> y :> z))-	, Layable w (Schematic Monad x (y :> z))-	, Layable x (Schematic Monad y z)-	, Layable y z+	, Lifting t (Schematic Monad u (v :> w :> x :> y :> z))+	, Lifting u (Schematic Monad v (w :> x :> y :> z))+	, Lifting v (Schematic Monad w (x :> y :> z))+	, Lifting w (Schematic Monad x (y :> z))+	, Lifting x (Schematic Monad y z)+	, Lifting y z 	) => Adaptable z (t :> u :> v :> w :> x :> y :> z) where-	adapt = lay . lay . lay . lay . lay . lay+	adapt = lift . lift . lift . lift . lift . lift  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))-	, Layable v (Schematic Monad w (x :> y :> z))-	, Layable w (Schematic Monad x (y :> z))-	, Layable x (Schematic Monad y z)+	, Lifting t (Schematic Monad u (v :> w :> x :> y :> z))+	, Lifting u (Schematic Monad v (w :> x :> y :> z))+	, Lifting v (Schematic Monad w (x :> y :> z))+	, Lifting w (Schematic Monad x (y :> z))+	, Lifting 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+	adapt = lift . lift . lift . lift . lift . 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+	, Lowering t (Schematic Comonad u (v :< w :< x :< y :< z))+	, Lowering u (Schematic Comonad v (w :< x :< y :< z))+	, Lowering v (Schematic Comonad w (x :< y :< z))+	, Lowering w (Schematic Comonad x (y :< z))+	, Lowering x (Schematic Comonad y z)+	, Lowering y z 	) => Adaptable (t :< u :< v :< w :< x :< y :< z) z where-	adapt = flick . flick . flick . flick . flick . flick+	adapt = lower . lower . lower . lower . lower . lower  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)+	, Lowering t (Schematic Comonad u (v :< w :< x :< y :< z))+	, Lowering u (Schematic Comonad v (w :< x :< y :< z))+	, Lowering v (Schematic Comonad w (x :< y :< z))+	, Lowering w (Schematic Comonad x (y :< z))+	, Lowering 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+	adapt = bring . lower . lower . lower . lower . lower  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))-	, 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+	, Lifting t (Schematic Monad u (v :> w :> x :> y :> z :> f))+	, Lifting u (Schematic Monad v (w :> x :> y :> z :> f))+	, Lifting v (Schematic Monad w (x :> y :> z :> f))+	, Lifting w (Schematic Monad x (y :> z :> f))+	, Lifting x (Schematic Monad y (z :> f))+	, Lifting y (Schematic Monad z f)+	, Lifting z f 	) => Adaptable f (t :> u :> v :> w :> x :> y :> z :> f) where-	adapt = lay . lay . lay . lay . lay . lay . lay+	adapt = lift . lift . lift . lift . lift . lift . lift  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))-	, 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)+	, Lifting t (Schematic Monad u (v :> w :> x :> y :> z :> f))+	, Lifting u (Schematic Monad v (w :> x :> y :> z :> f))+	, Lifting v (Schematic Monad w (x :> y :> z :> f))+	, Lifting w (Schematic Monad x (y :> z :> f))+	, Lifting x (Schematic Monad y (z :> f))+	, Lifting 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+	adapt = lift . lift . lift . lift . lift . lift . 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+	, Lowering t (Schematic Comonad u (v :< w :< x :< y :< z :< f))+	, Lowering u (Schematic Comonad v (w :< x :< y :< z :< f))+	, Lowering v (Schematic Comonad w (x :< y :< z :< f))+	, Lowering w (Schematic Comonad x (y :< z :< f))+	, Lowering x (Schematic Comonad y (z :< f))+	, Lowering y (Schematic Comonad z f)+	, Lowering z f 	) => Adaptable (t :< u :< v :< w :< x :< y :< z :< f) f where-	adapt = flick . flick . flick . flick . flick . flick . flick+	adapt = lower . lower . lower . lower . lower . lower . lower  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)+	, Lowering t (Schematic Comonad u (v :< w :< x :< y :< z :< f))+	, Lowering u (Schematic Comonad v (w :< x :< y :< z :< f))+	, Lowering v (Schematic Comonad w (x :< y :< z :< f))+	, Lowering w (Schematic Comonad x (y :< z :< f))+	, Lowering x (Schematic Comonad y (z :< f))+	, Lowering 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+	adapt = bring . lower . lower . lower . lower . lower . lower  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))-	, 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+	, Lifting t (Schematic Monad u (v :> w :> x :> y :> z :> f :> h))+	, Lifting u (Schematic Monad v (w :> x :> y :> z :> f :> h))+	, Lifting v (Schematic Monad w (x :> y :> z :> f :> h))+	, Lifting w (Schematic Monad x (y :> z :> f :> h))+	, Lifting x (Schematic Monad y (z :> f :> h))+	, Lifting y (Schematic Monad z (f :> h))+	, Lifting z (Schematic Monad f h)+	, Lifting f h 	) => Adaptable h (t :> u :> v :> w :> x :> y :> z :> f :> h) where-	adapt = lay . lay . lay . lay . lay . lay . lay . lay+	adapt = lift . lift . lift . lift . lift . lift . lift . lift  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))-	, 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)+	, Lifting t (Schematic Monad u (v :> w :> x :> y :> z :> f :> h))+	, Lifting u (Schematic Monad v (w :> x :> y :> z :> f :> h))+	, Lifting v (Schematic Monad w (x :> y :> z :> f :> h))+	, Lifting w (Schematic Monad x (y :> z :> f :> h))+	, Lifting x (Schematic Monad y (z :> f :> h))+	, Lifting y (Schematic Monad z (f :> h))+	, Lifting 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+	adapt = lift . lift . lift . lift . lift . lift . lift . 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+	, Lowering t (Schematic Comonad u (v :< w :< x :< y :< z :< f :< h))+	, Lowering u (Schematic Comonad v (w :< x :< y :< z :< f :< h))+	, Lowering v (Schematic Comonad w (x :< y :< z :< f :< h))+	, Lowering w (Schematic Comonad x (y :< z :< f :< h))+	, Lowering x (Schematic Comonad y (z :< f :< h))+	, Lowering y (Schematic Comonad z (f :< h))+	, Lowering z (Schematic Comonad f h)+	, Lowering f h 	) => Adaptable (t :< u :< v :< w :< x :< y :< z :< f :< h) h where-	adapt = flick . flick . flick . flick . flick . flick . flick . flick+	adapt = lower . lower . lower . lower . lower . lower . lower . lower  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)+	, Lowering t (Schematic Comonad u (v :< w :< x :< y :< z :< f :< h))+	, Lowering u (Schematic Comonad v (w :< x :< y :< z :< f :< h))+	, Lowering v (Schematic Comonad w (x :< y :< z :< f :< h))+	, Lowering w (Schematic Comonad x (y :< z :< f :< h))+	, Lowering x (Schematic Comonad y (z :< f :< h))+	, Lowering y (Schematic Comonad z (f :< h))+	, Lowering 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+	adapt = bring . lower . lower . lower . lower . lower . lower . lower++instance (Covariant u, Hoistable ((:>) t), Adaptable u u') => Adaptable (t :> u) (t :> u') where+	adapt = hoist adapt++instance+	( Covariant u+	, Covariant v+	, Traversable (Schematic Monad u v)+	, Hoistable ((:>) (t :> u))+	, Hoistable (Schematic Monad t)+	, Hoistable (Schematic Monad u)+	, Adaptable v v'+	) => Adaptable (t :> u :> v) (t :> u :> v') where+	adapt = hoist (hoist adapt)++instance+	( Covariant u, Covariant v, Covariant w+	, Traversable (Schematic Monad u v)+	, Traversable (Schematic Monad u (v :> w))+	, Traversable (Schematic Monad v w)+	, Hoistable ((:>) (t :> u :> v))+	, Hoistable (Schematic Monad t)+	, Hoistable (Schematic Monad u)+	, Hoistable (Schematic Monad v)+	, Adaptable w w'+	) => Adaptable (t :> u :> v :> w) (t :> u :> v :> w') where+	adapt = hoist (hoist (hoist adapt))++instance+	( Covariant u, Covariant v, Covariant w, Covariant x+	, Traversable (Schematic Monad u v)+	, Traversable (Schematic Monad u (v :> w))+	, Traversable (Schematic Monad v (w :> x))+	, Traversable (Schematic Monad u (v :> (w :> x)))+	, Traversable (Schematic Monad w x)+	, Hoistable ((:>) (t :> u :> v))+	, Hoistable (Schematic Monad t)+	, Hoistable (Schematic Monad u)+	, Hoistable (Schematic Monad v)+	, Hoistable (Schematic Monad w)+	, Adaptable x x'+	) => Adaptable (t :> u :> v :> w :> x) (t :> u :> v :> w :> x') where+	adapt = hoist (hoist (hoist (hoist adapt)))

@@ -1,4 +1,6 @@-module Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (..)) where+module Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (..)) where++type family Schematic (c :: (* -> *) -> k) (t :: * -> *) = (r :: (* -> *) -> * -> *) | r -> t  class Interpreted t where 	{-# MINIMAL run #-}

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

@@ -14,12 +14,12 @@ import Pandora.Pattern.Functor.Bindable (Bindable ((>>=))) import Pandora.Pattern.Functor.Extendable (Extendable ((=>>))) import Pandora.Pattern.Functor.Comonad (Comonad)-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))-import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic)+import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))+import Pandora.Pattern.Transformer.Hoistable (Hoistable (hoist))+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run))  class Interpreted t => Comonadic t where-	{-# MINIMAL flick, bring #-}-	flick :: Covariant u => t :< u ~> u+	{-# MINIMAL bring #-} 	bring :: Extractable u => t :< u ~> t  infixr 3 :<@@ -53,6 +53,12 @@ 	TC x =>> f = TC $ x =>> f . TC  instance (Extractable (t :< u), Extendable (t :< u)) => Comonad (t :< u) where++instance Lowerable (Schematic Comonad t) => Lowerable ((:<) t) where+	lower (TC x) = lower x++instance Hoistable (Schematic Comonad t) => Hoistable ((:<) t) where+	hoist f (TC x) = TC $ hoist f x  instance (Interpreted (Schematic Comonad t u)) => Interpreted (t :< u) where 	type Primary (t :< u) a = Primary (Schematic Comonad t u) a

@@ -14,12 +14,12 @@ import Pandora.Pattern.Functor.Bindable (Bindable ((>>=))) import Pandora.Pattern.Functor.Extendable (Extendable ((=>>))) import Pandora.Pattern.Functor.Monad (Monad)-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))-import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic)+import Pandora.Pattern.Transformer.Liftable (Liftable (lift))+import Pandora.Pattern.Transformer.Hoistable (Hoistable (hoist))+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run))  class Interpreted t => Monadic t where-	{-# MINIMAL lay, wrap #-}-	lay :: Covariant u => u ~> t :> u+	{-# MINIMAL wrap #-} 	wrap :: Pointable u => t ~> t :> u  infixr 3 :>@@ -53,6 +53,12 @@ 	TM x =>> f = TM $ x =>> f . TM  instance (Pointable (t :> u), Bindable (t :> u)) => Monad (t :> u) where++instance Liftable (Schematic Monad t) => Liftable ((:>) t) where+	lift = TM . lift++instance Hoistable (Schematic Monad t) => Hoistable ((:>) t) where+	hoist f (TM x) = TM $ hoist f x  instance (Interpreted (Schematic Monad t u)) => Interpreted (t :> u) where 	type Primary (t :> u) a = Primary (Schematic Monad t u) a

@@ -1,6 +1,6 @@ {-# OPTIONS_GHC -fno-warn-orphans #-} -module Pandora.Paradigm.Inventory (module Exports) where+module Pandora.Paradigm.Inventory (module Exports, zoom) where  import Pandora.Paradigm.Inventory.Optics as Exports import Pandora.Paradigm.Inventory.Store as Exports@@ -11,14 +11,16 @@ import Pandora.Paradigm.Inventory.Accumulator as Exports  import Pandora.Core.Morphism ((!), (%))-import Pandora.Pattern.Category ((.), ($))-import Pandora.Pattern.Functor.Extractable (extract)-import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))+import Pandora.Pattern.Category ((.), ($), identity)+import Pandora.Pattern.Functor (Adjoint ((-|), (|-)), extract, (<->)) import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:))) import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)+import Pandora.Paradigm.Controlflow.Effect.Adaptable (adapt)  instance Adjoint (Store s) (State s) where+	(-|) :: a -> (Store s a -> b) -> State s b 	x -| f = State $ \s -> (:*:) s . f . Store $ s :*: (x !)+	(|-) :: Store s a -> (a -> State s b) -> b 	Store (s :*: f) |- g = extract . run % s . g $ f s  instance Adjoint (Accumulator e) (Imprint e) where@@ -28,3 +30,6 @@ instance Adjoint (Equipment e) (Environment e) where 	x -| f = Environment $ x -| f . Equipment 	x |- g = run x |- run . g++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

@@ -11,9 +11,8 @@ import Pandora.Pattern.Object.Monoid (Monoid (zero)) import Pandora.Pattern.Object.Semigroup (Semigroup ((+))) import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))-import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))-import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic)+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run))+import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM)) import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt)) import Pandora.Paradigm.Schemes.UT (UT (UT), type (<.:>)) @@ -33,14 +32,13 @@ 	Accumulator (e :*: x) >>= f = let (e' :*: b) = run $ f x in 		Accumulator $ e + e':*: b -type instance Schematic Monad (Accumulator e) u = (:*:) e <.:> u+type instance Schematic Monad (Accumulator e) = (<.:>) ((:*:) e)  instance Interpreted (Accumulator e) where 	type Primary (Accumulator e) a = e :*: a 	run (Accumulator x) = x  instance Monoid e => Monadic (Accumulator e) where-	lay x = TM . UT $ (zero :*:) <$> x 	wrap = TM . UT . point . run  type Accumulated e t = Adaptable (Accumulator e) t

@@ -10,9 +10,8 @@ import Pandora.Pattern.Functor.Bindable (Bindable ((>>=))) import Pandora.Pattern.Functor.Monad (Monad) import Pandora.Core.Morphism ((!), (%))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))-import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))-import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic)+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run))+import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM)) import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt)) import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>)) @@ -39,10 +38,9 @@ 	type Primary (Environment e) a = (->) e a 	run (Environment x) = x -type instance Schematic Monad (Environment e) u = (->) e <:.> u+type instance Schematic Monad (Environment e) = (<:.>) ((->) e)  instance Monadic (Environment e) where-	lay = TM . TU . (!) 	wrap x = TM . TU $ point <$> run x  type Configured e = Adaptable (Environment e)

@@ -9,9 +9,8 @@ import Pandora.Pattern.Functor.Comonad (Comonad) import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), attached) import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))-import Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic (Comonadic (flick, bring), (:<) (TC))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))-import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic)+import Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic (Comonadic (bring), (:<) (TC))+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run)) import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))  newtype Equipment e a = Equipment (e :*: a)@@ -29,10 +28,9 @@ 	type Primary (Equipment e) a = e :*: a 	run (Equipment x) = x -type instance Schematic Comonad (Equipment e) u = (:*:) e <:.> u+type instance Schematic Comonad (Equipment e) = (<:.>) ((:*:) e)  instance Comonadic (Equipment e) where-	flick (TC (TU x)) = extract x 	bring (TC (TU x)) = Equipment $ extract <$> x  type Equipped e t = Adaptable t (Equipment e)

@@ -11,9 +11,8 @@ import Pandora.Pattern.Functor.Comonad (Comonad) import Pandora.Pattern.Object.Monoid (Monoid (zero)) import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))-import Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic (Comonadic (flick, bring), (:<) (TC))-import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic)+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run))+import Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic (Comonadic (bring), (:<) (TC)) import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable) import Pandora.Paradigm.Schemes.UT (UT (UT), type (<.:>)) @@ -35,10 +34,9 @@ 	type Primary (Imprint e) a = (->) e a 	run (Imprint x) = x -type instance Schematic Comonad (Imprint e) u = (->) e <.:> u+type instance Schematic Comonad (Imprint e) = (<.:>) ((->) e)  instance Monoid e => Comonadic (Imprint e) where-	flick (TC (UT x)) = extract <$> x 	bring (TC (UT x)) = Imprint . extract $ x  instance Covariant u => Covariant ((->) e <.:> u) where

@@ -3,16 +3,13 @@ module Pandora.Paradigm.Inventory.Optics where  import Pandora.Core.Functor (type (|->))-import Pandora.Pattern.Category (identity, (.), ($))+import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Covariant ((<$)) import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Representable (Representable (Representation, (<#>), tabulate))-import Pandora.Pattern.Functor.Bivariant ((<->)) import Pandora.Pattern.Object.Setoid (Setoid ((==))) import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:))) import Pandora.Paradigm.Primary.Object.Boolean ((?))-import Pandora.Paradigm.Controlflow.Effect.Adaptable (adapt)-import Pandora.Paradigm.Inventory.State (State (State), Stateful) import Pandora.Paradigm.Inventory.Store (Store (Store), access, position, retrofit)  infixr 0 :-.@@ -47,9 +44,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  represent :: (Representable t, Setoid (Representation t)) => Representation t -> t a :-. a represent r x = Store $ (r <#> x) :*: \new -> tabulate (\r' -> r' == r ? new $ r' <#> x)

@@ -1,29 +1,15 @@ {-# OPTIONS_GHC -fno-warn-orphans #-} -module Pandora.Paradigm.Inventory.State (State (..), Stateful, current, modify, replace, fold, find) where+module Pandora.Paradigm.Inventory.State where  import Pandora.Core.Functor (type (:.), type (:=)) import Pandora.Core.Morphism ((%)) import Pandora.Pattern.Category (identity, (.), ($))-import Pandora.Pattern.Functor ((<*+>))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))-import Pandora.Pattern.Functor.Extractable (extract)-import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (*>)))-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))-import Pandora.Pattern.Functor.Monad (Monad)-import Pandora.Pattern.Functor.Adjoint ((-|), (|-))-import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))-import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))-import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic)+import Pandora.Pattern.Functor (Covariant ((<$>), (<$$>)), Avoidable (empty), Pointable (point), Applicative ((<*>), (*>)), Alternative ((<+>)), Traversable ((->>)), Bindable ((>>=), (>=>)), Monad, extract, (-|), (|-), (<*+>))+import Pandora.Paradigm.Controlflow (Adaptable (adapt), Interpreted (Primary, run), Monadic (wrap), (:>) (TM), Schematic) import Pandora.Paradigm.Schemes.TUT (TUT (TUT), type (<:<.>:>))-import Pandora.Paradigm.Primary.Object.Boolean (bool)-import Pandora.Paradigm.Primary.Functor.Predicate (Predicate (Predicate))-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), delta)+import Pandora.Paradigm.Primary.Functor (Predicate (Predicate), Product ((:*:)), type (:*:), delta)+import Pandora.Paradigm.Primary.Object (bool)  newtype State s a = State ((->) s :. (:*:) s := a) @@ -54,25 +40,24 @@ 	type Primary (State s) a = (->) s :. (:*:) s := a 	run (State x) = x -type instance Schematic Monad (State s) u = (->) s <:<.>:> (:*:) s := u+type instance Schematic Monad (State s) = (->) s <:<.>:> (:*:) s  instance Monadic (State s) where-	lay x = TM . TUT $ \s -> (s :*:) <$> x 	wrap x = TM . TUT $ point <$> run x  type Stateful s = Adaptable (State s)  instance Covariant u => Covariant ((->) s <:<.>:> (:*:) s := u) where-	f <$> TUT x = TUT $ \old -> f <$$> x old+	f <$> TUT x = TUT $ (<$$>) f . x  instance Bindable u => Applicative ((->) s <:<.>:> (:*:) s := u) where-	TUT f <*> TUT x = TUT $ \old -> f old >>= \(new :*: g) -> g <$$> x new+	TUT f <*> TUT x = TUT $ f >=> \(new :*: g) -> g <$$> x new  instance Pointable u => Pointable ((->) s <:<.>:> (:*:) s := u) where 	point = TUT . (-| point)  instance Bindable u => Bindable ((->) s <:<.>:> (:*:) s := u) where-	TUT x >>= f = TUT $ \old -> x old >>= \(new :*: y) -> ($ new) . run . f $ y+	TUT x >>= f = TUT $ x >=> \(new :*: y) -> ($ new) . run . f $ y  instance Monad u => Monad ((->) s <:<.>:> (:*:) s := u) where 

@@ -1,22 +1,15 @@ {-# OPTIONS_GHC -fno-warn-orphans #-} -module Pandora.Paradigm.Inventory.Store (Store (..), Storable, position, access, retrofit) where+module Pandora.Paradigm.Inventory.Store where -import Pandora.Core.Functor (type (:.), type (:=), type (<-|), type (~>))-import Pandora.Core.Morphism ((%))+import Pandora.Core (type (:.), type (:=), type (<-|), type (~>), (%)) import Pandora.Pattern.Category (identity, (.), ($))-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.Adjoint ((-|), (|-))-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), attached)-import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))-import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic)+import Pandora.Pattern.Functor (Covariant ((<$>), (<$$>), (<$$$>)), Extractable (extract), Extendable ((=>>), (<<=$)), Comonad, (.|..), (-|), (|-))+import Pandora.Paradigm.Primary.Functor (Product ((:*:)), type (:*:), attached)+import Pandora.Paradigm.Controlflow (Adaptable (adapt), Interpreted (Primary, run), Schematic, Comonadic (bring), (:<) (TC)) import Pandora.Paradigm.Schemes.TUT (TUT (TUT), type (<:<.>:>))-import Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic (Comonadic (flick, bring), (:<) (TC)) + newtype Store p a = Store ((:*:) p :. (->) p := a)  instance Covariant (Store p) where@@ -34,10 +27,9 @@ 	type Primary (Store p) a = (:*:) p :. (->) p := a 	run (Store x) = x -type instance Schematic Comonad (Store p) u = (:*:) p <:<.>:> (->) p := u+type instance Schematic Comonad (Store p) = (:*:) p <:<.>:> (->) p  instance Comonadic (Store p) where-	flick (TC (TUT (p :*: f))) = ($ p) <$> f 	bring (TC (TUT (p :*: f))) = Store $ p :*: extract f  type Storable s x = Adaptable x (Store s)

@@ -1,3 +1,5 @@+{-# OPTIONS_GHC -fno-warn-orphans #-}+ module Pandora.Paradigm.Primary.Functor (module Exports, note, hush, left, right, this, that, here, there) where  import Pandora.Paradigm.Primary.Functor.Fix as Exports@@ -20,6 +22,14 @@  import Pandora.Core.Morphism ((!)) import Pandora.Core.Functor (type (~>))+import Pandora.Pattern.Category (($))+import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))++instance Adjoint (Product s) ((->) s) where+	(-|) :: a -> ((s :*: a) -> b) -> (s -> b)+	x -| f = \s -> f $ s :*: x+	(|-) :: (s :*: a) -> (a -> s -> b) -> b+	(s :*: x) |- f = f x s  note :: e -> Maybe ~> Conclusion e note x = maybe (Failure x) Success

@@ -15,9 +15,8 @@ import Pandora.Pattern.Object.Semigroup (Semigroup ((+))) import Pandora.Paradigm.Primary.Object.Boolean (Boolean (False)) import Pandora.Paradigm.Primary.Object.Ordering (Ordering (Less, Greater))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))-import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))-import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic)+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run))+import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM)) import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt)) import Pandora.Paradigm.Schemes.UT (UT (UT)) @@ -80,10 +79,9 @@ 	type Primary (Conclusion e) a = Conclusion e a 	run x = x -type instance Schematic Monad (Conclusion e) u = UT Covariant Covariant (Conclusion e) u+type instance Schematic Monad (Conclusion e) = UT Covariant Covariant (Conclusion e)  instance Monadic (Conclusion e) where-	lay x = TM . UT $ Success <$> x 	wrap x = TM . UT . point $ x  type Failable e = Adaptable (Conclusion e)

@@ -17,9 +17,8 @@ import Pandora.Pattern.Object.Lattice (Lattice) import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False)) import Pandora.Paradigm.Primary.Object.Ordering (Ordering (Less, Equal, Greater))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))-import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))-import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic)+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run))+import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM)) import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt)) import Pandora.Paradigm.Schemes.UT (UT (UT)) @@ -88,14 +87,14 @@ maybe x _ Nothing = x maybe _ f (Just y) = f y -type instance Schematic Monad Maybe u = UT Covariant Covariant Maybe u+-- type instance Schematic Monad Maybe u = UT Covariant Covariant Maybe u+type instance Schematic Monad Maybe = UT Covariant Covariant Maybe  instance Interpreted Maybe where 	type Primary Maybe a = Maybe a 	run x = x  instance Monadic Maybe where-	lay x = TM . UT $ Just <$> x 	wrap x = TM . UT . point $ x  type Optional = Adaptable Maybe

@@ -6,7 +6,6 @@ import Pandora.Pattern.Functor.Traversable (Traversable ((->>))) 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.Object.Setoid (Setoid ((==))) import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))@@ -20,56 +19,52 @@  infixr 1 :*: -data Product a b = a :*: b+data Product s a = s :*: a  type (:*:) = Product -instance Covariant (Product a) where-	f <$> (x :*: y) = x :*: f y+instance Covariant (Product s) where+	f <$> (s :*: x) = s :*: f x  instance Extractable (Product a) where 	extract (_ :*: y) = y -instance Traversable (Product a) where-	(x :*: y) ->> f = (:*:) x <$> f y--instance Extendable (Product a) where-	(x :*: y) =>> f = (:*:) x $ f (x :*: y)+instance Traversable (Product s) where+	(s :*: x) ->> f = (s :*:) <$> f x -instance Comonad (Product a) where+instance Extendable (Product s) where+	(s :*: x) =>> f = s :*: f (s :*: x) -instance Adjoint (Product a) ((->) a) where-	x -| f = \y -> f $ y :*: x-	(y :*: x) |- f = f x y+instance Comonad (Product s) where  instance Bivariant Product where-	f <-> g = \(x :*: y) -> f x :*: g y+	f <-> g = \(s :*: x) -> f s :*: g x -instance (Setoid a, Setoid b) => Setoid (Product a b) where-	(x :*: y) == (x' :*: y') = (x == x') * (y == y')+instance (Setoid s, Setoid a) => Setoid (Product s a) where+	(s :*: x) == (s' :*: x') = (s == s') * (x == x') -instance (Semigroup a, Semigroup b) => Semigroup (Product a b) where-	(x :*: y) + (x' :*: y') = x + x' :*: y + y'+instance (Semigroup s, Semigroup a) => Semigroup (Product s a) where+	(s :*: x) + (s' :*: x') = s + s' :*: x + x' -instance (Monoid a, Monoid b) => Monoid (Product a b) where+instance (Monoid s, Monoid a) => Monoid (Product s a) where 	zero = zero :*: zero -instance (Ringoid a, Ringoid b) => Ringoid (Product a b) where-	(x :*: y) * (x' :*: y') = x * x' :*: y * y'+instance (Ringoid s, Ringoid a) => Ringoid (Product s a) where+	(s :*: x) * (s' :*: x') = s * s' :*: x * x' -instance (Quasiring a, Quasiring b) => Quasiring (Product a b) where+instance (Quasiring s, Quasiring a) => Quasiring (Product s a) where 	one = one :*: one -instance (Infimum a, Infimum b) => Infimum (Product a b) where-	(x :*: y) /\ (x' :*: y') = x /\ x' :*: y /\ y'+instance (Infimum s, Infimum a) => Infimum (Product s a) where+	(s :*: x) /\ (s' :*: x') = s /\ s' :*: x /\ x' -instance (Supremum a, Supremum b) => Supremum (Product a b) where-	(x :*: y) \/ (x' :*: y') = x \/ x' :*: y \/ y'+instance (Supremum s, Supremum a) => Supremum (Product s a) where+	(s :*: x) \/ (s' :*: x') = s \/ s' :*: x \/ x' -instance (Lattice a, Lattice b) => Lattice (Product a b) where+instance (Lattice s, Lattice a) => Lattice (Product s a) where -instance (Group a, Group b) => Group (Product a b) where-	invert (x :*: y) = invert x :*: invert y+instance (Group s, Group a) => Group (Product s a) where+	invert (s :*: x) = invert s :*: invert x  instance Monotonic e a => Monotonic (Product a e) a where 	iterate f r (x :*: e) = iterate f (f x r) e

@@ -6,6 +6,7 @@ import Pandora.Pattern.Functor.Covariant (Covariant ((<$>))) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))+import Pandora.Pattern.Functor.Traversable (Traversable) import Pandora.Pattern.Functor.Bindable (Bindable ((>>=))) import Pandora.Pattern.Functor.Monad (Monad) import Pandora.Pattern.Transformer.Liftable (Liftable (lift))@@ -34,7 +35,7 @@ cwcc f = Continuation $ \g -> continue % g . f $ Continuation . (!) . g  -- | Delimit the continuation of any 'shift'-reset :: (forall u . Bindable u, Bindable t, Pointable t) => Continuation r t r -> Continuation s t r+reset :: (forall u . Bindable u, Monad t, Traversable t) => Continuation r t r -> Continuation s t r reset = lift . continue % point  -- | Capture the continuation up to the nearest enclosing 'reset' and pass it

@@ -1,6 +1,6 @@ module Pandora.Paradigm.Schemes.TU where -import Pandora.Core.Functor (type (:.), type (:=))+import Pandora.Core.Functor (type (:.), type (:=), type (~>)) import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>))) import Pandora.Pattern.Functor.Contravariant (Contravariant)@@ -23,10 +23,13 @@ 	run (TU x) = x  instance Pointable t => Liftable (TU Covariant Covariant t) where+	lift :: Covariant u => u ~> t <:.> u 	lift = TU . point  instance Extractable t => Lowerable (TU Covariant Covariant t) where+	lower :: t <:.> u ~> u 	lower (TU x) = extract x  instance Covariant t => Hoistable (TU Covariant Covariant t) where+	hoist :: u ~> v -> (t <:.> u ~> t <:.> v) 	hoist f (TU x) = TU $ f <$> x

@@ -1,12 +1,9 @@ module Pandora.Paradigm.Schemes.TUT where -import Pandora.Core.Functor (type (:.), type (:=))+import Pandora.Core.Functor (type (:.), type (:=), type (~>)) import Pandora.Pattern.Category (identity, ($)) import Pandora.Pattern.Functor.Covariant (Covariant) import Pandora.Pattern.Functor.Contravariant (Contravariant)-import Pandora.Pattern.Functor.Pointable (Pointable)-import Pandora.Pattern.Functor.Applicative (Applicative)-import Pandora.Pattern.Functor.Traversable (Traversable ((->>))) import Pandora.Pattern.Functor.Distributive (Distributive ((>>-))) import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-))) import Pandora.Pattern.Transformer.Liftable (Liftable (lift))@@ -28,8 +25,10 @@ 	type Primary (TUT ct ct' cu t t' u) a = t :. u :. t' := a 	run (TUT x) = x -instance (Adjoint t' t, Applicative t, Pointable t, forall u . Traversable u) => Liftable (t <:<.>:> t') where-	lift x = TUT $ x ->> (-| identity)+instance (Adjoint t' t, Distributive t) => Liftable (t <:<.>:> t') where+	lift :: Covariant u => u ~> t <:<.>:> t' := u+	lift x = TUT $ x >>- (-| identity)  instance (Adjoint t t', Distributive t') => Lowerable (t <:<.>:> t') where+	lower :: Covariant u => (t <:<.>:> t' := u) ~> u 	lower (TUT x) = x |- (>>- identity)

@@ -1,6 +1,6 @@ module Pandora.Paradigm.Schemes.UT where -import Pandora.Core.Functor (type (:.), type (:=))+import Pandora.Core.Functor (type (:.), type (:=), type (~>)) import Pandora.Pattern.Category (($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>))) import Pandora.Pattern.Functor.Contravariant (Contravariant)@@ -21,8 +21,10 @@ 	type Primary (UT ct cu t u) a = u :. t := a 	run (UT x) = x -instance (forall u . Covariant u, Pointable t) => Liftable (UT Covariant Covariant t) where+instance Pointable t => Liftable (UT Covariant Covariant t) where+	lift :: Covariant u => u ~> t <.:> u 	lift x = UT $ point <$> x  instance Extractable t => Lowerable (UT Covariant Covariant t) where+	lower :: Covariant u => t <.:> u ~> u 	lower (UT x) = extract <$> x

@@ -1,7 +1,22 @@+{-# OPTIONS_GHC -fno-warn-orphans #-}+ module Pandora.Paradigm.Structure (module Exports) where  import Pandora.Paradigm.Structure.Ability as Exports+import Pandora.Paradigm.Structure.Interface as Exports import Pandora.Paradigm.Structure.Rose as Exports import Pandora.Paradigm.Structure.Splay as Exports import Pandora.Paradigm.Structure.Binary as Exports import Pandora.Paradigm.Structure.Stack as Exports++import Pandora.Pattern (($), (.), extract)+import Pandora.Paradigm.Primary (Product ((:*:)), Tagged (Tag), Wye (Left, Right))+import Pandora.Paradigm.Inventory (Store (Store))++instance Substructure Left (Product s) where+	type Substructural Left (Product s) a = s+	substructure (extract -> s :*: x) = Store $ s :*: Tag . (:*: x)++instance Substructure Right (Product s) where+	type Substructural Right (Product s) a = a+	substructure (extract -> s :*: x) = Store $ x :*: Tag . (s :*:)

@@ -0,0 +1,3 @@+module Pandora.Paradigm.Structure.Interface (module Exports) where++import Pandora.Paradigm.Structure.Interface.Set as Exports

@@ -0,0 +1,7 @@+module Pandora.Paradigm.Structure.Interface.Set where++import Pandora.Pattern.Object.Setoid (Setoid)+import Pandora.Paradigm.Primary.Object.Boolean (Boolean)++class Set t where+	member :: Setoid a => a -> t a -> Boolean

@@ -3,7 +3,7 @@ module Pandora.Paradigm.Structure.Stack where  import Pandora.Core.Functor (type (~>))-import Pandora.Core.Morphism ((&), (%))+import Pandora.Core.Morphism ((&), (%), (!)) import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), (.|..)) import Pandora.Pattern.Functor.Alternative ((<+>))@@ -18,13 +18,14 @@ import Pandora.Pattern.Object.Monoid (Monoid (zero)) import Pandora.Paradigm.Primary.Object.Boolean ((?)) import Pandora.Paradigm.Primary.Functor.Delta (Delta ((:^:)))-import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))+import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing), maybe) import Pandora.Paradigm.Primary.Functor.Predicate (Predicate (Predicate)) import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:))) import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag))+import Pandora.Paradigm.Primary.Object (Boolean (True, False)) import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct) import Pandora.Paradigm.Primary.Transformer.Tap (Tap (Tap))-import Pandora.Paradigm.Inventory.State (fold)+import Pandora.Paradigm.Inventory.State (fold, find) import Pandora.Paradigm.Inventory.Store (Store (Store)) import Pandora.Paradigm.Inventory.Optics ((^.)) import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)@@ -33,6 +34,7 @@ import Pandora.Paradigm.Structure.Ability.Zipper (Zipper) import Pandora.Paradigm.Structure.Ability.Focusable (Focusable (Focusing, focusing), Location (Head), focus) import Pandora.Paradigm.Structure.Ability.Insertable (Insertable (insert))+import Pandora.Paradigm.Structure.Interface.Set (Set (member))  -- | Linear data structure that serves as a collection of elements type Stack = Maybe <:.> Construction Maybe@@ -56,6 +58,9 @@  instance Insertable Stack where 	insert x (TU stack) = TU $ (Construct x . Just <$> stack) <+> (point . point) x++instance Set Stack where+	member x = maybe False (True !) . find (Predicate (== x))  pop :: Stack ~> Stack pop (TU stack) = TU $ stack >>= deconstruct

@@ -11,7 +11,7 @@ > When providing a new instance, you should ensure it satisfies the three laws: > * Left identity: point a >>= f ≡ f a > * Right identity: h >>= point ≡ h-> * Associativity: h >>= (\x -> f x >>= g) ≡ (h >>= f) >>= g+> * Associativity: h >>= (f >=> g) ≡ (h >>= f) >>= g -}  class (Pointable t, Bindable t) => Monad t

@@ -1,5 +1,5 @@ name:                pandora-version:             0.3.0+version:             0.3.1 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@@ -76,7 +76,6 @@     Pandora.Paradigm.Controlflow.Effect.Transformer     Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic     Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic-    Pandora.Paradigm.Controlflow.Effect.Schematic     Pandora.Paradigm.Controlflow.Effect.Adaptable     Pandora.Paradigm.Controlflow.Observable     Pandora.Paradigm.Controlflow.Pipeline@@ -105,6 +104,8 @@     Pandora.Paradigm.Structure.Ability.Nonempty     Pandora.Paradigm.Structure.Ability.Zipper     Pandora.Paradigm.Structure.Ability.Monotonic+    Pandora.Paradigm.Structure.Interface+    Pandora.Paradigm.Structure.Interface.Set      Pandora.Pattern     -- Category typeclass@@ -149,7 +150,7 @@     Pandora.Pattern.Transformer.Liftable     Pandora.Pattern.Transformer.Lowerable   default-extensions:-    DataKinds, ConstraintKinds, ExistentialQuantification, GADTs, QuantifiedConstraints+    DataKinds, ConstraintKinds, ExistentialQuantification, GADTs, QuantifiedConstraints, InstanceSigs     FlexibleContexts, FlexibleInstances, KindSignatures, LiberalTypeSynonyms, LambdaCase     MultiParamTypeClasses, NoImplicitPrelude, PackageImports, PolyKinds, RankNTypes, ViewPatterns     ScopedTypeVariables, TypeApplications, TypeFamilies, TypeFamilyDependencies, TypeOperators