pandora 0.4.3 → 0.4.4

raw patch · 77 files changed

+866/−1118 lines, 77 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• CHANGELOG.md +29/−0
• Pandora/Paradigm/Controlflow/Effect/Adaptable.hs +44/−127
• Pandora/Paradigm/Controlflow/Effect/Interpreted.hs +1/−1
• Pandora/Paradigm/Controlflow/Effect/Transformer/Comonadic.hs +13/−13
• Pandora/Paradigm/Controlflow/Effect/Transformer/Monadic.hs +13/−13
• Pandora/Paradigm/Controlflow/Pipeline.hs +4/−4
• Pandora/Paradigm/Inventory.hs +15/−15
• Pandora/Paradigm/Inventory/Accumulator.hs +6/−6
• Pandora/Paradigm/Inventory/Environment.hs +13/−8
• Pandora/Paradigm/Inventory/Equipment.hs +10/−9
• Pandora/Paradigm/Inventory/Imprint.hs +16/−11
• Pandora/Paradigm/Inventory/Optics.hs +2/−2
• Pandora/Paradigm/Inventory/State.hs +21/−15
• Pandora/Paradigm/Inventory/Store.hs +8/−9
• Pandora/Paradigm/Primary.hs +4/−3
• Pandora/Paradigm/Primary/Algebraic.hs +30/−0
• Pandora/Paradigm/Primary/Algebraic/Exponential.hs +85/−0
• Pandora/Paradigm/Primary/Algebraic/Product.hs +85/−0
• Pandora/Paradigm/Primary/Functor.hs +2/−23
• Pandora/Paradigm/Primary/Functor/Conclusion.hs +19/−32
• Pandora/Paradigm/Primary/Functor/Constant.hs +7/−8
• Pandora/Paradigm/Primary/Functor/Convergence.hs +1/−1
• Pandora/Paradigm/Primary/Functor/Edges.hs +7/−7
• Pandora/Paradigm/Primary/Functor/Endo.hs +1/−1
• Pandora/Paradigm/Primary/Functor/Fix.hs +1/−1
• Pandora/Paradigm/Primary/Functor/Function.hs +0/−94
• Pandora/Paradigm/Primary/Functor/Identity.hs +14/−24
• Pandora/Paradigm/Primary/Functor/Maybe.hs +14/−25
• Pandora/Paradigm/Primary/Functor/Predicate.hs +2/−2
• Pandora/Paradigm/Primary/Functor/Product.hs +0/−97
• Pandora/Paradigm/Primary/Functor/Proxy.hs +11/−14
• Pandora/Paradigm/Primary/Functor/Tagged.hs +19/−18
• Pandora/Paradigm/Primary/Functor/These.hs +7/−10
• Pandora/Paradigm/Primary/Functor/Validation.hs +11/−17
• Pandora/Paradigm/Primary/Functor/Wedge.hs +7/−10
• Pandora/Paradigm/Primary/Functor/Wye.hs +0/−9
• Pandora/Paradigm/Primary/Linear/Vector.hs +1/−1
• Pandora/Paradigm/Primary/Transformer/Backwards.hs +16/−15
• Pandora/Paradigm/Primary/Transformer/Construction.hs +13/−18
• Pandora/Paradigm/Primary/Transformer/Continuation.hs +8/−8
• Pandora/Paradigm/Primary/Transformer/Day.hs +5/−5
• Pandora/Paradigm/Primary/Transformer/Instruction.hs +13/−11
• Pandora/Paradigm/Primary/Transformer/Jack.hs +13/−17
• Pandora/Paradigm/Primary/Transformer/Jet.hs +4/−4
• Pandora/Paradigm/Primary/Transformer/Outline.hs +1/−1
• Pandora/Paradigm/Primary/Transformer/Reverse.hs +10/−9
• Pandora/Paradigm/Primary/Transformer/Tap.hs +17/−16
• Pandora/Paradigm/Primary/Transformer/Yoneda.hs +4/−4
• Pandora/Paradigm/Schemes.hs +20/−20
• Pandora/Paradigm/Schemes/TU.hs +10/−10
• Pandora/Paradigm/Schemes/TUT.hs +20/−25
• Pandora/Paradigm/Schemes/T_U.hs +7/−7
• Pandora/Paradigm/Schemes/UT.hs +7/−7
• Pandora/Paradigm/Structure.hs +8/−8
• Pandora/Paradigm/Structure/Ability/Monotonic.hs +1/−1
• Pandora/Paradigm/Structure/Ability/Morphable.hs +2/−2
• Pandora/Paradigm/Structure/Interface/Set.hs +8/−7
• Pandora/Paradigm/Structure/Modification/Comprehension.hs +11/−10
• Pandora/Paradigm/Structure/Modification/Prefixed.hs +7/−6
• Pandora/Paradigm/Structure/Some/Binary.hs +8/−8
• Pandora/Paradigm/Structure/Some/List.hs +28/−29
• Pandora/Paradigm/Structure/Some/Rose.hs +6/−6
• Pandora/Paradigm/Structure/Some/Splay.hs +20/−20
• Pandora/Paradigm/Structure/Some/Stream.hs +4/−4
• Pandora/Pattern/Functor/Adjoint.hs +5/−42
• Pandora/Pattern/Functor/Applicative.hs +2/−2
• Pandora/Pattern/Functor/Bindable.hs +4/−30
• Pandora/Pattern/Functor/Bivariant.hs +5/−13
• Pandora/Pattern/Functor/Comonad.hs +1/−1
• Pandora/Pattern/Functor/Distributive.hs +6/−27
• Pandora/Pattern/Functor/Divariant.hs +11/−11
• Pandora/Pattern/Functor/Divisible.hs +3/−3
• Pandora/Pattern/Functor/Extendable.hs +5/−34
• Pandora/Pattern/Functor/Monad.hs +13/−13
• Pandora/Pattern/Functor/Pointable.hs +0/−3
• Pandora/Pattern/Functor/Traversable.hs +13/−28
• pandora.cabal +4/−3

@@ -488,3 +488,32 @@ * Remove `Covariant` superclass of `Hoistable`  # 0.4.4+* Remove experimental `Pointable_` typeclass+* Use experimental `Covariant_` as superclass of `Distributive`+* Use experimental `Covariant_` as superclass of `Traversable`+* Define experimental `Traversable_` typeclass+* Define experimental `Distributibe_` typeclass+* Define experimental `-<<-<<-` method of `Traversable_` typeclass+* Remove `Adjoint` typeclass+* Rename experimental `Adjoint_` to `Adjoint`+* Remove `Bivariant` typeclass+* Rename experimental `Bivariant_` to `Bivariant`+* Remove `Distributive` typeclass+* Rename experimental `Distributive_` to `Distributive`+* Remove `Divariant` typeclass+* Rename experimental `Divariant_` to `Divariant`+* Rename `Product` type to `:*:`+* Move `Paradigm.Primary.Functor.Function` module to `Paradigm.Primary.Algebraic.Exponential`+* Move `Paradigm.Primary.Functor.Product` module to `Paradigm.Primary.Algebraic.Product`+* Add `Covariant_`, `Pointable` and `Applicative_` constraints to `Traversable_` typeclass+* Remove `join_` method from `Bindable_` typeclass+* Remove `Traversable` typeclass+* Rename experimental `Traversable_` to `Traversable`+* Remove `Bindable` typeclass+* Rename experimental `Bindable_` to `Bindable`+* Use experimental `Extendable_` as superclass for `Comonad`+* Remove `Extendable` typeclass+* Rename experimental `Extendable_` to `Extendable`+* Rename experimental `Applicative_` to `Semimonoidal`++# 0.4.5

@@ -17,60 +17,53 @@ 	{-# MINIMAL adapt #-} 	adapt :: t ~> u -type Lifting t u = (Monadic t, Liftable (Schematic Monad t), Covariant u, Covariant_ u (->) (->))-type Lowering t u = (Comonadic t, Lowerable (Schematic Comonad t), Covariant u, Covariant_ u (->) (->))+type Lifting t u = (Monadic t, Liftable (Schematic Monad t), Covariant_ u (->) (->))+type Lowering t u = (Comonadic t, Lowerable (Schematic Comonad t), Covariant_ u (->) (->)) type Wrappable t u = (Monadic t, Pointable u (->)) type Bringable t u = (Comonadic t, Extractable u (->)) -instance Covariant t => Adaptable t t where+instance Adaptable t t where 	adapt = identity -instance (Covariant (t :> u), Lifting t u) => Adaptable u (t :> u) where+instance Lifting t u => Adaptable u (t :> u) where 	adapt = lift -instance (Covariant (t :> u), Wrappable t u) => Adaptable t (t :> u) where+instance Wrappable t u => Adaptable t (t :> u) where 	adapt = wrap -instance (Covariant (t :> u), Lowering t u) => Adaptable (t :< u) u where+instance Lowering t u => Adaptable (t :< u) u where 	adapt = lower -instance (Covariant (t :< u), Bringable t u) => Adaptable (t :< u) t where+instance Bringable t u => Adaptable (t :< u) t where 	adapt = bring  instance-	( Covariant (t :> u :> v)-	, Liftable (Schematic Monad t)-	, Covariant (Schematic Monad u v)+	( Liftable (Schematic Monad t) 	, Covariant_ (Schematic Monad u v) (->) (->) 	, Wrappable u v 	) => Adaptable u (t :> u :> v) where 	adapt = lift . wrap  instance-	( Covariant (t :> u :> v)-	, Lifting t (Schematic Monad u v)+	( Lifting t (Schematic Monad u v) 	, Lifting u v 	) => Adaptable v (t :> u :> v) where 	adapt = lift . lift  instance-	( Covariant (t :< u :< v)-	, Lowering t (Schematic Comonad u v)+	( Lowering t (Schematic Comonad u v) 	, Bringable u v 	) => Adaptable (t :< u :< v) u where 	adapt = bring . lower  instance-	( Covariant (t :< u :< v)-	, Lowering t (Schematic Comonad u v)+	( Lowering t (Schematic Comonad u v) 	, Lowering u v 	) => Adaptable (t :< u :< v) v where 	adapt = lower . lower  instance-	( Covariant_ t (->) (->) - 	, Covariant (t :> u :> v :> w)-	, Liftable (Schematic Monad t)+	( Liftable (Schematic Monad t) 	, Lifting t (Schematic Monad u (v :> w)) 	, Lifting u (Schematic Monad v w) 	, Wrappable v w@@ -78,8 +71,7 @@ 	adapt = lift . lift . wrap  instance-	( Covariant (t :> u :> v :> w)-	, Lifting t (Schematic Monad u v)+	( Lifting t (Schematic Monad u v) 	, Lifting t (Schematic Monad u (v :> w)) 	, Lifting u (Schematic Monad v w) 	, Lifting v w@@ -87,16 +79,14 @@ 	adapt = lift . lift . lift  instance-	( Covariant (t :< u :< v :< w)-	, Lowering t (Schematic Comonad u (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 . lower . lower  instance-	( Covariant (t :< u :< v :< w)-	, Lowering t (Schematic Comonad u v)+	( Lowering t (Schematic Comonad u v) 	, Lowering t (Schematic Comonad u (v :< w)) 	, Lowering u (Schematic Comonad v w) 	, Lowering v w@@ -104,8 +94,7 @@ 	adapt = lower . lower . lower  instance-	( Covariant (t :> u :> v :> w :> x)-	, Lifting t (Schematic Monad u (v :> 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@@ -113,8 +102,7 @@ 	adapt = lift . lift . lift . lift  instance-	( Covariant (t :> u :> v :> w :> x)-	, Lifting t (Schematic Monad u (v :> 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@@ -122,8 +110,7 @@ 	adapt = lift . lift . lift . wrap  instance-	( Covariant (t :< u :< v :< w :< x)-	, Lowering t (Schematic Comonad u (v :< 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@@ -131,8 +118,7 @@ 	adapt = lower . lower . lower . lower  instance-	( Covariant (t :< u :< v :< w :< x)-	, Lowering t (Schematic Comonad u (v :< 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@@ -140,8 +126,7 @@ 	adapt = bring . lower . lower . lower  instance-	( Covariant (t :> u :> v :> w :> x :> y)-	, Lifting t (Schematic Monad u (v :> w :> 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)@@ -150,8 +135,7 @@ 	adapt = lift . lift . lift . lift . lift  instance-	( Covariant (t :> u :> v :> w :> x :> y)-	, Lifting t (Schematic Monad u (v :> w :> 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)@@ -160,8 +144,7 @@ 	adapt = lift . lift . lift . lift . wrap  instance-	( Covariant (t :< u :< v :< w :< x :< y)-	, Lowering t (Schematic Comonad u (v :< w :< 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)@@ -170,8 +153,7 @@ 	adapt = lower . lower . lower . lower . lower  instance-	( Covariant (t :< u :< v :< w :< x :< y)-	, Lowering t (Schematic Comonad u (v :< w :< 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)@@ -180,8 +162,7 @@ 	adapt = bring . lower . lower . lower . lower  instance-	( Covariant (t :> u :> v :> w :> x :> y :> z)-	, Lifting t (Schematic Monad u (v :> w :> x :> 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))@@ -191,8 +172,7 @@ 	adapt = lift . lift . lift . lift . lift . lift  instance-	( Covariant (t :> u :> v :> w :> x :> y :> z)-	, Lifting t (Schematic Monad u (v :> w :> x :> 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))@@ -202,8 +182,7 @@ 	adapt = lift . lift . lift . lift . lift . wrap  instance-	( Covariant (t :< u :< v :< w :< x :< y :< z)-	, Lowering t (Schematic Comonad u (v :< w :< x :< 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))@@ -213,8 +192,7 @@ 	adapt = lower . lower . lower . lower . lower . lower  instance-	( Covariant (t :< u :< v :< w :< x :< y :< z)-	, Lowering t (Schematic Comonad u (v :< w :< x :< 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))@@ -224,8 +202,7 @@ 	adapt = bring . lower . lower . lower . lower . lower  instance-	( Covariant (t :> u :> v :> w :> x :> y :> z :> f)-	, Lifting t (Schematic Monad u (v :> w :> x :> y :> 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))@@ -236,8 +213,7 @@ 	adapt = lift . lift . lift . lift . lift . lift . lift  instance-	( Covariant (t :> u :> v :> w :> x :> y :> z :> f)-	, Lifting t (Schematic Monad u (v :> w :> x :> y :> 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))@@ -248,8 +224,7 @@ 	adapt = lift . lift . lift . lift . lift . lift . wrap  instance-	( Covariant (t :< u :< v :< w :< x :< y :< z :< f)-	, Lowering t (Schematic Comonad u (v :< w :< x :< y :< 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))@@ -260,8 +235,7 @@ 	adapt = lower . lower . lower . lower . lower . lower . lower  instance-	( Covariant (t :< u :< v :< w :< x :< y :< z :< f)-	, Lowering t (Schematic Comonad u (v :< w :< x :< y :< 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))@@ -272,8 +246,7 @@ 	adapt = bring . lower . lower . lower . lower . lower . lower  instance-	( Covariant (t :> u :> v :> w :> x :> y :> z :> f :> h)-	, Lifting t (Schematic Monad u (v :> w :> x :> y :> z :> 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))@@ -285,8 +258,7 @@ 	adapt = lift . lift . lift . lift . lift . lift . lift . lift  instance-	( Covariant (t :> u :> v :> w :> x :> y :> z :> f :> h)-	, Lifting t (Schematic Monad u (v :> w :> x :> y :> z :> 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))@@ -298,8 +270,7 @@ 	adapt = lift . lift . lift . lift . lift . lift . lift . wrap  instance-	( Covariant (t :< u :< v :< w :< x :< y :< z :< f :< h)-	, Lowering t (Schematic Comonad u (v :< w :< x :< y :< z :< 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))@@ -311,8 +282,7 @@ 	adapt = lower . lower . lower . lower . lower . lower . lower . lower  instance-	( Covariant (t :< u :< v :< w :< x :< y :< z :< f :< h)-	, Lowering t (Schematic Comonad u (v :< w :< x :< y :< z :< 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))@@ -327,9 +297,7 @@ 	adapt = hoist adapt  instance-	( Covariant u-	, Covariant v, Covariant_ v (->) (->)-	, Covariant (Schematic Monad u v)+	( Covariant_ v (->) (->) 	, Covariant_ (Schematic Monad u v) (->) (->) 	, Hoistable ((:>) (t :> u)) 	, Hoistable (Schematic Monad t)@@ -339,14 +307,11 @@ 	adapt = hoist (hoist adapt)  instance-	( Covariant u, Covariant_ u (->) (->)-	, Covariant v, Covariant_ v (->) (->)-	, Covariant w, Covariant_ w (->) (->)-	, Covariant (Schematic Monad u v)+	( Covariant_ u (->) (->)+	, Covariant_ v (->) (->)+	, Covariant_ w (->) (->) 	, Covariant_ (Schematic Monad u v) (->) (->)-	, Covariant (Schematic Monad u (v :> w)) 	, Covariant_ (Schematic Monad u (v :> w)) (->) (->)-	, Covariant (Schematic Monad v w) 	, Covariant_ (Schematic Monad v w) (->) (->) 	, Hoistable ((:>) (t :> u :> v)) 	, Hoistable (Schematic Monad t)@@ -357,14 +322,9 @@ 	adapt = hoist (hoist (hoist adapt))  instance-	( Covariant u, Covariant v, Covariant w, Covariant x, Covariant_ x (->) (->)-	, Covariant (Schematic Monad u v)-	, Covariant (Schematic Monad u (v :> w))-	, Covariant (Schematic Monad u (v :> (w :> x)))+	( Covariant_ x (->) (->) 	, Covariant_ (Schematic Monad u (v :> (w :> x))) (->) (->)-	, Covariant (Schematic Monad v (w :> x)) 	, Covariant_ (Schematic Monad v (w :> x)) (->) (->)-	, Covariant (Schematic Monad w x) 	, Covariant_ (Schematic Monad w x) (->) (->) 	, Hoistable ((:>) (t :> u :> v)) 	, Hoistable (Schematic Monad t)@@ -376,19 +336,10 @@ 	adapt = hoist (hoist (hoist (hoist adapt)))  instance-	( Covariant u, Covariant v, Covariant w, Covariant x-	, Covariant y, Covariant_ y (->) (->)-	, Covariant (Schematic Monad u v)-	, Covariant (Schematic Monad u (v :> w))-	, Covariant (Schematic Monad u (v :> (w :> x)))-	, Covariant (Schematic Monad u (v :> (w :> (x :> y))))+	( Covariant_ y (->) (->) 	, Covariant_ (Schematic Monad u (v :> (w :> (x :> y)))) (->) (->)-	, Covariant (Schematic Monad v (w :> x))-	, Covariant (Schematic Monad v (w :> (x :> y))) 	, Covariant_ (Schematic Monad v (w :> (x :> y))) (->) (->)-	, Covariant (Schematic Monad w (x :> y)) 	, Covariant_ (Schematic Monad w (x :> y)) (->) (->)-	, Covariant (Schematic Monad x y) 	, Covariant_ (Schematic Monad x y) (->) (->) 	, Hoistable ((:>) (t :> u :> v :> w)) 	, Hoistable (Schematic Monad t)@@ -401,25 +352,11 @@ 	adapt = hoist (hoist (hoist (hoist (hoist adapt))))  instance-	( Covariant u, Covariant v, Covariant w, Covariant x, Covariant y-	, Covariant z, Covariant_ z (->) (->)-	, Covariant (Schematic Monad u v)-	, Covariant (Schematic Monad u (v :> w))-	, Covariant (Schematic Monad u (v :> (w :> x)))-	, Covariant (Schematic Monad u (v :> (w :> (x :> y))))-	, Covariant (Schematic Monad u (v :> (w :> (x :> (y :> z)))))+	( Covariant z, Covariant_ z (->) (->) 	, Covariant_ (Schematic Monad u (v :> (w :> (x :> (y :> z))))) (->) (->)-	, Covariant (Schematic Monad v (w :> x))-	, Covariant (Schematic Monad v (w :> (x :> y)))-	, Covariant (Schematic Monad v (w :> (x :> (y :> z)))) 	, Covariant_ (Schematic Monad v (w :> (x :> (y :> z)))) (->) (->)-	, Covariant (Schematic Monad w (x :> y))-	, Covariant (Schematic Monad w (x :> (y :> z))) 	, Covariant_ (Schematic Monad w (x :> (y :> z))) (->) (->)-	, Covariant (Schematic Monad x y)-	, Covariant (Schematic Monad x (y :> z)) 	, Covariant_ (Schematic Monad x (y :> z)) (->) (->)-	, Covariant (Schematic Monad y z) 	, Covariant_ (Schematic Monad y z) (->) (->) 	, Hoistable ((:>) (t :> u :> v :> w)) 	, Hoistable (Schematic Monad t)@@ -434,9 +371,7 @@ 	adapt = hoist (hoist (hoist (hoist (hoist adapt))))  instance-	( Covariant u, Covariant v, Covariant w, Covariant x-	, Covariant y, Covariant z-	, Covariant f, Covariant_ f (->) (->)+	( Covariant f, Covariant_ f (->) (->) 	, Covariant (Schematic Monad u v) 	, Covariant (Schematic Monad u (v :> w)) 	, Covariant (Schematic Monad u (v :> (w :> x)))@@ -476,27 +411,9 @@ 	adapt = hoist (hoist (hoist (hoist (hoist (hoist adapt)))))  instance-	( Covariant u, Covariant v, Covariant w, Covariant x-	, Covariant y, Covariant z, Covariant f-	, Covariant h, Covariant_ h (->) (->)-	, Covariant (Schematic Monad u v)-	, Covariant (Schematic Monad u (v :> w))-	, Covariant (Schematic Monad u (v :> (w :> x)))-	, Covariant (Schematic Monad u (v :> (w :> (x :> y))))-	, Covariant (Schematic Monad u (v :> (w :> (x :> (y :> z)))))-	, Covariant (Schematic Monad u (v :> (w :> (x :> (y :> (z :> f))))))-	, Covariant (Schematic Monad u (v :> (w :> (x :> (y :> (z :> (f :> h)))))))+	( Covariant h, Covariant_ h (->) (->) 	, Covariant_ (Schematic Monad u (v :> (w :> (x :> (y :> (z :> (f :> h))))))) (->) (->)-	, Covariant (Schematic Monad v (w :> x))-	, Covariant (Schematic Monad v (w :> (x :> y)))-	, Covariant (Schematic Monad v (w :> (x :> (y :> z))))-	, Covariant (Schematic Monad v (w :> (x :> (y :> (z :> f)))))-	, Covariant (Schematic Monad v (w :> (x :> (y :> (z :> (f :> h)))))) 	, Covariant_ (Schematic Monad v (w :> (x :> (y :> (z :> (f :> h)))))) (->) (->)-	, Covariant (Schematic Monad w (x :> y))-	, Covariant (Schematic Monad w (x :> (y :> z)))-	, Covariant (Schematic Monad w (x :> (y :> (z :> f))))-	, Covariant (Schematic Monad w (x :> (y :> (z :> (f :> h))))) 	, Covariant_ (Schematic Monad w (x :> (y :> (z :> (f :> h))))) (->) (->) 	, Covariant (Schematic Monad x y) 	, Covariant (Schematic Monad x (y :> z))

@@ -4,7 +4,7 @@ import Pandora.Pattern.Category ((.)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>), (<$$$>), (<$$$$>)), Covariant_) import Pandora.Pattern.Transformer.Liftable (Liftable (lift))-import Pandora.Paradigm.Primary.Functor.Function ()+import Pandora.Paradigm.Primary.Algebraic.Exponential ()  infixr 2 ||=, =|| 

@@ -9,10 +9,10 @@ import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>))) import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))+import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))+import Pandora.Pattern.Functor.Extendable (Extendable ((<<=))) import Pandora.Pattern.Functor.Comonad (Comonad) import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower)) import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))@@ -43,19 +43,19 @@ instance Alternative (Schematic Comonad t u) => Alternative (t :< u) where 	TC x <+> TC y = TC $ x <+> y -instance Traversable (Schematic Comonad t u) => Traversable (t :< u) where-	TC x ->> f = TC <$> x ->> f+instance Traversable (Schematic Comonad t u) (->) (->) => Traversable (t :< u) (->) (->) where+	f <<- TC x = TC -<$>- f <<- x -instance Distributive (Schematic Comonad t u) => Distributive (t :< u) where-	x >>- f = TC $ x >>- tc . f+instance Distributive (Schematic Comonad t u) (->) (->) => Distributive (t :< u) (->) (->) where+	f -<< x = TC $ tc . f -<< x -instance Bindable (Schematic Comonad t u) => Bindable (t :< u) where-	TC x >>= f = TC $ x >>= tc . f+instance Bindable (Schematic Comonad t u) (->) => Bindable (t :< u) (->) where+	f =<< TC x = TC $ tc . f =<< x -instance Extendable (Schematic Comonad t u) => Extendable (t :< u) where-	TC x =>> f = TC $ x =>> f . TC+instance Extendable (Schematic Comonad t u) (->) => Extendable (t :< u) (->) where+	f <<= TC x = TC $ f . TC <<= x -instance (Extractable (t :< u) (->), Extendable (t :< u)) => Comonad (t :< u) (->) where+instance (Extractable (t :< u) (->), Extendable (t :< u) (->)) => Comonad (t :< u) (->) where  instance Lowerable (Schematic Comonad t) => Lowerable ((:<) t) where 	lower (TC x) = lower x

@@ -10,10 +10,10 @@ import Pandora.Pattern.Functor.Applicative (Applicative ((<*>))) import Pandora.Pattern.Functor.Alternative (Alternative ((<+>))) import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))+import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))+import Pandora.Pattern.Functor.Extendable (Extendable ((<<=))) import Pandora.Pattern.Functor.Monad (Monad) import Pandora.Pattern.Transformer.Liftable (Liftable (lift)) import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))@@ -47,19 +47,19 @@ instance Avoidable (Schematic Monad t u) => Avoidable (t :> u) where 	empty = TM empty -instance Traversable (Schematic Monad t u) => Traversable (t :> u) where-	TM x ->> f = TM <$> x ->> f+instance Traversable (Schematic Monad t u) (->) (->) => Traversable (t :> u) (->) (->) where+	f <<- TM x = TM -<$>- f <<- x -instance Distributive (Schematic Monad t u) => Distributive (t :> u) where-	x >>- f = TM $ x >>- tm . f+instance Distributive (Schematic Monad t u) (->) (->) => Distributive (t :> u) (->) (->) where+	f -<< x = TM $ tm . f -<< x -instance Bindable (Schematic Monad t u) => Bindable (t :> u) where-	TM x >>= f = TM $ x >>= tm . f+instance Bindable (Schematic Monad t u) (->) => Bindable (t :> u) (->) where+	f =<< TM x = TM $ tm . f =<< x -instance Extendable (Schematic Monad t u) => Extendable (t :> u) where-	TM x =>> f = TM $ x =>> f . TM+instance Extendable (Schematic Monad t u) (->) => Extendable (t :> u) (->) where+	f <<= TM x = TM $ f . TM <<= x -instance (Covariant_ (Schematic Monad t u) (->) (->), Pointable (t :> u) (->), Bindable (t :> u)) => Monad (t :> u) where+instance (Covariant_ (Schematic Monad t u) (->) (->), Pointable (t :> u) (->), Bindable (t :> u) (->)) => Monad (t :> u) where  instance Liftable (Schematic Monad t) => Liftable ((:>) t) where 	lift = TM . lift

@@ -2,8 +2,8 @@  import Pandora.Pattern.Category (($), (.), (#)) import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))-import Pandora.Paradigm.Primary.Functor.Function ((!.), (!..))+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))+import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.), (!..)) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite)) import Pandora.Paradigm.Primary.Transformer.Continuation (Continuation (Continuation)) @@ -44,8 +44,8 @@ finish = Continuation (Pipe (point () !..) !.)  -- | Do some effectful computation within pipeline-impact :: Bindable t => t a -> Pipeline i o t a a-impact action = Continuation $ \next -> Pipe $ \i o -> action >>= \x -> pipe (next x) i o+impact :: Bindable t (->) => t a -> Pipeline i o t a a+impact action = Continuation $ \next -> Pipe $ \i o -> (\x -> pipe (next x) i o) =<< action  -- | Compose two pipelines into one (=*=) :: forall i e o t . Pointable t (->) => Pipeline i e t () () -> Pipeline e o t () () -> Pipeline i o t () ()

@@ -17,30 +17,30 @@ import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-))) import Pandora.Pattern.Functor.Extractable (extract) import Pandora.Pattern.Functor.Bivariant ((<->))-import Pandora.Paradigm.Primary.Functor.Function ((!.), (%))+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))+import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.), (%)) import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:))) import Pandora.Paradigm.Controlflow.Effect.Interpreted (run) import Pandora.Paradigm.Controlflow.Effect.Adaptable (adapt) import Pandora.Paradigm.Structure.Ability.Accessible (Accessible (access)) -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 (Store s) (State s) (->) (->) where+	(-|) :: (Store s a -> b) -> a -> State s b+	f -| x = State $ \s -> (:*:) s . f . Store $ s :*: (x !.)+	(|-) :: (a -> State s b) -> Store s a -> b+	g |- Store (s :*: f) = extract . (run % s) . g $ f s -instance Adjoint (Accumulator e) (Imprint e) where-	x -| f = Imprint $ x -| f . Accumulator-	x |- g = run x |- run . g+instance Adjoint (Accumulator e) (Imprint e) (->) (->) where+	f -| x = Imprint $ f . Accumulator -| x+	g |- x = run . g |- run x -instance Adjoint (Equipment e) (Environment e) where-	x -| f = Environment $ x -| f . Equipment-	x |- g = run x |- run . g+instance Adjoint (Equipment e) (Environment e) (->) (->) where+	f -| x = Environment $ f . Equipment -| x+	g |- x = run . g |- run x  zoom :: Stateful bg t => Lens Identity bg ls -> State ls ~> t-zoom lens less = let restruct to = (to . Identity <-> identity) . run less . extract @Identity-	in adapt . State $ (|- restruct) . run . run lens+zoom lens less = let restruct to = (to . Identity <-> identity @(->)) . run less . extract @Identity+	in adapt . State $ (restruct |-) . run . run lens  (=<>) :: Stateful src t => Lens mode src tgt -> mode tgt -> t src lens =<> new = modify $ set lens new

@@ -6,11 +6,11 @@ import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<))) import Pandora.Pattern.Functor.Monad (Monad) import Pandora.Pattern.Object.Monoid (Monoid (zero)) import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:))+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:))) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite)) import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM)) import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))@@ -31,8 +31,8 @@ instance Monoid e => Pointable (Accumulator e) (->) where 	point = Accumulator . (zero :*:) -instance Semigroup e => Bindable (Accumulator e) where-	Accumulator (e :*: x) >>= f = let e' :*: b = run $ f x in+instance Semigroup e => Bindable (Accumulator e) (->) where+	f =<< Accumulator (e :*: x) = let e' :*: b = run $ f x in 		Accumulator $ e + e':*: b  type instance Schematic Monad (Accumulator e) = (<.:>) ((:*:) e)@@ -54,8 +54,8 @@ instance {-# OVERLAPS #-} (Pointable u (->), Monoid e) => Pointable ((:*:) e <.:> u) (->) where 	point = UT . point . (zero :*:) -instance {-# OVERLAPS #-} (Semigroup e, Pointable u (->), Bindable u) => Bindable ((:*:) e <.:> u) where-	UT x >>= f = UT $ x >>= \(acc :*: v) -> (\(acc' :*: y) -> (acc + acc' :*: y)) <$> run (f v)+instance {-# OVERLAPS #-} (Semigroup e, Pointable u (->), Bindable u (->)) => Bindable ((:*:) e <.:> u) (->) where+	f =<< UT x = UT $ (\(acc :*: v) -> (\(acc' :*: y) -> (acc + acc' :*: y)) -<$>- run (f v)) =<< x  gather :: Accumulated e t => e -> t () gather x = adapt . Accumulator $ x :*: ()

@@ -4,13 +4,15 @@  import Pandora.Pattern.Category (identity, (.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))+import Pandora.Pattern.Functor.Contravariant (Contravariant_ ((->$<-))) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))+import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<))) import Pandora.Pattern.Functor.Monad (Monad) import Pandora.Pattern.Functor.Divariant (Divariant ((>->)))-import Pandora.Paradigm.Primary.Functor.Function ((!.), (%))+import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.), (%))+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip)) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite)) import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM)) import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))@@ -24,21 +26,24 @@ instance Covariant_ (Environment e) (->) (->) where 	f -<$>- Environment x = Environment $ f . x +instance Contravariant_ (Flip Environment a) (->) (->) where+	f ->$<- Flip (Environment g) = Flip . Environment $ g . f+ instance Pointable (Environment e) (->) where 	point x = Environment (x !.)  instance Applicative (Environment e) where 	f <*> x = Environment $ run f <*> run x -instance Distributive (Environment e) where-	g >>- f = Environment $ g >>- (run <$> f)+instance Distributive (Environment e) (->) (->) where+	f -<< g = Environment $ (run -<$>- f) -<< g -instance Bindable (Environment e) where-	Environment x >>= f = Environment $ \e -> (run % e) . f . x $ e+instance Bindable (Environment e) (->) where+	f =<< Environment x = Environment $ \e -> (run % e) . f . x $ e  instance Monad (Environment e) where -instance Divariant Environment where+instance Divariant Environment (->) (->) (->) where 	(>->) ab cd bc = Environment $ ab >-> cd $ run bc  instance Interpreted (Environment e) where

@@ -5,10 +5,11 @@ import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))+import Pandora.Pattern.Functor.Extendable (Extendable ((<<=))) import Pandora.Pattern.Functor.Comonad (Comonad)-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), attached)+import Pandora.Paradigm.Primary.Algebraic ()+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), attached) import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt)) import Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic (Comonadic (bring), (:<) (TC)) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite))@@ -25,11 +26,11 @@ instance Extractable (Equipment e) (->) where 	extract = extract . run -instance Traversable (Equipment e) where-	Equipment x ->> f = Equipment <$> x ->> f+instance Traversable (Equipment e) (->) (->) where+	f <<- Equipment x = Equipment -<$>- f <<- x -instance Extendable (Equipment e) where-	Equipment (e :*: x) =>> f = Equipment . (:*:) e . f . Equipment $ e :*: x+instance Extendable (Equipment e) (->) where+	f <<= Equipment (e :*: x) = Equipment . (:*:) e . f . Equipment $ e :*: x  instance Interpreted (Equipment e) where 	type Primary (Equipment e) a = e :*: a@@ -43,8 +44,8 @@  type Equipped e t = Adaptable t (Equipment e) -instance {-# OVERLAPS #-} Extendable u => Extendable ((:*:) e <:.> u) where-	TU (e :*: x) =>> f = TU . (:*:) e $ x =>> f . TU . (:*:) e+instance {-# OVERLAPS #-} Extendable u (->) => Extendable ((:*:) e <:.> u) (->) where+	f <<= TU (e :*: x) = TU . (:*:) e $ f . TU . (:*:) e <<= x  instance Comonad (Equipment e) (->) where 

@@ -4,14 +4,16 @@  import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))+import Pandora.Pattern.Functor.Contravariant (Contravariant_ ((->$<-))) import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))+import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))+import Pandora.Pattern.Functor.Extendable (Extendable ((<<=))) import Pandora.Pattern.Functor.Comonad (Comonad) import Pandora.Pattern.Functor.Divariant (Divariant ((>->))) import Pandora.Pattern.Object.Monoid (Monoid (zero)) import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))-import Pandora.Paradigm.Primary.Functor.Function ()+import Pandora.Paradigm.Primary.Algebraic.Exponential ()+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip)) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite, (||=))) import Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic (Comonadic (bring), (:<) (TC)) import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable)@@ -23,19 +25,22 @@ 	f <$> Imprint x = Imprint $ f . x  instance Covariant_ (Imprint e) (->) (->) where-	f -<$>- Imprint x = Imprint $ f . x+	f -<$>- Imprint g = Imprint $ f . g -instance Distributive (Imprint e) where-	g >>- f = Imprint $ g >>- (run <$> f)+instance Contravariant_ (Flip Imprint a) (->) (->) where+	f ->$<- Flip (Imprint g) = Flip . Imprint $ g . f +instance Distributive (Imprint e) (->) (->) where+	f -<< g = Imprint $ (run -<$>- f) -<< g+ instance Monoid e => Extractable (Imprint e) (->) where 	extract (Imprint x) = x zero -instance Divariant Imprint where+instance Divariant Imprint (->) (->) (->) where 	(>->) ab cd bc = ab >-> cd ||= bc -instance Semigroup e => Extendable (Imprint e) where-	Imprint x =>> f = Imprint $ \e -> f $ Imprint $ x . (e +)+instance Semigroup e => Extendable (Imprint e) (->) where+	f <<= Imprint x = Imprint $ \e -> f $ Imprint $ x . (e +)  instance Interpreted (Imprint e) where 	type Primary (Imprint e) a = (->) e a@@ -47,7 +52,7 @@ instance Monoid e => Comonadic (Imprint e) where 	bring (TC (UT x)) = Imprint . extract $ x -instance {-# OVERLAPS #-} (Semigroup e, Extendable u) => Extendable ((->) e <.:> u) where-	UT x =>> f = UT $ x =>> (\x' e -> f . UT . (<$>) (. (e +)) $ x')+instance {-# OVERLAPS #-} (Semigroup e, Extendable u (->)) => Extendable ((->) e <.:> u) (->) where+	f <<= UT x = UT $ (\x' e -> f . UT . (-<$>-) (. (e +)) $ x') <<= x  type Traceable e t = Adaptable t (Imprint e)

@@ -11,10 +11,10 @@ import Pandora.Pattern.Functor.Representable (Representable (Representation, (<#>), tabulate)) import Pandora.Pattern.Object.Setoid (Setoid ((==))) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (run))+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))+import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.), (%)) import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))-import Pandora.Paradigm.Primary.Functor.Function ((!.), (%)) import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:))) import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip)) import Pandora.Paradigm.Primary.Object.Boolean ((?)) import Pandora.Paradigm.Inventory.Store (Store (Store), position, look, retrofit)

@@ -7,11 +7,11 @@ import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Invariant (Invariant ((<$<))) 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.Applicative (Applicative ((<*>)), Semimonoidal (multiply))+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.Pattern.Functor.Adjoint ((-|), (|-)) import Pandora.Pattern.Functor.Bivariant ((<->)) import Pandora.Pattern.Functor.Divariant ((>->)) import Pandora.Paradigm.Primary.Transformer (Flip)@@ -19,7 +19,7 @@ import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (||=)), Schematic) import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM)) import Pandora.Paradigm.Schemes.TUT (TUT (TUT), type (<:<.>:>))-import Pandora.Paradigm.Primary.Functor (Product ((:*:)), type (:*:), delta)+import Pandora.Paradigm.Primary.Algebraic ((:*:) ((:*:)), (%), (!.), (-<*>-), delta)  -- | Effectful computation with a variable newtype State s a = State ((->) s :. (:*:) s := a)@@ -31,18 +31,24 @@ 	f -<$>- x = State $ (-<$>-) f . run x  instance Applicative (State s) where-	f <*> x = State $ (|- (<$>)) . (run x <-> identity) . run f+	f <*> x = State $ ((<$>) |-) . (run x <-> identity @(->)) . run f +instance Semimonoidal (State s) (:*:) (->) (->) where+	multiply f (State g :*: State h) = State $ \s -> +		let old :*: x = g s in+		let new :*: y = h old in+		new :*: f (x :*: y)+ instance Pointable (State s) (->) where-	point = State . (-| identity)+	point = State . (identity @(->) -|) -instance Bindable (State s) where-	x >>= f = State $ run x $|- run . f+instance Bindable (State s) (->) where+	f =<< x = State $ (run . f |-) -<$>- run x  instance Monad (State s) where  instance Invariant (Flip State r) where-	f <$< g = ((g >-> (f <-> identity) ||=) ||=)+	f <$< g = ((g >-> ((<->) @_ @_ @(->) @(->) f identity) ||=) ||=)  instance Interpreted (State s) where 	type Primary (State s) a = (->) s :. (:*:) s := a@@ -68,10 +74,10 @@ replace :: Stateful s t => s -> t s replace s = adapt . State $ \_ -> s :*: s -reconcile :: (Bindable t, Stateful s t, Adaptable u t) => (s -> u s) -> t s-reconcile f = current >>= adapt . f >>= replace+reconcile :: (Bindable t (->), Stateful s t, Adaptable u t) => (s -> u s) -> t s+reconcile f = replace =<< adapt . f =<< current -type Memorable s t = (Pointable t (->), Applicative t, Stateful s t)+type Memorable s t = (Pointable t (->), Semimonoidal t (:*:) (->) (->), Stateful s t) -fold :: (Traversable t, Memorable s u) => (a -> s -> s) -> t a -> u s-fold op struct = struct ->> modify . op *> current+fold :: (Traversable t (->) (->), Memorable s u) => (a -> s -> s) -> t a -> u s+fold op struct = ((!.) %) -<$>- (modify . op <<- struct) -<*>- current

@@ -7,16 +7,15 @@ import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>), (.#..)), Covariant_ ((-<$>-)), (-<$$>-)) import Pandora.Pattern.Functor.Invariant (Invariant ((<$<))) import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))+import Pandora.Pattern.Functor.Extendable (Extendable ((<<=))) import Pandora.Pattern.Functor.Comonad (Comonad) import Pandora.Pattern.Functor.Bivariant ((<->)) import Pandora.Pattern.Functor.Divariant ((>->)) import Pandora.Pattern.Functor.Adjoint ((-|), (|-))-import Pandora.Paradigm.Primary.Functor.Function ((%))-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), attached)-import Pandora.Paradigm.Primary.Functor ()+import Pandora.Paradigm.Primary.Algebraic.Exponential ((%))+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), attached)+import Pandora.Paradigm.Primary.Algebraic () import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))---import Pandora.Paradigm.Primary.Transformer () import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt)) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (||=)), Schematic) import Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic (Comonadic (bring), (:<) (TC))@@ -32,15 +31,15 @@ 	f -<$>- Store x = Store $ f -<$$>- x  instance Extractable (Store s) (->) where-	extract = (|- ($)) . run+	extract = (($) |-) . run -instance Extendable (Store s) where-	Store x =>> f = Store $ f <$$> Store .#.. (-| identity) <$> x+instance Extendable (Store s) (->) where+	f <<= Store x = Store $ f -<$$>- (Store .#.. (identity @(->) -|) -<$>- x)  instance Comonad (Store s) (->) where  instance Invariant (Flip Store r) where-	f <$< g = \(Flip x) -> Flip $ f <-> (g >-> identity) ||= x+	f <$< g = \(Flip x) -> Flip $ (<->) @_ @_ @(->) f (g >-> identity @(->)) ||= x  instance Interpreted (Store s) where 	type Primary (Store s) a = (:*:) s :. (->) s := a

@@ -6,6 +6,7 @@ import Pandora.Paradigm.Primary.Transformer as Exports import Pandora.Paradigm.Primary.Functor as Exports import Pandora.Paradigm.Primary.Object as Exports+import Pandora.Paradigm.Primary.Algebraic as Exports  import Pandora.Core.Functor (type (:=)) import Pandora.Pattern.Category (Category ((.), ($), (#), identity))@@ -35,9 +36,9 @@ instance Extractable (Flip (:*:) a) (->) where 	extract (Flip (x :*: _)) = x -instance Adjoint (Flip Product s) ((->) s) where-	x -| f = \s -> f $ Flip $ x :*: s-	Flip (x :*: s) |- f = f x s+instance Adjoint (Flip (:*:) s) ((->) s) (->) (->) where+	f -| x = \s -> f $ Flip $ x :*: s+	f |- Flip (x :*: s) = f x s  instance Morphable (Into Maybe) (Conclusion e) where 	type Morphing (Into Maybe) (Conclusion e) = Maybe

@@ -0,0 +1,30 @@+{-# OPTIONS_GHC -fno-warn-orphans #-}++module Pandora.Paradigm.Primary.Algebraic (module Exports, (-<*>-)) where++import Pandora.Paradigm.Primary.Algebraic.Exponential as Exports+import Pandora.Paradigm.Primary.Algebraic.Product as Exports++import Pandora.Pattern.Category (($))+import Pandora.Pattern.Functor.Covariant (Covariant_ ((-<$>-)))+import Pandora.Pattern.Functor.Extractable (Extractable (extract))+import Pandora.Pattern.Functor.Applicative (Semimonoidal (multiply))+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))+import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))++infixl 4 -<*>-++instance Semimonoidal ((->) e) (:*:) (->) (->) where+	multiply f (g :*: h) = \x -> f $ g x :*: h x++instance Traversable ((:*:) s) (->) (->) where+	f <<- x = (attached x :*:) -<$>- f (extract x)++instance Adjoint ((:*:) s) ((->) s) (->) (->) where+	(-|) :: ((s :*: a) -> b) -> a -> (s -> b)+	f -| x = \s -> f $ s :*: x+	(|-) :: (a -> s -> b) -> (s :*: a) -> b+	f |- ~(s :*: x) = f x s++(-<*>-) :: forall a b t . (Semimonoidal t (:*:) (->) (->)) => t (a -> b) -> t a -> t b+(-<*>-) = (%) ((-|) @((:*:) (t (a -> b))) (multiply @t @(:*:) @(->) @(->) ((&) |-)))

@@ -0,0 +1,85 @@+{-# OPTIONS_GHC -fno-warn-orphans #-}++module Pandora.Paradigm.Primary.Algebraic.Exponential where++import Pandora.Pattern.Category (Category ((.), ($), (#), identity))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))+import Pandora.Pattern.Functor.Contravariant (Contravariant_ ((->$<-)))+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))+import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))+import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))+import Pandora.Pattern.Functor.Representable (Representable (Representation, (<#>), tabulate))+import Pandora.Pattern.Functor.Divariant (Divariant ((>->)))+import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))+import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))++infixr 2 !.+infixr 9 %+infixl 1 &++instance Category (->) where+	identity x = x+	f . g = \x -> f (g x)++instance Covariant ((->) a) where+	(<$>) = (.)++instance Covariant_ ((->) a) (->) (->) where+	(-<$>-) = (.)++instance Contravariant_ (Flip (->) a) (->) (->) where+	f ->$<- Flip g = Flip $ g . f++instance Applicative ((->) e) where+	(<*>) f g x = f x $ g x++instance Distributive ((->) e) (->) (->) where+	f -<< g = \e -> (f % e) -<$>- g++instance Pointable ((->) e) (->) where+	point = (!.)++instance Bindable ((->) e) (->) where+	f =<< g = \x -> f # g x # x++instance Representable ((->) e) where+	type Representation ((->) e) = e+	(<#>) = (identity %)+	tabulate = identity++instance Divariant ((->)) (->) (->) (->) where+	(>->) ab cd bc = cd . bc . ab++instance Semigroup r => Semigroup (e -> r) where+	f + g = \e -> f e + g e++instance Ringoid r => Ringoid (e -> r) where+	f * g = \e -> f e * g e++(-.#..-) :: (Covariant_ (v a) (->) target, Category v) => v c d -> target (v a (v b c)) (v a (v b d))+(-.#..-) f = (-<$>-) (f .)++{-# INLINE (!.) #-}+(!.) :: a -> b -> a+x !. _ = x++{-# INLINE (!..) #-}+(!..) :: a -> b -> c -> a+(!..) x _ _ = x++{-# INLINE (!...) #-}+(!...) :: a -> b -> c -> d -> a+(!...) x _ _ _ = x++{-# INLINE (%) #-}+(%) :: (a -> b -> c) -> b -> a -> c+(%) f x y = f y x++{-# INLINE (&) #-}+(&) :: a -> (a -> b) -> b+x & f = f x++fix :: (a -> a) -> a+fix f = let x = f x in x

@@ -0,0 +1,85 @@+module Pandora.Paradigm.Primary.Algebraic.Product where++import Pandora.Core.Functor (type (:=))+import Pandora.Pattern.Category (($), (#))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))+import Pandora.Pattern.Functor.Extractable (Extractable (extract))+import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))+import Pandora.Pattern.Functor.Comonad (Comonad)+import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))+import Pandora.Pattern.Object.Setoid (Setoid ((==)))+import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))+import Pandora.Pattern.Object.Monoid (Monoid (zero))+import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))+import Pandora.Pattern.Object.Quasiring (Quasiring (one))+import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))+import Pandora.Pattern.Object.Lattice (Lattice)+import Pandora.Pattern.Object.Group (Group (invert))+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))+import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))++infixr 0 :*:++data (:*:) s a = s :*: a++instance Covariant ((:*:) s) where+	f <$> x = attached x :*: f # extract x++instance Covariant_ ((:*:) s) (->) (->) where+	f -<$>- x = attached x :*: f # extract x++instance Covariant_ (Flip (:*:) a) (->) (->) where+	f -<$>- (Flip (x :*: y)) = Flip $ f x :*: y++instance Extractable ((:*:) a) (->) where+	extract ~(_ :*: y) = y++instance Extendable ((:*:) s) (->) where+	f <<= x = attached x :*: f (attached x :*: extract x)++instance Comonad ((:*:) s) (->) where++instance Bivariant (:*:) (->) (->) (->) where+	f <-> g = \ ~(s :*: x) -> f s :*: g x++instance (Setoid s, Setoid a) => Setoid (s :*: a) where+	x == y = (attached x == attached y) * (extract x == extract y)++instance (Semigroup s, Semigroup a) => Semigroup (s :*: a) where+	x + y = attached x + attached y :*: extract x + extract y++instance (Monoid s, Monoid a) => Monoid (s :*: a) where+	zero = zero :*: zero++instance (Ringoid s, Ringoid a) => Ringoid (s :*: a) where+	x * y = attached x * attached y :*: extract x * extract y++instance (Quasiring s, Quasiring a) => Quasiring (s :*: a) where+	one = one :*: one++instance (Infimum s, Infimum a) => Infimum (s :*: a) where+	x /\ y = attached x /\ attached y :*: extract x /\ extract y++instance (Supremum s, Supremum a) => Supremum (s :*: a) where+	x \/ y = attached x \/ attached y :*: extract x \/ extract y++instance (Lattice s, Lattice a) => Lattice (s :*: a) where++instance (Group s, Group a) => Group (s :*: a) where+	invert x = invert # attached x :*: invert # extract x++instance {-# OVERLAPS #-} Applicative t => Applicative (t <:.:> t := (:*:)) where+	T_U (lfs :*: rfs) <*> T_U (ls :*: rs) = T_U $ lfs <*> ls :*: rfs <*> rs++delta :: a -> a :*: a+delta x = x :*: x++swap :: a :*: b -> b :*: a+swap ~(x :*: y) = y :*: x++attached :: a :*: b -> a+attached ~(x :*: _) = x++twosome :: t a -> u a -> (<:.:>) t u (:*:) a+twosome x y = T_U $ x :*: y

@@ -1,7 +1,7 @@ {-# LANGUAGE AllowAmbiguousTypes #-} {-# OPTIONS_GHC -fno-warn-orphans #-} -module Pandora.Paradigm.Primary.Functor (module Exports, Equivalence, Comparison, match, (-<*>-)) where+module Pandora.Paradigm.Primary.Functor (module Exports, Equivalence, Comparison, match) where  import Pandora.Paradigm.Primary.Functor.Fix as Exports import Pandora.Paradigm.Primary.Functor.Convergence as Exports@@ -16,37 +16,16 @@ import Pandora.Paradigm.Primary.Functor.Endo as Exports import Pandora.Paradigm.Primary.Functor.Proxy as Exports import Pandora.Paradigm.Primary.Functor.Tagged as Exports-import Pandora.Paradigm.Primary.Functor.Product as Exports import Pandora.Paradigm.Primary.Functor.Constant as Exports import Pandora.Paradigm.Primary.Functor.Identity as Exports-import Pandora.Paradigm.Primary.Functor.Function as Exports  import Pandora.Pattern.Category (($))-import Pandora.Pattern.Functor.Applicative (Applicative_ (multiply))-import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)), Adjoint_ ((--|-), (-|--)))+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:))) import Pandora.Paradigm.Primary.Object.Boolean (Boolean, (?)) import Pandora.Paradigm.Primary.Object.Ordering (Ordering)  type Equivalence = Convergence Boolean type Comparison = Convergence Ordering -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--instance Adjoint_ (Product s) ((->) s) (->) (->) where-	(--|-) :: ((s :*: a) -> b) -> a -> (s -> b)-	f --|- x = \s -> f $ s :*: x-	(-|--) :: (a -> s -> b) -> (s :*: a) -> b-	f -|-- ~(s :*: x) = f x s--instance Applicative_ ((->) e) (:*:) (->) (->) where-	multiply f (g :*: h) = \x -> f $ g x :*: h x- match :: Predicate a -> (a -> r) -> a -> r -> r :*: a match (Predicate p) f x r = p x ? (f x :*: x) $ r :*: x--(-<*>-) :: forall a b t v . (Applicative_ t v (->) (->), Adjoint_ (v (a -> b)) ((->) (a -> b)) (->) (->), Adjoint_ (v (t (a -> b))) ((->) (t (a -> b))) (->) (->)) => t (a -> b) -> t a -> t b-(-<*>-) = (%) ((--|-) @(v (t (a -> b))) (multiply @t @v @(->) @(->) ((&) -|--)))

@@ -3,19 +3,19 @@ import Pandora.Core.Functor (type (~>)) import Pandora.Pattern.Category (identity, (.), ($), (#)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))-import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_))+import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)), Applicative_ (multiply))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)), Bindable_ (join_))+import Pandora.Pattern.Functor.Applicative (Semimonoidal (multiply))+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<))) import Pandora.Pattern.Functor.Monad (Monad)-import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)), Bivariant_ ((-<->-)))+import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->))) import Pandora.Pattern.Object.Setoid (Setoid ((==))) import Pandora.Pattern.Object.Chain (Chain ((<=>))) 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.Primary.Functor.Product (Product ((:*:)), type (:*:))+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:))) import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip)) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite)) import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM))@@ -39,19 +39,12 @@ instance Pointable (Conclusion e) (->) where 	point = Success -instance Pointable_ (Conclusion e) (->) where-	point_ = Success--instance Applicative (Conclusion e) where-	Success f <*> x = f <$> x-	Failure y <*> _ = Failure y--instance Applicative_ (Conclusion e) (:*:) (->) (->) where+instance Semimonoidal (Conclusion e) (:*:) (->) (->) where 	multiply f (Success x :*: Success y) = Success . f $ x :*: y 	multiply _ (Failure x :*: _) = Failure x 	multiply _ (_ :*: Failure x) = Failure x -instance Applicative_ (Conclusion e) Conclusion (->) (->) where+instance Semimonoidal (Conclusion e) Conclusion (->) (->) where 	multiply f (Failure (Success x)) = Success . f $ Failure x 	multiply f (Success (Success y)) = Success . f $ Success y 	multiply _ (Failure (Failure e)) = Failure e@@ -61,27 +54,21 @@ 	Failure _ <+> x = x 	Success x <+> _ = Success x -instance Traversable (Conclusion e) where-	Failure y ->> _ = point $ Failure y-	Success x ->> f = Success <$> f x--instance Bindable (Conclusion e) where-	Success x >>= f = f x-	Failure y >>= _ = Failure y+instance Traversable (Conclusion e) (->) (->) where+	(<<-) :: (Covariant_ u (->) (->), Pointable u (->), Semimonoidal u (:*:) (->) (->))+		 => (a -> u b) -> Conclusion e a -> u (Conclusion e b)+	_ <<- Failure y = point $ Failure y+	f <<- Success x = Success -<$>- f x -instance Bindable_ (Conclusion e) (->) where-	join_ (Success (Success x)) = Success x-	join_ (Success (Failure y)) = Failure y-	join_ (Failure y) = Failure y+instance Bindable (Conclusion e) (->) where+	f =<< Success x = f x+	_ =<< Failure y = Failure y  instance Monad (Conclusion e) where -instance Bivariant Conclusion where+instance Bivariant Conclusion (->) (->) (->) where 	f <-> g = conclusion # Failure . f # Success . g -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@@ -129,6 +116,6 @@ 	catch (Failure e) handle = handle e 	catch (Success x) _ = Success x -instance Monad u => Catchable e (Conclusion e <.:> u) where+instance (Pointable u (->), Bindable u (->)) => Catchable e (Conclusion e <.:> u) where 	catch (UT x) handle = let conclude = conclusion # run . handle # point . Success-		in UT $ x >>= conclude+		in UT $ conclude =<< x

@@ -1,11 +1,9 @@ module Pandora.Paradigm.Primary.Functor.Constant where -import Pandora.Pattern.Category (($))+import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<))) import Pandora.Pattern.Functor.Invariant (Invariant ((<$<)))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>))) import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->))) import Pandora.Pattern.Object.Setoid (Setoid ((==))) import Pandora.Pattern.Object.Chain (Chain ((<=>)))@@ -16,7 +14,8 @@ import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/))) import Pandora.Pattern.Object.Lattice (Lattice) import Pandora.Pattern.Object.Group (Group (invert))-import Pandora.Paradigm.Primary.Functor.Function ()+import Pandora.Paradigm.Primary.Algebraic.Exponential ()+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))  newtype Constant a b = Constant a @@ -26,16 +25,16 @@ instance Covariant_ (Constant a) (->) (->) where 	_ -<$>- Constant x = Constant x +instance Covariant_ (Flip Constant b) (->) (->) where+	f -<$>- Flip (Constant x) = Flip . Constant $ f x+ instance Contravariant (Constant a) where 	_ >$< Constant x = Constant x  instance Invariant (Constant a) where 	_ <$< _ = \(Constant x) -> Constant x -instance Traversable (Constant a) where-	Constant x ->> _ = point $ Constant x--instance Bivariant Constant where+instance Bivariant Constant (->) (->) (->)where 	f <-> _ = \(Constant x) -> Constant $ f x  instance Setoid a => Setoid (Constant a b) where

@@ -4,7 +4,7 @@ import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)), Contravariant_ ((->$<-))) import Pandora.Pattern.Functor.Divisible (Divisible ((>*<))) import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)))+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))  data Convergence r a = Convergence (a -> a -> r) 

@@ -3,8 +3,8 @@ import Pandora.Pattern.Category (($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Paradigm.Primary.Functor.Function ()+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))+import Pandora.Paradigm.Primary.Algebraic.Exponential ()  data Edges a = Empty | Leap a | Connect a | Overlay a @@ -20,11 +20,11 @@ 	f -<$>- Overlay x = Overlay $ f x 	f -<$>- Leap x = Leap $ f x -instance Traversable Edges where-	Empty ->> _ = point Empty-	Connect x ->> f = Connect <$> f x-	Overlay x ->> f = Overlay <$> f x-	Leap x ->> f = Leap <$> f x+instance Traversable Edges (->) (->) where+	_ <<- Empty = point Empty+	f <<- Connect x = Connect -<$>- f x+	f <<- Overlay x = Overlay -<$>- f x+	f <<- Leap x = Leap -<$>- f x  edges :: r -> (a -> r) -> (a -> r) -> (a -> r) -> Edges a -> r edges r _ _ _ Empty = r

@@ -6,7 +6,7 @@ import Pandora.Pattern.Object.Semigroup (Semigroup ((+))) import Pandora.Pattern.Object.Monoid (Monoid (zero)) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (||=)))-import Pandora.Paradigm.Primary.Functor.Function ()+import Pandora.Paradigm.Primary.Algebraic.Exponential ()  newtype Endo a = Endo { endo :: a -> a } 

@@ -3,7 +3,7 @@ import Pandora.Core.Functor (type (<:=), type (:=>)) import Pandora.Pattern.Category ((.)) import Pandora.Pattern.Functor.Covariant (Covariant (comap))-import Pandora.Paradigm.Primary.Functor.Function ()+import Pandora.Paradigm.Primary.Algebraic.Exponential ()  newtype Fix t = Fix { unfix :: t (Fix t) } 

@@ -1,94 +0,0 @@-{-# OPTIONS_GHC -fno-warn-orphans #-}--module Pandora.Paradigm.Primary.Functor.Function where--import Pandora.Pattern.Category (Category ((.), ($), (#), identity))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))-import Pandora.Pattern.Functor.Contravariant (Contravariant_ ((->$<-)))-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))-import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)), Bindable_ (join_))-import Pandora.Pattern.Functor.Representable (Representable (Representation, (<#>), tabulate))-import Pandora.Pattern.Functor.Divariant (Divariant ((>->)), Divariant_ ((->->-)))-import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))-import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))-import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))--infixr 2 !.-infixr 9 %-infixl 1 &--instance Category (->) where-	identity x = x-	f . g = \x -> f (g x)--instance Covariant ((->) a) where-	(<$>) = (.)--instance Covariant_ ((->) a) (->) (->) where-	(-<$>-) = (.)--instance Contravariant_ (Flip (->) a) (->) (->) where-	f ->$<- Flip g = Flip $ g . f--instance Applicative ((->) e) where-	(<*>) f g x = f x $ g x--instance Distributive ((->) e) where-	g >>- f = \e -> (f % e) <$> g--instance Pointable ((->) e) (->) where-	point = (!.)--instance Pointable_ ((->) e) (->) where-	point_ = (!.)--instance Bindable ((->) e) where-	f >>= g = \x -> g # f x # x--instance Bindable_ ((->) e) (->) where-	join_ f = \x -> f x # x--instance Representable ((->) e) where-	type Representation ((->) e) = e-	(<#>) = (identity %)-	tabulate = identity--instance Divariant ((->)) where-	(>->) ab cd bc = cd . bc . ab--instance Divariant_ ((->)) (->) (->) (->) where-	(->->-) ab cd bc = cd . bc . ab--instance Semigroup r => Semigroup (e -> r) where-	f + g = \e -> f e + g e--instance Ringoid r => Ringoid (e -> r) where-	f * g = \e -> f e * g e--(-.#..-) :: (Covariant_ (v a) (->) target, Category v) => v c d -> target (v a (v b c)) (v a (v b d))-(-.#..-) f = (-<$>-) (f .)--{-# INLINE (!.) #-}-(!.) :: a -> b -> a-x !. _ = x--{-# INLINE (!..) #-}-(!..) :: a -> b -> c -> a-(!..) x _ _ = x--{-# INLINE (!...) #-}-(!...) :: a -> b -> c -> d -> a-(!...) x _ _ _ = x--{-# INLINE (%) #-}-(%) :: (a -> b -> c) -> b -> a -> c-(%) f x y = f y x--{-# INLINE (&) #-}-(&) :: a -> (a -> b) -> b-x & f = f x--fix :: (a -> a) -> a-fix f = let x = f x in x

@@ -3,12 +3,11 @@ import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), comap), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_))+import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)), Bindable_ (join_))-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))+import Pandora.Pattern.Functor.Extendable (Extendable ((<<=))) import Pandora.Pattern.Functor.Monad (Monad) import Pandora.Pattern.Functor.Comonad (Comonad) import Pandora.Pattern.Functor.Representable (Representable (Representation, (<#>), tabulate))@@ -22,7 +21,7 @@ import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/))) import Pandora.Pattern.Object.Lattice (Lattice) import Pandora.Pattern.Object.Group (Group (invert))-import Pandora.Paradigm.Primary.Functor.Function ()+import Pandora.Paradigm.Primary.Algebraic.Exponential ()  newtype Identity a = Identity a @@ -35,31 +34,22 @@ instance Pointable Identity (->) where 	point = Identity -instance Pointable_ Identity (->) where-	point_ = Identity- instance Extractable Identity (->) where 	extract (Identity x) = x  instance Applicative Identity where 	Identity f <*> Identity x = Identity $ f x -instance Traversable Identity where-	Identity x ->> f = Identity <$> f x--instance Distributive Identity where-	x >>- f = Identity $ extract . f <$> x--instance Bindable Identity where-	Identity x >>= f = f x+instance Traversable Identity (->) (->) where+	f <<- Identity x = Identity -<$>- f x -instance Bindable_ Identity (->) where-	join_ (Identity x) = x+instance Bindable Identity (->) where+	f =<< Identity x = f x	  instance Monad Identity -instance Extendable Identity where-	x =>> f = Identity . f $ x+instance Extendable Identity (->) where+	f <<= x = Identity . f $ x  instance Comonad Identity (->) @@ -68,9 +58,9 @@ 	() <#> Identity x = x 	tabulate f = Identity $ f () -instance Adjoint Identity Identity where-	x -| f = Identity . f . Identity $ x-	x |- g = extract . extract . comap g $ x+instance Adjoint Identity Identity (->) (->) where+	f -| x = Identity . f . Identity $ x+	g |- x = extract . extract . comap g $ x  instance Setoid a => Setoid (Identity a) where 	Identity x == Identity y = x == y

@@ -4,11 +4,11 @@ import Pandora.Pattern.Category (identity, (.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))-import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_))+import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)), Applicative_ (multiply))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)), Bindable_ (join_))+import Pandora.Pattern.Functor.Applicative (Semimonoidal (multiply))+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<))) import Pandora.Pattern.Functor.Monad (Monad) import Pandora.Pattern.Object.Setoid (Setoid ((==))) import Pandora.Pattern.Object.Chain (Chain ((<=>)))@@ -23,9 +23,9 @@ import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt)) import Pandora.Paradigm.Schemes.UT (UT (UT), type (<.:>)) import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (reduce))+import Pandora.Paradigm.Primary.Algebraic.Exponential ()+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:))) import Pandora.Paradigm.Primary.Functor.Conclusion (Conclusion (Failure, Success))-import Pandora.Paradigm.Primary.Functor.Function ()-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:))  data Maybe a = Nothing | Just a @@ -40,22 +40,15 @@ instance Pointable Maybe (->) where 	point = Just -instance Pointable_ Maybe (->) where-	point_ = Just- instance Avoidable Maybe where 	empty = Nothing -instance Applicative Maybe where-	Just f <*> x = f <$> x-	Nothing <*> _ = Nothing--instance Applicative_ Maybe (:*:) (->) (->) where+instance Semimonoidal Maybe (:*:) (->) (->) where 	multiply f (Just x :*: Just y) = Just . f $ x :*: y 	multiply _ (Nothing :*: _) = Nothing 	multiply _ (_ :*: Nothing) = Nothing -instance Applicative_ Maybe Conclusion (->) (->) where+instance Semimonoidal Maybe Conclusion (->) (->) where 	multiply f (Failure (Just x)) = Just . f $ Failure x 	multiply f (Success (Just y)) = Just . f $ Success y 	multiply _ (Failure Nothing) = Nothing@@ -65,17 +58,13 @@ 	Nothing <+> y = y 	Just x <+> _ = Just x -instance Traversable Maybe where-	Nothing ->> _ = point Nothing-	Just x ->> f = Just <$> f x--instance Bindable Maybe where-	Just x >>= f = f x-	Nothing >>= _ = Nothing+instance Traversable Maybe (->) (->) where+	_ <<- Nothing = point Nothing+	f <<- Just x = Just -<$>- f x -instance Bindable_ Maybe (->) where-	join_ (Just x) = x -	join_ Nothing = Nothing+instance Bindable Maybe (->) where+	f =<< Just x = f x+	_ =<< Nothing = Nothing  instance Monad Maybe where 

@@ -10,8 +10,8 @@ import Pandora.Pattern.Object.Setoid (Setoid ((==))) import Pandora.Pattern.Object.Ringoid ((*)) import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False), bool, (?))-import Pandora.Paradigm.Primary.Functor.Function ((!.))-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:))+import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.))+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:))) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))  newtype Predicate a = Predicate (a -> Boolean)

@@ -1,97 +0,0 @@-module Pandora.Paradigm.Primary.Functor.Product where--import Pandora.Core.Functor (type (:=))-import Pandora.Pattern.Category (($), (#))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))-import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)), Extendable_ (duplicate_))-import Pandora.Pattern.Functor.Comonad (Comonad)-import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)), Bivariant_ ((-<->-)))-import Pandora.Pattern.Object.Setoid (Setoid ((==)))-import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))-import Pandora.Pattern.Object.Monoid (Monoid (zero))-import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))-import Pandora.Pattern.Object.Quasiring (Quasiring (one))-import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))-import Pandora.Pattern.Object.Lattice (Lattice)-import Pandora.Pattern.Object.Group (Group (invert))-import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))-import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))--infixr 0 :*:--data Product s a = s :*: a--type (:*:) = Product--instance Covariant (Product s) where-	f <$> x = attached x :*: f # extract x--instance Covariant_ (Product s) (->) (->) where-	f -<$>- x = attached x :*: f # extract x--instance Covariant_ (Flip (:*:) a) (->) (->) where-	f -<$>- (Flip (x :*: y)) = Flip $ f x :*: y--instance Extractable (Product a) (->) where-	extract ~(_ :*: y) = y--instance Traversable (Product s) where-	x ->> f = (attached x :*:) <$> f (extract x)--instance Extendable (Product s) where-	x =>> f = attached x :*: f (attached x :*: extract x)--instance Extendable_ (Product s) (->) where-	duplicate_ (s :*: x) = s :*: (s :*: x) --instance Comonad (Product s) (->) where--instance Bivariant Product where-	f <-> g = \ ~(s :*: x) -> f s :*: g x--instance Bivariant_ Product (->) (->) (->) where-	f -<->- g = \ ~(s :*: x) -> f s :*: g x--instance (Setoid s, Setoid a) => Setoid (s :*: a) where-	x == y = (attached x == attached y) * (extract x == extract y)--instance (Semigroup s, Semigroup a) => Semigroup (s :*: a) where-	x + y = attached x + attached y :*: extract x + extract y--instance (Monoid s, Monoid a) => Monoid (s :*: a) where-	zero = zero :*: zero--instance (Ringoid s, Ringoid a) => Ringoid (s :*: a) where-	x * y = attached x * attached y :*: extract x * extract y--instance (Quasiring s, Quasiring a) => Quasiring (s :*: a) where-	one = one :*: one--instance (Infimum s, Infimum a) => Infimum (s :*: a) where-	x /\ y = attached x /\ attached y :*: extract x /\ extract y--instance (Supremum s, Supremum a) => Supremum (s :*: a) where-	x \/ y = attached x \/ attached y :*: extract x \/ extract y--instance (Lattice s, Lattice a) => Lattice (s :*: a) where--instance (Group s, Group a) => Group (s :*: a) where-	invert x = invert # attached x :*: invert # extract x--instance {-# OVERLAPS #-} Applicative t => Applicative (t <:.:> t := (:*:)) where-	T_U (lfs :*: rfs) <*> T_U (ls :*: rs) = T_U $ lfs <*> ls :*: rfs <*> rs--delta :: a -> a :*: a-delta x = x :*: x--swap :: a :*: b -> b :*: a-swap ~(x :*: y) = y :*: x--attached :: a :*: b -> a-attached ~(x :*: _) = x--twosome :: t a -> u a -> (<:.:>) t u (:*:) a-twosome x y = T_U $ x :*: y

@@ -2,14 +2,14 @@  import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))-import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_))+import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>))) import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))+import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))+import Pandora.Pattern.Functor.Extendable (Extendable ((<<=))) import Pandora.Pattern.Functor.Monad (Monad)-import Pandora.Paradigm.Primary.Functor.Function ()+import Pandora.Paradigm.Primary.Algebraic.Exponential ()  data Proxy a = Proxy @@ -25,22 +25,19 @@ instance Pointable Proxy (->) where 	point _ = Proxy -instance Pointable_ Proxy (->) where-	point_ _ = Proxy- instance Applicative Proxy where 	_ <*> _ = Proxy  instance Alternative Proxy where 	_ <+> _ = Proxy -instance Distributive Proxy where-	_ >>- _ = Proxy+instance Distributive Proxy (->) (->) where+	_ -<< _ = Proxy -instance Bindable Proxy where-	_ >>= _ = Proxy+instance Bindable Proxy (->) where+	_ =<< _ = Proxy  instance Monad Proxy -instance Extendable Proxy where-	_ =>> _ = Proxy+instance Extendable Proxy (->) where+	_ <<= _ = Proxy

@@ -4,12 +4,12 @@ import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_))+import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))+import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))+import Pandora.Pattern.Functor.Extendable (Extendable ((<<=))) import Pandora.Pattern.Functor.Monad (Monad) import Pandora.Pattern.Functor.Comonad (Comonad) import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))@@ -22,7 +22,8 @@ import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/))) import Pandora.Pattern.Object.Lattice (Lattice) import Pandora.Pattern.Object.Group (Group (invert))-import Pandora.Paradigm.Primary.Functor.Function ()+import Pandora.Paradigm.Primary.Algebraic.Exponential ()+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))  newtype Tagged tag a = Tag a @@ -35,35 +36,35 @@ instance Covariant_ (Tagged tag) (->) (->) where 	f -<$>- Tag x = Tag $ f x +instance Covariant_ (Flip Tagged a) (->) (->) where+	_ -<$>- Flip (Tag x) = Flip $ Tag x+ instance Pointable (Tagged tag) (->) where 	point = Tag -instance Pointable_ (Tagged tag) (->) where-	point_ = Tag- instance Extractable (Tagged tag) (->) where 	extract (Tag x) = x  instance Applicative (Tagged tag) where 	Tag f <*> Tag x = Tag $ f x -instance Traversable (Tagged tag) where-	Tag x ->> f = Tag <$> f x+instance Traversable (Tagged tag) (->) (->) where+	f <<- Tag x = Tag -<$>- f x -instance Distributive (Tagged tag) where-	x >>- f = Tag $ extract . f <$> x+instance Distributive (Tagged tag) (->) (->) where+	f -<< x = Tag $ extract . f -<$>- x -instance Bindable (Tagged tag) where-	Tag x >>= f = f x+instance Bindable (Tagged tag) (->) where+	f =<< Tag x = f x  instance Monad (Tagged tag) -instance Extendable (Tagged tag) where-	x =>> f = Tag . f $ x+instance Extendable (Tagged tag) (->) where+	f <<= x = Tag . f $ x  instance Comonad (Tagged tag) (->) -instance Bivariant Tagged where+instance Bivariant Tagged (->) (->) (->)where 	_ <-> g = \(Tag x) -> Tag $ g x  instance Setoid a => Setoid (Tagged tag a) where

@@ -2,10 +2,10 @@  import Pandora.Pattern.Category (($), (#)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))-import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))+import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-))) import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))-import Pandora.Paradigm.Primary.Functor.Function ()+import Pandora.Paradigm.Primary.Algebraic.Exponential ()  data These e a = This a | That e | These e a @@ -22,13 +22,10 @@ instance Pointable (These e) (->) where 	point = This -instance Pointable_ (These e) (->) where-	point_ = This--instance Traversable (These e) where-	This x ->> f = This <$> f x-	That y ->> _ = point $ That y-	These y x ->> f = These y <$> f x+instance Traversable (These e) (->) (->) where+	f <<- This x = This -<$>- f x+	_ <<- That y = point $ That y+	f <<- These y x = These y -<$>- f x  instance (Semigroup e, Semigroup a) => Semigroup (These e a) where 	This x + This x' = This # x + x'

@@ -2,16 +2,16 @@  import Pandora.Pattern.Category ((.), ($), (#)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))-import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_))-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)), Applicative_ (multiply))+import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)), Semimonoidal (multiply)) import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)), Bivariant_ ((-<->-)))+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))+import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->))) import Pandora.Pattern.Object.Setoid (Setoid ((==))) import Pandora.Pattern.Object.Chain (Chain ((<=>))) import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))-import Pandora.Paradigm.Primary.Functor.Function ()-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:))+import Pandora.Paradigm.Primary.Algebraic.Exponential ()+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:))) import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip)) import Pandora.Paradigm.Primary.Object.Boolean (Boolean (False)) import Pandora.Paradigm.Primary.Object.Ordering (Ordering (Less, Greater))@@ -41,16 +41,13 @@ instance Pointable (Validation e) (->) where 	point = Validated -instance Pointable_ (Validation e) (->) where-	point_ = Validated- instance Semigroup e => Applicative (Validation e) where 	Flaws e <*> Flaws e' = Flaws $ e + e' 	Flaws e <*> Validated _ = Flaws e 	Validated _ <*> Flaws e' = Flaws e' 	Validated f <*> Validated x = Validated $ f x -instance Semigroup e => Applicative_ (Validation e) (:*:) (->) (->) where+instance Semigroup e => Semimonoidal (Validation e) (:*:) (->) (->) where 	multiply f (Validated x :*: Validated y) = Validated . f $ x :*: y 	multiply _ (Flaws x :*: Flaws y) = Flaws $ x + y 	multiply _ (Validated _ :*: Flaws y) = Flaws y@@ -60,15 +57,12 @@ 	Flaws _ <+> x = x 	Validated x <+> _ = Validated x -instance Traversable (Validation e) where-	Validated x ->> f = Validated <$> f x-	Flaws e ->> _ = point $ Flaws e+instance Traversable (Validation e) (->) (->) where+	f <<- Validated x = Validated -<$>- f x+	_ <<- Flaws e = point $ Flaws e -instance Bivariant Validation where+instance Bivariant Validation (->) (->) (->) where 	f <-> g = validation # Flaws . f # Validated . g--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

@@ -2,9 +2,9 @@  import Pandora.Pattern.Category (($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))-import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Paradigm.Primary.Functor.Function ()+import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))+import Pandora.Paradigm.Primary.Algebraic.Exponential ()  data Wedge e a = Nowhere | Here e | There a @@ -21,13 +21,10 @@ instance Pointable (Wedge e) (->) where 	point = There -instance Pointable_ (Wedge e) (->) where-	point_ = There--instance Traversable (Wedge e) where-	Nowhere ->> _ = point Nowhere-	Here x ->> _ = point $ Here x-	There x ->> f = There <$> f x+instance Traversable (Wedge e) (->) (->) where+	_ <<- Nowhere = point Nowhere+	_ <<- Here x = point $ Here x+	f <<- There x = There -<$>- f x  wedge :: (e -> r) -> (a -> r) -> r -> Wedge e a -> r wedge f _ _ (Here x) = f x

@@ -3,9 +3,6 @@ import Pandora.Core.Functor (type (~>)) import Pandora.Pattern.Category ((#)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Applicative ((<*>))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>))) import Pandora.Pattern.Object.Semigroup (Semigroup ((+))) import Pandora.Pattern.Object.Monoid (Monoid (zero)) import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (reduce))@@ -23,12 +20,6 @@ 	f -<$>- Left x = Left # f x 	f -<$>- Right y = Right # f y 	f -<$>- Both x y = Both # f x # f y--instance Traversable Wye where-	End ->> _ = point End-	Left x ->> f = Left <$> f x-	Right y ->> f = Right <$> f y-	Both x y ->> f = Both <$> f x <*> f y  instance Monotonic a (Wye a) where 	reduce f r (Left x) = f x r

@@ -10,8 +10,8 @@ import Pandora.Pattern.Object.Quasiring (Quasiring (one)) import Pandora.Pattern.Object.Group (Group (invert)) import Pandora.Pattern.Object.Setoid (Setoid ((==)))+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:))) import Pandora.Paradigm.Primary.Functor.Maybe (Maybe)-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:)) import Pandora.Paradigm.Primary.Transformer.Construction (Construction) import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty) import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (reduce))

@@ -1,17 +1,19 @@ module Pandora.Paradigm.Primary.Transformer.Backwards where  import Pandora.Pattern.Category ((.), ($), (#))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (.#..)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<))) import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_))-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))+import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Applicative (Semimonoidal (multiply))+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))+import Pandora.Pattern.Functor.Distributive (Distributive ((-<<))) import Pandora.Pattern.Transformer.Liftable (Liftable (lift)) import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower)) import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))-import Pandora.Paradigm.Primary.Functor.Function ((&))+import Pandora.Paradigm.Primary.Algebraic ((-<*>-))+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))+import Pandora.Paradigm.Primary.Algebraic.Exponential ((%)) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))  newtype Backwards t a = Backwards (t a)@@ -25,20 +27,19 @@ instance Pointable t (->) => Pointable (Backwards t) (->) where 	point = Backwards . point -instance Pointable_ t (->) => Pointable_ (Backwards t) (->) where-	point_ = Backwards . point_- instance Extractable t (->) => Extractable (Backwards t) (->) where 	extract (Backwards x) = extract x -instance Applicative t => Applicative (Backwards t) where-	Backwards f <*> Backwards x = Backwards # (&) <$> x <*> f+-- TODO: check that effects evaluation goes in opposite order+instance Semimonoidal t (:*:) (->) (->) => Semimonoidal (Backwards t) (:*:) (->) (->) where+	multiply f (Backwards x :*: Backwards y) = Backwards #+		f .#.. ((:*:) %) -<$>- y -<*>- x -instance Traversable t => Traversable (Backwards t) where-	Backwards x ->> f = Backwards <$> x ->> f+instance Traversable t (->) (->) => Traversable (Backwards t) (->) (->) where+	f <<- Backwards x = Backwards -<$>- f <<- x -instance Distributive t => Distributive (Backwards t) where-	x >>- f = Backwards $ x >>- run . f+instance Distributive t (->) (->) => Distributive (Backwards t) (->) (->) where+	f -<< x = Backwards $ run . f -<< x  instance Contravariant t => Contravariant (Backwards t) where 	f >$< Backwards x = Backwards $ f >$< x

@@ -6,13 +6,13 @@ import Pandora.Pattern.Category ((.), ($), (#)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)), Covariant_ ((-<$>-)), (-<$$>-)) import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))-import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_))+import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Alternative (Alternative ((<+>))) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (<**>)))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=), ($>>=)) , Bindable_ (join_))-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>), extend))+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (-<<-<<-))+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))+import Pandora.Pattern.Functor.Extendable (Extendable ((<<=))) import Pandora.Pattern.Functor.Monad (Monad) import Pandora.Pattern.Functor.Comonad (Comonad) import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))@@ -21,7 +21,8 @@ import Pandora.Pattern.Object.Semigroup (Semigroup ((+))) import Pandora.Pattern.Object.Ringoid ((*)) import Pandora.Pattern.Object.Monoid (Monoid (zero))-import Pandora.Paradigm.Primary.Functor.Function ()+import Pandora.Paradigm.Primary.Algebraic ((-<*>-))+import Pandora.Paradigm.Primary.Algebraic.Exponential () import Pandora.Paradigm.Controlflow.Effect.Interpreted (run) import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (reduce)) import Pandora.Paradigm.Schemes (type (<:.>))@@ -39,26 +40,20 @@ instance (Avoidable t, Covariant_ t (->) (->)) => Pointable (Construction t) (->) where 	point x = Construct x empty -instance (Avoidable t, Covariant_ t (->) (->)) => Pointable_ (Construction t) (->) where-	point_ x = Construct x empty- instance Covariant_ t (->) (->) => Extractable (Construction t) (->) where 	extract ~(Construct x _) = x  instance Applicative t => Applicative (Construction t) where 	~(Construct f fs) <*> ~(Construct x xs) = Construct # f x # fs <**> xs -instance Traversable t => Traversable (Construction t) where-	~(Construct x xs) ->> f = Construct <$> f x <*> xs ->>> f--instance (Alternative t, Covariant_ t (->) (->)) => Bindable (Construction t) where-	~(Construct x xs) >>= f = Construct # extract (f x) # deconstruct (f x) <+> xs $>>= f+instance Traversable t (->) (->) => Traversable (Construction t) (->) (->) where+	f <<- ~(Construct x xs) = Construct -<$>- f x -<*>- f -<<-<<- xs -instance (Covariant_ t (->) (->), Alternative t) => Bindable_ (Construction t) (->) where-	join_ (Construct x xs) = Construct # extract x # deconstruct x <+> (join_ @_ @(->) -<$>- xs)+instance (Covariant_ t (->) (->), Alternative t) => Bindable (Construction t) (->) where+	f =<< ~(Construct x xs) = Construct # extract (f x) # deconstruct (f x) <+> ((f =<<) -<$>- xs) -instance Covariant t => Extendable (Construction t) where-	x =>> f = Construct # f x # extend f <$> deconstruct x+instance Covariant_ t (->) (->) => Extendable (Construction t) (->) where+	f <<= x = Construct # f x # (f <<=) -<$>- deconstruct x  instance (Avoidable t, Alternative t, Covariant_ t (->) (->)) => Monad (Construction t) where @@ -93,4 +88,4 @@ f .-+ x = Construct x $ (f .-+) <$> f x  section :: Comonad t (->) => t ~> Construction t-section xs = Construct # extract xs $ xs =>> section+section xs = Construct # extract xs $ section <<= xs

@@ -1,3 +1,4 @@+{-# LANGUAGE UndecidableInstances #-} module Pandora.Paradigm.Primary.Transformer.Continuation where  import Pandora.Core.Functor (type (:.), type (:=), type (::|:.))@@ -5,12 +6,11 @@ import Pandora.Pattern.Functor.Covariant (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.Bindable (Bindable ((=<<))) import Pandora.Pattern.Functor.Monad (Monad) import Pandora.Pattern.Transformer.Liftable (Liftable (lift)) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))-import Pandora.Paradigm.Primary.Functor.Function ((!.), (%))+import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.), (%))  newtype Continuation r t a = Continuation ((->) ::|:. a :. t := r) @@ -31,20 +31,20 @@ instance Covariant t => Applicative (Continuation r t) where 	f <*> x = Continuation $ \h -> run f $ \g -> run x # h . g -instance Covariant t => Bindable (Continuation r t) where-	x >>= f = Continuation $ \g -> run x $ \y -> run # f y # g+instance Covariant_ t (->) (->) => Bindable (Continuation r t) (->) where+	f =<< x = Continuation $ \g -> run x $ \y -> run # f y # g  instance Monad t => Monad (Continuation r t) where -instance (forall u . Bindable u) => Liftable (Continuation r) where-	lift = Continuation . (>>=)+instance (forall u . Bindable u (->)) => Liftable (Continuation r) where+	lift = Continuation . (%) (=<<)  -- | Call with current continuation cwcc :: ((a -> Continuation r t b) -> Continuation r t a) -> Continuation r t a cwcc f = Continuation $ \g -> (run % g) . f $ Continuation . (!.) . g  -- | Delimit the continuation of any 'shift'-reset :: (forall u . Bindable u, Monad t, Traversable t) => Continuation r t r -> Continuation s t r+reset :: (forall u . Bindable u (->), Monad t) => Continuation r t r -> Continuation s t r reset = lift . (run % point)  -- | Capture the continuation up to the nearest enclosing 'reset' and pass it

@@ -7,11 +7,11 @@ import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))+import Pandora.Pattern.Functor.Extendable (Extendable ((<<=))) import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower)) import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))-import Pandora.Paradigm.Primary.Functor.Function ((!..), (-.#..-))-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)))+import Pandora.Paradigm.Primary.Algebraic.Exponential ((!..), (-.#..-))+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))  data Day t u a = forall b c . Day (t b) (u c) (b -> c -> a) @@ -31,8 +31,8 @@ instance (Extractable t (->), Extractable u (->)) => Extractable (Day t u) (->) where 	extract (Day tb uc bcad) = bcad # extract tb # extract uc -instance (Extendable t, Extendable u) => Extendable (Day t u) where-	day@(Day tb uc _) =>> f = Day tb uc (f day !..)+instance (Extendable t (->), Extendable u (->)) => Extendable (Day t u) (->) where+	f <<= day@(Day tb uc _) = Day tb uc (f day !..)  instance Extractable t (->) => Lowerable (Day t) where 	lower (Day tb uc bca) = bca (extract tb) -<$>- uc

@@ -9,13 +9,13 @@ import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Alternative (Alternative ((<+>))) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))+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)) import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower)) import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\), hoist))-import Pandora.Paradigm.Primary.Functor.Function ()+import Pandora.Paradigm.Primary.Algebraic.Exponential ()  data Instruction t a = Enter a | Instruct (t :. Instruction t := a) @@ -43,20 +43,22 @@ 	Enter f <*> Instruct y = Instruct $ f <$$> y 	Instruct f <*> y = Instruct $ (<*> y) <$> f -instance Covariant t => Bindable (Instruction t) where-	Enter x >>= f = f x-	Instruct xs >>= f = Instruct $ (>>= f) <$> xs+instance Covariant_ t (->) (->) => Bindable (Instruction t) (->) where+	f =<< Enter x = f x+	f =<< Instruct xs = Instruct $ (f =<<) -<$>- xs -instance Traversable t => Traversable (Instruction t) where-	Enter x ->> f = Enter <$> f x-	Instruct xs ->> f = Instruct <$> xs ->>> f+instance Monad t => Monad (Instruction t) where +instance Traversable t (->) (->) => Traversable (Instruction t) (->) (->) where+	f <<- Enter x = Enter -<$>- f x+	f <<- Instruct xs = Instruct -<$>- f -<<-<<- xs+ instance Liftable Instruction where 	lift x = Instruct $ Enter -<$>- x -instance (forall t . Monad t) => Lowerable Instruction where+instance (forall t . Bindable t (->), forall t . Pointable t (->)) => Lowerable Instruction where 	lower (Enter x) = point x-	lower (Instruct xs) = xs >>= lower+	lower (Instruct xs) = lower =<< xs  instance (forall v . Covariant v) => Hoistable Instruction where 	_ /|\ Enter x = Enter x

@@ -9,15 +9,14 @@ import Pandora.Pattern.Functor.Alternative (Alternative ((<+>))) import Pandora.Pattern.Functor.Avoidable (Avoidable (empty)) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-), distribute))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))+import Pandora.Pattern.Functor.Extendable (Extendable ((<<=))) import Pandora.Pattern.Transformer.Liftable (Liftable (lift)) import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\))) import Pandora.Pattern.Object.Setoid (Setoid ((==))) import Pandora.Pattern.Object.Chain (Chain ((<=>)))-import Pandora.Paradigm.Primary.Functor.Function ()+import Pandora.Paradigm.Primary.Algebraic.Exponential () import Pandora.Paradigm.Primary.Object.Boolean (Boolean (False)) import Pandora.Paradigm.Primary.Object.Ordering (Ordering (Less, Greater)) @@ -52,20 +51,17 @@ 	Other f <*> It x = Other $ ($ x) <$> f 	Other f <*> Other y = Other $ f <*> y -instance Traversable t => Traversable (Jack t) where-	It x ->> f = It <$> f x-	Other y ->> f = Other <$> y ->> f--instance Distributive t => Distributive (Jack t) where-	x >>- f = distribute $ f <$> x+instance Traversable t (->) (->) => Traversable (Jack t) (->) (->) where+	f <<- It x = It -<$>- f x+	f <<- Other y = Other -<$>- f <<- y -instance (Pointable t (->), Bindable t) => Bindable (Jack t) where-	It x >>= f = f x-	Other x >>= f = Other $ x >>= jack point identity . f+instance (Pointable t (->), Bindable t (->)) => Bindable (Jack t) (->) where+	f =<< It x = f x+	f =<< Other x = Other $ jack point identity . f =<< x -instance Extendable t => Extendable (Jack t) where-	It x =>> f = It . f $ It x-	Other x =>> f = Other $ x =>> f . Other+instance Extendable t (->) => Extendable (Jack t) (->) where+	f <<= It x = It . f $ It x+	f <<= Other x = Other $ f . Other <<= x  instance Liftable Jack where 	lift = Other

@@ -6,8 +6,8 @@ import Pandora.Pattern.Functor.Avoidable (Avoidable (empty)) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (-<<-<<-))+import Pandora.Paradigm.Primary.Algebraic ((-<*>-))  data Jet t a = Jet a (Jet t (t a)) @@ -17,8 +17,8 @@ instance Covariant_ t (->) (->) => Covariant_ (Jet t) (->) (->) where 	f -<$>- Jet x xs = Jet (f x) (f -<$$>- xs) -instance Traversable t => Traversable (Jet t) where-	Jet x xs ->> f = Jet <$> f x <*> xs ->>> f+instance Traversable t (->) (->) => Traversable (Jet t) (->) (->) where+	f <<- Jet x xs = Jet -<$>- f x -<*>- f -<<-<<- xs  instance (forall u . Avoidable u, Covariant_ t (->) (->)) => Pointable (Jet t) (->) where 	point x = Jet x empty

@@ -10,7 +10,7 @@ import Pandora.Pattern.Transformer.Liftable (Liftable (lift)) import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\))) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))-import Pandora.Paradigm.Primary.Functor.Function ((%))+import Pandora.Paradigm.Primary.Algebraic.Exponential ((%))  data Outline t a where 	Line :: a -> Outline t a

@@ -7,12 +7,13 @@ import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<))) import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))+import Pandora.Pattern.Functor.Applicative (Semimonoidal (multiply))+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))+import Pandora.Pattern.Functor.Distributive (Distributive ((-<<))) import Pandora.Pattern.Transformer.Liftable (Liftable (lift)) import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower)) import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:))) import Pandora.Paradigm.Primary.Transformer.Backwards (Backwards (Backwards)) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite)) @@ -30,14 +31,14 @@ instance Extractable t (->) => Extractable (Reverse t) (->) where 	extract (Reverse x) = extract x -instance Applicative t => Applicative (Reverse t) where-	Reverse f <*> Reverse x = Reverse # f <*> x+instance Semimonoidal t (:*:) (->) (->) => Semimonoidal (Reverse t) (:*:) (->) (->) where+	multiply f (Reverse x :*: Reverse y) = Reverse . multiply f $ x :*: y -instance Traversable t => Traversable (Reverse t) where-	Reverse x ->> f = Reverse <$> run (x ->> Backwards . f)+instance Traversable t (->) (->) => Traversable (Reverse t) (->) (->) where+	f <<- Reverse x = Reverse -<$>- run (Backwards . f <<- x) -instance Distributive t => Distributive (Reverse t) where-	x >>- f = Reverse $ x >>- run . f+instance Distributive t (->) (->) => Distributive (Reverse t) (->) (->) where+	f -<< x = Reverse $ run . f -<< x  instance Contravariant t => Contravariant (Reverse t) where 	f >$< Reverse x = Reverse # f >$< x

@@ -10,19 +10,20 @@ import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Alternative (Alternative ((<+>))) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))+import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<))) import Pandora.Pattern.Transformer.Liftable (Liftable (lift)) import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower)) import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\))) import Pandora.Paradigm.Inventory.Store (Store (Store)) import Pandora.Paradigm.Controlflow.Effect.Interpreted (run) -import Pandora.Paradigm.Primary.Functor.Function ((%))+import Pandora.Paradigm.Primary.Algebraic ((-<*>-))+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), twosome)+import Pandora.Paradigm.Primary.Algebraic.Exponential ((%)) import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), twosome)-import Pandora.Paradigm.Primary.Transformer.Reverse (Reverse (Reverse)) import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))+import Pandora.Paradigm.Primary.Transformer.Reverse (Reverse (Reverse)) import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>)) import Pandora.Paradigm.Schemes.P_Q_T (P_Q_T (P_Q_T)) import Pandora.Paradigm.Structure.Ability.Substructure@@ -39,20 +40,20 @@ instance (Avoidable t, Covariant_ t (->) (->)) => Pointable (Tap t) (->) where 	point = Tap % empty -instance (Covariant t, Covariant_ t (->) (->))  => Extractable (Tap t) (->) where+instance (Covariant_ t (->) (->)) => Extractable (Tap t) (->) where 	extract (Tap x _) = x  instance Applicative t => Applicative (Tap t) where 	Tap f fs <*> Tap x xs = Tap # f x # fs <*> xs -instance Traversable t => Traversable (Tap t) where-	Tap x xs ->> f = Tap <$> f x <*> xs ->> f+instance Traversable t (->) (->) => Traversable (Tap t) (->) (->) where+	f <<- Tap x xs = Tap -<$>- f x -<*>- f <<- xs -instance (Extractable t (->), Alternative t, Bindable t) => Bindable (Tap t) where-	Tap x xs >>= f = case f x of ~(Tap y ys) -> Tap y $ ys <+> (xs >>= lower . f)+instance (Extractable t (->), Alternative t, Bindable t (->)) => Bindable (Tap t) (->) where+	f =<< Tap x xs = case f x of ~(Tap y ys) -> Tap y $ ys <+> (lower . f =<< xs) -instance (Extendable t, Covariant_ t (->) (->)) => Extendable (Tap t) where-	x =>> f = Tap # f x $ lower x =>> f . Tap (extract x)+instance (Extendable t (->), Covariant_ t (->) (->)) => Extendable (Tap t) (->) where+	f <<= x = Tap # f x $ f . Tap (extract x) <<= lower x  instance Lowerable Tap where 	lower (Tap _ xs) = xs@@ -63,9 +64,9 @@ instance {-# OVERLAPS #-} Applicative t => Applicative (Tap (t <:.:> t := (:*:))) where 	Tap f (T_U (lfs :*: rfs)) <*> Tap x (T_U (ls :*: rs)) = Tap # f x # T_U (lfs <*> ls :*: rfs <*> rs) -instance {-# OVERLAPS #-} Traversable t => Traversable (Tap (t <:.:> t := (:*:))) where-	Tap x (T_U (future :*: past)) ->> f = (\past' x' future' -> Tap x' $ twosome # future' # run past')-		<$> Reverse past ->> f <*> f x <*> future ->> f+instance {-# OVERLAPS #-} Traversable t (->) (->) => Traversable (Tap (t <:.:> t := (:*:))) (->) (->) where+	f <<- Tap x (T_U (future :*: past)) = (\past' x' future' -> Tap x' $ twosome # future' # run past')+		-<$>- f <<- Reverse past -<*>- f x -<*>- f <<- future  instance (Covariant t, Covariant_ t (->) (->)) => Substructure Root (Tap (t <:.:> t := (:*:))) where 	type Available Root (Tap (t <:.:> t := (:*:))) = Identity

@@ -12,7 +12,7 @@ import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-))) import Pandora.Pattern.Transformer.Liftable (Liftable (lift))-import Pandora.Paradigm.Primary.Functor.Function ((!.))+import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.))  newtype Yoneda t a = Yoneda 	{ yoneda :: forall b . (a -> b) -> t b }@@ -41,6 +41,6 @@ instance Liftable Yoneda where 	lift x = Yoneda (-<$>- x) -instance (Extractable t (->), Pointable t (->), Extractable u (->) , Pointable u (->)) => Adjoint (Yoneda t) (Yoneda u) where-	x -| f = point . f . point # x-	x |- g = extract . extract # g <$> x+instance (Extractable t (->), Pointable t (->), Extractable u (->) , Pointable u (->)) => Adjoint (Yoneda t) (Yoneda u) (->) (->) where+	f -| x = point . f . point # x+	g |- x = extract . extract # g <$> x

@@ -19,28 +19,28 @@ import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-))) import Pandora.Paradigm.Controlflow.Effect.Interpreted (run) -instance (Covariant (v <:.> t), Covariant (u <:.> w), Adjoint t u, Adjoint v w)-	=> Adjoint (v <:.> t) (u <:.> w) where-		TU y |- g = y |- (|- run . g)-		x -| f = TU $ x -| (-| f . TU)+instance (Covariant (v <:.> t), Covariant (u <:.> w), Adjoint t u (->) (->), Adjoint v w (->) (->))+	=> Adjoint (v <:.> t) (u <:.> w) (->) (->) where+		g |- TU y = (run . g |-) |- y+		f -| x = TU $ (f . TU -|) -| x -instance (Covariant (v <:.> t), Covariant (w <.:> u), Adjoint t u, Adjoint v w)-	=> Adjoint (v <:.> t) (w <.:> u) where-		TU t |- g = t |- (|- run . g)-		x -| f = UT $ x -| (-| f . TU)+instance (Covariant (v <:.> t), Covariant (w <.:> u), Adjoint t u (->) (->), Adjoint v w (->) (->))+	=> Adjoint (v <:.> t) (w <.:> u) (->) (->) where+		g |- TU t = (run . g |-) |- t+		f -| x = UT $ (f . TU -|) -| x -instance (Covariant (t <.:> v), Covariant (w <.:> u), Adjoint t u, Adjoint v w)-	=> Adjoint (t <.:> v) (w <.:> u) where-		UT t |- g = t |- (|- run . g)-		x -| f = UT $ x -| (-| f . UT)+instance (Covariant (t <.:> v), Covariant (w <.:> u), Adjoint t u (->) (->), Adjoint v w (->) (->))+	=> Adjoint (t <.:> v) (w <.:> u) (->) (->) where+		g |- UT t =  (run . g |-) |- t+		f -| x = UT $ (f . UT -|) -| x -instance (Covariant (t <.:> v), Covariant (w <:.> u) , Adjoint v u, Adjoint t w)-	=> Adjoint (t <.:> v) (w <:.> u) where-		UT t |- g = t |- (|- run . g)-		x -| f = TU $ x -| (-| f . UT)+instance (Covariant (t <.:> v), Covariant (w <:.> u) , Adjoint v u (->) (->), Adjoint t w (->) (->))+	=> Adjoint (t <.:> v) (w <:.> u) (->) (->) where+		g |- UT x = (run . g |-) |- x+		f -| x = TU $ (f . UT -|) -| x  instance (Covariant ((t <:<.>:> u) t'), Covariant ((v <:<.>:> w) v')-	, Adjoint t w, Adjoint t' v', Adjoint t v, Adjoint u v, Adjoint v' t')-	=> Adjoint ((t <:<.>:> u) t') ((v <:<.>:> w) v') where-		TUT t |- g = t |- (|- (|- run . g))-		x -| f = TUT $ x -| (-| (-| f . TUT))+	, Adjoint t w (->) (->), Adjoint t' v' (->) (->), Adjoint t v (->) (->), Adjoint u v (->) (->), Adjoint v' t' (->) (->))+	=> Adjoint ((t <:<.>:> u) t') ((v <:<.>:> w) v') (->) (->) where+		g |- TUT x = ((run . g |-) |-) |- x+		f -| x = TUT $  ((f . TUT -|) -|) -| x

@@ -1,7 +1,7 @@ module Pandora.Paradigm.Schemes.TU where  import Pandora.Core.Functor (type (:.), type (:=), type (~>))-import Pandora.Pattern.Category ((.), ($))+import Pandora.Pattern.Category ((.), ($), identity) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)), Covariant_ ((-<$>-)), (-<$$>-)) import Pandora.Pattern.Functor.Contravariant (Contravariant) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (<**>)))@@ -9,9 +9,9 @@ import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Avoidable (Avoidable (empty)) import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=), join))+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (-<<-<<-))+import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<))) import Pandora.Pattern.Transformer.Liftable (Liftable (lift)) import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower)) import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))@@ -52,11 +52,11 @@ instance (Extractable t (->), Extractable u (->)) => Extractable (t <:.> u) (->) where 	extract = extract . extract . run -instance (Traversable t, Traversable u) => Traversable (t <:.> u) where-	x ->> f = TU <$> run x ->>> f+instance (Traversable t (->) (->), Traversable u (->) (->)) => Traversable (t <:.> u) (->) (->) where+	f <<- x = TU -<$>- f -<<-<<- run x -instance (Bindable t, Distributive t, Bindable u) => Bindable (t <:.> u) where-	TU x >>= f = TU $ x >>= \i -> join <$> i >>- run . f+instance (Bindable t (->), Distributive t (->) (->), Covariant_ u (->) (->), Bindable u (->)) => Bindable (t <:.> u) (->) where+	f =<< TU x = TU $ (\i -> (identity =<<) -<$>- run . f -<< i) =<< x  instance Pointable t (->) => Liftable (TU Covariant Covariant t) where 	lift :: Covariant_ u (->) (->) => u ~> t <:.> u@@ -66,6 +66,6 @@ 	lower :: t <:.> u ~> u 	lower (TU x) = extract x -instance Covariant t => Hoistable (TU Covariant Covariant t) where+instance Covariant_ t (->) (->) => Hoistable (TU Covariant Covariant t) where 	(/|\) :: u ~> v -> (t <:.> u ~> t <:.> v)-	f /|\ TU x = TU $ f <$> x+	f /|\ TU x = TU $ f -<$>- x

@@ -2,17 +2,12 @@  import Pandora.Core.Functor (type (:.), type (:=), type (~>)) import Pandora.Pattern.Category (identity, (.), ($))-import Pandora.Pattern.Functor ((<*+>)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$$>)), Covariant_ ((-<$>-)), (-<$$$>-)) import Pandora.Pattern.Functor.Contravariant (Contravariant)-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))-import Pandora.Pattern.Functor.Avoidable (Avoidable (empty)) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=), ($>>=)))-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>), ($=>>)))-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))+import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))+import Pandora.Pattern.Functor.Distributive (Distributive ((-<<))) import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-))) import Pandora.Pattern.Transformer.Liftable (Liftable (lift)) import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))@@ -42,31 +37,31 @@ instance (Covariant_ t (->) (->), Covariant_ t' (->) (->), Covariant_ u (->) (->)) => Covariant_ (t <:<.>:> t' := u) (->) (->)where 	f -<$>- TUT x = TUT $ f -<$$$>- x -instance (Covariant t, Covariant t', Adjoint t' t, Bindable u) => Applicative (t <:<.>:> t' := u) where-	f <*> x = TUT $ (>>= (|- (<$$$> run x))) <$> run f+--instance (Covariant t, Covariant t', Adjoint t' t (->) (->), Bindable u (->)) => Applicative (t <:<.>:> t' := u) where+--	f <*> x = TUT $ (>>= ((<$$$> run x) |-)) <$> run f -instance (Applicative t, Covariant t', Alternative u) => Alternative (t <:<.>:> t' := u) where-	x <+> y = TUT $ run x <*+> run y+--instance (Applicative t, Covariant t', Alternative u) => Alternative (t <:<.>:> t' := u) where+--	x <+> y = TUT $ run x <*+> run y -instance (Pointable t (->), Applicative t, Covariant t', Avoidable u) => Avoidable (t <:<.>:> t' := u) where-	empty = TUT $ point empty+--instance (Pointable t (->), Applicative t, Covariant t', Avoidable u) => Avoidable (t <:<.>:> t' := u) where+--	empty = TUT $ point empty -instance (Covariant_ t (->) (->), Covariant_ t' (->) (->), Pointable u (->), Adjoint t' t) => Pointable (t <:<.>:> t' := u) (->) where-	point = unite . (-| point)+instance (Covariant_ t (->) (->), Covariant_ t' (->) (->), Pointable u (->), Adjoint t' t (->) (->)) => Pointable (t <:<.>:> t' := u) (->) where+	point = unite . (point @_ @(->) -|) -instance (Covariant t, Covariant t', Adjoint t' t, Bindable u) => Bindable (t <:<.>:> t' := u) where-	x >>= f = TUT $ run x $>>= (|- run . f)+--instance (Covariant t, Covariant t', Adjoint t' t (->) (->), Bindable u (->)) => Bindable (t <:<.>:> t' := u) (->) where+--	f =<< x = TUT $ ((run . f |-) =<<) -<$>- x -instance (Covariant t', Covariant t, Adjoint t' t, Extendable u) => Extendable (t' <:<.>:> t := u) where-	x =>> f = TUT $ run x $=>> (-| f . unite)+instance (Covariant t', Covariant t, Adjoint t' t (->) (->), Extendable u (->)) => Extendable (t' <:<.>:> t := u) (->) where+	f <<= x = TUT $ ((f . unite -|) <<=) -<$>- run x -instance (Covariant_ t (->) (->), Covariant_ t' (->) (->), Adjoint t t', Extractable u (->)) => Extractable (t <:<.>:> t' := u) (->) where-	extract = (|- extract) . run+instance (Covariant_ t (->) (->), Covariant_ t' (->) (->), Adjoint t t' (->) (->), Extractable u (->)) => Extractable (t <:<.>:> t' := u) (->) where+	extract = (extract @_ @(->) |-) . run -instance (forall u . Covariant u, Adjoint t' t, Distributive t) => Liftable (t <:<.>:> t') where+instance (forall u . Covariant u, Adjoint t' t (->) (->), Distributive t(->) (->) ) => Liftable (t <:<.>:> t') where 	lift :: Covariant_ u (->) (->) => u ~> t <:<.>:> t' := u-	lift x = TUT $ x >>- (-| identity)+	lift x = TUT $ (identity @(->) -|) -<< x -instance (forall u . Covariant u, Adjoint t t', Distributive t') => Lowerable (t <:<.>:> t') where+instance (forall u . Covariant u, Adjoint t t' (->) (->), Distributive t'(->) (->) ) => Lowerable (t <:<.>:> t') where 	lower :: Covariant_ u (->) (->) => (t <:<.>:> t' := u) ~> u-	lower (TUT x) = x |- (>>- identity)+	lower (TUT x) = (identity @(->) -<<) |- x

@@ -3,8 +3,8 @@ import Pandora.Core.Functor (type (:=)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))-import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)), Bivariant_ ((-<->-)))-import Pandora.Pattern.Functor.Divariant (Divariant ((>->))) +import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))+import Pandora.Pattern.Functor.Divariant (Divariant ((>->))) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (||=)))  newtype T_U ct cu p t u a = T_U (p (t a) (u a))@@ -21,14 +21,14 @@ 	run ~(T_U x) = x 	unite = T_U -instance (forall i . Covariant (p i), Bivariant p, Covariant t, Covariant u) => Covariant (t <:.:> u := p) where+instance (forall i . Covariant (p i), Bivariant p (->) (->) (->), Covariant t, Covariant u) => Covariant (t <:.:> u := p) where 	f <$> x = (f <$>) <-> (f <$>) ||= x -instance (forall i . Covariant_ (p i) (->) (->), Bivariant_ p (->) (->) (->), Covariant_ t (->) (->), Covariant_ u (->) (->)) => Covariant_ (t <:.:> u := p) (->) (->) where-	f -<$>- x = (f -<$>-) -<->- (f -<$>-) ||= x+instance (forall i . Covariant_ (p i) (->) (->), Bivariant p (->) (->) (->), Covariant_ t (->) (->), Covariant_ u (->) (->)) => Covariant_ (t <:.:> u := p) (->) (->) where+	f -<$>- x = (f -<$>-) <-> (f -<$>-) ||= x -instance (Divariant p, Contravariant t, Covariant u) => Covariant (t >:.:> u := p) where+instance (Divariant p (->) (->) (->), Contravariant t, Covariant u) => Covariant (t >:.:> u := p) where 	f <$> x = (f >$<) >-> (f <$>) ||= x -instance (forall i . Covariant (p i), Bivariant p, Contravariant t, Contravariant u) => Contravariant (t >:.:< u := p) where+instance (forall i . Covariant (p i), Bivariant p (->) (->) (->), Contravariant t, Contravariant u) => Contravariant (t >:.:< u := p) where 	f >$< x = (f >$<) <-> (f >$<) ||= x

@@ -1,18 +1,18 @@ module Pandora.Paradigm.Schemes.UT where  import Pandora.Core.Functor (type (:.), type (:=), type (~>))-import Pandora.Pattern.Category ((.), ($))+import Pandora.Pattern.Category ((.), ($), identity) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)), Covariant_ ((-<$>-)), (-<$$>-)) import Pandora.Pattern.Functor.Contravariant (Contravariant)-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (<**>)))+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (<**>)), Semimonoidal) import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=), join))+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<))) import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Pattern.Functor.Monad (Monad)+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-))) import Pandora.Pattern.Transformer.Liftable (Liftable (lift)) import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower)) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))  newtype UT ct cu t u a = UT (u :. t := a) @@ -40,8 +40,8 @@ instance (Pointable t (->), Pointable u (->)) => Pointable (t <.:> u) (->) where 	point = UT . point . point -instance (Traversable t, Bindable t, Applicative u, Monad u) => Bindable (t <.:> u) where-	UT x >>= f = UT $ x >>= \i -> join <$> i ->> run . f+instance (Traversable t (->) (->), Bindable t (->), Semimonoidal u (:*:) (->) (->), Pointable u (->), Bindable u (->)) => Bindable (t <.:> u) (->) where+	f =<< UT x = UT $ ((identity =<<) -<$>-) . (run . f <<-) =<< x  instance (Extractable t (->), Extractable u (->)) => Extractable (t <.:> u) (->) where 	extract = extract . extract . run

@@ -18,12 +18,12 @@ import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (||=)) import Pandora.Paradigm.Inventory.Optics () import Pandora.Paradigm.Inventory.Store (Store (Store))+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), attached, twosome)+import Pandora.Paradigm.Primary.Algebraic.Exponential ((%)) import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False))-import Pandora.Paradigm.Primary.Functor.Function ((%)) import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity)) import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing)) import Pandora.Paradigm.Primary.Functor.Predicate (Predicate (Predicate))-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), attached, twosome) import Pandora.Paradigm.Primary.Functor.Wye (Wye (Both, Left, Right, End)) import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct)) import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))@@ -69,15 +69,15 @@ 	type Morphing (Into (o ds)) Binary = Maybe <:.> Morphing (Into (o ds)) (Construction Wye) 	morphing (premorph -> xs) = comap (into @(o ds)) ||= xs -instance Substructure Left (Flip Product a) where-	type Available Left (Flip Product a) = Identity-	type Substance Left (Flip Product a) = Identity+instance Substructure Left (Flip (:*:) a) where+	type Available Left (Flip (:*:) a) = Identity+	type Substance Left (Flip (:*:) a) = Identity 	substructure = P_Q_T $ \product -> case run # lower product of 		s :*: x -> Store $ Identity (Identity s) :*: lift . Flip . (:*: x) . extract . extract -instance Substructure Right (Product s) where-	type Available Right (Product s) = Identity-	type Substance Right (Product s) = Identity+instance Substructure Right ((:*:) s) where+	type Available Right ((:*:) s) = Identity+	type Substance Right ((:*:) s) = Identity 	substructure = P_Q_T $ \product -> case lower product of 		s :*: x -> Store $ Identity (Identity x) :*: lift . (s :*:) . extract . extract 

@@ -2,7 +2,7 @@  import Pandora.Pattern.Category ((#)) import Pandora.Pattern.Functor.Covariant ((.#..))-import Pandora.Paradigm.Primary.Functor.Function ((!.))+import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.))  class Monotonic a e where 	{-# MINIMAL reduce #-}

@@ -7,12 +7,12 @@ import Pandora.Pattern.Functor.Extractable (extract) import Pandora.Pattern.Object.Chain (Chain ((<=>))) import Pandora.Pattern.Object.Setoid (Setoid)+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:))) import Pandora.Paradigm.Primary.Functor (Comparison) import Pandora.Paradigm.Primary.Functor.Convergence (Convergence (Convergence)) import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity)) import Pandora.Paradigm.Primary.Functor.Maybe (Maybe) import Pandora.Paradigm.Primary.Functor.Predicate (Predicate, equate)-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:)) import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag)) import Pandora.Paradigm.Controlflow.Effect.Interpreted (run) import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))@@ -65,5 +65,5 @@ lookup :: forall mod key struct a . (Morphed (Lookup mod) struct ((->) key <:.> Maybe)) => key -> struct a -> Maybe a lookup key struct = run # morph @(Lookup mod) struct # key -vary :: forall mod key value struct . (Morphed (Vary mod) struct ((Product key <:.> Identity) <:.:> struct := (->))) => key -> value -> struct value -> struct value+vary :: forall mod key value struct . (Morphed (Vary mod) struct (((:*:) key <:.> Identity) <:.:> struct := (->))) => key -> value -> struct value -> struct value vary key value xs = run # morph @(Vary mod) @struct xs # TU (key :*: Identity value)

@@ -4,15 +4,16 @@  import Pandora.Core.Functor (type (:=)) import Pandora.Pattern.Category ((.), ($))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-))) import Pandora.Pattern.Object.Setoid (Setoid ((!=))) import Pandora.Pattern.Object.Semigroup ((+)) import Pandora.Pattern.Object.Quasiring (one)-import Pandora.Paradigm.Primary.Functor.Function ((!.), (%))+import Pandora.Paradigm.Primary.Algebraic ()+import Pandora.Paradigm.Primary.Algebraic.Product (attached)+import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.), (%)) import Pandora.Paradigm.Primary.Functor.Convergence (Convergence (Convergence)) import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Nothing)) import Pandora.Paradigm.Primary.Functor.Predicate (Predicate, equate)-import Pandora.Paradigm.Primary.Functor.Product (attached) import Pandora.Paradigm.Primary.Object.Boolean (Boolean) import Pandora.Paradigm.Primary.Object.Numerator (Numerator (Zero)) import Pandora.Paradigm.Schemes.T_U (type (<:.:>))@@ -20,10 +21,10 @@ import Pandora.Paradigm.Inventory.State (State, modify) import Pandora.Paradigm.Controlflow.Effect (run) -type Set t f a = (Traversable t, Setoid a, Setoid (t a), Morphable (Find f) t)+type Set t f a = (Traversable t (->) (->), Setoid a, Setoid (t a), Morphable (Find f) t)  subset :: forall t f a . (Set t f a, Morphing (Find f) t ~ (Predicate <:.:> Maybe := (->))) => Convergence Boolean := t a-subset = Convergence $ \s ss -> Nothing != ss ->> (find @f @t @Maybe % s) . equate+subset = Convergence $ \s ss -> Nothing != (find @f @t @Maybe % s) . equate <<- ss -cardinality :: Traversable t => t a -> Numerator-cardinality s = attached . run @(State _) % Zero $ s ->> (modify @Numerator (+ one) !.)+cardinality :: Traversable t (->) (->) => t a -> Numerator+cardinality s = attached . run @(State _) % Zero $ (modify @Numerator (+ one) !.) <<- s

@@ -11,15 +11,15 @@ import Pandora.Pattern.Functor.Applicative (Applicative ((<*>))) import Pandora.Pattern.Functor.Alternative (Alternative ((<+>))) import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<))) import Pandora.Pattern.Functor.Monad (Monad) import Pandora.Pattern.Transformer.Liftable (lift) import Pandora.Pattern.Object.Semigroup (Semigroup ((+))) import Pandora.Pattern.Object.Monoid (Monoid (zero)) import Pandora.Pattern.Object.Setoid (Setoid ((==))) import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))-import Pandora.Paradigm.Primary.Functor.Function ((%))+import Pandora.Paradigm.Primary.Algebraic.Exponential ((%)) import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct)) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite)) import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))@@ -49,16 +49,17 @@ instance (Avoidable t, Alternative t) => Avoidable (Comprehension t) where 	empty = Comprehension empty -instance Traversable (t <:.> Construction t) => Traversable (Comprehension t) where-	Comprehension x ->> f = Comprehension <$> x ->> f+instance Traversable (t <:.> Construction t) (->) (->) => Traversable (Comprehension t) (->) (->) where+	f <<- Comprehension x = Comprehension -<$>- f <<- x -instance (forall a . Semigroup (t <:.> Construction t := a), Bindable t, Pointable t (->), Avoidable t) => Applicative (Comprehension t) where-	fs <*> xs = fs >>= \f -> xs >>= Comprehension . TU . point . point . f+instance (forall a . Semigroup (t <:.> Construction t := a), Bindable t (->), Pointable t (->), Avoidable t) => Applicative (Comprehension t) where+	fs <*> xs = (\f -> Comprehension . TU . point . point . f =<< xs) =<< fs -instance (forall a . Semigroup (t <:.> Construction t := a), Bindable t) => Bindable (Comprehension t) where-	Comprehension (TU t) >>= f = Comprehension . TU $ t >>= \(Construct x xs) -> run . run $ f x + (Comprehension (TU xs) >>= f)+instance (forall a . Semigroup (t <:.> Construction t := a), Bindable t (->)) => Bindable (Comprehension t) (->) where+	f =<< Comprehension (TU t) = Comprehension . TU $ (\(Construct x xs) -> run . run $ f x + (f =<< Comprehension (TU xs))) =<< t+		-- t >>= \(Construct x xs) -> run . run $ f x + (Comprehension (TU xs) >>= f) -instance (forall a . Semigroup (t <:.> Construction t := a), Pointable t (->), Avoidable t, Bindable t) => Monad (Comprehension t) where+instance (forall a . Semigroup (t <:.> Construction t := a), Pointable t (->), Avoidable t, Bindable t (->)) => Monad (Comprehension t) where  instance Setoid (t <:.> Construction t := a) => Setoid (Comprehension t a) where 	Comprehension ls == Comprehension rs = ls == rs

@@ -7,20 +7,21 @@ import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)), Covariant_ ((-<$>-)), (-<$$>-)) import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (-<<-<<-)) import Pandora.Pattern.Functor.Extractable (extract) import Pandora.Pattern.Functor.Alternative (Alternative ((<+>))) import Pandora.Pattern.Functor.Avoidable (Avoidable (empty)) import Pandora.Pattern.Object.Monoid (Monoid (zero))-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)))+import Pandora.Paradigm.Primary.Algebraic ()+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:))) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite)) import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), Morph (Into), premorph) import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty) -newtype Prefixed t k a = Prefixed (t :. Product k := a)+newtype Prefixed t k a = Prefixed (t :. (:*:) k := a)  instance Interpreted (Prefixed t k) where-	type Primary (Prefixed t k) a = t :. Product k := a+	type Primary (Prefixed t k) a = t :. (:*:) k := a 	run ~(Prefixed x) = x 	unite = Prefixed @@ -30,8 +31,8 @@ instance Covariant_ t (->) (->) => Covariant_ (Prefixed t k) (->) (->) where 	f -<$>- Prefixed x = Prefixed $ f -<$$>- x -instance Traversable t => Traversable (Prefixed t k) where-	Prefixed x ->> f = Prefixed <$> x ->>> f+instance Traversable t (->) (->) => Traversable (Prefixed t k) (->) (->) where+	f <<- Prefixed x = Prefixed -<$>- f -<<-<<- x  instance (Monoid k, Pointable t (->)) => Pointable (Prefixed t k) (->) where 	point = Prefixed . point . (:*:) zero

@@ -7,23 +7,23 @@ import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), ($$$>)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Extractable (extract) import Pandora.Pattern.Functor.Avoidable (empty)-import Pandora.Pattern.Functor.Bindable ((>>=))+import Pandora.Pattern.Functor.Bindable ((=<<)) import Pandora.Pattern.Transformer.Liftable (lift) import Pandora.Pattern.Transformer.Lowerable (lower) import Pandora.Pattern.Object.Semigroup (Semigroup ((+))) import Pandora.Pattern.Object.Chain (Chain ((<=>))) import Pandora.Paradigm.Primary ()+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), type (:*:), attached, twosome)+import Pandora.Paradigm.Primary.Algebraic.Exponential ((%), (&)) import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False)) import Pandora.Paradigm.Primary.Object.Ordering (order) import Pandora.Paradigm.Primary.Object.Numerator (Numerator (Numerator, Zero)) import Pandora.Paradigm.Primary.Object.Denumerator (Denumerator (One)) import Pandora.Paradigm.Primary.Functor (Comparison) import Pandora.Paradigm.Primary.Functor.Convergence (Convergence (Convergence))-import Pandora.Paradigm.Primary.Functor.Function ((%), (&)) import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity)) import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing)) import Pandora.Paradigm.Primary.Functor.Predicate (Predicate (Predicate))-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), attached, twosome) import Pandora.Paradigm.Primary.Functor.Wye (Wye (End, Left, Right, Both)) import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct) import Pandora.Paradigm.Schemes (TU (TU), T_U (T_U), P_Q_T (P_Q_T), type (<:.>), type (<:.:>))@@ -138,11 +138,11 @@ 	morphing (run . run . premorph -> Nothing) = lift Nothing 	morphing (run . run . premorph -> Just tree) = TU $ \key -> 		let root = extract tree in key <=> attached root & order (Just # extract root)-			(view # sub @Left # tree >>= lookup @Key key . Prefixed)-			(view # sub @Right # tree >>= lookup @Key key . Prefixed)+			(lookup @Key key . Prefixed =<< view # sub @Left # tree)+			(lookup @Key key . Prefixed =<< view # sub @Right # tree)  instance Chain k => Morphable (Vary Element) (Prefixed Binary k) where-	type Morphing (Vary Element) (Prefixed Binary k) = (Product k <:.> Identity) <:.:> Prefixed Binary k := (->)+	type Morphing (Vary Element) (Prefixed Binary k) = ((:*:) k <:.> Identity) <:.:> Prefixed Binary k := (->) 	morphing (run . run . premorph -> Nothing) = T_U $ \(TU (key :*: Identity value)) -> Prefixed . lift . leaf $ key :*: value 	morphing (run . run . premorph -> Just tree) = T_U $ \(TU (key :*: Identity value)) -> 		let continue = ((vary @Element @k @_ @(Prefixed Binary _) key value =||) =||)@@ -157,8 +157,8 @@ 	type Morphing (Lookup Key) (Prefixed (Construction Wye) key) = (->) key <:.> Maybe 	morphing (run . premorph -> Construct x xs) = TU $ \key -> 		key <=> attached x & order (Just # extract x)-			(view # sub @Left # xs >>= lookup @Key key . Prefixed . extract)-			(view # sub @Right # xs >>= lookup @Key key . Prefixed . extract)+			(lookup @Key key . Prefixed . extract =<< view # sub @Left # xs)+			(lookup @Key key . Prefixed . extract =<< view # sub @Left # xs)  -------------------------------------- Zipper of binary tree --------------------------------------- 

@@ -5,16 +5,14 @@ import Pandora.Core.Functor (type (:.), type (:=), type (:::)) import Pandora.Core.Impliable (imply) import Pandora.Pattern.Category ((.), ($), (#), identity)-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (.#..)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (.#..)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>))) import Pandora.Pattern.Functor.Extractable (extract) import Pandora.Pattern.Functor.Avoidable (empty)-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))-import Pandora.Pattern.Functor.Bindable ((>>=))+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))+import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<))) import Pandora.Pattern.Functor.Bivariant ((<->))-import Pandora.Pattern.Functor.Adjoint ((|-))-import Pandora.Pattern.Functor () import Pandora.Pattern.Transformer.Liftable (lift) import Pandora.Pattern.Transformer.Lowerable (lower) import Pandora.Pattern.Object.Setoid (Setoid ((==)))@@ -23,11 +21,12 @@ import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False), (?)) import Pandora.Paradigm.Primary.Object.Numerator (Numerator (Numerator)) import Pandora.Paradigm.Primary.Object.Denumerator (Denumerator (One))-import Pandora.Paradigm.Primary.Functor.Function ((%))+import Pandora.Paradigm.Primary.Algebraic ((-<*>-))+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), attached, twosome)+import Pandora.Paradigm.Primary.Algebraic.Exponential ((%)) import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing)) import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity)) import Pandora.Paradigm.Primary.Functor.Predicate (Predicate (Predicate))-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), attached, twosome) import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right)) import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct, (.-+)) import Pandora.Paradigm.Primary.Transformer.Tap (Tap (Tap))@@ -118,7 +117,7 @@ 		Nothing -> Store $ Identity empty :*: lift . identity . extract  -- | Transform any traversable structure into a stack-linearize :: forall t a . Traversable t => t a -> List a+linearize :: forall t a . Traversable t (->) (->) => t a -> List a linearize = TU . extract . (run @(State (Maybe :. Nonempty List := a)) % Nothing) . fold (Just .#.. Construct)  ----------------------------------------- Non-empty list -------------------------------------------@@ -132,7 +131,7 @@ instance Morphable (Find Element) (Construction Maybe) where 	type Morphing (Find Element) (Construction Maybe) = Predicate <:.:> Maybe := (->) 	morphing (premorph -> Construct x xs) = T_U $ \p ->-		run p x ? Just x $ xs >>= find @Element @(Nonempty List) @Maybe # p+		run p x ? Just x $ find @Element @(Nonempty List) @Maybe # p =<< xs  instance Morphable (Into List) (Construction Maybe) where 	type Morphing (Into List) (Construction Maybe) = List@@ -167,16 +166,16 @@  type instance Zipper List (Left ::: Right) = Tap (List <:.:> List := (:*:)) -instance {-# OVERLAPS #-} Applicative (Tap (List <:.:> List := (:*:))) where-	Tap f (T_U (lfs :*: rfs)) <*> Tap x (T_U (ls :*: rs)) = Tap # f x # T_U (lfs <*> ls :*: rfs <*> rs)+--instance {-# OVERLAPS #-} Applicative (Tap (List <:.:> List := (:*:))) where+	--Tap f (T_U (lfs :*: rfs)) <*> Tap x (T_U (ls :*: rs)) = Tap # f x # T_U (lfs <*> ls :*: rfs <*> rs) -instance {-# OVERLAPS #-} Traversable (Tap (List <:.:> List := (:*:))) where-	Tap x (T_U (future :*: past)) ->> f = (\past' x' future' -> Tap x' $ twosome # future' # run past')-		<$> Reverse past ->> f <*> f x <*> future ->> f+instance {-# OVERLAPS #-} Traversable (Tap (List <:.:> List := (:*:))) (->) (->) where+	f <<- Tap x (T_U (future :*: past)) = (\past' x' future' -> Tap x' $ twosome # future' # run past')+		-<$>- f <<- Reverse past -<*>- f x -<*>- f <<- future -instance {-# OVERLAPS #-} Extendable (Tap (List <:.:> List := (:*:))) where-	z =>> f = let move rtt = TU . deconstruct $ run . rtt .-+ z in-		Tap # f z $ twosome # f <$> move (rotate @Left) # f <$> move (rotate @Right)+instance {-# OVERLAPS #-} Extendable (Tap (List <:.:> List := (:*:))) (->) where+	f <<= z = let move rtt = TU . deconstruct $ run . rtt .-+ z in+		Tap # f z $ twosome # f -<$>- move (rotate @Left) # f -<$>- move (rotate @Right)  instance Morphable (Rotate Left) (Tap (List <:.:> List := (:*:))) where 	type Morphing (Rotate Left) (Tap (List <:.:> List := (:*:))) = Maybe <:.> Tap (List <:.:> List := (:*:))@@ -197,13 +196,13 @@ instance Morphable (Into List) (Tap (List <:.:> List := (:*:))) where 	type Morphing (Into List) (Tap (List <:.:> List := (:*:))) = List 	morphing (premorph -> Tap x (T_U (future :*: past))) = attached $ run @(State _)-		# past ->> modify . item @Push @List+		# modify . item @Push @List <<- past 		# item @Push x future  instance Morphable (Into (Comprehension Maybe)) (Tap (List <:.:> List := (:*:))) where 	type Morphing (Into (Comprehension Maybe)) (Tap (List <:.:> List := (:*:))) = Comprehension Maybe 	morphing (premorph -> Tap x (T_U (future :*: past))) = attached $ run @(State _)-		# past ->> modify . item @Push @(Comprehension Maybe)+		# modify . item @Push @(Comprehension Maybe) <<- past 		# item @Push x (Comprehension future)  ------------------------------------- Zipper of non-empty list -------------------------------------@@ -228,22 +227,22 @@ 	type Morphing (Into (Tap (List <:.:> List := (:*:)))) (Tap (Construction Maybe <:.:> Construction Maybe := (:*:))) = Tap (List <:.:> List := (:*:)) 	morphing (premorph -> zipper) = Tap # extract zipper $ lift <-> lift ||= lower zipper -instance Morphable (Into (Tap (Construction Maybe <:.:> Construction Maybe := (:*:)))) (Tap (List <:.:> List := (:*:))) where-	type Morphing (Into (Tap (Construction Maybe <:.:> Construction Maybe := (:*:)))) (Tap (List <:.:> List := (:*:))) =-		Maybe <:.> Tap (Construction Maybe <:.:> Construction Maybe := (:*:))-	morphing (premorph -> zipper) = let spread x y = (:*:) <$> x <*> y in TU $-		Tap (extract zipper) . T_U <$> ((|- spread) . (run <-> run) . run $ lower zipper)+--instance Morphable (Into (Tap (Construction Maybe <:.:> Construction Maybe := (:*:)))) (Tap (List <:.:> List := (:*:))) where+	--type Morphing (Into (Tap (Construction Maybe <:.:> Construction Maybe := (:*:)))) (Tap (List <:.:> List := (:*:))) =+		--Maybe <:.> Tap (Construction Maybe <:.:> Construction Maybe := (:*:))+	--morphing (premorph -> zipper) = let spread x y = (:*:) -<$>- x -<*>- y in TU $+		--Tap (extract zipper) . T_U -<$>- ((spread |-) . (run <-> run) . run $ lower zipper)  instance Morphable (Into (Construction Maybe)) (Tap (Construction Maybe <:.:> Construction Maybe := (:*:))) where 	type Morphing (Into (Construction Maybe)) (Tap (Construction Maybe <:.:> Construction Maybe := (:*:))) = Construction Maybe 	morphing (premorph -> Tap x (T_U (future :*: past))) = attached $ run @(State _)-		# past ->> modify . item @Push @(Nonempty List)+		# modify . item @Push @(Nonempty List) <<- past 		# item @Push x future  instance Morphable (Into List) (Tap (Construction Maybe <:.:> Construction Maybe := (:*:))) where 	type Morphing (Into List) (Tap (Construction Maybe <:.:> Construction Maybe := (:*:))) = List 	morphing (premorph -> Tap x (T_U (future :*: past))) = attached $ run @(State _)-		# past ->> modify . item @Push @List+		# modify . item @Push @List <<- past 		# item @Push x (lift future)  ------------------------------------ Zipper of combinative list ------------------------------------@@ -257,11 +256,11 @@  instance Setoid key => Morphable (Lookup Key) (Prefixed List key) where 	type Morphing (Lookup Key) (Prefixed List key) = (->) key <:.> Maybe-	morphing (run . premorph -> list) = TU $ \key -> Prefixed <$> run list >>= lookup @Key key+	morphing (run . premorph -> list) = TU $ \key -> lookup @Key key =<< Prefixed -<$>- run list   ------------------------------------ Prefixed non-empty list ---------------------------------------  instance Setoid key => Morphable (Lookup Key) (Prefixed (Construction Maybe) key) where 	type Morphing (Lookup Key) (Prefixed (Construction Maybe) key) = (->) key <:.> Maybe 	morphing (run . premorph -> Construct x xs) = TU $ \key -> extract <$> search key where-		search key = key == attached x ? Just x $ xs >>= find @Element # Predicate ((key ==) . attached)+		search key = key == attached x ? Just x $ find @Element # Predicate ((key ==) . attached) =<< xs

@@ -8,16 +8,16 @@ import Pandora.Pattern.Functor.Contravariant ((>$<)) import Pandora.Pattern.Functor.Extractable (extract) import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<))) import Pandora.Pattern.Transformer.Liftable (lift) import Pandora.Pattern.Transformer.Lowerable (lower) import Pandora.Pattern.Object.Setoid (Setoid ((==), (!=))) import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False), (?))-import Pandora.Paradigm.Primary.Functor.Function ((!.), (%))+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), attached)+import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.), (%)) import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity)) import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing)) import Pandora.Paradigm.Primary.Functor.Predicate (Predicate (Predicate), equate)-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), attached) import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag)) import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct) import Pandora.Paradigm.Schemes (TU (TU), T_U (T_U), P_Q_T (P_Q_T), type (<:.>), type (<:.:>))@@ -77,7 +77,7 @@  -- TODO: Ineffiecient - we iterate over all branches in subtree, but we need to short-circuit on the first matching part of instance Setoid k => Morphable (Vary Element) (Prefixed Rose k) where-	type Morphing (Vary Element) (Prefixed Rose k) = (Product (Nonempty List k) <:.> Identity) <:.:> Prefixed Rose k := (->)+	type Morphing (Vary Element) (Prefixed Rose k) = ((:*:) (Nonempty List k) <:.> Identity) <:.:> Prefixed Rose k := (->) 	morphing (run . run . premorph -> Nothing) = T_U $ \(TU (Construct key _ :*: Identity value)) -> Prefixed . lift $ Construct (key :*: value) empty 	morphing (run . run . premorph -> Just (Construct focused subtree)) = T_U $ \(TU (breadcrumbs :*: Identity value)) -> case breadcrumbs of 		Construct key Nothing -> Prefixed . lift $ attached focused == key ? Construct (key :*: value) subtree $ Construct focused subtree@@ -89,7 +89,7 @@ -- TODO: Ineffiecient - we iterate over all branches in subtree, but we need to short-circuit on the first matching part of instance Setoid k => Morphable (Vary Element) (Prefixed (Construction List) k) where 	type Morphing (Vary Element) (Prefixed (Construction List) k) =-		(Product (Nonempty List k) <:.> Identity) <:.:> Prefixed (Construction List) k := (->)+		((:*:) (Nonempty List k) <:.> Identity) <:.:> Prefixed (Construction List) k := (->) 	morphing (run . premorph -> Construct x (TU Nothing)) = T_U $ \(TU (breadcrumbs :*: Identity value)) -> case breadcrumbs of 		Construct key Nothing -> Prefixed $ attached x == key ? Construct (key :*: value) empty $ Construct x empty 		Construct _ (Just _) -> Prefixed $ Construct x (TU Nothing)@@ -101,7 +101,7 @@  find_rose_sub_tree :: forall k a . Setoid k => Nonempty List k -> Nonempty Rose := k :*: a -> Maybe a find_rose_sub_tree (Construct k Nothing) tree = k == attached (extract tree) ? Just (extract $ extract tree) $ Nothing-find_rose_sub_tree (Construct k (Just ks)) tree = k != attached (extract tree) ? Nothing $ subtree >>= find_rose_sub_tree ks where+find_rose_sub_tree (Construct k (Just ks)) tree = k != attached (extract tree) ? Nothing $ find_rose_sub_tree ks =<< subtree where  	subtree :: Maybe :. Nonempty Rose := k :*: a 	subtree = find @Element # attached . extract >$< equate (extract ks) # deconstruct tree

@@ -5,13 +5,13 @@  import Pandora.Core.Functor (type (~>), type (:.), type (:=)) import Pandora.Pattern.Category ((.), ($), (#))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))-import Pandora.Pattern.Functor.Applicative ((<*>))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Extractable (extract)-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<))) import Pandora.Paradigm.Primary ()+import Pandora.Paradigm.Primary.Algebraic ((-<*>-))+import Pandora.Paradigm.Primary.Algebraic.Product (twosome) import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just))-import Pandora.Paradigm.Primary.Functor.Product (twosome) import Pandora.Paradigm.Primary.Functor.Tagged (type (:#)) import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right)) import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct)@@ -27,39 +27,39 @@  instance Morphable (Rotate (Left Zig)) Binary where 	type Morphing (Rotate (Left Zig)) Binary = Binary-	morphing (premorph -> binary) = unite $ run binary >>= run . rotate @(Left Zig)+	morphing (premorph -> binary) = unite $ run . rotate @(Left Zig) =<< run binary  instance Morphable (Rotate (Right Zig)) Binary where 	type Morphing (Rotate (Right Zig)) Binary = Binary-	morphing (premorph -> binary) = unite $ run binary >>= run . rotate @(Right Zig)+	morphing (premorph -> binary) = unite $ run . rotate @(Right Zig) =<< run binary  instance Morphable (Rotate (Left (Zig Zig))) Binary where 	type Morphing (Rotate (Left (Zig Zig))) Binary = Binary-	morphing (premorph -> binary) = unite $ run binary >>= run . rotate @(Left (Zig Zig))+	morphing (premorph -> binary) = unite $ run . rotate @(Left (Zig Zig)) =<< run binary  instance Morphable (Rotate (Right (Zig Zig))) Binary where 	type Morphing (Rotate (Right (Zig Zig))) Binary = Binary-	morphing (premorph -> binary) = unite $ run binary >>= run . rotate @(Right (Zig Zig))+	morphing (premorph -> binary) = unite $ run . rotate @(Right (Zig Zig)) =<< run binary  instance Morphable (Rotate (Left (Zig Zag))) Binary where 	type Morphing (Rotate (Left (Zig Zag))) Binary = Binary-	morphing (premorph -> binary) = unite $ run binary >>= run . rotate @(Left (Zig Zag))+	morphing (premorph -> binary) = unite $ run . rotate @(Left (Zig Zag)) =<< run binary  instance Morphable (Rotate (Right (Zig Zag))) Binary where 	type Morphing (Rotate (Right (Zig Zag))) Binary = Binary-	morphing (premorph -> binary) = unite $ run binary >>= run . rotate @(Right (Zig Zag))+	morphing (premorph -> binary) = unite $ run . rotate @(Right (Zig Zag)) =<< run binary  -------------------------------------- Non-empty Splay tree ----------------------------------------  instance Morphable (Rotate (Left Zig)) (Construction Wye) where 	type Morphing (Rotate (Left Zig)) (Construction Wye) = Binary 	morphing :: forall a . (:#) (Rotate (Left Zig)) <:.> Construction Wye := a -> Binary a-	morphing (premorph -> Construct x xs) = TU $ Construct <$> parent <*> Just nodes where+	morphing (premorph -> Construct x xs) = TU $ Construct -<$>- parent -<*>- Just nodes where  		nodes :: Wye :. Nonempty Binary := a 		nodes = into @Wye . twosome (branch @Left xs) . Just . Construct x-			. into @Wye $ twosome (deconstruct <$> branch @Right xs >>= branch @Left)-				(deconstruct <$> branch @Right xs >>= branch @Right)+			. into @Wye $ twosome (branch @Left =<< deconstruct <$> branch @Right xs)+				(branch @Right =<< deconstruct <$> branch @Right xs)  		parent :: Maybe a 		parent = extract <$> branch @Right xs@@ -67,11 +67,11 @@ instance Morphable (Rotate (Right Zig)) (Construction Wye) where 	type Morphing (Rotate (Right Zig)) (Construction Wye) = Binary 	morphing :: forall a . (:#) (Rotate (Right Zig)) <:.> Construction Wye := a -> Binary a-	morphing (premorph -> Construct x xs) = TU $ Construct <$> parent <*> Just nodes where+	morphing (premorph -> Construct x xs) = TU $ Construct -<$>- parent -<*>- Just nodes where  		nodes :: Wye :. Nonempty Binary := a-		nodes = into @Wye . twosome (deconstruct <$> branch @Left xs >>= branch @Left) . Just . Construct x-			. into @Wye $ twosome (deconstruct <$> branch @Left xs >>= branch @Right) # branch @Right xs+		nodes = into @Wye . twosome (branch @Left =<< deconstruct <$> branch @Left xs) . Just . Construct x+			. into @Wye $ twosome (branch @Right =<< deconstruct <$> branch @Left xs) # branch @Right xs  		parent :: Maybe a 		parent = extract <$> branch @Left xs@@ -79,22 +79,22 @@ -- TODO: Morphing ... = Conclussion Error <:.> Nonempty Binary instance Morphable (Rotate (Left (Zig Zig))) (Construction Wye) where 	type Morphing (Rotate (Left (Zig Zig))) (Construction Wye) = Binary-	morphing (premorph -> tree) = TU $ run # rotate @(Left Zig) tree >>= run . rotate @(Left Zig)+	morphing (premorph -> tree) = TU $ run . rotate @(Left Zig) =<< run # rotate @(Left Zig) tree  -- TODO: Morphing ... = Conclussion Error <:.> Nonempty Binary instance Morphable (Rotate (Right (Zig Zig))) (Construction Wye) where 	type Morphing (Rotate (Right (Zig Zig))) (Construction Wye) = Binary-	morphing (premorph -> tree) = TU $ run # rotate @(Right Zig) tree >>= run . rotate @(Right Zig)+	morphing (premorph -> tree) = TU $ run . rotate @(Right Zig) =<< run # rotate @(Right Zig) tree  -- TODO: Morphing ... = Conclussion Error <:.> Nonempty Binary instance Morphable (Rotate (Left (Zig Zag))) (Construction Wye) where 	type Morphing (Rotate (Left (Zig Zag))) (Construction Wye) = Binary-	morphing = rotate @(Left Zig) . over (sub @Left) (>>= run . rotate @(Right Zig)) . premorph+	morphing = rotate @(Left Zig) . over (sub @Left) (run . rotate @(Right Zig) =<<) . premorph  -- TODO: Morphing ... = Conclussion Error <:.> Nonempty Binary instance Morphable (Rotate (Right (Zig Zag))) (Construction Wye) where 	type Morphing (Rotate (Right (Zig Zag))) (Construction Wye) = Binary-	morphing = rotate @(Right Zig) . over (sub @Right) (>>= run . rotate @(Left Zig)) . premorph+	morphing = rotate @(Right Zig) . over (sub @Right) (run . rotate @(Left Zig) =<<) . premorph  branch :: forall b . Morphable (Into (b Maybe)) Wye => Wye ~> Morphing (Into (b Maybe)) Wye branch = into @(b Maybe)

@@ -7,8 +7,8 @@ import Pandora.Pattern.Functor.Covariant (Covariant ((<$>))) import Pandora.Pattern.Functor.Pointable (point) import Pandora.Pattern.Functor.Extractable (extract)-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), twosome)+import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), twosome) import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity)) import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right)) import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct, (.-+))@@ -31,8 +31,8 @@ 	morphing (premorph -> Tap x (T_U (bs :*: fs))) = Tap # extract fs 		$ twosome # Construct x (point bs) # extract (deconstruct fs) -instance {-# OVERLAPS #-} Extendable (Tap (Stream <:.:> Stream := (:*:))) where-	z =>> f = let move rtt = extract . deconstruct $ point . rtt .-+ z+instance {-# OVERLAPS #-} Extendable (Tap (Stream <:.:> Stream := (:*:))) (->) where+	f <<= z = let move rtt = extract . deconstruct $ point . rtt .-+ z 		in f <$> Tap z (twosome # (move $ rotate @Left) # (move $ rotate @Right))  repeat :: a :=> Stream

@@ -1,11 +1,10 @@ module Pandora.Pattern.Functor.Adjoint where -import Pandora.Core.Functor (type (:.), type (:=))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>), (<$$$>), (<$$$$>)), Covariant_)+import Pandora.Pattern.Functor.Covariant (Covariant_)  type (-|) = Adjoint -infixl 3 -|, |-, -|$, $|-, $$|-, $$$|-, $$$$|-+infixl 3 -|, |-  {- | > When providing a new instance, you should ensure it satisfies:@@ -15,42 +14,6 @@ > * Right adjunction interchange: psi f ≡ epsilon . comap f -} -class Adjoint t u where-	{-# MINIMAL (-|), (|-) #-}-	-- | Left adjunction-	(-|) :: a -> (t a -> b) -> u b-	-- | Right adjunction-	(|-) :: t a -> (a -> u b) -> b--	-- | Prefix and flipped version of '-|'-	phi :: (t a -> b) -> a -> u b-	phi f x = x -| f-	-- | Prefix and flipped version of '|-'-	psi :: (a -> u b) -> t a -> b-	psi g x = x |- g-	-- | Also known as 'unit'-	eta :: a -> u :. t := a-	eta = phi (\x -> x)-	-- | Also known as 'counit'-	epsilon :: t :. u := a -> a-	epsilon = psi (\x -> x)--	(-|$) :: Covariant v => v a -> (t a -> b) -> v (u b)-	x -|$ f = (-| f) <$> x--	-- | Versions of `|-` with various nesting levels-	($|-) :: Covariant v => v (t a) -> (a -> u b) -> v b-	x $|- f = (|- f) <$> x-	($$|-) :: (Covariant v, Covariant w) =>-		v :. w :. t := a -> (a -> u b) -> v :. w := b-	x $$|- f = (|- f) <$$> x-	($$$|-) :: (Covariant v, Covariant w, Covariant x) =>-		v :. w :. x :. t := a -> (a -> u b) -> v :. w :. x := b-	x $$$|- f = (|- f) <$$$> x-	($$$$|-) :: (Covariant v, Covariant w, Covariant x, Covariant y) =>-		v :. w :. x :. y :. t := a -> (a -> u b) -> v :. w :. x :. y := b-	x $$$$|- f = (|- f) <$$$$> x--class (Covariant_ t target source, Covariant_ u source target) => Adjoint_ t u source target where-	(--|-) :: source (t a) b -> target a (u b)-	(-|--) :: target a (u b) -> source (t a) b+class (Covariant_ t target source, Covariant_ u source target) => Adjoint t u source target where+	(-|) :: source (t a) b -> target a (u b)+	(|-) :: target a (u b) -> source (t a) b

@@ -1,7 +1,7 @@ module Pandora.Pattern.Functor.Applicative where  import Pandora.Core.Functor (type (:.), type (:=))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$)), Covariant_) import Pandora.Pattern.Functor.Bivariant (Bivariant)  infixl 4 <*>, <*, *>@@ -47,5 +47,5 @@ 		-> t :. u :. v :. w := b 	f <****> x = (<***>) <$> f <*> x -class Bivariant v => Applicative_ t v source target where+class (Covariant_ t source target, Bivariant v source source target) => Semimonoidal t v source target where 	multiply :: source (v a b) r -> target (v (t a) (t b)) (t r)

@@ -1,39 +1,13 @@ module Pandora.Pattern.Functor.Bindable where -import Pandora.Core.Functor (type (:.), type (:=))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_)+import Pandora.Pattern.Functor.Covariant (Covariant_) -infixl 1 >>=-infixr 1 =<<, <=<, >=>+infixr 1 =<<  {- | > When providing a new instance, you should ensure it satisfies : > * Interchange: t >>= f = join (f <$> t) -} -class Covariant t => Bindable t where-	{-# MINIMAL (>>=) #-}-	-- | Infix and flipped version of 'bind', the dual of '=>>'-	(>>=) :: t a -> (a -> t b) -> t b--	-- | Flipped version of '>>=', the dual of '<<='-	(=<<) :: (a -> t b) -> t a -> t b-	f =<< x = x >>= f-	-- | Prefix and flipped version of '>>=', the dual of 'extend'-	bind :: (a -> t b) -> t a -> t b-	bind f t = t >>= f-	-- | Merge effects/contexts, the dual of 'duplicate'-	join :: t :. t := a -> t a-	join t = t >>= \x -> x-	-- | Left-to-right Kleisli composition-	(>=>) :: (a -> t b) -> (b -> t c) -> (a -> t c)-	f >=> g = \x -> f x >>= g-	-- | Right-to-left Kleisli composition-	(<=<) :: (b -> t c) -> (a -> t b) -> (a -> t c)-	g <=< f = f >=> g--	($>>=) :: Covariant u => u :. t := a -> (a -> t b) -> u :. t := b-	x $>>= f = (>>= f) <$> x--class Covariant_ t source source => Bindable_ t source where-	join_ :: source (t (t a)) (t a)+class Covariant_ t source source => Bindable t source where+	(=<<) :: source a (t b) -> source (t a) (t b)

@@ -1,24 +1,16 @@ module Pandora.Pattern.Functor.Bivariant where -import Pandora.Pattern.Functor.Covariant (Covariant, Covariant_)+import Pandora.Pattern.Functor.Covariant (Covariant_) import Pandora.Paradigm.Primary.Transformer.Flip (Flip)  infixl 4 <->  {- | > When providing a new instance, you should ensure it satisfies:-> * Identity: bimap identity identity ≡ identity-> * Parametricity: bimap  (f . g) (h . i) ≡ bimap f h . bimap g i+> * Identity: identity <-> identity ≡ identity+> * Parametricity: (f . g) <-> (h . i) ≡ f <-> h . g <-> i -} -class (forall i . Covariant (v i)) => Bivariant (v :: * -> * -> *) where-	{-# MINIMAL (<->) #-}-	(<->) :: (forall i . Covariant (v i)) => (a -> b) -> (c -> d) -> v a c -> v b d--	-- | Prefix version of '<->'-	bimap :: (forall i . Covariant (v i)) => (a -> b) -> (c -> d) -> v a c -> v b d-	bimap f g x = (f <-> g) x- class (forall i . Covariant_ (v i) left target, forall i . Covariant_ (Flip v i) right target)-	=> Bivariant_ v left right target where-	(-<->-) :: left a b -> right c d -> target (v a c) (v b d) +	=> Bivariant v left right target where+	(<->) :: left a b -> right c d -> target (v a c) (v b d) 

@@ -13,4 +13,4 @@ > * Associativity: extend f . extend g ≡ extend (f . extend g) -} -class (Extractable t source, Extendable t) => Comonad t source+class (Extractable t source, Extendable t (->)) => Comonad t source

@@ -1,37 +1,16 @@ module Pandora.Pattern.Functor.Distributive where -import Pandora.Core.Functor (type (:.), type (:=))-import Pandora.Pattern.Functor.Covariant (Covariant)+import Pandora.Pattern.Functor.Covariant (Covariant_)  {- | > Let f :: Distributive g => (a -> g b)  > When providing a new instance, you should ensure it satisfies:-> * Identity morphism: distribute . distribute ≡ identity-> * Interchange collection: collect f ≡ distribute . comap f+> * Identity morphism: (identity -<<) . (identity -<<) ≡ identity+> * Interchange collection: (f -<<) ≡ (identity -<<) . (f -<$>-) -} -infixl 5 >>-, >>>-, >>>>-, >>>>>---class Covariant t => Distributive t where-	{-# MINIMAL (>>-) #-}-	-- | Infix and flipped version of 'collect'-	(>>-) :: Covariant u => u a -> (a -> t b) -> t :. u := b--	-- | Prefix version of '>>-'-	collect :: Covariant u => (a -> t b) -> u a -> t :. u := b-	collect f t = t >>- f-	-- | The dual of 'sequence'-	distribute :: Covariant u => u :. t := a -> t :. u := a-	distribute t = t >>- (\x -> x)+infixl 5 -<< -	-- | Infix versions of `collect` with various nesting levels-	(>>>-) :: (Covariant u, Covariant v)-		=> u :. v := a -> (a -> t b) -> t :. u :. v := b-	x >>>- f = x >>- (>>- f)-	(>>>>-) :: (Covariant u, Covariant v, Covariant w)-		=> u :. v :. w := a -> (a -> t b) -> t :. u :. v :. w := b-	x >>>>- f = x >>- (>>- (>>- f))-	(>>>>>-) :: (Covariant u, Covariant v, Covariant w, Covariant j)-		=> u :. v :. w :. j := a -> (a -> t b) -> t :. u :. v :. w :. j := b-	x >>>>>- f = x >>- (>>- (>>- (>>- f)))+class Covariant_ t source target => Distributive t source target where+	(-<<) :: Covariant_ u source target => source a (t b) -> target (u a) (t (u b))

@@ -1,6 +1,6 @@ module Pandora.Pattern.Functor.Divariant where -import Pandora.Pattern.Functor.Covariant (Covariant, Covariant_)+import Pandora.Pattern.Functor.Covariant (Covariant_) import Pandora.Pattern.Functor.Contravariant (Contravariant_) import Pandora.Paradigm.Primary.Transformer.Flip (Flip) @@ -8,17 +8,17 @@  {- | > When providing a new instance, you should ensure it satisfies:-> * Identity: dimap identity identity ≡ identity-> * Interpreted: dimap (f . g) (h . i) ≡ dimap g h . dimap f i+> * Identity: identity >-> identity ≡ identity+> * Interpreted: f . g >-> h . i ≡ g >-> h . f >-> i -} -class (forall i . Covariant (v i)) => Divariant (v :: * -> * -> *) where-	{-# MINIMAL (>->) #-}-	(>->) :: (a -> b) -> (c -> d) -> v b c -> v a d-	-- | Prefix version of '>->'-	dimap :: (a -> b) -> (c -> d) -> v b c -> v a d-	dimap f g x = (f >-> g) x+--class (forall i . Covariant (v i)) => Divariant (v :: * -> * -> *) where+--	{-# MINIMAL (>->) #-}+--	(>->) :: (a -> b) -> (c -> d) -> v b c -> v a d+--	-- | Prefix version of '>->'+--	dimap :: (a -> b) -> (c -> d) -> v b c -> v a d+--	dimap f g x = (f >-> g) x  class (forall i . Contravariant_ (Flip v i) left target, forall i . Covariant_ (v i) right target) -	=> Divariant_ v left right target where-	(->->-) :: left a b -> right c d -> target (v b c) (v a d)+	=> Divariant v left right target where+	(>->) :: left a b -> right c d -> target (v b c) (v a d)

@@ -2,7 +2,7 @@  import Pandora.Pattern.Functor.Contravariant (Contravariant) import Pandora.Pattern.Functor.Bivariant (Bivariant)-import Pandora.Paradigm.Primary.Functor.Product (type (:*:))+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))  infixr 5 >*< @@ -10,5 +10,5 @@ 	{-# MINIMAL (>*<) #-} 	(>*<) :: t b -> t c -> t (b :*: c) -class Bivariant v => Divisible_ t v source target where-	divide :: Bivariant v => source r (v a b) -> target (v (t a) (t b)) (t r)+class Bivariant v source source target => Divisible_ t v source target where+	divide :: source r (v a b) -> target (v (t a) (t b)) (t r)

@@ -3,42 +3,13 @@ import Pandora.Core.Functor (type (:.), type (:=)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_) -infixl 1 =>>-infixr 1 <<=, =<=, =>=+infixr 1 <<=  {- | > When providing a new instance, you should ensure it satisfies:-> * Duplication interchange: comap (comap f) . duplicate ≡ duplicate . comap f-> * Extension interchange: extend f ≡ comap f . duplicate+> * Duplication interchange: (f -<$$>-) . (identity <<=) ≡ (identity <<=) . (f -<$>-)+> * Extension interchange: (f <<=) ≡ (f -<$>-) . (identity <<=) -} -class Covariant t => Extendable t where-	{-# MINIMAL (=>>) #-}-	-- | Infix and flipped version of 'extend', the dual of '>>='-	(=>>) :: t a -> (t a -> b) -> t b--	-- | Flipped version of '>>=', the dual of '=<<'-	(<<=) :: (t a -> b) -> t a -> t b-	f <<= x = x =>> f-	-- | Prefix and flipped version of '=>>', the dual of 'bind'-	extend :: (t a -> b) -> t a -> t b-	extend f t = t =>> f-	-- | Clone existing structure, the dual of 'join'-	duplicate :: t a -> t :. t := a-	duplicate t = t =>> (\x -> x)-	-- | Right-to-left Cokleisli composition-	(=<=) :: (t b -> c) -> (t a -> b) -> t a -> c-	f =<= g = \x -> f (extend g x)--	-- | Left-to-right Cokleisli composition-	(=>=) :: (t a -> b) -> (t b -> c) -> t a -> c-	f =>= g = \x -> g (extend f x)--	-- | Experimental methods-	($=>>) :: Covariant u => u :. t := a -> (t a -> b) -> u :. t := b-	x $=>> f = (=>> f) <$> x-	(<<=$) :: Covariant u => u :. t := a -> (t a -> b) -> u :. t := b-	x <<=$ f = (=>> f) <$> x--class Covariant_ t source source => Extendable_ t source where-	duplicate_ :: source (t a) (t (t a))+class Covariant_ t source source => Extendable t source where+	(<<=) :: source (t a) b -> source (t a) (t b)

@@ -1,8 +1,8 @@ module Pandora.Pattern.Functor.Monad where  import Pandora.Pattern.Functor.Covariant (Covariant_)-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))-import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Bindable (Bindable)+import Pandora.Pattern.Functor.Pointable (Pointable)  {- | > Let f :: (Pointable t, Bindable t) => a -> t a@@ -15,15 +15,15 @@ > * Associativity: h >>= (f >=> g) ≡ (h >>= f) >>= g -} -infixl 1 >>=-, ->>=-infixr 1 -=<<, =<<-+--infixl 1 >>=-, ->>=+--infixr 1 -=<<, =<<- -class (Covariant_ t (->) (->), Pointable t (->), Bindable t) => Monad t where-	(>>=-) :: t a -> t b -> t a-	(>>=-) x y = x >>= \r -> y >>= \_ -> point r-	(->>=) :: t a -> t b -> t b-	(->>=) x y = x >>= \_ -> y >>= \r -> point r-	(-=<<) :: t a -> t b -> t b-	(-=<<) x y = x >>= \_ -> y >>= \r -> point r-	(=<<-) :: t a -> t b -> t a-	(=<<-) x y = x >>= \r -> y >>= \_ -> point r+class (Covariant_ t (->) (->), Pointable t (->), Bindable t (->)) => Monad t where+	--(>>=-) :: t a -> t b -> t a+	--(>>=-) x y = x >>= \r -> y >>= \_ -> point r+	--(->>=) :: t a -> t b -> t b+	--(->>=) x y = x >>= \_ -> y >>= \r -> point r+	--(-=<<) :: t a -> t b -> t b+	--(-=<<) x y = x >>= \_ -> y >>= \r -> point r+	--(=<<-) :: t a -> t b -> t a+	--(=<<-) x y = x >>= \r -> y >>= \_ -> point r

@@ -5,6 +5,3 @@ class Covariant_ t source source => Pointable t source where 	{-# MINIMAL point #-} 	point :: source a (t a)--class Pointable_ t target where-	point_ :: target a (t a)

@@ -1,42 +1,27 @@ module Pandora.Pattern.Functor.Traversable where -import Pandora.Core.Functor (type (:.), type (:=))-import Pandora.Pattern.Functor.Covariant (Covariant)-import Pandora.Pattern.Functor.Applicative (Applicative)+import Pandora.Pattern.Functor.Covariant (Covariant_)+import Pandora.Pattern.Functor.Applicative (Semimonoidal) import Pandora.Pattern.Functor.Pointable (Pointable)+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))  {- | > Let f :: (Applicative t, Applicative g) => t a -> u a > Let p :: (Pointable t, Pointable g) => t a -> u a  > When providing a new instance, you should ensure it satisfies:-> * Numeratority of traversing: g . traverse f ≡ traverse (g . f)-> * Numeratority of sequencing: f . sequence = sequence . comap f+> * Numeratority of traversing: g . (f <<--) ≡ (g . f <<--)+> * Numeratority of sequencing: f . (identity <<--)= (identity <<--) . (f -<$>-) > * Preserving point: p (point x) ≡ point x-> * Preserving apply: f (x <*> y) ≡ f x <*> f y+> * Preserving apply: f (x -<*>- y) ≡ f x -<*>- f y -} -infixl 5 ->>, ->>>, ->>>>, ->>>>>--class Covariant t => Traversable t where-	{-# MINIMAL (->>) #-}-	-- | Infix version of 'traverse'-	(->>) :: (Pointable u (->), Applicative u) => t a -> (a -> u b) -> u :. t := b+infixl 5 <<-, -<<-<<- -	-- | Prefix version of '->>'-	traverse :: (Pointable u (->), Applicative u) => (a -> u b) -> t a -> u :. t := b-	traverse f t = t ->> f-	-- | The dual of 'distribute'-	sequence :: (Pointable u (->), Applicative u) => t :. u := a -> u :. t := a-	sequence t = t ->> (\x -> x)+class Covariant_ t source target => Traversable t source target where+	(<<-) :: (Covariant_ u source target, Pointable u target, Semimonoidal u (:*:) source target) => source a (u b) -> target (t a) (u (t b)) -	-- | Infix versions of `traverse` with various nesting levels-	(->>>) :: (Pointable u (->), Applicative u, Traversable v)-		=> v :. t := a -> (a -> u b) -> u :. v :. t := b-	x ->>> f = x ->> (->> f)-	(->>>>) :: (Pointable u (->), Applicative u, Traversable v, Traversable w)-		=> w :. v :. t := a -> (a -> u b) -> u :. w :. v :. t := b-	x ->>>> f = x ->> (->> (->> f))-	(->>>>>) :: (Pointable u (->), Applicative u, Traversable v, Traversable w, Traversable j)-		=> j :. w :. v :. t := a -> (a -> u b) -> u :. j :. w :. v :. t := b-	x ->>>>> f = x ->> (->> (->> (->> f)))+(-<<-<<-) :: forall t u v category a b . +	(Traversable t category category, Covariant_ u category category, Pointable u category, Semimonoidal u (:*:) category category, Traversable v category category)+	=> category a (u b) -> category (v (t a)) (u (v (t b)))+(-<<-<<-) f = ((<<-) ((<<-) @t @category @category f))

@@ -1,5 +1,5 @@ name:                pandora-version:             0.4.3+version:             0.4.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@@ -28,12 +28,14 @@     -- Basic constructions     Pandora.Paradigm.Primary     Pandora.Paradigm.Primary.Object+    Pandora.Paradigm.Primary.Algebraic+    Pandora.Paradigm.Primary.Algebraic.Exponential+    Pandora.Paradigm.Primary.Algebraic.Product     Pandora.Paradigm.Primary.Object.Boolean     Pandora.Paradigm.Primary.Object.Ordering     Pandora.Paradigm.Primary.Object.Numerator     Pandora.Paradigm.Primary.Object.Denumerator     Pandora.Paradigm.Primary.Functor-    Pandora.Paradigm.Primary.Functor.Function     Pandora.Paradigm.Primary.Functor.Conclusion     Pandora.Paradigm.Primary.Functor.Constant     Pandora.Paradigm.Primary.Functor.Edges@@ -41,7 +43,6 @@     Pandora.Paradigm.Primary.Functor.Fix     Pandora.Paradigm.Primary.Functor.Identity     Pandora.Paradigm.Primary.Functor.Maybe-    Pandora.Paradigm.Primary.Functor.Product     Pandora.Paradigm.Primary.Functor.Proxy     Pandora.Paradigm.Primary.Functor.Tagged     Pandora.Paradigm.Primary.Functor.These