pandora 0.4.5 → 0.4.6

raw patch · 87 files changed

+895/−779 lines, 87 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• CHANGELOG.md +34/−0
• Pandora/Paradigm/Controlflow/Effect/Adaptable.hs +49/−48
• Pandora/Paradigm/Controlflow/Effect/Interpreted.hs +9/−9
• Pandora/Paradigm/Controlflow/Effect/Transformer/Comonadic.hs +16/−18
• Pandora/Paradigm/Controlflow/Effect/Transformer/Monadic.hs +16/−18
• Pandora/Paradigm/Controlflow/Pipeline.hs +7/−5
• Pandora/Paradigm/Inventory.hs +4/−4
• Pandora/Paradigm/Inventory/Accumulator.hs +7/−16
• Pandora/Paradigm/Inventory/Environment.hs +16/−14
• Pandora/Paradigm/Inventory/Equipment.hs +4/−14
• Pandora/Paradigm/Inventory/Imprint.hs +6/−15
• Pandora/Paradigm/Inventory/Optics.hs +1/−2
• Pandora/Paradigm/Inventory/State.hs +15/−13
• Pandora/Paradigm/Inventory/Store.hs +15/−9
• Pandora/Paradigm/Primary.hs +10/−20
• Pandora/Paradigm/Primary/Algebraic.hs +73/−25
• Pandora/Paradigm/Primary/Algebraic/Exponential.hs +15/−17
• Pandora/Paradigm/Primary/Algebraic/One.hs +3/−0
• Pandora/Paradigm/Primary/Algebraic/Product.hs +25/−22
• Pandora/Paradigm/Primary/Algebraic/Sum.hs +7/−7
• Pandora/Paradigm/Primary/Algebraic/Zero.hs +8/−0
• Pandora/Paradigm/Primary/Functor.hs +0/−3
• Pandora/Paradigm/Primary/Functor/Conclusion.hs +22/−20
• Pandora/Paradigm/Primary/Functor/Constant.hs +4/−4
• Pandora/Paradigm/Primary/Functor/Convergence.hs +1/−1
• Pandora/Paradigm/Primary/Functor/Edges.hs +3/−3
• Pandora/Paradigm/Primary/Functor/Fix.hs +3/−3
• Pandora/Paradigm/Primary/Functor/Identity.hs +27/−17
• Pandora/Paradigm/Primary/Functor/Maybe.hs +29/−17
• Pandora/Paradigm/Primary/Functor/Predicate.hs +1/−1
• Pandora/Paradigm/Primary/Functor/Proxy.hs +7/−11
• Pandora/Paradigm/Primary/Functor/Tagged.hs +23/−14
• Pandora/Paradigm/Primary/Functor/These.hs +3/−6
• Pandora/Paradigm/Primary/Functor/Validation.hs +18/−16
• Pandora/Paradigm/Primary/Functor/Wedge.hs +3/−6
• Pandora/Paradigm/Primary/Functor/Wye.hs +13/−2
• Pandora/Paradigm/Primary/Object/Denumerator.hs +7/−7
• Pandora/Paradigm/Primary/Object/Numerator.hs +2/−2
• Pandora/Paradigm/Primary/Transformer/Backwards.hs +26/−18
• Pandora/Paradigm/Primary/Transformer/Construction.hs +29/−21
• Pandora/Paradigm/Primary/Transformer/Continuation.hs +10/−11
• Pandora/Paradigm/Primary/Transformer/Day.hs +2/−14
• Pandora/Paradigm/Primary/Transformer/Instruction.hs +17/−15
• Pandora/Paradigm/Primary/Transformer/Jack.hs +8/−14
• Pandora/Paradigm/Primary/Transformer/Jet.hs +2/−6
• Pandora/Paradigm/Primary/Transformer/Kan.hs +2/−2
• Pandora/Paradigm/Primary/Transformer/Outline.hs +2/−11
• Pandora/Paradigm/Primary/Transformer/Reverse.hs +26/−12
• Pandora/Paradigm/Primary/Transformer/Tap.hs +25/−19
• Pandora/Paradigm/Primary/Transformer/Yoneda.hs +2/−16
• Pandora/Paradigm/Schemes.hs +10/−11
• Pandora/Paradigm/Schemes/TU.hs +34/−17
• Pandora/Paradigm/Schemes/TUT.hs +31/−16
• Pandora/Paradigm/Schemes/T_U.hs +3/−3
• Pandora/Paradigm/Schemes/UT.hs +27/−18
• Pandora/Paradigm/Structure.hs +4/−4
• Pandora/Paradigm/Structure/Ability/Morphable.hs +1/−1
• Pandora/Paradigm/Structure/Ability/Substructure.hs +2/−2
• Pandora/Paradigm/Structure/Interface/Set.hs +2/−2
• Pandora/Paradigm/Structure/Modification/Comprehension.hs +17/−9
• Pandora/Paradigm/Structure/Modification/Prefixed.hs +6/−12
• Pandora/Paradigm/Structure/Some/Binary.hs +10/−11
• Pandora/Paradigm/Structure/Some/List.hs +10/−16
• Pandora/Paradigm/Structure/Some/Rose.hs +1/−1
• Pandora/Paradigm/Structure/Some/Splay.hs +3/−4
• Pandora/Paradigm/Structure/Some/Stream.hs +3/−3
• Pandora/Pattern/Functor.hs +7/−8
• Pandora/Pattern/Functor/Adjoint.hs +1/−1
• Pandora/Pattern/Functor/Bindable.hs +1/−1
• Pandora/Pattern/Functor/Bivariant.hs +2/−2
• Pandora/Pattern/Functor/Comonad.hs +6/−4
• Pandora/Pattern/Functor/Contravariant.hs +3/−4
• Pandora/Pattern/Functor/Covariant.hs +15/−16
• Pandora/Pattern/Functor/Distributive.hs +2/−2
• Pandora/Pattern/Functor/Divariant.hs +2/−2
• Pandora/Pattern/Functor/Extendable.hs +1/−1
• Pandora/Pattern/Functor/Extractable.hs +0/−7
• Pandora/Pattern/Functor/Monad.hs +6/−5
• Pandora/Pattern/Functor/Monoidal.hs +9/−0
• Pandora/Pattern/Functor/Pointable.hs +0/−7
• Pandora/Pattern/Functor/Representable.hs +1/−2
• Pandora/Pattern/Functor/Semimonoidal.hs +2/−2
• Pandora/Pattern/Functor/Traversable.hs +6/−7
• Pandora/Pattern/Transformer/Hoistable.hs +2/−2
• Pandora/Pattern/Transformer/Liftable.hs +2/−3
• Pandora/Pattern/Transformer/Lowerable.hs +2/−2
• pandora.cabal +4/−3

@@ -549,3 +549,37 @@ * Rename experimental `Contravariant_` to `Contravariant`  # 0.4.6+* Define `void` method in `Algebraic` module+* Define `<--` type synonymous for reverted arrows+* Define `Zero` module in `Algebraic` directory+* Define `One` module in `Algebraic` directory+* Rename `One` constructor in `Denumerator` to `Single`+* Define `Unit` type family+* Define `Monoidal` typeclass+* Define `absurd` method+* Define `empty` method+* Define `sum` method+* Add `Monoidal` constraint to `Applicative` and `Alternative` constraints+* Define `point_` method+* Use `Monoidal` superclass in `Traversable` instead of `Pointable`+* Use `Monoidal` superclass in `Monad` instead of `Pointable`+* Remove `Pointable` typeclass+* Rename `point_` to `point`+* Define `extract_` method+* Remove `Extractable` typeclass+* Rename `extract_` to `extract`+* Use `Monoidal` as superclass of `Comonad`+* Rename `multiply_` to `multiply`+* Rearrange type parameters in `Covariant` typeclass+* Rearrange type parameters in `Contravariant` typeclass+* Rearrange type parameters in `Semimonoidal` typeclass+* Rearrange type parameters in `Adjoint` typeclass+* Rearrange type parameters in `Bivariant` typeclass+* Rearrange type parameters in `Traversable` typeclass+* Rearrange type parameters in `Distributive` typeclass+* Rearrange type parameters in `Bindaple` typeclass+* Rearrange type parameters in `Extendable` typeclass+* Rearrange type parameters in `Monoidal` typeclass+* Rearrange type parameters in `Divariant` typeclass+* Generalize `Liftable` typeclass+* Generalize `Lowerable` typeclass

@@ -6,11 +6,12 @@ import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category (identity) import Pandora.Pattern.Functor.Covariant (Covariant)-import Pandora.Pattern.Functor.Pointable (Pointable)-import Pandora.Pattern.Functor.Extractable (Extractable)+import Pandora.Pattern.Functor.Monoidal (Monoidal) import Pandora.Pattern.Functor.Comonad (Comonad) import Pandora.Pattern.Functor.Monad (Monad) import Pandora.Pattern.Transformer (Liftable (lift), Lowerable (lower), Hoistable (hoist))+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))+import Pandora.Paradigm.Primary.Algebraic (Extractable_) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic) import Pandora.Paradigm.Controlflow.Effect.Transformer (Monadic, Comonadic, wrap, bring, (:>), (:<)) @@ -18,10 +19,10 @@ 	{-# MINIMAL adapt #-} 	adapt :: t ~> 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 (->))+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, Monoidal (->) (->) (:*:) (:*:) u)+type Bringable t u = (Comonadic t, Extractable_ u)  instance Adaptable t t where 	adapt = identity@@ -39,8 +40,8 @@ 	adapt = bring  instance-	( 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@@ -64,7 +65,7 @@ 	adapt = lower . lower  instance-	( Liftable (Schematic Monad t)+	( Liftable (->) (Schematic Monad t) 	, Lifting t (Schematic Monad u (v :> w)) 	, Lifting u (Schematic Monad v w) 	, Wrappable v w@@ -294,12 +295,12 @@ 	) => Adaptable (t :< u :< v :< w :< x :< y :< z :< f :< h) f where 	adapt = bring . lower . lower . lower . lower . lower . lower . lower -instance (Covariant u (->) (->), Hoistable ((:>) t), Adaptable u u') => Adaptable (t :> u) (t :> u') where+instance (Covariant (->) (->) u, Hoistable ((:>) t), Adaptable u u') => Adaptable (t :> u) (t :> u') where 	adapt = hoist adapt  instance-	( Covariant v (->) (->)-	, Covariant (Schematic Monad u v) (->) (->)+	( Covariant (->) (->) v+	, Covariant (->) (->) (Schematic Monad u v) 	, Hoistable ((:>) (t :> u)) 	, Hoistable (Schematic Monad t) 	, Hoistable (Schematic Monad u)@@ -308,12 +309,12 @@ 	adapt = hoist (hoist adapt)  instance-	( Covariant u (->) (->)-	, Covariant v (->) (->)-	, Covariant w (->) (->)-	, Covariant (Schematic Monad u v) (->) (->)-	, Covariant (Schematic Monad u (v :> w)) (->) (->)-	, Covariant (Schematic Monad v w) (->) (->)+	( Covariant (->) (->) u+	, Covariant (->) (->) v+	, Covariant (->) (->) w+	, Covariant (->) (->) (Schematic Monad u v)+	, Covariant (->) (->) (Schematic Monad u (v :> w))+	, Covariant (->) (->) (Schematic Monad v w) 	, Hoistable ((:>) (t :> u :> v)) 	, Hoistable (Schematic Monad t) 	, Hoistable (Schematic Monad u)@@ -323,10 +324,10 @@ 	adapt = hoist (hoist (hoist adapt))  instance-	( Covariant x (->) (->)-	, Covariant (Schematic Monad u (v :> (w :> x))) (->) (->)-	, Covariant (Schematic Monad v (w :> x)) (->) (->)-	, Covariant (Schematic Monad w x) (->) (->)+	( Covariant (->) (->) x+	, Covariant (->) (->) (Schematic Monad u (v :> (w :> x)))+	, Covariant (->) (->) (Schematic Monad v (w :> x))+	, Covariant (->) (->) (Schematic Monad w x) 	, Hoistable ((:>) (t :> u :> v)) 	, Hoistable (Schematic Monad t) 	, Hoistable (Schematic Monad u)@@ -337,11 +338,11 @@ 	adapt = hoist (hoist (hoist (hoist adapt)))  instance-	( Covariant y (->) (->)-	, Covariant (Schematic Monad u (v :> (w :> (x :> y)))) (->) (->)-	, Covariant (Schematic Monad v (w :> (x :> y))) (->) (->)-	, Covariant (Schematic Monad w (x :> y)) (->) (->)-	, Covariant (Schematic Monad x y) (->) (->)+	( Covariant (->) (->) y+	, Covariant (->) (->) (Schematic Monad u (v :> (w :> (x :> y))))+	, Covariant (->) (->) (Schematic Monad v (w :> (x :> y)))+	, Covariant (->) (->) (Schematic Monad w (x :> y))+	, Covariant (->) (->) (Schematic Monad x y) 	, Hoistable ((:>) (t :> u :> v :> w)) 	, Hoistable (Schematic Monad t) 	, Hoistable (Schematic Monad u)@@ -353,12 +354,12 @@ 	adapt = hoist (hoist (hoist (hoist (hoist adapt))))  instance-	( Covariant z (->) (->)-	, Covariant (Schematic Monad u (v :> (w :> (x :> (y :> z))))) (->) (->)-	, Covariant (Schematic Monad v (w :> (x :> (y :> z)))) (->) (->)-	, Covariant (Schematic Monad w (x :> (y :> z))) (->) (->)-	, Covariant (Schematic Monad x (y :> z)) (->) (->)-	, Covariant (Schematic Monad y z) (->) (->)+	( Covariant (->) (->) z+	, Covariant (->) (->) (Schematic Monad u (v :> (w :> (x :> (y :> z)))))+	, Covariant (->) (->) (Schematic Monad v (w :> (x :> (y :> z))))+	, Covariant (->) (->) (Schematic Monad w (x :> (y :> z)))+	, Covariant (->) (->) (Schematic Monad x (y :> z))+	, Covariant (->) (->) (Schematic Monad y z) 	, Hoistable ((:>) (t :> u :> v :> w)) 	, Hoistable (Schematic Monad t) 	, Hoistable (Schematic Monad u)@@ -372,13 +373,13 @@ 	adapt = hoist (hoist (hoist (hoist (hoist adapt))))  instance-	( Covariant f (->) (->)-	, Covariant (Schematic Monad u (v :> (w :> (x :> (y :> (z :> f)))))) (->) (->)-	, Covariant (Schematic Monad v (w :> (x :> (y :> (z :> f))))) (->) (->)-	, Covariant (Schematic Monad w (x :> (y :> (z :> f)))) (->) (->)-	, Covariant (Schematic Monad x (y :> (z :> f))) (->) (->)-	, Covariant (Schematic Monad y (z :> f)) (->) (->)-	, Covariant (Schematic Monad z f) (->) (->)+	( Covariant (->) (->) f+	, Covariant (->) (->) (Schematic Monad u (v :> (w :> (x :> (y :> (z :> f))))))+	, Covariant (->) (->) (Schematic Monad v (w :> (x :> (y :> (z :> f)))))+	, Covariant (->) (->) (Schematic Monad w (x :> (y :> (z :> f))))+	, Covariant (->) (->) (Schematic Monad x (y :> (z :> f)))+	, Covariant (->) (->) (Schematic Monad y (z :> f))+	, Covariant (->) (->) (Schematic Monad z f) 	, Hoistable ((:>) (t :> u :> v :> w)) 	, Hoistable (Schematic Monad t) 	, Hoistable (Schematic Monad u)@@ -393,14 +394,14 @@ 	adapt = hoist (hoist (hoist (hoist (hoist (hoist adapt)))))  instance-	( Covariant h (->) (->)-	, Covariant (Schematic Monad u (v :> (w :> (x :> (y :> (z :> (f :> h))))))) (->) (->)-	, Covariant (Schematic Monad v (w :> (x :> (y :> (z :> (f :> h)))))) (->) (->)-	, Covariant (Schematic Monad w (x :> (y :> (z :> (f :> h))))) (->) (->)-	, Covariant (Schematic Monad x (y :> (z :> (f :> h)))) (->) (->)-	, Covariant (Schematic Monad y (z :> (f :> h))) (->) (->)-	, Covariant (Schematic Monad z (f :> h)) (->) (->)-	, Covariant (Schematic Monad f h) (->) (->)+	( Covariant (->) (->) h+	, Covariant (->) (->) (Schematic Monad u (v :> (w :> (x :> (y :> (z :> (f :> h)))))))+	, Covariant (->) (->) (Schematic Monad v (w :> (x :> (y :> (z :> (f :> h))))))+	, Covariant (->) (->) (Schematic Monad w (x :> (y :> (z :> (f :> h)))))+	, Covariant (->) (->) (Schematic Monad x (y :> (z :> (f :> h))))+	, Covariant (->) (->) (Schematic Monad y (z :> (f :> h)))+	, Covariant (->) (->) (Schematic Monad z (f :> h))+	, Covariant (->) (->) (Schematic Monad f h) 	, Hoistable ((:>) (t :> u :> v :> w)) 	, Hoistable (Schematic Monad t) 	, Hoistable (Schematic Monad u)

@@ -22,38 +22,38 @@ 	(=||) :: Interpreted u => (t a -> u b) -> Primary t a -> Primary u b 	(=||) f = run . f . unite -	(<$||=) :: (Covariant j (->) (->), Interpreted u)+	(<$||=) :: (Covariant (->) (->) j, Interpreted u) 		=> (Primary t a -> Primary u b) -> j := t a -> j := u b 	f <$||= x = (f ||=) -<$>- x -	(<$$||=) :: (Covariant j (->) (->), Covariant k (->) (->), Interpreted u)+	(<$$||=) :: (Covariant (->) (->) j, Covariant (->) (->) k, Interpreted u) 		=> (Primary t a -> Primary u b) -> j :. k := t a -> j :. k := u b 	f <$$||= x = (f ||=) -<$$>- x -	(<$$$||=) :: (Covariant j (->) (->), Covariant k (->) (->), Covariant l (->) (->), Interpreted u)+	(<$$$||=) :: (Covariant (->) (->) j, Covariant (->) (->) k, Covariant (->) (->) l, Interpreted u) 		=> (Primary t a -> Primary u b) -> j :. k :. l := t a -> j :. k :. l := u b 	f <$$$||= x = (f ||=) -<$$$>- x -	(<$$$$||=) :: (Covariant j (->) (->), Covariant k (->) (->), Covariant l (->) (->), Covariant m (->) (->), Interpreted u)+	(<$$$$||=) :: (Covariant (->) (->) j, Covariant (->) (->) k, Covariant (->) (->) l, Covariant (->) (->) m, Interpreted u) 		=> (Primary t a -> Primary u b) -> j :. k :. l :. m := t a -> j :. k :. l :. m := u b 	f <$$$$||= x = (f ||=) -<$$$$>- x -	(=||$>) :: (Covariant j (->) (->), Interpreted u)+	(=||$>) :: (Covariant (->) (->) j, Interpreted u) 		=> (t a -> u b) -> j := Primary t a -> j := Primary u b 	f =||$> x = (f =||) -<$>- x -	(=||$$>) :: (Covariant j (->) (->), Covariant k (->) (->), Interpreted u)+	(=||$$>) :: (Covariant (->) (->) j, Covariant (->) (->) k, Interpreted u) 		=> (t a -> u b) -> j :. k := Primary t a -> j :. k := Primary u b 	f =||$$> x = (f =||) -<$$>- x -	(=||$$$>) :: (Covariant j (->) (->), Covariant k (->) (->), Covariant l (->) (->), Interpreted u)+	(=||$$$>) :: (Covariant (->) (->) j, Covariant (->) (->) k, Covariant (->) (->) l, Interpreted u) 		=> (t a -> u b) -> j :. k :. l := Primary t a -> j :. k :. l := Primary u b 	f =||$$$> x = (f =||) -<$$$>- x -	(=||$$$$>) :: (Covariant j (->) (->), Covariant k (->) (->), Covariant l (->) (->), Covariant m (->) (->), Interpreted u)+	(=||$$$$>) :: (Covariant (->) (->) j, Covariant (->) (->) k, Covariant (->) (->) l, Covariant (->) (->) m, Interpreted u) 		=> (t a -> u b) -> j :. k :. l :. m := Primary t a -> j :. k :. l :. m := Primary u b 	f =||$$$$> x = (f =||) -<$$$$>- x -(-=:) :: (Liftable t, Interpreted (t u), Interpreted (t v), Covariant u (->) (->))+(-=:) :: (Liftable (->) t, Interpreted (t u), Interpreted (t v), Covariant (->) (->) u) 	=> (t u a -> t v b) -> u a -> Primary (t v) b (-=:) f = run . f . lift

@@ -6,9 +6,8 @@ import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category (($)) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit)) import Pandora.Pattern.Functor.Distributive (Distributive ((-<<))) import Pandora.Pattern.Functor.Traversable (Traversable ((<<-))) import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))@@ -17,42 +16,41 @@ import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower)) import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\))) import Pandora.Paradigm.Primary.Algebraic.Product ((:*:)((:*:)))+import Pandora.Paradigm.Primary.Algebraic.One (One (One))+import Pandora.Paradigm.Primary.Algebraic (Extractable_, point) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite))  class Interpreted t => Comonadic t where 	{-# MINIMAL bring #-}-	bring :: Extractable u (->) => t :< u ~> t+	bring :: Extractable_ u => t :< u ~> t  infixr 3 :< newtype (:<) t u a = TC { tc :: Schematic Comonad t u a } -instance Covariant (Schematic Comonad t u) (->) (->) => Covariant (t :< u) (->) (->) where+instance Covariant (->) (->) (Schematic Comonad t u) => Covariant (->) (->) (t :< u) where 	f -<$>- TC x = TC $ f -<$>- x -instance Pointable (Schematic Comonad t u) (->) => Pointable (t :< u) (->) where-	point = TC . point--instance Extractable (Schematic Comonad t u) (->) => Extractable (t :< u) (->) where-	extract = extract . tc+instance Semimonoidal (->) (:*:) (:*:) (Schematic Comonad t u) => Semimonoidal (->) (:*:) (:*:) (t :< u) where+	multiply (TC f :*: TC x) = TC $ multiply $ f :*: x -instance Semimonoidal (Schematic Comonad t u) (->) (:*:) (:*:) => Semimonoidal (t :< u) (->) (:*:) (:*:) where-	multiply_ (TC f :*: TC x) = TC $ multiply_ $ f :*: x+instance Monoidal (->) (->) (:*:) (:*:) (Schematic Comonad t u) => Monoidal (->) (->) (:*:) (:*:) (t :< u) where+	unit _ f = TC . point $ f One -instance Traversable (Schematic Comonad t u) (->) (->) => Traversable (t :< u) (->) (->) where+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+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+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+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+instance Lowerable (->) (Schematic Comonad t) => Lowerable (->) ((:<) t) where 	lower (TC x) = lower x  instance Hoistable (Schematic Comonad t) => Hoistable ((:<) t) where

@@ -6,9 +6,8 @@ import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category (($)) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit)) import Pandora.Pattern.Functor.Distributive (Distributive ((-<<))) import Pandora.Pattern.Functor.Traversable (Traversable ((<<-))) import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))@@ -17,42 +16,41 @@ import Pandora.Pattern.Transformer.Liftable (Liftable (lift)) import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\))) import Pandora.Paradigm.Primary.Algebraic.Product ((:*:)((:*:)))+import Pandora.Paradigm.Primary.Algebraic.One (One (One))+import Pandora.Paradigm.Primary.Algebraic (point) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite))  class Interpreted t => Monadic t where 	{-# MINIMAL wrap #-}-	wrap :: Pointable u (->) => t ~> t :> u+	wrap :: Monoidal (->) (->) (:*:) (:*:) u => t ~> t :> u  infixr 3 :> newtype (:>) t u a = TM { tm :: Schematic Monad t u a } -instance Covariant (Schematic Monad t u) (->) (->) => Covariant (t :> u) (->) (->) where+instance Covariant (->) (->) (Schematic Monad t u) => Covariant (->) (->) (t :> u) where 	f -<$>- TM x = TM $ f -<$>- x -instance Pointable (Schematic Monad t u) (->) => Pointable (t :> u) (->) where-	point = TM . point--instance Extractable (Schematic Monad t u) (->) => Extractable (t :> u) (->) where-	extract = extract . tm+instance Semimonoidal (->) (:*:) (:*:) (Schematic Monad t u) => Semimonoidal (->) (:*:) (:*:) (t :> u) where+	multiply (TM f :*: TM x) = TM $ multiply $ f :*: x -instance Semimonoidal (Schematic Monad t u) (->) (:*:) (:*:) => Semimonoidal (t :> u) (->) (:*:) (:*:) where-	multiply_ (TM f :*: TM x) = TM $ multiply_ $ f :*: x+instance Monoidal (->) (->) (:*:) (:*:) (Schematic Monad t u) => Monoidal (->) (->) (:*:) (:*:) (t :> u) where+	unit _ f = TM . point $ f One -instance Traversable (Schematic Monad t u) (->) (->) => Traversable (t :> u) (->) (->) where+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+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+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+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), Monoidal (->) (->) (:*:) (:*:) (Schematic Monad t u), Bindable (->) (t :> u)) => Monad (t :> u) where -instance Liftable (Schematic Monad t) => Liftable ((:>) t) where+instance Liftable (->) (Schematic Monad t) => Liftable (->) ((:>) t) where 	lift = TM . lift  instance Hoistable (Schematic Monad t) => Hoistable ((:>) t) where

@@ -2,9 +2,11 @@  import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category (($), (#))-import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))+import Pandora.Pattern.Functor.Monoidal (Monoidal) import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.), (!..))+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))+import Pandora.Paradigm.Primary.Algebraic (point) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite)) import Pandora.Paradigm.Primary.Transformer.Continuation (Continuation (Continuation)) @@ -41,22 +43,22 @@ yield v = Continuation $ \next -> Pipe $ \i (Consumer o) -> o v # pause next i  -- | Pipeline that does nothing-finish :: Pointable t (->) => Pipeline i o t () ()+finish :: Monoidal (->) (->) (:*:) (:*:) t => Pipeline i o t () () finish = Continuation (Pipe (point () !..) !.)  -- | Do some effectful computation within pipeline-impact :: Bindable t (->) => t a -> Pipeline i o t a a+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 () ()+(=*=) :: forall i e o t . Monoidal (->) (->) (:*:) (:*:) t => Pipeline i e t () () -> Pipeline e o t () () -> Pipeline i o t () () p =*= q = Continuation $ \_ -> Pipe $ \i -> pipe # run q end # pause (run p end !.) i where  	end :: b -> Pipe c d () t () 	end _ = Pipe (point () !..)  -- | Run pipeline and get result-pipeline :: Pointable t (->) => Pipeline i o t () () -> t ()+pipeline :: Monoidal (->) (->) (:*:) (:*:) t => Pipeline i o t () () -> t () pipeline p = pipe # run p (Pipe . (!..) . point) # i # o where  	i :: Producer i t ()

@@ -15,26 +15,26 @@ import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category (($), (#), identity) import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))-import Pandora.Pattern.Functor.Extractable (extract) import Pandora.Pattern.Functor.Bivariant ((<->)) import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:))) import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.), (%))+import Pandora.Paradigm.Primary.Algebraic (extract) import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity)) 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+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+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+instance Adjoint (->) (->) (Equipment e) (Environment e) where 	f -| x = Environment $ f . Equipment -| x 	g |- x = run . g |- run x 

@@ -5,13 +5,13 @@ import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category (($), (#)) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply)) import Pandora.Pattern.Functor.Bindable (Bindable ((=<<))) import Pandora.Pattern.Functor.Monad (Monad)-import Pandora.Pattern.Object.Monoid (Monoid (zero))+import Pandora.Pattern.Object.Monoid (Monoid) import Pandora.Pattern.Object.Semigroup (Semigroup ((+))) import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))+import Pandora.Paradigm.Primary.Algebraic (point) 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))@@ -19,17 +19,14 @@  newtype Accumulator e a = Accumulator (e :*: a) -instance Covariant (Accumulator e) (->) (->) where+instance Covariant (->) (->) (Accumulator e) where 	f -<$>- Accumulator x = Accumulator $ f -<$>- x -instance Semigroup e => Semimonoidal (Accumulator e) (->) (:*:) (:*:) where-	multiply_ (x :*: y) = Accumulator $ k # run x # run y where+instance Semigroup e => Semimonoidal (->) (:*:) (:*:) (Accumulator e) where+	multiply (x :*: y) = Accumulator $ k # run x # run y where 		k ~(ex :*: x') ~(ey :*: y') = ex + ey :*: x' :*: y' -instance Monoid e => Pointable (Accumulator e) (->) where-	point = Accumulator . (zero :*:)--instance Semigroup e => Bindable (Accumulator e) (->) where+instance Semigroup e => Bindable (->) (Accumulator e) where 	f =<< Accumulator (e :*: x) = let e' :*: b = run $ f x in 		Accumulator $ e + e':*: b @@ -44,12 +41,6 @@ 	wrap = TM . UT . point . run  type Accumulated e t = Adaptable (Accumulator e) t--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-	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 :*: ()

@@ -6,15 +6,17 @@ import Pandora.Pattern.Category (identity, ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-))) import Pandora.Pattern.Functor.Contravariant (Contravariant ((->$<-)))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit)) 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.Algebraic.Exponential ((!.), (%))+import Pandora.Paradigm.Primary.Algebraic.Exponential ((%)) import Pandora.Paradigm.Primary.Algebraic () import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))+import Pandora.Paradigm.Primary.Algebraic.One (One (One))+import Pandora.Paradigm.Primary.Algebraic (point) 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))@@ -23,27 +25,27 @@  newtype Environment e a = Environment (e -> a) -instance Covariant (Environment e) (->) (->) where+instance Covariant (->) (->) (Environment e) where 	f -<$>- Environment x = Environment $ f . x -instance Contravariant (Flip Environment a) (->) (->) where+instance Contravariant (->) (->) (Flip Environment a) where 	f ->$<- Flip (Environment g) = Flip . Environment $ g . f -instance Pointable (Environment e) (->) where-	point x = Environment (x !.)+instance Semimonoidal (->) (:*:) (:*:) (Environment e) where+	multiply (x :*: y) = unite $ multiply $ run x :*: run y -instance Semimonoidal (Environment e) (->) (:*:) (:*:) where-	multiply_ (x :*: y) = unite $ multiply_ $ run x :*: run y+instance Monoidal (->) (->) (:*:) (:*:) (Environment e) where+	unit _ f = Environment $ \_ -> f One -instance Distributive (Environment e) (->) (->) where+instance Distributive (->) (->) (Environment e) where 	f -<< g = Environment $ (run -<$>- f) -<< g -instance Bindable (Environment e) (->) where+instance Bindable (->) (Environment e) where 	f =<< Environment x = Environment $ \e -> (run % e) . f . x $ e -instance Monad (Environment e) where+--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@@ -54,7 +56,7 @@ type instance Schematic Monad (Environment e) = (<:.>) ((->) e)  instance Monadic (Environment e) where-	wrap x = TM . TU $ point @_ @(->) -<$>- run x+	wrap x = TM . TU $ point -<$>- run x  type Configured e = Adaptable (Environment e) 

@@ -5,29 +5,24 @@ import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category (($)) import Pandora.Pattern.Functor.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.Comonad (Comonad) 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)) import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))  newtype Equipment e a = Equipment (e :*: a) -instance Covariant (Equipment e) (->) (->) where+instance Covariant (->) (->) (Equipment e) where 	f -<$>- Equipment x = Equipment $ f -<$>- x -instance Extractable (Equipment e) (->) where-	extract = extract . run--instance Traversable (Equipment e) (->) (->) where+instance Traversable (->) (->) (Equipment e) where 	f <<- Equipment x = Equipment -<$>- f <<- x -instance Extendable (Equipment e) (->) where+instance Extendable (->) (Equipment e) where 	f <<= Equipment (e :*: x) = Equipment . (:*:) e . f . Equipment $ e :*: x  instance Interpreted (Equipment e) where@@ -37,15 +32,10 @@  type instance Schematic Comonad (Equipment e) = (<:.>) ((:*:) e) -instance Comonadic (Equipment e) where-	bring (TC (TU x)) = Equipment $ extract @_ @(->) -<$>- x- type Equipped e t = Adaptable t (Equipment e) -instance {-# OVERLAPS #-} Extendable u (->) => Extendable ((:*:) e <:.> u) (->) where+instance {-# OVERLAPS #-} Extendable (->) u => Extendable (->) ((:*:) e <:.> u) where 	f <<= TU (e :*: x) = TU . (:*:) e $ f . TU . (:*:) e <<= x--instance Comonad (Equipment e) (->) where  retrieve :: Equipped e t => t a -> e retrieve = attached . run @(Equipment _) . adapt

@@ -6,38 +6,32 @@ import Pandora.Pattern.Category (($)) import Pandora.Pattern.Functor.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.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.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) import Pandora.Paradigm.Schemes.UT (UT (UT), type (<.:>))  newtype Imprint e a = Imprint (e -> a) -instance Covariant (Imprint e) (->) (->) where+instance Covariant (->) (->) (Imprint e) where 	f -<$>- Imprint g = Imprint $ f . g -instance Contravariant (Flip Imprint a) (->) (->) where+instance Contravariant (->) (->) (Flip Imprint a) where 	f ->$<- Flip (Imprint g) = Flip . Imprint $ g . f -instance Distributive (Imprint e) (->) (->) where+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+instance Semigroup e => Extendable (->) (Imprint e) where 	f <<= Imprint x = Imprint $ \e -> f $ Imprint $ x . (e +)  instance Interpreted (Imprint e) where@@ -47,10 +41,7 @@  type instance Schematic Comonad (Imprint e) = (<.:>) ((->) e) -instance Monoid e => Comonadic (Imprint e) where-	bring (TC (UT x)) = Imprint . extract $ x--instance {-# OVERLAPS #-} (Semigroup e, Extendable u (->)) => Extendable ((->) e <.:> u) (->) where+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)

@@ -6,7 +6,6 @@ import Pandora.Pattern.Semigroupoid (Semigroupoid ((.))) import Pandora.Pattern.Category (Category (identity, ($), (#))) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))-import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Invariant (Invariant ((<$<))) import Pandora.Pattern.Functor.Divariant ((>->)) import Pandora.Pattern.Functor.Representable (Representable (Representation, (<#>), tabulate))@@ -14,7 +13,7 @@ import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (run)) import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:))) import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.), (%))-import Pandora.Paradigm.Primary.Algebraic (($>-))+import Pandora.Paradigm.Primary.Algebraic (($>-), extract) import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity)) import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing)) import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))

@@ -7,8 +7,8 @@ import Pandora.Pattern.Category (identity, ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-))) import Pandora.Pattern.Functor.Invariant (Invariant ((<$<)))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit)) import Pandora.Pattern.Functor.Traversable (Traversable ((<<-))) import Pandora.Pattern.Functor.Bindable (Bindable ((=<<))) import Pandora.Pattern.Functor.Monad (Monad)@@ -21,29 +21,31 @@ import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM)) import Pandora.Paradigm.Schemes.TUT (TUT (TUT), type (<:<.>:>)) import Pandora.Paradigm.Primary.Algebraic ((:*:) ((:*:)), (*>-), delta)+import Pandora.Paradigm.Primary.Algebraic.One (One (One))+import Pandora.Paradigm.Primary.Algebraic (point)  -- | Effectful computation with a variable newtype State s a = State ((->) s :. (:*:) s := a) -instance Covariant (State s) (->) (->) where+instance Covariant (->) (->) (State s) where 	f -<$>- x = State $ (-<$>-) f . run x -instance Semimonoidal (State s) (->) (:*:) (:*:) where-	multiply_ (State g :*: State h) = State $ \s -> +instance Semimonoidal (->) (:*:) (:*:) (State s) where+	multiply (State g :*: State h) = State $ \s ->  		let old :*: x = g s in  	  	let new :*: y = h old in 		new :*: x :*: y -instance Pointable (State s) (->) where-	point = State . (identity @(->) -|)+instance Monoidal (->) (->) (:*:) (:*:) (State s) where+	unit _ f = State . (identity @(->) -|) $ f One -instance Bindable (State s) (->) where+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@@ -53,7 +55,7 @@ type instance Schematic Monad (State s) = (->) s <:<.>:> (:*:) s  instance Monadic (State s) where-	wrap x = TM . TUT $ point @_ @(->) -<$>- run x+	wrap x = TM . TUT $ point -<$>- run x  type Stateful s = Adaptable (State s) @@ -69,10 +71,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 :: (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 (->), Semimonoidal t (->) (:*:) (:*:), Stateful s t)+type Memorable s t = (Covariant (->) (->) t, Monoidal (->) (->) (:*:) (:*:) t,  Stateful s t) -fold :: (Traversable t (->) (->), Memorable s u) => (a -> s -> s) -> t a -> u s+fold :: (Traversable (->) (->) t, Memorable s u) => (a -> s -> s) -> t a -> u s fold op struct = (modify . op <<- struct) *>- current

@@ -6,16 +6,17 @@ import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category (identity, ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)), (-<$$>-))+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit)) import Pandora.Pattern.Functor.Invariant (Invariant ((<$<)))-import Pandora.Pattern.Functor.Extractable (Extractable (extract)) 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.Algebraic.Exponential ((%), (-.#..-))+import Pandora.Pattern.Functor.Adjoint ((-|))+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), (%), (!.), (-.#..-)) import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), attached)-import Pandora.Paradigm.Primary.Algebraic ()+import Pandora.Paradigm.Primary.Algebraic (extract) import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip)) import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt)) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (||=)), Schematic)@@ -25,19 +26,24 @@ -- | Context based computation on value newtype Store s a = Store ((:*:) s :. (->) s := a) -instance Covariant (Store s) (->) (->) where+instance Covariant (->) (->) (Store s) where 	f -<$>- Store x = Store $ f -<$$>- x -instance Extractable (Store s) (->) where-	extract = (($) |-) . run+instance Semimonoidal (<--) (:*:) (:*:) (Store s) where+	multiply = Flip $ \(Store (s :*: f)) -> +		let (x :*: y) = f s in+		Store (s :*: (x !.)) :*: Store (s :*: (y !.)) -instance Extendable (Store s) (->) where+instance Monoidal (<--) (->) (:*:) (:*:) (Store s) where+	unit _ = Flip $ \(Store (s :*: f)) -> (\_ -> f s)++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

@@ -10,10 +10,9 @@  import Pandora.Core.Functor (type (:=)) import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))-import Pandora.Pattern.Category (Category (($), (#), identity))+import Pandora.Pattern.Category (Category (($), (#))) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-))) import Pandora.Pattern.Functor.Adjoint (Adjoint ((|-), (-|)))-import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Transformer.Liftable (lift) import Pandora.Pattern.Transformer.Lowerable (lower) import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)@@ -23,16 +22,7 @@ import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), Morph (Into), premorph) import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Available, Substance, substructure)) -instance Semigroupoid (Flip (->)) where-	Flip f . Flip g = Flip $ \x -> g (f x)--instance Category (Flip (->)) where-	identity = Flip identity--instance Extractable (Flip (:*:) a) (->) where-	extract (Flip (x :*: _)) = x--instance Adjoint (Flip (:*:) s) ((->) s) (->) (->) where+instance Adjoint (->) (->) (Flip (:*:) s) ((->) s) where 	f -| x = \s -> f $ Flip $ x :*: s 	f |- Flip (x :*: s) = f x s @@ -99,16 +89,16 @@ 	type Available Left Wye = Maybe 	type Substance Left Wye = Identity 	substructure = P_Q_T $ \new -> case lower new of-		End -> Store $ Nothing :*: lift . resolve Left End . (extract @_ @(->) -<$>-)-		Left x -> Store $ Just (Identity x) :*: lift . resolve Left End . (extract @_ @(->) -<$>-)-		Right y -> Store $ Nothing :*: (lift # Right y !.) . (extract @_ @(->) -<$>-)-		Both x y -> Store $ Just (Identity x) :*: lift . resolve (Both % y) (Right y) . (extract @_ @(->) -<$>-)+		End -> Store $ Nothing :*: lift . resolve Left End . (extract -<$>-)+		Left x -> Store $ Just (Identity x) :*: lift . resolve Left End . (extract -<$>-)+		Right y -> Store $ Nothing :*: (lift # Right y !.) . (extract -<$>-)+		Both x y -> Store $ Just (Identity x) :*: lift . resolve (Both % y) (Right y) . (extract -<$>-)  instance Substructure Right Wye where 	type Available Right Wye = Maybe 	type Substance Right Wye = Identity 	substructure = P_Q_T $ \new -> case lower new of-		End -> Store $ Nothing :*: lift . resolve Right End . (extract @_ @(->) -<$>-)-		Left x -> Store $ Nothing :*: (lift # Left x !.) . (extract @_ @(->) -<$>-)-		Right y -> Store $ Just (Identity y) :*: lift . resolve Right End . (extract @_ @(->) -<$>-)-		Both x y -> Store $ Just (Identity y) :*: lift . resolve (Both x) (Left x) . (extract @_ @(->) -<$>-)+		End -> Store $ Nothing :*: lift . resolve Right End . (extract -<$>-)+		Left x -> Store $ Nothing :*: (lift # Left x !.) . (extract -<$>-)+		Right y -> Store $ Just (Identity y) :*: lift . resolve Right End . (extract -<$>-)+		Both x y -> Store $ Just (Identity y) :*: lift . resolve (Both x) (Left x) . (extract -<$>-)

@@ -1,60 +1,108 @@ {-# OPTIONS_GHC -fno-warn-orphans #-} -module Pandora.Paradigm.Primary.Algebraic (module Exports, Applicative_, Alternative_, ($>-), ($$>-), ($$$>-), (-<*>-), (*>-), forever_, (-+-)) where+module Pandora.Paradigm.Primary.Algebraic (module Exports, Applicative_, Alternative_, Extractable_, ($>-), ($$>-), ($$$>-), (-<*>-), (*>-), forever_, (-+-), void, empty, point, extract) where  import Pandora.Paradigm.Primary.Algebraic.Exponential as Exports import Pandora.Paradigm.Primary.Algebraic.Product as Exports import Pandora.Paradigm.Primary.Algebraic.Sum as Exports+import Pandora.Paradigm.Primary.Algebraic.Zero as Exports+import Pandora.Paradigm.Primary.Algebraic.One as Exports  import Pandora.Pattern.Category (($))-import Pandora.Pattern.Functor (Endofunctor) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)), (-<$$>-), (-<$$$>-))-import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit), Unit)+import Pandora.Pattern.Functor.Comonad (Comonad) import Pandora.Pattern.Functor.Traversable (Traversable ((<<-))) import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))+import Pandora.Paradigm.Primary.Functor.Proxy (Proxy (Proxy))+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip)) +type instance Unit (:*:) = One+type instance Unit (:+:) = Zero+ infixl 4 -<*>- -($>-) :: Covariant t (->) (->) => t a -> b -> t b+($>-) :: Covariant (->) (->) t => t a -> b -> t b x $>- r = (r !.) -<$>- x -($$>-) :: (Covariant t (->) (->), Covariant u (->) (->)) => t (u a) -> b -> t (u b)+($$>-) :: (Covariant (->) (->) t, Covariant (->) (->) u) => t (u a) -> b -> t (u b) x $$>- r = (r !.) -<$$>- x -($$$>-) :: (Covariant t (->) (->), Covariant u (->) (->), Covariant v (->) (->)) => t (u (v a)) -> b -> t (u (v b))+($$$>-) :: (Covariant (->) (->) t, Covariant (->) (->) u, Covariant (->) (->) v) => t (u (v a)) -> b -> t (u (v b)) x $$$>- r = (r !.) -<$$$>- x -instance Traversable ((:*:) s) (->) (->) where+void :: Covariant (->) (->) t => t a -> t ()+void x = x $>- ()++instance Traversable (->) (->) ((:*:) s) where 	f <<- x = (attached x :*:) -<$>- f (extract x) -instance Adjoint ((:*:) s) ((->) s) (->) (->) where+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 -instance Semimonoidal ((->) e) (->) (:*:) (:*:) where-	multiply_ :: ((e -> a) :*: (e -> b)) -> e -> (a :*: b)-	multiply_ (g :*: h) = \x -> g x :*: h x+instance Semimonoidal (->) (:*:) (:*:) ((->) e) where+	multiply :: ((e -> a) :*: (e -> b)) -> e -> (a :*: b)+	multiply (g :*: h) = \x -> g x :*: h x -instance Semimonoidal ((:+:) e) (->) (:*:) (:+:) where-	multiply_ :: ((e :+: a) :*: (e :+: b)) -> e :+: a :+: b-	multiply_ (Option _ :*: Option e') = Option e'-	multiply_ (Option _ :*: Adoption y) = Adoption $ Adoption y-	multiply_ (Adoption x :*: _) = Adoption $ Option x+instance Semimonoidal (<--) (:*:) (:*:) ((->) e) where+	multiply = Flip $ \f -> (\e -> attached $ f e) :*: (\e -> extract $ f e) -type Applicative_ t = (Endofunctor Covariant t (->), Semimonoidal t (->) (:*:) (:*:))-type Alternative_ t = (Endofunctor Covariant t (->), Semimonoidal t (->) (:*:) (:+:))+instance Semimonoidal (->) (:*:) (:+:) ((:+:) e) where+	multiply :: ((e :+: a) :*: (e :+: b)) -> e :+: a :+: b+	multiply (Option _ :*: Option e') = Option e'+	multiply (Option _ :*: Adoption y) = Adoption $ Adoption y+	multiply (Adoption x :*: _) = Adoption $ Option x -(-<*>-) :: Applicative_ t => t (a -> b) -> t a -> t b-f -<*>- x = (|-) @_ @_ @(->) @(->) (&) -<$>- multiply_ @_ @_ @_ @(:*:) (f :*: x)+instance Semimonoidal (->) (:*:) (:*:) ((:+:) e) where+	multiply (Adoption x :*: Adoption y) = Adoption $ x :*: y+	multiply (Option e :*: _) = Option e+	multiply (_ :*: Option e) = Option e -forever_ :: Applicative_ t => t a -> t b+instance Monoidal (->) (->) (:*:) (:*:) ((:+:) e) where+	unit _ f = Adoption $ f One++instance Semimonoidal (<--) (:*:) (:*:) ((:*:) s) where+	multiply = Flip $ \(s :*: x :*: y) -> (s :*: x) :*: (s :*: y)++instance Monoidal (<--) (->) (:*:) (:*:) ((:*:) s) where+	unit _ = Flip $ \(_ :*: x) -> (\_ -> x)++instance Comonad ((:*:) s) (->) where++instance Semimonoidal (<--) (:*:) (:*:) (Flip (:*:) a) where+	multiply = Flip $ \(Flip ((sx :*: sy) :*: r)) -> Flip (sx :*: r) :*: Flip (sy :*: r)++instance Monoidal (<--) (->) (:*:) (:*:) (Flip (:*:) a) where+	unit _ = Flip $ \(Flip (s :*: _)) -> (\_ -> s)++type Applicative_ t = (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:*:) t, Monoidal (->) (->) (:*:) (:*:) t)+type Alternative_ t = (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:+:) t, Monoidal (->) (->) (:*:) (:+:) t)++(-<*>-) :: (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:*:) t)+	=> t (a -> b) -> t a -> t b+f -<*>- x = (|-) @(->) @(->) (&) -<$>- multiply @_ @_ @(:*:) (f :*: x)++forever_ :: (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:*:) t) => t a -> t b forever_ x = let r = x *>- r in r -(*>-) :: Applicative_ t => t a -> t b -> t b+(*>-) :: (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:*:) t) => t a -> t b -> t b x *>- y = ((!.) %) -<$>- x -<*>- y -(-+-) :: Alternative_ t => t a -> t b -> (a :+: b -> r) -> t r-x -+- y = \f -> f -<$>- multiply_ (x :*: y)+(-+-) :: (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:+:) t)+	  => t a -> t b -> (a :+: b -> r) -> t r+x -+- y = \f -> f -<$>- multiply (x :*: y)++point :: Monoidal (->) (->) (:*:) (:*:) t => a -> t a+point x = unit (Proxy @(:*:)) (\One -> x)++empty :: Monoidal (->) (->) (:*:) (:+:) t => t a+empty = unit (Proxy @(:*:)) absurd++type Extractable_ t = Monoidal (<--) (->) (:*:) (:*:) t++extract :: Extractable_ t => t a -> a+extract j = let Flip f = unit @(<--) @(->) @(:*:) @(:*:) Proxy in f j $ One

@@ -7,9 +7,7 @@ import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-))) import Pandora.Pattern.Functor.Contravariant (Contravariant ((->$<-))) 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 ((*)))@@ -26,26 +24,15 @@ instance Category (->) where 	identity x = x -instance Covariant ((->) a) (->) (->) where+instance Covariant (->) (->) ((->) a) where 	(-<$>-) = (.) -instance Contravariant (Flip (->) a) (->) (->) where-	f ->$<- Flip g = Flip $ g . f--instance Distributive ((->) e) (->) (->) where+instance Distributive (->) (->) ((->) e) where 	f -<< g = \e -> (f % e) -<$>- g -instance Pointable ((->) e) (->) where-	point = (!.)--instance Bindable ((->) e) (->) where+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 @@ -55,7 +42,18 @@ instance Ringoid r => Ringoid (e -> r) where 	f * g = \e -> f e * g e -(-.#..-) :: (Covariant (v a) (->) target, Semigroupoid v) => v c d -> target (v a (v b c)) (v a (v b d))+type (<--) = Flip (->)++instance Semigroupoid (<--) where+	Flip f . Flip g = Flip $ \x -> g (f x)++instance Category (<--) where+	identity = Flip identity++instance Contravariant (->) (->) ((<--) a) where+	f ->$<- Flip g = Flip $ g . f++(-.#..-) :: (Covariant (->) target (v a), Semigroupoid v) => v c d -> target (v a (v b c)) (v a (v b d)) (-.#..-) f = (-<$>-) (f .)  {-# INLINE (!.) #-}

@@ -0,0 +1,3 @@+module Pandora.Paradigm.Primary.Algebraic.One where++data One = One

@@ -3,10 +3,8 @@ import Pandora.Core.Functor (type (:=)) import Pandora.Pattern.Category (($), (#)) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))-import Pandora.Pattern.Functor.Extractable (Extractable (extract))+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply)) 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 ((+)))@@ -16,6 +14,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.Algebraic.Exponential (type (<--)) import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip)) import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>)) @@ -23,51 +22,55 @@  data (:*:) s a = s :*: a -instance Covariant ((:*:) s) (->) (->) where-	f -<$>- x = attached x :*: f # extract x+instance Covariant (->) (->) ((:*:) s) where+	f -<$>- ~(s :*: x) = s :*: f x -instance Covariant (Flip (:*:) a) (->) (->) where+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 Extendable (->) ((:*:) s) where+	f <<= ~(s :*: x) = s :*: f (s :*: x) -instance Bivariant (:*:) (->) (->) (->) 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)+	~(sx :*: x) == ~(sy :*: y) = (sx == sy) * (x == y)  instance (Semigroup s, Semigroup a) => Semigroup (s :*: a) where-	x + y = attached x + attached y :*: extract x + extract y+	~(sx :*: x) + ~(sy :*: y) = sx + sy :*: x + 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+	~(sx :*: x) * ~(sy :*: y) = sx * sy :*: x * 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+	~(sx :*: x) /\ ~(sy :*: y) = sx /\ sy :*: x /\ y  instance (Supremum s, Supremum a) => Supremum (s :*: a) where-	x \/ y = attached x \/ attached y :*: extract x \/ extract y+	~(sx :*: x) \/ ~(sy :*: y) = sx \/ sy :*: x \/ 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+	invert ~(s :*: x) = invert # s :*: invert # x -instance {-# OVERLAPS #-} Semimonoidal t (->) (:*:) (:*:) => Semimonoidal (t <:.:> t := (:*:)) (->) (:*:) (:*:) where-	multiply_ (T_U (xls :*: xrs) :*: T_U (yls :*: yrs)) = T_U $ multiply_ (xls :*: yls) :*: multiply_ (xrs :*: yrs)+instance {-# OVERLAPS #-} Semimonoidal (->) (:*:) (:*:) t => Semimonoidal (->) (:*:) (:*:) (t <:.:> t := (:*:)) where+	multiply (T_U (xls :*: xrs) :*: T_U (yls :*: yrs)) = T_U $ multiply (xls :*: yls) :*: multiply (xrs :*: yrs)++-- TODO: Generalize (:*:) as Bivariant p+instance (Semimonoidal (<--) (:*:) (:*:) t, Semimonoidal (<--) (:*:) (:*:) u) => Semimonoidal (<--) (:*:) (:*:) (t <:.:> u := (:*:)) where+	multiply = Flip $ \(T_U (lxys :*: rxys)) ->+		let Flip f = multiply @(<--) @(:*:) @(:*:) in+		let Flip g = multiply @(<--) @(:*:) @(:*:) in+		let (lxs :*: lys) = f lxys in+		let (rxs :*: rys) = g rxys in+		T_U (lxs :*: rxs) :*: T_U (lys :*: rys)  delta :: a -> a :*: a delta x = x :*: x

@@ -3,7 +3,6 @@ import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category (($)) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))-import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->))) import Pandora.Paradigm.Primary.Algebraic.Exponential () import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))@@ -12,18 +11,19 @@  data (:+:) s a = Option s | Adoption a -instance Covariant ((:+:) s) (->) (->) where+instance Covariant (->) (->) ((:+:) s) where 	_ -<$>- Option s = Option s 	f -<$>- Adoption x = Adoption $ f x -instance Pointable ((:+:) e) (->) where-	point = Adoption--instance Bivariant (:+:) (->) (->) (->) where+instance Bivariant (->) (->) (->) (:+:) where 	f <-> g = \case 		Option s -> Option $ f s 		Adoption x -> Adoption $ g x -instance Covariant (Flip (:+:) a) (->) (->) where+instance Covariant (->) (->) (Flip (:+:) a) where 	_ -<$>- Flip (Adoption x) = Flip $ Adoption x 	f -<$>- Flip (Option y) = Flip . Option $ f y++sum :: (e -> r) -> (a -> r) -> e :+: a -> r+sum f _ (Option x) = f x+sum _ s (Adoption x) = s x

@@ -0,0 +1,8 @@+{-# LANGUAGE EmptyCase #-}++module Pandora.Paradigm.Primary.Algebraic.Zero where++data Zero++absurd :: Zero -> a+absurd x = case x of {}

@@ -1,6 +1,3 @@-{-# LANGUAGE AllowAmbiguousTypes #-}-{-# OPTIONS_GHC -fno-warn-orphans #-}- module Pandora.Paradigm.Primary.Functor (module Exports, Equivalence, Comparison, match) where  import Pandora.Paradigm.Primary.Functor.Fix as Exports

@@ -3,10 +3,10 @@ import Pandora.Core.Functor (type (~>)) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category (identity, ($), (#))-import Pandora.Pattern.Functor (Endofunctor)+--import Pandora.Pattern.Functor (Endofunctor) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit)) import Pandora.Pattern.Functor.Traversable (Traversable ((<<-))) import Pandora.Pattern.Functor.Bindable (Bindable ((=<<))) import Pandora.Pattern.Functor.Monad (Monad)@@ -23,42 +23,44 @@ import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM)) import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt)) import Pandora.Paradigm.Schemes.UT (UT (UT), type (<.:>))+import Pandora.Paradigm.Primary.Algebraic.One (One (One))+import Pandora.Paradigm.Primary.Algebraic (point)  data Conclusion e a = Failure e | Success a -instance Covariant (Conclusion e) (->) (->) where+instance Covariant (->) (->) (Conclusion e) where 	f -<$>- Success x = Success $ f x 	_ -<$>- Failure y = Failure y -instance Covariant (Flip Conclusion e) (->) (->) where+instance Covariant (->) (->) (Flip Conclusion e) where 	_ -<$>- Flip (Success x) = Flip $ Success x 	f -<$>- Flip (Failure y) = Flip . Failure $ f y -instance Pointable (Conclusion e) (->) where-	point = Success+instance Semimonoidal (->) (:*:) (:*:) (Conclusion e) where+	multiply (Success x :*: Success y) = Success $ x :*: y+	multiply (Failure x :*: _) = Failure x+	multiply (_ :*: Failure x) = Failure x -instance Semimonoidal (Conclusion e) (->) (:*:) (:*:) where-	multiply_ (Success x :*: Success y) = Success $ x :*: y-	multiply_ (Failure x :*: _) = Failure x-	multiply_ (_ :*: Failure x) = Failure x+instance Monoidal (->) (->) (:*:) (:*:) (Conclusion e) where+	unit _ f = Success $ f One -instance Semigroup e => Semimonoidal (Conclusion e) (->) (:*:) (:+:) where-	multiply_ (Failure _ :*: x) = Adoption -<$>- x-	multiply_ (Success x :*: _) = Option -<$>- Success x+instance Semigroup e => Semimonoidal (->) (:*:) (:+:) (Conclusion e) where+	multiply (Failure _ :*: x) = Adoption -<$>- x+	multiply (Success x :*: _) = Option -<$>- Success x -instance Traversable (Conclusion e) (->) (->) where-	(<<-) :: (Endofunctor Covariant u (->), Pointable u (->), Semimonoidal u (->) (:*:) (:*:))+instance Traversable (->) (->) (Conclusion e) where+	(<<-) :: (Covariant (->) (->) u, Monoidal (->) (->) (:*:) (:*:) 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+instance Bindable (->) (Conclusion e) where 	f =<< Success x = f x 	_ =<< Failure y = Failure y -instance Monad (Conclusion e) where+--instance Monad (Conclusion e) where -instance Bivariant Conclusion (->) (->) (->) where+instance Bivariant (->) (->) (->) Conclusion where 	f <-> g = conclusion # Failure . f # Success . g  instance (Setoid e, Setoid a) => Setoid (Conclusion e a) where@@ -108,6 +110,6 @@ 	catch (Failure e) handle = handle e 	catch (Success x) _ = Success x -instance (Pointable u (->), Bindable u (->)) => Catchable e (Conclusion e <.:> u) where+instance (Monoidal (->) (->) (:*:) (:*:) u, Bindable (->) u) => Catchable e (Conclusion e <.:> u) where 	catch (UT x) handle = let conclude = conclusion # run . handle # point . Success 		in UT $ conclude =<< x

@@ -20,19 +20,19 @@  newtype Constant a b = Constant a -instance Covariant (Constant a) (->) (->) where+instance Covariant (->) (->) (Constant a) where 	_ -<$>- Constant x = Constant x -instance Covariant (Flip Constant b) (->) (->) where+instance Covariant (->) (->) (Flip Constant b) where 	f -<$>- Flip (Constant x) = Flip . Constant $ f x -instance Contravariant (Constant a) (->) (->) where+instance Contravariant (->) (->) (Constant a) where 	_ ->$<- Constant x = Constant x  instance Invariant (Constant a) where 	_ <$< _ = \(Constant x) -> Constant x -instance Bivariant Constant (->) (->) (->)where+instance Bivariant (->) (->) (->) Constant where 	f <-> _ = \(Constant x) -> Constant $ f x  instance Setoid a => Setoid (Constant a b) where

@@ -6,5 +6,5 @@  data Convergence r a = Convergence (a -> a -> r) -instance Contravariant (Convergence r) (->) (->) where+instance Contravariant (->) (->) (Convergence r) where 	f ->$<- Convergence g = Convergence $ \x y -> g # f x # f y

@@ -2,19 +2,19 @@  import Pandora.Pattern.Category (($)) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))-import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Traversable (Traversable ((<<-))) import Pandora.Paradigm.Primary.Algebraic.Exponential ()+import Pandora.Paradigm.Primary.Algebraic (point)  data Edges a = Empty | Leap a | Connect a | Overlay a -instance Covariant Edges (->) (->) where+instance Covariant (->) (->) Edges where 	_ -<$>- Empty = Empty 	f -<$>- Connect x = Connect $ f x 	f -<$>- Overlay x = Overlay $ f x 	f -<$>- Leap x = Leap $ f x -instance Traversable Edges (->) (->) where+instance Traversable (->) (->) Edges where 	_ <<- Empty = point Empty 	f <<- Connect x = Connect -<$>- f x 	f <<- Overlay x = Overlay -<$>- f x

@@ -7,11 +7,11 @@  newtype Fix t = Fix { unfix :: t (Fix t) } -cata :: Covariant t (->) (->) => (a <:= t) -> Fix t -> a+cata :: Covariant (->) (->) t => (a <:= t) -> Fix t -> a cata f = f . (cata f -<$>-) . unfix -ana :: Covariant t (->) (->) => (a :=> t) -> a -> Fix t+ana :: Covariant (->) (->) t => (a :=> t) -> a -> Fix t ana f = Fix . (ana f -<$>-) . f -hylo :: Covariant t (->) (->) => (b <:= t) -> (a :=> t) -> (a -> b)+hylo :: Covariant (->) (->) t => (b <:= t) -> (a :=> t) -> (a -> b) hylo phi psi = cata phi . ana psi

@@ -3,14 +3,14 @@ import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category (($)) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))-import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit)) 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))+--import Pandora.Pattern.Functor.Representable (Representable (Representation, (<#>), tabulate)) import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-))) import Pandora.Pattern.Object.Setoid (Setoid ((==))) import Pandora.Pattern.Object.Chain (Chain ((<=>)))@@ -21,38 +21,48 @@ import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/))) import Pandora.Pattern.Object.Lattice (Lattice) import Pandora.Pattern.Object.Group (Group (invert))-import Pandora.Paradigm.Primary.Algebraic.Exponential ()+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--))+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))+import Pandora.Paradigm.Primary.Algebraic.One (One (One))+import Pandora.Paradigm.Primary.Algebraic (extract)+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))  newtype Identity a = Identity a -instance Covariant Identity (->) (->) where+instance Covariant (->) (->) Identity where 	f -<$>- Identity x = Identity $ f x -instance Pointable Identity (->) where-	point = Identity+instance Semimonoidal (->) (:*:) (:*:) Identity where+	multiply (Identity x :*: Identity y) = Identity $ x :*: y -instance Extractable Identity (->) where-	extract (Identity x) = x+instance Monoidal (->) (->) (:*:) (:*:) Identity where+	unit _ f = Identity $ f One -instance Traversable Identity (->) (->) where+instance Semimonoidal (<--) (:*:) (:*:) Identity where+	multiply = Flip $ \(Identity (x :*: y)) -> Identity x :*: Identity y++instance Monoidal (<--) (->) (:*:) (:*:) Identity where+	unit _ = Flip $ \(Identity x) -> (\_ -> x)++instance Traversable (->) (->) Identity where 	f <<- Identity x = Identity -<$>- f x -instance Bindable Identity (->) where+instance Bindable (->) Identity where 	f =<< Identity x = f x	  instance Monad Identity -instance Extendable Identity (->) where+instance Extendable (->) Identity where 	f <<= x = Identity . f $ x  instance Comonad Identity (->) -instance Representable Identity where-	type Representation Identity = ()-	() <#> Identity x = x-	tabulate f = Identity $ f ()+--instance Representable Identity where+	--type Representation Identity = ()+	--() <#> Identity x = x+	--tabulate f = Identity $ f () -instance Adjoint Identity Identity (->) (->) where+instance Adjoint (->) (->) Identity Identity where 	f -| x = Identity . f . Identity $ x 	g |- x = extract . extract . (g -<$>-) $ x 

@@ -4,8 +4,8 @@ import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category (identity, ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit)) import Pandora.Pattern.Functor.Traversable (Traversable ((<<-))) import Pandora.Pattern.Functor.Bindable (Bindable ((=<<))) import Pandora.Pattern.Functor.Monad (Monad)@@ -22,38 +22,50 @@ 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.Exponential (type (<--)) import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:))) import Pandora.Paradigm.Primary.Algebraic.Sum ((:+:) (Option, Adoption))+import Pandora.Paradigm.Primary.Algebraic.One (One (One))+import Pandora.Paradigm.Primary.Algebraic (point)+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))  data Maybe a = Nothing | Just a -instance Covariant Maybe (->) (->) where+instance Covariant (->) (->) Maybe where 	f -<$>- Just x = Just $ f x 	_ -<$>- Nothing = Nothing -instance Pointable Maybe (->) where-	point = Just+instance Semimonoidal (->) (:*:) (:*:) Maybe where+	multiply (Just x :*: Just y) = Just $ x :*: y+	multiply (Nothing :*: _) = Nothing+	multiply (_ :*: Nothing) = Nothing -instance Semimonoidal Maybe (->) (:*:) (:*:) where-	multiply_ (Just x :*: Just y) = Just $ x :*: y-	multiply_ (Nothing :*: _) = Nothing-	multiply_ (_ :*: Nothing) = Nothing+instance Semimonoidal (->) (:*:) (:+:) Maybe where+	multiply (Just x :*: _) = Just $ Option x+	multiply (Nothing :*: Just y) = Just $ Adoption y+	multiply (Nothing :*: Nothing) = Nothing -instance Semimonoidal Maybe (->) (:*:) (:+:) where-	multiply_ (Just x :*: Just _) = Just $ Option x-	multiply_ (Nothing :*: Just y) = Just $ Adoption y-	multiply_ (Nothing :*: Nothing) = Nothing+instance Monoidal (->) (->) (:*:) (:*:) Maybe where+	unit _ f = Just $ f One -instance Traversable Maybe (->) (->) where+instance Monoidal (->) (->) (:*:) (:+:) Maybe where+	unit _ _ = Nothing++-- TODO: Check laws+instance Semimonoidal (<--) (:*:) (:*:) Maybe where+	multiply = Flip $ \case+		Just (x :*: y) -> Just x :*: Just y+		Nothing -> Nothing :*: Nothing++instance Traversable (->) (->) Maybe where 	_ <<- Nothing = point Nothing 	f <<- Just x = Just -<$>- f x -instance Bindable Maybe (->) where+instance Bindable (->) Maybe where 	f =<< Just x = f x 	_ =<< Nothing = Nothing -instance Monad Maybe where+--instance Monad Maybe where  instance Setoid a => Setoid (Maybe a) where 	Just x == Just y = x == y

@@ -15,7 +15,7 @@ 	run ~(Predicate f) = f 	unite = Predicate -instance Contravariant Predicate (->) (->) where+instance Contravariant (->) (->) Predicate where 	f ->$<- Predicate g = Predicate $ g . f  equate :: Setoid a => a :=> Predicate

@@ -2,31 +2,27 @@  import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-))) import Pandora.Pattern.Functor.Contravariant (Contravariant ((->$<-)))-import Pandora.Pattern.Functor.Pointable (Pointable (point)) 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.Monad (Monad) import Pandora.Paradigm.Primary.Algebraic.Exponential ()  data Proxy a = Proxy -instance Covariant Proxy (->) (->) where+instance Covariant (->) (->) Proxy where 	_ -<$>- Proxy = Proxy -instance Contravariant Proxy (->) (->) where+instance Contravariant (->) (->) Proxy where 	_ ->$<- _ = Proxy -instance Pointable Proxy (->) where-	point _ = Proxy--instance Distributive Proxy (->) (->) where+instance Distributive (->) (->) Proxy where 	_ -<< _ = Proxy -instance Bindable Proxy (->) where+instance Bindable (->) Proxy where 	_ =<< _ = Proxy -instance Monad Proxy+--instance Monad Proxy -instance Extendable Proxy (->) where+instance Extendable (->) Proxy where 	_ <<= _ = Proxy

@@ -4,8 +4,8 @@ import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category (($)) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))-import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit)) import Pandora.Pattern.Functor.Traversable (Traversable ((<<-))) import Pandora.Pattern.Functor.Distributive (Distributive ((-<<))) import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))@@ -22,7 +22,10 @@ import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/))) import Pandora.Pattern.Object.Lattice (Lattice) import Pandora.Pattern.Object.Group (Group (invert))-import Pandora.Paradigm.Primary.Algebraic.Exponential ()+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--))+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))+import Pandora.Paradigm.Primary.Algebraic.One (One (One))+import Pandora.Paradigm.Primary.Algebraic (extract) import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))  newtype Tagged tag a = Tag a@@ -30,35 +33,41 @@ infixr 0 :# type (:#) tag = Tagged tag -instance Covariant (Tagged tag) (->) (->) where+instance Covariant (->) (->) (Tagged tag) where 	f -<$>- Tag x = Tag $ f x -instance Covariant (Flip Tagged a) (->) (->) where+instance Covariant (->) (->) (Flip Tagged a) where 	_ -<$>- Flip (Tag x) = Flip $ Tag x -instance Pointable (Tagged tag) (->) where-	point = Tag+instance Semimonoidal (->) (:*:) (:*:) (Tagged tag) where+	multiply (x :*: y) = Tag $ extract x :*: extract y -instance Extractable (Tagged tag) (->) where-	extract (Tag x) = x+instance Monoidal (->) (->) (:*:) (:*:) (Tagged tag) where+	unit _ f = Tag $ f One -instance Traversable (Tagged tag) (->) (->) where+instance Semimonoidal (<--) (:*:) (:*:) (Tagged tag) where+	multiply = Flip $ \(Tag (x :*: y)) -> Tag x :*: Tag y++instance Monoidal (<--) (->) (:*:) (:*:) (Tagged tag) where+	unit _ = Flip $ \(Tag x) -> (\_ -> x)++instance Traversable (->) (->) (Tagged tag) where 	f <<- Tag x = Tag -<$>- f x -instance Distributive (Tagged tag) (->) (->) where+instance Distributive (->) (->) (Tagged tag) where 	f -<< x = Tag $ extract . f -<$>- x -instance Bindable (Tagged tag) (->) where+instance Bindable (->) (Tagged tag) where 	f =<< Tag x = f x  instance Monad (Tagged tag) -instance Extendable (Tagged tag) (->) where+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,22 +2,19 @@  import Pandora.Pattern.Category (($), (#)) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))-import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Traversable (Traversable ((<<-))) import Pandora.Pattern.Object.Semigroup (Semigroup ((+))) import Pandora.Paradigm.Primary.Algebraic.Exponential ()+import Pandora.Paradigm.Primary.Algebraic (point)  data These e a = This a | That e | These e a -instance Covariant (These e) (->) (->) where+instance Covariant (->) (->) (These e) where 	f -<$>- This x = This $ f x 	_ -<$>- That y = That y 	f -<$>- These y x = These y $ f x -instance Pointable (These e) (->) where-	point = This--instance Traversable (These e) (->) (->) where+instance Traversable (->) (->) (These e) where 	f <<- This x = This -<$>- f x 	_ <<- That y = point $ That y 	f <<- These y x = These y -<$>- f x

@@ -3,8 +3,8 @@ import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category (($), (#)) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit)) import Pandora.Pattern.Functor.Traversable (Traversable ((<<-))) import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->))) import Pandora.Pattern.Object.Setoid (Setoid ((==)))@@ -13,13 +13,15 @@ import Pandora.Paradigm.Primary.Algebraic.Exponential () import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:))) import Pandora.Paradigm.Primary.Algebraic.Sum ((:+:) (Option, Adoption))+import Pandora.Paradigm.Primary.Algebraic.One (One (One))+import Pandora.Paradigm.Primary.Algebraic (point) 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))  data Validation e a = Flaws e | Validated a -instance Covariant (Validation e) (->) (->) where+instance Covariant (->) (->) (Validation e) where 	_ -<$>- Flaws e = Flaws e 	f -<$>- Validated x = Validated $ f x 	_ -<$>- Flaws e = Flaws e@@ -27,7 +29,7 @@ 	_ -<$>- Flaws e = Flaws e 	f -<$>- Validated x = Validated $ f x -instance Covariant (Flip Validation a) (->) (->) where+instance Covariant (->) (->) (Flip Validation a) where 	f -<$>- Flip (Flaws e) = Flip . Flaws $ f e 	_ -<$>- Flip (Validated x) = Flip $ Validated x 	f -<$>- Flip (Flaws e) = Flip . Flaws $ f e@@ -35,24 +37,24 @@ 	f -<$>- Flip (Flaws e) = Flip . Flaws $ f e 	_ -<$>- Flip (Validated x) = Flip $ Validated x -instance Pointable (Validation e) (->) where-	point = Validated+instance Semigroup e => Semimonoidal (->) (:*:) (:*:) (Validation e) where+	multiply (Validated x :*: Validated y) = Validated $ x :*: y+	multiply (Flaws x :*: Flaws y) = Flaws $ x + y+	multiply (Validated _ :*: Flaws y) = Flaws y+	multiply (Flaws x :*: Validated _) = Flaws x -instance Semigroup e => Semimonoidal (Validation e) (->) (:*:) (:*:) where-	multiply_ (Validated x :*: Validated y) = Validated $ x :*: y-	multiply_ (Flaws x :*: Flaws y) = Flaws $ x + y-	multiply_ (Validated _ :*: Flaws y) = Flaws y-	multiply_ (Flaws x :*: Validated _) = Flaws x+instance Semigroup e => Monoidal (->) (->) (:*:) (:*:) (Validation e) where+	unit _ f = Validated $ f One -instance Semigroup e => Semimonoidal (Validation e) (->) (:*:) (:+:) where-	multiply_ (Flaws _ :*: y) = Adoption -<$>- y-	multiply_ (Validated x :*: _) = Option -<$>- Validated x+instance Semigroup e => Semimonoidal (->) (:*:) (:+:) (Validation e) where+	multiply (Flaws _ :*: y) = Adoption -<$>- y+	multiply (Validated x :*: _) = Option -<$>- Validated x -instance Traversable (Validation e) (->) (->) where+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 (Setoid e, Setoid a) => Setoid (Validation e a) where

@@ -2,21 +2,18 @@  import Pandora.Pattern.Category (($)) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))-import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Traversable (Traversable ((<<-))) import Pandora.Paradigm.Primary.Algebraic.Exponential ()+import Pandora.Paradigm.Primary.Algebraic (point)  data Wedge e a = Nowhere | Here e | There a -instance Covariant (Wedge e) (->) (->) where+instance Covariant (->) (->) (Wedge e) where 	_ -<$>- Nowhere = Nowhere 	_ -<$>- Here x = Here x 	f -<$>- There x = There $ f x -instance Pointable (Wedge e) (->) where-	point = There--instance Traversable (Wedge e) (->) (->) where+instance Traversable (->) (->) (Wedge e) where 	_ <<- Nowhere = point Nowhere 	_ <<- Here x = point $ Here x 	f <<- There x = There -<$>- f x

@@ -1,20 +1,31 @@ module Pandora.Paradigm.Primary.Functor.Wye where  import Pandora.Core.Functor (type (~>))-import Pandora.Pattern.Category ((#))+import Pandora.Pattern.Category ((#), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply)) import Pandora.Pattern.Object.Semigroup (Semigroup ((+))) import Pandora.Pattern.Object.Monoid (Monoid (zero))+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--))+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip)) import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (reduce))  data Wye a = End | Left a | Right a | Both a a -instance Covariant Wye (->) (->) where+instance Covariant (->) (->) Wye where 	_ -<$>- End = End 	f -<$>- Left x = Left # f x 	f -<$>- Right y = Right # f y 	f -<$>- Both x y = Both # f x # f y +instance Semimonoidal (<--) (:*:) (:*:) Wye where+	multiply = Flip $ \case+		End -> End :*: End+		Left (x :*: y) -> Left x :*: Left y+		Right (x :*: y) -> Right x :*: Right y+		Both (x :*: y) (x' :*: y') -> Both x x' :*: Both y y'+	 instance Monotonic a (Wye a) where 	reduce f r (Left x) = f x r 	reduce f r (Right x) = f x r

@@ -7,23 +7,23 @@ import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False)) import Pandora.Paradigm.Primary.Object.Ordering (Ordering (Less, Equal, Greater)) -data Denumerator = One | Denumerator Denumerator+data Denumerator = Single | Denumerator Denumerator  instance Setoid Denumerator where-	One == One = True+	Single == Single = True 	Denumerator n == Denumerator m = n == m 	_ == _ = False  instance Chain Denumerator where-	One <=> One = Equal-	One <=> Denumerator _ = Less-	Denumerator _ <=> One = Greater+	Single <=> Single = Equal+	Single <=> Denumerator _ = Less+	Denumerator _ <=> Single = Greater 	Denumerator n <=> Denumerator m = n <=> m  instance Semigroup Denumerator where-	One + m = Denumerator m+	Single + m = Denumerator m 	Denumerator n + m = Denumerator (n + m)  instance Ringoid Denumerator where-	One * n = n+	Single * n = n 	Denumerator n * m = m + n * m

@@ -8,7 +8,7 @@ import Pandora.Pattern.Object.Quasiring (Quasiring (one)) import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False)) import Pandora.Paradigm.Primary.Object.Ordering (Ordering (Less, Equal, Greater))-import Pandora.Paradigm.Primary.Object.Denumerator (Denumerator (One))+import Pandora.Paradigm.Primary.Object.Denumerator (Denumerator (Single))  data Numerator = Zero | Numerator Denumerator @@ -37,4 +37,4 @@ 	zero = Zero  instance Quasiring Numerator where-	one = Numerator One+	one = Numerator Single

@@ -4,42 +4,50 @@ import Pandora.Pattern.Category (($), (#)) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-))) import Pandora.Pattern.Functor.Contravariant (Contravariant ((->$<-)))-import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit)) import Pandora.Pattern.Functor.Traversable (Traversable ((<<-))) import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))+import Pandora.Pattern.Functor.Bivariant ((<->)) 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 ((-<*>-)) import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))-import Pandora.Paradigm.Primary.Algebraic.Exponential ((%))+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), (%))+import Pandora.Paradigm.Primary.Algebraic.One (One (One))+import Pandora.Paradigm.Primary.Algebraic (point, extract)+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip)) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))  newtype Backwards t a = Backwards (t a) -instance Covariant t (->) (->) => Covariant (Backwards t) (->) (->) where+instance Covariant (->) (->) t => Covariant (->) (->) (Backwards t) where 	f -<$>- Backwards x = Backwards $ f -<$>- x -instance Pointable t (->) => Pointable (Backwards t) (->) where-	point = Backwards . point--instance Extractable t (->) => Extractable (Backwards t) (->) where-	extract (Backwards x) = extract x- -- TODO: check that effects evaluation goes in opposite order-instance (Semimonoidal t (->) (:*:) (:*:), Covariant t (->) (->)) => Semimonoidal (Backwards t) (->) (:*:) (:*:) where-	multiply_ (Backwards x :*: Backwards y) = Backwards #+instance (Semimonoidal (->) (:*:) (:*:) t, Covariant (->) (->) t) => Semimonoidal (->) (:*:) (:*:) (Backwards t) where+	multiply (Backwards x :*: Backwards y) = Backwards # 		((:*:) %) -<$>- y -<*>- x -instance Traversable t (->) (->) => Traversable (Backwards t) (->) (->) where+instance (Covariant (->) (->) t, Monoidal (->) (->) (:*:) (:*:) t) => Monoidal (->) (->) (:*:) (:*:) (Backwards t) where+	unit _ f = Backwards . point $ f One++instance (Semimonoidal (<--) (:*:) (:*:) t, Covariant (->) (->) t) => Semimonoidal (<--) (:*:) (:*:) (Backwards t) where+	multiply = Flip $ \(Backwards x) -> +		let Flip f = multiply @(<--) @(:*:) @(:*:) in+		(Backwards <-> Backwards) $ f x++instance (Covariant (->) (->) t, Monoidal (<--) (->) (:*:) (:*:) t) => Monoidal (<--) (->) (:*:) (:*:) (Backwards t) where+	unit _ = Flip $ \(Backwards x) -> (\_ -> extract x)++instance Traversable (->) (->) t => Traversable (->) (->) (Backwards t) where 	f <<- Backwards x = Backwards -<$>- f <<- x -instance Distributive t (->) (->) => Distributive (Backwards t) (->) (->) where+instance Distributive (->) (->) t => Distributive (->) (->) (Backwards t) where 	f -<< x = Backwards $ run . f -<< x -instance Contravariant t (->) (->) => Contravariant (Backwards t) (->) (->) where+instance Contravariant (->) (->) t => Contravariant (->) (->) (Backwards t) where 	f ->$<- Backwards x = Backwards $ f ->$<- x  instance Interpreted (Backwards t) where@@ -47,10 +55,10 @@ 	run ~(Backwards x) = x 	unite = Backwards -instance Liftable Backwards where+instance Liftable (->) Backwards where 	lift = Backwards -instance Lowerable Backwards where+instance Lowerable (->) Backwards where 	lower = run  instance Hoistable Backwards where

@@ -6,20 +6,22 @@ import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category (($), (#)) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)), (-<$$>-))-import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit)) import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (-<<-<<-)) import Pandora.Pattern.Functor.Extendable (Extendable ((<<=))) import Pandora.Pattern.Functor.Comonad (Comonad)+import Pandora.Pattern.Functor.Bivariant ((<->)) import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower)) import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\), hoist)) import Pandora.Pattern.Object.Setoid (Setoid ((==))) import Pandora.Pattern.Object.Semigroup (Semigroup ((+))) import Pandora.Pattern.Object.Ringoid ((*)) import Pandora.Pattern.Object.Monoid (Monoid (zero))-import Pandora.Paradigm.Primary.Algebraic ((-<*>-))-import Pandora.Paradigm.Primary.Algebraic.Exponential ()-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:)((:*:)))+import Pandora.Paradigm.Primary.Algebraic ((-<*>-), extract)+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--))+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip)) import Pandora.Paradigm.Controlflow.Effect.Interpreted (run) import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (reduce)) import Pandora.Paradigm.Schemes (type (<:.>))@@ -28,36 +30,42 @@  data Construction t a = Construct a (t :. Construction t := a) -instance Covariant t (->) (->) => Covariant (Construction t) (->) (->) where+instance Covariant (->) (->) t => Covariant (->) (->) (Construction t) where 	f -<$>- ~(Construct x xs) = Construct # f x # f -<$$>- xs -instance Covariant t (->) (->) => Extractable (Construction t) (->) where-	extract ~(Construct x _) = x+instance (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:*:) t) => Semimonoidal (->) (:*:) (:*:) (Construction t) where+	multiply (Construct x xs :*: Construct y ys) = Construct (x :*: y) (multiply @(->) @(:*:) -<$>- multiply (xs :*: ys)) -instance (Covariant t (->) (->), Semimonoidal t (->) (:*:) (:*:)) => Semimonoidal (Construction t) (->) (:*:) (:*:) where-	multiply_ (Construct x xs :*: Construct y ys) = Construct (x :*: y) (multiply_ @_ @(->) @(:*:) -<$>- multiply_ (xs :*: ys))+instance (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t) => Semimonoidal (<--) (:*:) (:*:) (Construction t) where+	multiply = Flip $ \(Construct (x :*: y) xys) ->+		let Flip f = multiply @(<--) @(:*:) @(:*:) in+		let Flip g = multiply @(<--) @(:*:) @(:*:) in+		(Construct x <-> Construct y) $ f $ g -<$>- xys -instance Traversable t (->) (->) => Traversable (Construction t) (->) (->) where+instance (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t) => Monoidal (<--) (->) (:*:) (:*:) (Construction t) where+	unit _ = Flip $ \(Construct x _) -> (\_ -> x)++instance Traversable (->) (->) t => Traversable (->) (->) (Construction t) where 	f <<- ~(Construct x xs) = Construct -<$>- f x -<*>- f -<<-<<- xs -instance Covariant t (->) (->) => Extendable (Construction t) (->) where+instance Covariant (->) (->) t => Extendable (->) (Construction t) where 	f <<= x = Construct # f x # (f <<=) -<$>- deconstruct x -instance (Covariant t (->) (->)) => Comonad (Construction t) (->) where+instance (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t) => Comonad (Construction t) (->) where -instance Lowerable Construction where-	lower x = extract @_ @(->) -<$>- deconstruct x+instance (forall u . Semimonoidal (<--) (:*:) (:*:) u) => Lowerable (->) Construction where+	lower x = extract -<$>- deconstruct x -instance Hoistable Construction where+instance (forall u . Semimonoidal (<--) (:*:) (:*:) u) => Hoistable Construction where 	f /|\ x = Construct # extract x $ f # hoist f -<$>- deconstruct x -instance (Setoid a, forall b . Setoid b => Setoid (t b), Covariant t (->) (->)) => Setoid (Construction t a) where+instance (Setoid a, forall b . Setoid b => Setoid (t b), Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t) => Setoid (Construction t a) where 	x == y = (extract x == extract y) * (deconstruct x == deconstruct y) -instance (Semigroup a, forall b . Semigroup b => Semigroup (t b), Covariant t (->) (->)) => Semigroup (Construction t a) where+instance (Semigroup a, forall b . Semigroup b => Semigroup (t b), Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t) => Semigroup (Construction t a) where 	x + y = Construct # extract x + extract y # deconstruct x + deconstruct y -instance (Monoid a, forall b . Semigroup b => Monoid (t b), Covariant t (->) (->)) => Monoid (Construction t a) where+instance (Monoid a, forall b . Semigroup b => Monoid (t b), Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t) => Monoid (Construction t a) where 	zero = Construct zero zero  instance Monotonic a (t :. Construction t := a) => Monotonic a (Construction t a) where@@ -70,8 +78,8 @@ deconstruct ~(Construct _ xs) = xs  -- Generate a construction from seed using effectful computation-(.-+) :: Covariant t (->) (->) => a :=> t -> a :=> Construction t+(.-+) :: Covariant (->) (->) t => a :=> t -> a :=> Construction t f .-+ x = Construct x $ (f .-+) -<$>- f x -section :: Comonad t (->) => t ~> Construction t+section :: (Comonad t (->), Monoidal (<--) (->) (:*:) (:*:) t) => t ~> Construction t section xs = Construct # extract xs $ section <<= xs

@@ -5,12 +5,14 @@ import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category (($), (#)) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))-import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Monoidal (Monoidal) 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.Algebraic.Exponential ((!.), (%))+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))+import Pandora.Paradigm.Primary.Algebraic (point)  newtype Continuation r t a = Continuation ((->) ::|:. a :. t := r) @@ -19,18 +21,15 @@ 	run ~(Continuation x) = x 	unite = Continuation -instance Covariant t (->) (->) => Covariant (Continuation r t) (->) (->) where+instance Covariant (->) (->) t => Covariant (->) (->) (Continuation r t) where 	f -<$>- Continuation continuation = Continuation $ continuation . (. f) -instance Covariant t (->) (->) => Pointable (Continuation r t) (->) where-	point x = Continuation ($ x)--instance Covariant t (->) (->) => Bindable (Continuation r t) (->) where+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 Monad t => Monad (Continuation r t) where -instance (forall u . Bindable u (->)) => Liftable (Continuation r) where+instance (forall u . Bindable (->) u) => Liftable (->) (Continuation r) where 	lift = Continuation . (%) (=<<)  -- | Call with current continuation@@ -38,12 +37,12 @@ cwcc f = Continuation $ \g -> (run % g) . f $ Continuation . (!.) . g  -- | Delimit the continuation of any 'shift'-reset :: (forall u . Bindable u (->), Monad 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-shift :: Pointable t (->) => ((a -> t r) -> Continuation r t r) -> Continuation r t a+shift :: Monoidal (->) (->) (:*:) (:*:) t => ((a -> t r) -> Continuation r t r) -> Continuation r t a shift f = Continuation $ (run % point) . f -interruptable :: Pointable t (->) => ((a -> Continuation a t a) -> Continuation a t a) -> t a+interruptable :: Monoidal (->) (->) (:*:) (:*:) t => ((a -> Continuation a t a) -> Continuation a t a) -> t a interruptable = (run % point) . cwcc

@@ -4,29 +4,17 @@  import Pandora.Pattern.Category ((#)) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))-import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower)) import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\))) import Pandora.Paradigm.Primary.Algebraic.Exponential ((!..), (-.#..-))  data Day t u a = forall b c . Day (t b) (u c) (b -> c -> a) -instance Covariant (Day t u) (->) (->) where+instance Covariant (->) (->) (Day t u) where 	f -<$>- Day tb uc g = Day tb uc # f -.#..- g -instance (Pointable t (->), Pointable u (->)) => Pointable (Day t u) (->) where-	point x = Day # point () # point () # (x !..)--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+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  instance Hoistable (Day t) where 	g /|\ Day tb uc bca = Day tb # g uc # bca

@@ -5,8 +5,8 @@ import Pandora.Core.Functor (type (:.), type (:=)) import Pandora.Pattern.Category (($)) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)), (-<$$>-))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit)) import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (-<<-<<-)) import Pandora.Pattern.Functor.Bindable (Bindable ((=<<))) import Pandora.Pattern.Functor.Monad (Monad)@@ -15,39 +15,41 @@ import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\), hoist)) import Pandora.Paradigm.Primary.Algebraic.Exponential () import Pandora.Paradigm.Primary.Algebraic.Product ((:*:)((:*:)))+import Pandora.Paradigm.Primary.Algebraic.One (One (One))+import Pandora.Paradigm.Primary.Algebraic (point)  data Instruction t a = Enter a | Instruct (t :. Instruction t := a) -instance Covariant t (->) (->) => Covariant (Instruction t) (->) (->) where+instance Covariant (->) (->) t => Covariant (->) (->) (Instruction t) where 	f -<$>- Enter x = Enter $ f x 	f -<$>- Instruct xs = Instruct $ f -<$$>- xs -instance Covariant t (->) (->) => Pointable (Instruction t) (->) where-	point = Enter+instance (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:*:) t) => Semimonoidal (->) (:*:) (:*:) (Instruction t) where+	multiply (Enter x :*: Enter y) = Enter $ x :*: y+	multiply (Enter x :*: Instruct y) = (x :*:) -<$>- Instruct y+	multiply (Instruct x :*: Enter y) = (:*: y) -<$>- Instruct x+	multiply (Instruct x :*: Instruct y) = Instruct $ multiply @(->) @(:*:) -<$>- multiply (x :*: y) -instance (Covariant t (->) (->), Semimonoidal t (->) (:*:) (:*:)) => Semimonoidal (Instruction t) (->) (:*:) (:*:) where-	multiply_ (Enter x :*: Enter y) = Enter $ x :*: y-	multiply_ (Enter x :*: Instruct y) = (x :*:) -<$>- Instruct y-	multiply_ (Instruct x :*: Enter y) = (:*: y) -<$>- Instruct x-	multiply_ (Instruct x :*: Instruct y) = Instruct $ multiply_ @_ @(->) @(:*:) -<$>- multiply_ (x :*: y)+instance (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:*:) t) => Monoidal (->) (->) (:*:) (:*:) (Instruction t) where+	unit _ f = Enter $ f One -instance Covariant t (->) (->) => Bindable (Instruction t) (->) where+instance Covariant (->) (->) t => Bindable (->) (Instruction t) where 	f =<< Enter x = f x 	f =<< Instruct xs = Instruct $ (f =<<) -<$>- xs  instance Monad t => Monad (Instruction t) where -instance Traversable t (->) (->) => Traversable (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+instance Liftable (->) Instruction where 	lift x = Instruct $ Enter -<$>- x -instance (forall t . Bindable t (->), forall t . Pointable t (->)) => Lowerable Instruction where+instance (forall t . Bindable (->) t, forall t . Monoidal (->) (->) (:*:) (:*:) t) => Lowerable (->) Instruction where 	lower (Enter x) = point x 	lower (Instruct xs) = lower =<< xs -instance (forall v . Covariant v (->) (->)) => Hoistable Instruction where+instance (forall v . Covariant (->) (->) v) => Hoistable Instruction where 	_ /|\ Enter x = Enter x 	f /|\ Instruct xs = Instruct $ hoist f -<$>- f xs

@@ -5,8 +5,7 @@ import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category (identity, ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Extractable (Extractable (extract))+import Pandora.Pattern.Functor.Monoidal (Monoidal) import Pandora.Pattern.Functor.Traversable (Traversable ((<<-))) import Pandora.Pattern.Functor.Bindable (Bindable ((=<<))) import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))@@ -15,35 +14,30 @@ import Pandora.Pattern.Object.Setoid (Setoid ((==))) import Pandora.Pattern.Object.Chain (Chain ((<=>))) import Pandora.Paradigm.Primary.Algebraic.Exponential ()+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))+import Pandora.Paradigm.Primary.Algebraic (point) import Pandora.Paradigm.Primary.Object.Boolean (Boolean (False)) import Pandora.Paradigm.Primary.Object.Ordering (Ordering (Less, Greater))  data Jack t a = It a | Other (t a) -instance Covariant t (->) (->) => Covariant (Jack t) (->) (->) where+instance Covariant (->) (->) t => Covariant (->) (->) (Jack t) where 	f -<$>- It x = It $ f x 	f -<$>- Other y = Other $ f -<$>- y -instance Covariant t (->) (->) => Pointable (Jack t) (->) where-	point = It--instance Extractable t (->) => Extractable (Jack t) (->) where-	extract (It x) = x-	extract (Other y) = extract y--instance Traversable t (->) (->) => Traversable (Jack t) (->) (->) where+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+instance (Monoidal (->) (->) (:*:) (:*:) 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+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+instance Liftable (->) Jack where 	lift = Other  instance Hoistable Jack where

@@ -3,17 +3,13 @@ module Pandora.Paradigm.Primary.Transformer.Jet where  import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)), (-<$$>-))-import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (-<<-<<-)) import Pandora.Paradigm.Primary.Algebraic ((-<*>-))  data Jet t a = Jet a (Jet t (t a)) -instance Covariant t (->) (->) => Covariant (Jet t) (->) (->) where+instance Covariant (->) (->) t => Covariant (->) (->) (Jet t) where 	f -<$>- Jet x xs = Jet (f x) (f -<$$>- xs) -instance Traversable t (->) (->) => Traversable (Jet t) (->) (->) where+instance Traversable (->) (->) t => Traversable (->) (->) (Jet t) where 	f <<- Jet x xs = Jet -<$>- f x -<*>- f -<<-<<- xs--instance Covariant t (->) (->) => Extractable (Jet t) (->) where-	extract (Jet x _) = x

@@ -11,7 +11,7 @@  data instance Kan Left t u b a = Lan ((t b -> a) -> u b) -instance Contravariant (Kan Left t u b) (->) (->) where+instance Contravariant (->) (->) (Kan Left t u b) where 	f ->$<- Lan x = Lan $ x . (f .)  instance Interpreted (Kan Left t u b) where@@ -21,7 +21,7 @@  data instance Kan Right t u b a = Ran ((a -> t b) -> u b) -instance Covariant (Kan Right t u b) (->) (->) where+instance Covariant (->) (->) (Kan Right t u b) where 	f -<$>- Ran x = Ran $ x . (. f)  instance Interpreted (Kan Right t u b) where

@@ -5,8 +5,6 @@ import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category (identity, ($), (#)) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Transformer.Liftable (Liftable (lift)) import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\))) import Pandora.Paradigm.Primary.Algebraic.Exponential ()@@ -15,18 +13,11 @@ 	Line :: a -> Outline t a 	Outlined :: t a -> Outline t (a -> b) -> Outline t b -instance Covariant (Outline t) (->) (->) where+instance Covariant (->) (->) (Outline t) where 	f -<$>- Line a = Line $ f a 	f -<$>- Outlined x y = Outlined x # (.) f -<$>- y -instance Pointable (Outline t) (->) where-	point = Line--instance Extractable t (->) => Extractable (Outline t) (->) where-	extract (Line x) = x-	extract (Outlined x y) = extract y # extract x--instance Liftable Outline where+instance Liftable (->) Outline where 	lift t = Outlined t (Line identity)  instance Hoistable Outline where

@@ -6,34 +6,48 @@ import Pandora.Pattern.Category (($), (#)) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-))) import Pandora.Pattern.Functor.Contravariant (Contravariant ((->$<-)))-import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit)) import Pandora.Pattern.Functor.Traversable (Traversable ((<<-))) import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))+import Pandora.Pattern.Functor.Bivariant ((<->)) import Pandora.Pattern.Transformer.Liftable (Liftable (lift)) import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower)) import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\))) import Pandora.Paradigm.Primary.Transformer.Backwards (Backwards (Backwards))+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--))+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))+import Pandora.Paradigm.Primary.Algebraic.One (One (One))+import Pandora.Paradigm.Primary.Algebraic (point, extract)+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip)) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))  newtype Reverse t a = Reverse (t a) -instance Covariant t (->) (->) => Covariant (Reverse t) (->) (->) where+instance Covariant (->) (->) t => Covariant (->) (->) (Reverse t) where 	f -<$>- Reverse x = Reverse # f -<$>- x -instance Pointable t (->) => Pointable (Reverse t) (->) where-	point = Reverse . point+instance (Semimonoidal (->) (:*:) (:*:) t, Covariant (->) (->) t) => Semimonoidal (->) (:*:) (:*:) (Reverse t) where+	multiply (Reverse x :*: Reverse y) = Reverse # multiply (x :*: y) -instance Extractable t (->) => Extractable (Reverse t) (->) where-	extract (Reverse x) = extract x+instance (Covariant (->) (->) t, Monoidal (->) (->) (:*:) (:*:) t) => Monoidal (->) (->) (:*:) (:*:) (Reverse t) where+	unit _ f = Reverse . point $ f One -instance Traversable t (->) (->) => Traversable (Reverse t) (->) (->) where+instance (Semimonoidal (<--) (:*:) (:*:) t, Covariant (->) (->) t) => Semimonoidal (<--) (:*:) (:*:) (Reverse t) where+	multiply = Flip $ \(Reverse x) -> +		let Flip f = multiply @(<--) @(:*:) @(:*:) in+		(Reverse <-> Reverse) $ f x++instance (Covariant (->) (->) t, Monoidal (<--) (->) (:*:) (:*:) t) => Monoidal (<--) (->) (:*:) (:*:) (Reverse t) where+	unit _ = Flip $ \(Reverse x) -> (\_ -> extract x)++instance Traversable (->) (->) t => Traversable (->) (->) (Reverse t) where 	f <<- Reverse x = Reverse -<$>- run (Backwards . f <<- x) -instance Distributive t (->) (->) => Distributive (Reverse t) (->) (->) where+instance Distributive (->) (->) t => Distributive (->) (->) (Reverse t) where 	f -<< x = Reverse $ run . f -<< x -instance Contravariant t (->) (->) => Contravariant (Reverse t) (->) (->) where+instance Contravariant (->) (->) t => Contravariant (->) (->) (Reverse t) where 	f ->$<- Reverse x = Reverse # f ->$<- x  instance Interpreted (Reverse t) where@@ -41,10 +55,10 @@ 	run ~(Reverse x) = x 	unite = Reverse -instance Liftable Reverse where+instance Liftable (->) Reverse where 	lift = Reverse -instance Lowerable Reverse where+instance Lowerable (->) Reverse where 	lower = run  instance Hoistable Reverse where

@@ -6,8 +6,8 @@ import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category (($), (#)) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))-import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit)) import Pandora.Pattern.Functor.Traversable (Traversable ((<<-))) import Pandora.Pattern.Functor.Extendable (Extendable ((<<=))) import Pandora.Pattern.Transformer.Liftable (Liftable (lift))@@ -15,11 +15,12 @@ import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\))) import Pandora.Paradigm.Inventory.Store (Store (Store)) import Pandora.Paradigm.Controlflow.Effect.Interpreted (run) -import Pandora.Paradigm.Primary.Algebraic ((-<*>-))+import Pandora.Paradigm.Primary.Algebraic ((-<*>-), extract) import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), twosome)-import Pandora.Paradigm.Primary.Algebraic.Exponential ((%))+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), (%)) import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity)) import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip)) 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))@@ -28,48 +29,53 @@  data Tap t a = Tap a (t a) -instance Covariant t (->) (->) => Covariant (Tap t) (->) (->) where+instance Covariant (->) (->) t => Covariant (->) (->) (Tap t) where 	f -<$>- Tap x xs = Tap # f x # f -<$>- xs -instance (Covariant t (->) (->)) => Extractable (Tap t) (->) where-	extract (Tap x _) = x+instance Semimonoidal (->) (:*:) (:*:) t => Semimonoidal (->) (:*:) (:*:) (Tap t) where+	multiply (Tap x xs :*: Tap y ys) = Tap (x :*: y) $ multiply $ xs :*: ys -instance Semimonoidal t (->) (:*:) (:*:) => Semimonoidal (Tap t) (->) (:*:) (:*:) where-	multiply_ (Tap x xs :*: Tap y ys) = Tap (x :*: y) $ multiply_ $ xs :*: ys+instance Semimonoidal (<--) (:*:) (:*:) t => Semimonoidal (<--) (:*:) (:*:) (Tap t) where+	multiply = Flip $ \(Tap (x :*: y) xys) -> +		let Flip f = multiply @(<--) @(:*:) @(:*:) in+		let (xs :*: ys) = f xys in Tap x xs :*: Tap y ys -instance Traversable t (->) (->) => Traversable (Tap t) (->) (->) where+instance Semimonoidal (<--) (:*:) (:*:) t => Monoidal (<--) (->) (:*:) (:*:) (Tap t) where+	unit _ = Flip $ \(Tap x _) -> (\_ -> x)++instance Traversable (->) (->) t => Traversable (->) (->) (Tap t) where 	f <<- Tap x xs = Tap -<$>- f x -<*>- f <<- xs -instance (Extendable t (->), Covariant t (->) (->)) => Extendable (Tap t) (->) where+instance (Semimonoidal (<--) (:*:) (:*:) t, Extendable (->) t, Covariant (->) (->) t) => Extendable (->) (Tap t) where 	f <<= x = Tap # f x $ f . Tap (extract x) <<= lower x -instance Lowerable Tap where+instance Lowerable (->) Tap where 	lower (Tap _ xs) = xs  instance Hoistable Tap where 	f /|\ Tap x xs = Tap x # f xs -instance Semimonoidal t (->) (:*:) (:*:) => Semimonoidal (Tap (t <:.:> t := (:*:))) (->) (:*:) (:*:) where-	multiply_ (Tap x (T_U (xls :*: xrs)) :*: Tap y (T_U (yls :*: yrs))) = Tap (x :*: y)-		$ T_U $ multiply_ (xls :*: yls) :*: multiply_ (xrs :*: yrs)+instance {-# OVERLAPS #-} Semimonoidal (->) (:*:) (:*:) t => Semimonoidal (->) (:*:) (:*:) (Tap (t <:.:> t := (:*:))) where+	multiply (Tap x (T_U (xls :*: xrs)) :*: Tap y (T_U (yls :*: yrs))) = Tap (x :*: y)+		$ T_U $ multiply (xls :*: yls) :*: multiply (xrs :*: yrs) -instance {-# OVERLAPS #-} Traversable t (->) (->) => Traversable (Tap (t <:.:> t := (:*:))) (->) (->) where+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 (->) (->)) => Substructure Root (Tap (t <:.:> t := (:*:))) where+instance (Covariant (->) (->) t) => Substructure Root (Tap (t <:.:> t := (:*:))) where 	type Available Root (Tap (t <:.:> t := (:*:))) = Identity 	type Substance Root (Tap (t <:.:> t := (:*:))) = Identity 	substructure = P_Q_T $ \zipper -> case lower zipper of 		Tap x xs -> Store $ Identity (Identity x) :*: lift . (Tap % xs) . extract . extract -instance (Covariant t (->) (->)) => Substructure Left (Tap (t <:.:> t := (:*:))) where+instance (Covariant (->) (->) t) => Substructure Left (Tap (t <:.:> t := (:*:))) where 	type Available Left (Tap (t <:.:> t := (:*:))) = Identity 	type Substance Left (Tap (t <:.:> t := (:*:))) = t 	substructure = P_Q_T $ \zipper -> case lower zipper of 		Tap x (T_U (future :*: past)) -> Store $ Identity future :*: lift . Tap x . T_U . (:*: past) . extract -instance (Covariant t (->) (->)) => Substructure Right (Tap (t <:.:> t := (:*:))) where+instance (Covariant (->) (->) t) => Substructure Right (Tap (t <:.:> t := (:*:))) where 	type Available Right (Tap (t <:.:> t := (:*:))) = Identity 	type Substance Right (Tap (t <:.:> t := (:*:))) = t 	substructure = P_Q_T $ \zipper -> case lower zipper of

@@ -3,29 +3,15 @@ module Pandora.Paradigm.Primary.Transformer.Yoneda where  import Pandora.Pattern.Semigroupoid ((.))-import Pandora.Pattern.Category (identity, ($), (#)) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-))) import Pandora.Pattern.Transformer.Liftable (Liftable (lift)) import Pandora.Paradigm.Primary.Algebraic.Exponential ()  newtype Yoneda t a = Yoneda 	{ yoneda :: forall b . (a -> b) -> t b } -instance Covariant (Yoneda t) (->) (->) where+instance Covariant (->) (->) (Yoneda t) where 	f -<$>- x = Yoneda (\k -> yoneda x (k . f)) -instance Pointable t (->) => Pointable (Yoneda t) (->) where-	point x = Yoneda (\f -> point $ f x)--instance Extractable t (->) => Extractable (Yoneda t) (->) where-	extract (Yoneda f) = extract $ f identity--instance Liftable Yoneda where+instance Liftable (->) Yoneda where 	lift x = Yoneda (-<$>- 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

@@ -20,29 +20,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 (->) (->))+instance (Covariant (->) (->) (v <:.> t), Covariant (->) (->) (u <:.> w), Adjoint (->) (->) t u, Adjoint (->) (->) v w) -	=> Adjoint (v <:.> t) (u <:.> w) (->) (->) where+	=> 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+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+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+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+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 		g |- TUT x = ((run . g |-) |-) |- x 		f -| x = TUT $  ((f . TUT -|) -|) -| x

@@ -5,17 +5,22 @@ import Pandora.Pattern.Category (($), identity) import Pandora.Pattern.Functor.Covariant (Covariant, Covariant ((-<$>-)), (-<$$>-)) import Pandora.Pattern.Functor.Contravariant (Contravariant)-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Extractable (Extractable (extract))+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit)) import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (-<<-<<-)) import Pandora.Pattern.Functor.Distributive (Distributive ((-<<))) import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))+import Pandora.Pattern.Functor.Bivariant ((<->)) import Pandora.Pattern.Transformer.Liftable (Liftable (lift)) import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower)) import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\))) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:)((:*:)))+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--))+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))+import Pandora.Paradigm.Primary.Algebraic.Sum ((:+:) (Option, Adoption), sum)+import Pandora.Paradigm.Primary.Algebraic.One (One (One))+import Pandora.Paradigm.Primary.Algebraic (empty, point, extract)+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))  newtype TU ct cu t u a = TU (t :. u := a) @@ -31,32 +36,44 @@ 	run ~(TU x) = x 	unite = TU -instance (Covariant t (->) (->), Covariant u (->) (->)) => Covariant (t <:.> u) (->) (->) where+instance (Covariant (->) (->) t, Covariant (->) (->) u) => Covariant (->) (->) (t <:.> u) where 	f -<$>- x = TU $ f -<$$>- run x -instance (Covariant t (->) (->), Semimonoidal t (->) (:*:) (:*:), Semimonoidal u (->) (:*:) (:*:)) => Semimonoidal (t <:.> u) (->) (:*:) (:*:) where-	multiply_ (TU x :*: TU y) = TU $ multiply_ @_ @(->) @(:*:) -<$>- multiply_ (x :*: y)+instance (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:*:) t, Semimonoidal (->) (:*:) (:*:) u) => Semimonoidal (->) (:*:) (:*:) (t <:.> u) where+	multiply (TU x :*: TU y) = TU $ multiply @(->) @(:*:) -<$>- multiply (x :*: y) -instance (Pointable t (->), Pointable u (->)) => Pointable (t <:.> u) (->) where-	point = TU . point . point+instance (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (->) (:*:) (:*:) u, Monoidal (->) (->) (:*:) (:*:) t, Monoidal (->) (->) (:*:) (:*:) u) => Monoidal (->) (->) (:*:) (:*:) (t <:.> u) where+	unit _ f = TU . point . point $ f One -instance (Extractable t (->), Extractable u (->)) => Extractable (t <:.> u) (->) where-	extract = extract . extract . run+instance (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (->) (:*:) (:+:) t) => Semimonoidal (->) (:*:) (:+:) (t <:.> u) where+	multiply (TU x :*: TU y) = TU $ sum (Option -<$>-) (Adoption -<$>-) -<$>- multiply @(->) @(:*:) @(:+:) (x :*: y) -instance (Traversable t (->) (->), Traversable u (->) (->)) => Traversable (t <:.> u) (->) (->) where+instance (Covariant (->) (->) t, Covariant (->) (->) u, Monoidal (->) (->) (:*:) (:+:) t) => Monoidal (->) (->) (:*:) (:+:) (t <:.> u) where+	unit _ _ = TU empty++instance (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t, Semimonoidal (<--) (:*:) (:*:) u) => Semimonoidal (<--) (:*:) (:*:) (t <:.> u) where+	multiply = Flip $ \(TU xys) ->+		let Flip f = multiply @(<--) @(:*:) @(:*:) in+		let Flip g = multiply @(<--) @(:*:) @(:*:) in+		(TU <-> TU) $ g (f -<$>- xys) where++instance (Covariant (->) (->) t, Monoidal (<--) (->) (:*:) (:*:) t, Monoidal (<--) (->) (:*:) (:*:) u) => Monoidal (<--) (->) (:*:) (:*:) (t <:.> u) where+	unit _ = Flip $ \(TU x) -> (\_ -> extract $ extract x)++instance (Traversable (->) (->) t, Traversable (->) (->) u) => Traversable (->) (->) (t <:.> u) where 	f <<- x = TU -<$>- f -<<-<<- run x -instance (Bindable t (->), Distributive t (->) (->), Covariant u (->) (->), Bindable u (->)) => Bindable (t <:.> u) (->) where+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+instance Monoidal (->) (->) (:*:) (:*:) t => Liftable (->) (TU Covariant Covariant t) where+	lift :: Covariant (->) (->) u => u ~> t <:.> u 	lift = TU . point -instance Extractable t (->) => Lowerable (TU Covariant Covariant t) where+instance Monoidal (<--) (->) (:*:) (:*:) t => Lowerable (->) (TU Covariant Covariant t) where 	lower :: t <:.> u ~> u 	lower (TU x) = extract x -instance Covariant t (->) (->) => Hoistable (TU Covariant Covariant t) where+instance Covariant (->) (->) t => Hoistable (TU Covariant Covariant t) where 	(/|\) :: u ~> v -> (t <:.> u ~> t <:.> v) 	f /|\ TU x = TU $ f -<$>- x

@@ -5,15 +5,20 @@ import Pandora.Pattern.Category (identity, ($)) import Pandora.Pattern.Functor.Covariant (Covariant, Covariant ((-<$>-)), (-<$$>-), (-<$$$>-)) import Pandora.Pattern.Functor.Contravariant (Contravariant)-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Extractable (Extractable (extract))+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit)) import Pandora.Pattern.Functor.Extendable (Extendable ((<<=))) import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))+import Pandora.Pattern.Functor.Bivariant ((<->)) import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-))) import Pandora.Pattern.Transformer.Liftable (Liftable (lift)) import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--)) import Pandora.Paradigm.Primary.Algebraic.Product ((:*:)((:*:)))+import Pandora.Paradigm.Primary.Algebraic.One (One (One))+import Pandora.Paradigm.Primary.Algebraic (point, extract)+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip)) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))  newtype TUT ct ct' cu t t' u a = TUT (t :. u :. t' := a)@@ -34,25 +39,35 @@ 	run ~(TUT x) = x 	unite = TUT -instance (Covariant t (->) (->), Covariant t' (->) (->), Covariant u (->) (->)) => Covariant (t <:<.>:> t' := u) (->) (->) where+instance (Covariant (->) (->) t, Covariant (->) (->) t', Covariant (->) (->) u) => Covariant (->) (->) (t <:<.>:> t' := u) where 	f -<$>- TUT x = TUT $ f -<$$$>- x -instance (Covariant t (->) (->), Covariant t' (->) (->), Covariant u (->) (->), Semimonoidal t (->) (:*:) (:*:), Semimonoidal u (->) (:*:) (:*:), Semimonoidal t' (->) (:*:) (:*:)) => Semimonoidal (t <:<.>:> t' := u) (->) (:*:) (:*:) where-	multiply_ (TUT x :*: TUT y) = TUT $ multiply_ @_ @(->) @(:*:) -<$$>- multiply_ @_ @(->) @(:*:) -<$>- multiply_ (x :*: y)+instance (Covariant (->) (->) t, Covariant (->) (->) t', Covariant (->) (->) u, Semimonoidal (->) (:*:) (:*:) t, Semimonoidal (->) (:*:) (:*:) u, Semimonoidal (->) (:*:) (:*:) t') => Semimonoidal (->) (:*:) (:*:) (t <:<.>:> t' := u) where+	multiply (TUT x :*: TUT y) = TUT $ multiply @(->) @(:*:) -<$$>- multiply @(->) @(:*:) -<$>- multiply (x :*: y) -instance (Covariant t (->) (->), Covariant t' (->) (->), Pointable u (->), Adjoint t' t (->) (->)) => Pointable (t <:<.>:> t' := u) (->) where-	point = unite . (point @_ @(->) -|)+instance (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t, Covariant (->) (->) u, Semimonoidal (<--) (:*:) (:*:) u, Covariant (->) (->) t', Semimonoidal (<--) (:*:) (:*:) t') => Semimonoidal (<--) (:*:) (:*:) (t <:<.>:> t' := u) where+	multiply = Flip $ \(TUT xys) ->+		let Flip f = multiply @(<--) @(:*:) @(:*:) in+		let Flip g = multiply @(<--) @(:*:) @(:*:) in+		let Flip h = multiply @(<--) @(:*:) @(:*:) in+		(TUT <-> TUT) $ f (g -<$>- (h -<$$>- xys)) where -instance (Adjoint t' t (->) (->), Extendable u (->)) => Extendable (t' <:<.>:> t := u) (->) where-	f <<= x = TUT $ ((f . unite -|) <<=) -<$>- run x+instance (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (<--) (:*:) (:*:) t, Semimonoidal (<--) (:*:) (:*:) t', Monoidal (<--) (->) (:*:) (:*:) u, Adjoint (->) (->) t t') => Monoidal (<--) (->) (:*:) (:*:) (t <:<.>:> t' := u) where+	unit _ = Flip $ \(TUT xys) -> (\_ -> (extract |-) xys) -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, Bindable (->) u) => Bindable (->) (t <:<.>:> t' := u) where+	f =<< x = TUT $ ((run . f |-) =<<) -<$>- run x -instance (Adjoint t' t (->) (->), Distributive t(->) (->) ) => Liftable (t <:<.>:> t') where-	lift :: Covariant u (->) (->) => u ~> t <:<.>:> t' := u+instance (Covariant (->) (->) t, Covariant (->) (->) u, Covariant (->) (->) t', Semimonoidal (->) (:*:) (:*:) t, Semimonoidal (->) (:*:) (:*:) t', Monoidal (->) (->) (:*:) (:*:) u, Adjoint (->) (->) t' t) => Monoidal (->) (->) (:*:) (:*:) (t <:<.>:> t' := u) where+	unit _ f = unite . (point -|) . f $ One++instance (Adjoint (->) (->) t' t, Extendable (->) u) => Extendable (->) (t' <:<.>:> t := u) where+	f <<= x = TUT $ ((f . unite -|) <<=) -<$>- run x++instance (Adjoint (->) (->) t' t, Distributive (->) (->) t) => Liftable (->) (t <:<.>:> t') where+	lift :: Covariant (->) (->) u => u ~> t <:<.>:> t' := u 	lift x = TUT $ (identity @(->) -|) -<< x -instance (Adjoint t t' (->) (->), Distributive t'(->) (->) ) => Lowerable (t <:<.>:> t') where-	lower :: Covariant u (->) (->) => (t <:<.>:> t' := u) ~> u+instance (Adjoint (->) (->) t t', Distributive (->) (->) t') => Lowerable (->) (t <:<.>:> t') where+	lower :: Covariant (->) (->) u => (t <:<.>:> t' := u) ~> u 	lower (TUT x) = (identity @(->) -<<) |- x

@@ -21,11 +21,11 @@ 	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 (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

@@ -5,15 +5,18 @@ import Pandora.Pattern.Category (($), identity) import Pandora.Pattern.Functor.Covariant (Covariant, Covariant ((-<$>-)), (-<$$>-)) import Pandora.Pattern.Functor.Contravariant (Contravariant)-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))-import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit)) import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))-import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))+import Pandora.Pattern.Functor.Bivariant ((<->)) 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 ((:*:) ((:*:)))+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--))+import Pandora.Paradigm.Primary.Algebraic.One (One (One))+import Pandora.Paradigm.Primary.Algebraic ((:*:) ((:*:)), point, extract)+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))  newtype UT ct cu t u a = UT (u :. t := a) @@ -29,25 +32,31 @@ 	run ~(UT x) = x 	unite = UT -instance (Covariant t (->) (->), Covariant u (->) (->)) => Covariant (t <.:> u) (->) (->) where+instance (Covariant (->) (->) t, Covariant (->) (->) u) => Covariant (->) (->) (t <.:> u) where 	f -<$>- x = UT $ f -<$$>- run x -instance (Covariant u (->) (->), Semimonoidal t (->) (:*:) (:*:), Semimonoidal u (->) (:*:) (:*:)) => Semimonoidal (t <.:> u) (->) (:*:) (:*:) where-	multiply_ (UT x :*: UT y) = UT $ multiply_ @_ @(->) @(:*:) -<$>- multiply_ (x :*: y)+instance (Covariant (->) (->) u, Semimonoidal (->) (:*:) (:*:) t, Semimonoidal (->) (:*:) (:*:) u) => Semimonoidal (->) (:*:) (:*:) (t <.:> u) where+	multiply (UT x :*: UT y) = UT $ multiply @(->) @(:*:) -<$>- multiply (x :*: y) -instance (Pointable t (->), Pointable u (->)) => Pointable (t <.:> u) (->) where-	point = UT . point . point+instance (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (->) (:*:) (:*:) u, Monoidal (->) (->) (:*:) (:*:) t, Monoidal (->) (->) (:*:) (:*:) u) => Monoidal (->) (->) (:*:) (:*:) (t <.:> u) where+	unit _ f = UT . point . point $ f One -instance (Traversable t (->) (->), Bindable t (->), Semimonoidal u (->) (:*:) (:*:), Pointable u (->), Bindable u (->)) => Bindable (t <.:> u) (->) where+instance (Traversable (->) (->) t, Bindable (->) t, Semimonoidal (->) (:*:) (:*:) u, Monoidal (->) (->) (:*:) (:*:) 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+instance (Covariant (->) (->) u, Semimonoidal (<--) (:*:) (:*:) t, Semimonoidal (<--) (:*:) (:*:) u) => Semimonoidal (<--) (:*:) (:*:) (t <.:> u) where+	multiply = Flip $ \(UT xys) ->+		let Flip f = multiply @(<--) @(:*:) @(:*:) in+		let Flip g = multiply @(<--) @(:*:) @(:*:) in+		(UT <-> UT) $ f (g -<$>- xys) where -instance Pointable t (->) => Liftable (UT Covariant Covariant t) where-	lift :: Covariant u (->) (->) => u ~> t <.:> u-	lift x = UT $ point @_ @(->) -<$>- x+instance (Covariant (->) (->) u, Monoidal (<--) (->) (:*:) (:*:) t, Monoidal (<--) (->) (:*:) (:*:) u) => Monoidal (<--) (->) (:*:) (:*:) (t <.:> u) where+	unit _ = Flip $ \(UT x) -> (\_ -> extract $ extract x) -instance Extractable t (->) => Lowerable (UT Covariant Covariant t) where-	lower :: Covariant u (->) (->) => t <.:> u ~> u-	lower (UT x) = extract @_ @(->) -<$>- x+instance Monoidal (->) (->) (:*:) (:*:) t => Liftable (->) (UT Covariant Covariant t) where+	lift :: Covariant (->) (->) u => u ~> t <.:> u+	lift x = UT $ point -<$>- x++instance Monoidal (<--) (->) (:*:) (:*:) t => Lowerable (->) (UT Covariant Covariant t) where+	lower :: Covariant (->) (->) u => t <.:> u ~> u+	lower (UT x) = extract -<$>- x

@@ -11,7 +11,6 @@ import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category (($), (#)) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))-import Pandora.Pattern.Functor.Extractable (extract) import Pandora.Pattern.Transformer.Liftable (lift) import Pandora.Pattern.Transformer.Lowerable (lower) import Pandora.Pattern.Object.Semigroup ((+))@@ -20,6 +19,7 @@ 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.Algebraic (extract) import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False)) import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity)) import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))@@ -38,7 +38,7 @@ instance Nullable Maybe where 	null = Predicate $ \case { Just _ -> True ; _ -> False } -instance (Covariant t (->) (->)) => Substructure Tail (Tap t) where+instance (Covariant (->) (->) t) => Substructure Tail (Tap t) where 	type Available Tail (Tap t) = Identity 	type Substance Tail (Tap t) = t 	substructure = P_Q_T $ \tap -> case extract # run tap of@@ -90,13 +90,13 @@ instance {-# OVERLAPS #-} Accessible b a => Accessible b (s :*: a) where 	access = access @b . access @a -instance (Covariant t (->) (->)) => Substructure Left (t <:.:> t := (:*:)) where+instance (Covariant (->) (->) t) => Substructure Left (t <:.:> t := (:*:)) where 	type Available Left (t <:.:> t := (:*:)) = Identity 	type Substance Left (t <:.:> t := (:*:)) = t 	substructure = P_Q_T $ \x -> case run # lower x of 		ls :*: rs -> Store $ Identity ls :*: lift . (twosome % rs) . extract -instance (Covariant t (->) (->)) => Substructure Right (t <:.:> t := (:*:)) where+instance (Covariant (->) (->) t) => Substructure Right (t <:.:> t := (:*:)) where 	type Available Right (t <:.:> t := (:*:)) = Identity 	type Substance Right (t <:.:> t := (:*:)) = t 	substructure = P_Q_T $ \x -> case run # lower x of

@@ -5,10 +5,10 @@ import Pandora.Core.Functor (type (:=), type (~>), type (:=:=>)) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category ((#))-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.Algebraic (extract) import Pandora.Paradigm.Primary.Functor (Comparison) import Pandora.Paradigm.Primary.Functor.Convergence (Convergence (Convergence)) import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))

@@ -23,5 +23,5 @@ 	type Substance segment structure :: * -> * 	substructure :: (Tagged segment <:.> structure) #=@ Substance segment structure := Available segment structure -	sub :: (Covariant structure (->) (->)) => structure #=@ Substance segment structure := Available segment structure-	sub = lift >-> (lower -<$>-) ||= substructure @segment @structure+	sub :: (Covariant (->) (->) structure) => structure #=@ Substance segment structure := Available segment structure+	sub = lift @(->) >-> (lower @(->) -<$>-) ||= substructure @segment @structure

@@ -22,10 +22,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 != (find @f @t @Maybe % s) . equate <<- ss -cardinality :: Traversable t (->) (->) => t a -> Numerator+cardinality :: Traversable (->) (->) t => t a -> Numerator cardinality s = attached . run @(State _) % Zero $ (modify @Numerator (+ one) !.) <<- s

@@ -8,8 +8,8 @@ import Pandora.Pattern.Category (($)) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-))) import Pandora.Pattern.Functor.Contravariant ((->$<-))-import Pandora.Pattern.Functor.Pointable (Pointable)-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply))+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit)) import Pandora.Pattern.Functor.Traversable (Traversable ((<<-))) import Pandora.Pattern.Functor.Bindable (Bindable ((=<<))) import Pandora.Pattern.Transformer.Liftable (lift)@@ -23,7 +23,9 @@ import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>)) import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), Morph (Push), premorph) import Pandora.Paradigm.Structure.Ability.Nullable (Nullable (null))-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:)((:*:)))+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))+import Pandora.Paradigm.Primary.Algebraic.Sum ((:+:))+import Pandora.Paradigm.Primary.Algebraic (empty)  newtype Comprehension t a = Comprehension (t <:.> Construction t := a) @@ -32,16 +34,22 @@ 	run ~(Comprehension x) = x 	unite = Comprehension -instance Covariant (t <:.> Construction t) (->) (->) => Covariant (Comprehension t) (->) (->) where+instance Covariant (->) (->) (t <:.> Construction t) => Covariant (->) (->) (Comprehension t) where 	f -<$>- Comprehension x = Comprehension $ f -<$>- x -instance Traversable (t <:.> Construction t) (->) (->) => Traversable (Comprehension t) (->) (->) where+instance Traversable (->) (->) (t <:.> Construction t) => Traversable (->) (->) (Comprehension t) where 	f <<- Comprehension x = Comprehension -<$>- f <<- x -instance (Covariant t (->) (->), Semimonoidal t (->) (:*:) (:*:)) => Semimonoidal (Comprehension t) (->) (:*:) (:*:) where-	multiply_ (Comprehension x :*: Comprehension y) = Comprehension $ multiply_ (x :*: y)+instance (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:*:) t) => Semimonoidal (->) (:*:) (:*:) (Comprehension t) where+	multiply (Comprehension x :*: Comprehension y) = Comprehension $ multiply (x :*: y) -instance (forall a . Semigroup (t <:.> Construction t := a), Bindable t (->)) => Bindable (Comprehension t) (->) where+instance (Covariant (->) (->) t, Semimonoidal (->) (:*:) (:+:) t) => Semimonoidal (->) (:*:) (:+:) (Comprehension t) where+	multiply (Comprehension x :*: Comprehension y) = Comprehension $ multiply (x :*: y)++instance (Covariant (->) (->) t, Monoidal (->) (->) (:*:) (:+:) t) => Monoidal (->) (->) (:*:) (:+:) (Comprehension t) where+	unit _ _ = Comprehension empty++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  instance Setoid (t <:.> Construction t := a) => Setoid (Comprehension t a) where@@ -53,7 +61,7 @@ instance Monoid (t <:.> Construction t := a) => Monoid (Comprehension t a) where 	zero = Comprehension zero -instance (Covariant t (->) (->), Pointable t (->)) => Morphable Push (Comprehension t) where+instance (Covariant (->) (->) t, Monoidal (->) (->) (:*:) (:*:) t)  => Morphable Push (Comprehension t) where 	type Morphing Push (Comprehension t) = Identity <:.:> Comprehension t := (->) 	morphing (run . premorph -> xs) = T_U $ \(Identity x) -> Comprehension . lift . Construct x . run $ xs 

@@ -7,12 +7,9 @@ import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category (($)) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)), (-<$$>-))-import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (-<<-<<-))-import Pandora.Pattern.Functor.Extractable (extract)-import Pandora.Pattern.Object.Monoid (Monoid (zero))-import Pandora.Paradigm.Primary.Algebraic ()-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))+import Pandora.Paradigm.Primary.Algebraic (extract)+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)@@ -24,17 +21,14 @@ 	run ~(Prefixed x) = x 	unite = Prefixed -instance Covariant t (->) (->) => Covariant (Prefixed t k) (->) (->) where+instance Covariant (->) (->) t => Covariant (->) (->) (Prefixed t k) where 	f -<$>- Prefixed x = Prefixed $ f -<$$>- x -instance Traversable t (->) (->) => Traversable (Prefixed t k) (->) (->) where+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--instance Covariant t (->) (->) => Morphable (Into t) (Prefixed t k) where+instance Covariant (->) (->) t => Morphable (Into t) (Prefixed t k) where 	type Morphing (Into t) (Prefixed t k) = t-	morphing (run . premorph -> prefixed) = extract @_ @(->) -<$>- prefixed+	morphing (run . premorph -> prefixed) = extract -<$>- prefixed  type instance Nonempty (Prefixed t k) = Prefixed (Nonempty t) k

@@ -6,7 +6,6 @@ import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category (($), (#)) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))-import Pandora.Pattern.Functor.Extractable (extract) import Pandora.Pattern.Functor.Bindable ((=<<)) import Pandora.Pattern.Transformer.Liftable (lift) import Pandora.Pattern.Transformer.Lowerable (lower)@@ -15,11 +14,11 @@ import Pandora.Paradigm.Primary () import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), type (:*:), attached, twosome) import Pandora.Paradigm.Primary.Algebraic.Exponential ((%), (&))-import Pandora.Paradigm.Primary.Algebraic (($$$>-))+import Pandora.Paradigm.Primary.Algebraic (($$$>-), extract) 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.Object.Denumerator (Denumerator (Single)) import Pandora.Paradigm.Primary.Functor (Comparison) import Pandora.Paradigm.Primary.Functor.Convergence (Convergence (Convergence)) import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))@@ -72,14 +71,14 @@ 	type Substance Left Binary = Construction Wye 	substructure = P_Q_T $ \bintree -> case run . lower # bintree of 		Nothing -> Store $ Nothing :*: lift . TU-		Just tree -> lift . lift -<$>- run (sub @Left) tree+		Just tree -> lift . lift @(->) -<$>- run (sub @Left) tree  instance Substructure Right Binary where 	type Available Right Binary = Maybe 	type Substance Right Binary = Construction Wye 	substructure = P_Q_T $ \bintree -> case run . extract . run # bintree of 		Nothing -> Store $ Nothing :*: lift . TU-		Just tree -> lift . lift -<$>- run (sub @Right) tree+		Just tree -> lift . lift @(->) -<$>- run (sub @Right) tree  -------------------------------------- Non-empty binary tree --------------------------------------- @@ -101,10 +100,10 @@  instance Measurable Heighth (Construction Wye) where 	type Measural Heighth (Construction Wye) a = Denumerator-	measurement (deconstruct . extract -> End) = One-	measurement (deconstruct . extract -> Left lst) = One + measure @Heighth lst-	measurement (deconstruct . extract -> Right rst) = One + measure @Heighth rst-	measurement (deconstruct . extract -> Both lst rst) = One ++	measurement (deconstruct . extract -> End) = Single+	measurement (deconstruct . extract -> Left lst) = Single + measure @Heighth lst+	measurement (deconstruct . extract -> Right rst) = Single + measure @Heighth rst+	measurement (deconstruct . extract -> Both lst rst) = Single + 		let (lm :*: rm) = measure @Heighth lst :*: measure @Heighth rst 		in lm <=> rm & order lm rm lm @@ -136,7 +135,7 @@  instance Chain k => Morphable (Lookup Key) (Prefixed Binary k) where 	type Morphing (Lookup Key) (Prefixed Binary k) = (->) k <:.> Maybe-	morphing (run . run . premorph -> Nothing) = lift Nothing+	morphing (run . run . premorph -> Nothing) = TU $ \_ -> Nothing 	morphing (run . run . premorph -> Just tree) = TU $ \key -> 		let root = extract tree in key <=> attached root & order (Just # extract root) 			(lookup @Key key . Prefixed =<< view # sub @Left # tree)@@ -165,7 +164,7 @@  data Biforked a = Top | Leftward a | Rightward a -instance Covariant Biforked (->) (->) where+instance Covariant (->) (->) Biforked where 	_ -<$>- Top = Top 	f -<$>- Leftward l = Leftward $ f l 	f -<$>- Rightward r = Rightward $ f r

@@ -7,8 +7,6 @@ import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category (($), (#), identity) import Pandora.Pattern.Functor.Covariant (Covariant, Covariant ((-<$>-)))-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (multiply_))-import Pandora.Pattern.Functor.Extractable (extract) import Pandora.Pattern.Functor.Traversable (Traversable ((<<-))) import Pandora.Pattern.Functor.Extendable (Extendable ((<<=))) import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))@@ -21,8 +19,8 @@ import Pandora.Pattern.Object.Monoid (Monoid (zero)) 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.Algebraic ((-<*>-), (-.#..-))+import Pandora.Paradigm.Primary.Object.Denumerator (Denumerator (Single))+import Pandora.Paradigm.Primary.Algebraic ((-<*>-), (-.#..-), extract) import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), attached, twosome) import Pandora.Paradigm.Primary.Algebraic.Exponential ((%)) import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))@@ -114,11 +112,11 @@ 	type Available Tail List = Identity 	type Substance Tail List = List 	substructure = P_Q_T $ \x -> case run . extract . run $ x of-		Just ns -> lift . lift -<$>- run (sub @Tail) ns+		Just ns -> lift . lift @(->) -<$>- run (sub @Tail) ns 		Nothing -> Store $ Identity zero :*: 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 -------------------------------------------@@ -144,8 +142,8 @@  instance Measurable Length (Construction Maybe) where 	type Measural Length (Construction Maybe) a = Denumerator-	measurement (deconstruct . extract -> Nothing) = One-	measurement (deconstruct . extract -> Just xs) = One + measure @Length xs+	measurement (deconstruct . extract -> Nothing) = Single+	measurement (deconstruct . extract -> Just xs) = Single + measure @Length xs  instance Substructure Root (Construction Maybe) where 	type Available Root (Construction Maybe) = Identity@@ -167,11 +165,11 @@  type instance Zipper List (Left ::: Right) = Tap (List <:.:> List := (:*:)) -instance {-# OVERLAPS #-} Traversable (Tap (List <:.:> List := (:*:))) (->) (->) where+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+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) @@ -223,7 +221,7 @@  instance Morphable (Into (Tap (List <:.:> List := (:*:)))) (Tap (Construction Maybe <:.:> Construction Maybe := (:*:))) where 	type Morphing (Into (Tap (List <:.:> List := (:*:)))) (Tap (Construction Maybe <:.:> Construction Maybe := (:*:))) = Tap (List <:.:> List := (:*:))-	morphing (premorph -> zipper) = Tap # extract zipper $ lift <-> lift ||= lower zipper+	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 := (:*:))) =@@ -247,10 +245,6 @@  type instance Zipper (Comprehension Maybe) (Left ::: Right) = Tap (Comprehension Maybe <:.:> Comprehension Maybe := (:*:)) -instance Semimonoidal (Tap (Comprehension Maybe <:.:> Comprehension Maybe := (:*:))) (->) (:*:) (:*:) where-	multiply_ (Tap x (T_U (xls :*: xrs)) :*: Tap y (T_U (yls :*: yrs))) = Tap (x :*: y)-		$ T_U $ multiply_ (xls :*: yls) :*: multiply_ (xrs :*: yrs)- ----------------------------------------- Prefixed list --------------------------------------------  instance Setoid key => Morphable (Lookup Key) (Prefixed List key) where@@ -261,5 +255,5 @@  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+	morphing (run . premorph -> Construct x xs) = TU $ \key -> extract -<$>- search key where 		search key = key == attached x ? Just x $ find @Element # Predicate ((key ==) . attached) =<< xs

@@ -6,7 +6,6 @@ import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category (($), (#)) import Pandora.Pattern.Functor.Contravariant ((->$<-))-import Pandora.Pattern.Functor.Extractable (extract) import Pandora.Pattern.Functor.Bindable (Bindable ((=<<))) import Pandora.Pattern.Transformer.Liftable (lift) import Pandora.Pattern.Transformer.Lowerable (lower)@@ -14,6 +13,7 @@ import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False), (?)) import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), attached) import Pandora.Paradigm.Primary.Algebraic.Exponential ((%))+import Pandora.Paradigm.Primary.Algebraic (extract) 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)

@@ -7,10 +7,9 @@ import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category (($), (#)) import Pandora.Pattern.Functor.Covariant (Covariant ((-<$>-)))-import Pandora.Pattern.Functor.Extractable (extract) import Pandora.Pattern.Functor.Bindable (Bindable ((=<<))) import Pandora.Paradigm.Primary ()-import Pandora.Paradigm.Primary.Algebraic ((-<*>-))+import Pandora.Paradigm.Primary.Algebraic ((-<*>-), extract) import Pandora.Paradigm.Primary.Algebraic.Product (twosome) import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just)) import Pandora.Paradigm.Primary.Functor.Tagged (type (:#))@@ -63,7 +62,7 @@ 				(branch @Right =<< deconstruct -<$>- branch @Right xs)  		parent :: Maybe a-		parent = extract @_ @(->) -<$>- branch @Right xs+		parent = extract -<$>- branch @Right xs  instance Morphable (Rotate (Right Zig)) (Construction Wye) where 	type Morphing (Rotate (Right Zig)) (Construction Wye) = Binary@@ -75,7 +74,7 @@ 			. into @Wye $ twosome (branch @Right =<< deconstruct -<$>- branch @Left xs) # branch @Right xs  		parent :: Maybe a-		parent = extract @_ @(->) -<$>- branch @Left xs+		parent = extract -<$>- branch @Left xs  -- TODO: Morphing ... = Conclussion Error <:.> Nonempty Binary instance Morphable (Rotate (Left (Zig Zig))) (Construction Wye) where

@@ -6,10 +6,9 @@ import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category (($), (#)) 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.Algebraic.Product ((:*:) ((:*:)), twosome)+import Pandora.Paradigm.Primary.Algebraic (extract) 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, (.-+))@@ -17,6 +16,7 @@ import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), Morph (Rotate), premorph, rotate) import Pandora.Paradigm.Structure.Ability.Zipper (Zipper) import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))+import Pandora.Paradigm.Primary.Algebraic (point)  type Stream = Construction Identity @@ -32,7 +32,7 @@ 	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+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)) 

@@ -1,4 +1,4 @@-module Pandora.Pattern.Functor (module Exports, Endofunctor) where+module Pandora.Pattern.Functor (module Exports) where  import Pandora.Pattern.Functor.Bivariant as Exports import Pandora.Pattern.Functor.Divariant as Exports@@ -10,15 +10,14 @@ import Pandora.Pattern.Functor.Bindable as Exports import Pandora.Pattern.Functor.Distributive as Exports import Pandora.Pattern.Functor.Traversable as Exports-import Pandora.Pattern.Functor.Extractable as Exports-import Pandora.Pattern.Functor.Pointable as Exports+import Pandora.Pattern.Functor.Monoidal as Exports import Pandora.Pattern.Functor.Semimonoidal as Exports import Pandora.Pattern.Functor.Invariant as Exports import Pandora.Pattern.Functor.Contravariant as Exports import Pandora.Pattern.Functor.Covariant as Exports -type family Endofunctor constraint functor category where-	Endofunctor Covariant t category = Covariant t category category-	Endofunctor Contravariant t category = Contravariant t category category-	Endofunctor Traversable t category = Traversable t category category-	Endofunctor Distributive t category = Distributive t category category+--type family Endofunctor constraint functor category where+	--Endofunctor Covariant t category = Covariant category category t+	--Endofunctor Contravariant t category = Contravariant t category category+	--Endofunctor Traversable t category = Traversable t category category+	--Endofunctor Distributive t category = Distributive t category category

@@ -14,6 +14,6 @@ > * Right adjunction interchange: psi f ≡ epsilon . comap f -} -class (Covariant t target source, Covariant u source target) => Adjoint t u source target where+class (Covariant target source t, Covariant source target u) => Adjoint source target t u where 	(-|) :: source (t a) b -> target a (u b) 	(|-) :: target a (u b) -> source (t a) b

@@ -9,5 +9,5 @@ > * Interchange: t >>= f = join (f <$> t) -} -class Covariant t source source => Bindable t source where+class Covariant source source t => Bindable source t where 	(=<<) :: source a (t b) -> source (t a) (t b)

@@ -11,6 +11,6 @@ > * Parametricity: (f . g) <-> (h . i) ≡ f <-> h . g <-> i -} -class (forall i . Covariant (v i) left target, forall i . Covariant (Flip v i) right target)-	=> Bivariant v left right target where+class (forall i . Covariant left target (v i), forall i . Covariant right target (Flip v i))+	=> Bivariant left right target v where 	(<->) :: left a b -> right c d -> target (v a c) (v b d) 

@@ -1,11 +1,13 @@ module Pandora.Pattern.Functor.Comonad where -import Pandora.Pattern.Functor.Extractable (Extractable)+import Pandora.Pattern.Functor.Monoidal (Monoidal) import Pandora.Pattern.Functor.Extendable (Extendable)+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--))+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))  {- |-> Let f :: (Pointable t, Bindable t) => t a -> b-> Let g :: (Pointable t, Bindable t) => t a -> b+> Let f :: (Extendable t, Extractable t) => t a -> b+> Let g :: (Extendable t, Extractable t) => t a -> b  > When providing a new instance, you should ensure it satisfies: > * Left identity: extend extract ≡ identity@@ -13,4 +15,4 @@ > * Associativity: extend f . extend g ≡ extend (f . extend g) -} -class (Extractable t source, Extendable t (->)) => Comonad t source+class (Monoidal (<--) source (:*:) (:*:) t, Extendable source t) => Comonad t source

@@ -4,12 +4,11 @@  infixl 4 ->$<- --- TODO: use ->$<- instead of contramap here {- | > When providing a new instance, you should ensure it satisfies:-> * Identity morphism: contramap identity ≡ identity-> * Interpreted of morphisms: contramap f . contramap g ≡ contramap (g . f)+> * Identity morphism: (identity ->$<-) ≡ identity+> * Interpreted of morphisms: (f ->$<-) . (g ->$<-) ≡ (g . f ->$<-) -} -class (Category source, Category target) => Contravariant t source target where+class (Category source, Category target) => Contravariant source target t where 	(->$<-) :: source a b -> target (t b) (t a)

@@ -5,40 +5,39 @@ infixl 4 -<$>- infixl 3 -<<$$>-, -<$$>>- --- TODO: use -<$>- instead of comap here {- | > When providing a new instance, you should ensure it satisfies:-> * Identity morphism: comap identity ≡ identity-> * Interpreted of morphisms: comap (f . g) ≡ comap f . comap g+> * Identity morphism: (identity -<$>-) ≡ identity+> * Interpreted of morphisms: (f . g -<$>-) ≡ (f -<$>-) . (g -<$>-) -} -class (Semigroupoid source, Semigroupoid target) => Covariant t source target where+class (Semigroupoid source, Semigroupoid target) => Covariant source target t where 	(-<$>-) :: source a b -> target (t a) (t b) 	 (-<$$>-) :: forall t u category a b -	. (Covariant u category category, Covariant t category category) +	. (Covariant category category u, Covariant category category t)  	=> category a b -> category (t (u a)) (t (u b))-(-<$$>-) s = ((-<$>-) ((-<$>-) @u @category @category s))+(-<$$>-) s = ((-<$>-) ((-<$>-) @category @category @u s))  (-<<$$>-) :: forall t u source target a b -	. (Covariant u source source, Covariant t source target) +	. (Covariant source source u, Covariant source target t)  	=> source a b -> target (t (u a)) (t (u b))-(-<<$$>-) s = ((-<$>-) ((-<$>-) @u @source @source s))+(-<<$$>-) s = ((-<$>-) ((-<$>-) @source @source @u s)) -(-<$$>>-) :: forall t u source target a b -	. (Covariant u source target, Covariant t target target) +(-<$$>>-) :: forall source target t u a b +	. (Covariant source target u, Covariant target target t)  	=> source a b -> target (t (u a)) (t (u b))-(-<$$>>-) s = ((-<$>-) ((-<$>-) @u @source @target s))+(-<$$>>-) s = ((-<$>-) ((-<$>-) @source @target @u s))  -- TODO: Figure out how to work with hidden type variables -- to put intermediate category `between`  (-<$$$>-) :: forall t u v category a b-	. (Covariant t category category, Covariant u category category, Covariant v category category) +	. (Covariant category category t, Covariant category category u, Covariant category category v)  	=> category a b -> category (t (u (v a))) (t (u (v b)))-(-<$$$>-) s = ((-<$>-) @t @category @category ((-<$>-) @u @category @category ((-<$>-) @v @category @category s)))+(-<$$$>-) s = ((-<$>-) @category @category @t ((-<$>-) @category @category @u ((-<$>-) @category @category @v s))) -(-<$$$$>-) :: forall t u v w category a b-	. (Covariant t category category, Covariant u category category, Covariant v category category, Covariant w category category) +(-<$$$$>-) :: forall category t u v w a b+	. (Covariant category category t, Covariant category category u, Covariant category category v, Covariant category category w)  	=> category a b -> category (t (u (v (w a)))) (t (u (v (w b))))-(-<$$$$>-) s = ((-<$>-) @t @category @category ((-<$>-) @u @category @category ((-<$>-) @v @category @category ((-<$>-) @w @category @category s))))+(-<$$$$>-) s = ((-<$>-) @category @category @t ((-<$>-) @category @category @u ((-<$>-) @category @category @v ((-<$>-) @category @category @w s))))

@@ -12,5 +12,5 @@  infixl 5 -<< -class Covariant t source target => Distributive t source target where-	(-<<) :: Covariant u source target => source a (t b) -> target (u a) (t (u b))+class Covariant source target t => Distributive source target t where+	(-<<) :: Covariant source target u => source a (t b) -> target (u a) (t (u b))

@@ -12,6 +12,6 @@ > * Interpreted: f . g >-> h . i ≡ g >-> h . f >-> i -} -class (forall i . Contravariant (Flip v i) left target, forall i . Covariant (v i) right target) -	=> Divariant v left right target where+class (forall i . Contravariant left target (Flip v i), forall i . Covariant right target (v i)) +	=> Divariant left right target v where 	(>->) :: left a b -> right c d -> target (v b c) (v a d)

@@ -10,5 +10,5 @@ > * Extension interchange: (f <<=) ≡ (f -<$>-) . (identity <<=) -} -class Covariant t source source => Extendable t source where+class Covariant source source t => Extendable source t where 	(<<=) :: source (t a) b -> source (t a) (t b)

@@ -1,7 +0,0 @@-module Pandora.Pattern.Functor.Extractable where--import Pandora.Pattern.Functor.Covariant (Covariant)--class Covariant t source source => Extractable t source where-	{-# MINIMAL extract #-}-	extract :: source (t a) a

@@ -2,12 +2,13 @@  import Pandora.Pattern.Functor.Covariant (Covariant) import Pandora.Pattern.Functor.Bindable (Bindable)-import Pandora.Pattern.Functor.Pointable (Pointable)+import Pandora.Pattern.Functor.Monoidal (Monoidal)+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))  {- |-> Let f :: (Pointable t, Bindable t) => a -> t a-> Let g :: (Pointable t, Bindable t) => a -> t a-> Let h :: (Pointable t, Bindable t) => t a+> Let f :: (Monoidal t (->) (->) (:*:) (:*:), Bindable t) => a -> t a+> Let g :: (Monoidal t (->) (->) (:*:) (:*:), Bindable t) => a -> t a+> Let h :: (Monoidal t (->) (->) (:*:) (:*:), Bindable t) => t a  > When providing a new instance, you should ensure it satisfies: > * Left identity: point a >>= f ≡ f a@@ -18,7 +19,7 @@ --infixl 1 >>=-, ->>= --infixr 1 -=<<, =<<- -class (Covariant t (->) (->), Pointable t (->), Bindable t (->)) => Monad t where+class (Covariant (->) (->) t, Monoidal (->) (->) (:*:) (:*:) 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

@@ -0,0 +1,9 @@+module Pandora.Pattern.Functor.Monoidal where++import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal)+import Pandora.Paradigm.Primary.Functor.Proxy (Proxy)++type family Unit (p :: * -> * -> *) = r | r -> p++class Semimonoidal p source target t => Monoidal p q source target t where+	unit :: Proxy source -> p (q (Unit target) a) (t a)

@@ -1,7 +0,0 @@-module Pandora.Pattern.Functor.Pointable where--import Pandora.Pattern.Functor.Covariant (Covariant)--class Covariant t source source => Pointable t source where-	{-# MINIMAL point #-}-	point :: source a (t a)

@@ -1,7 +1,6 @@ module Pandora.Pattern.Functor.Representable where  import Pandora.Core.Functor (type (<:=))-import Pandora.Pattern.Functor.Pointable (Pointable)  {- | > When providing a new instance, you should ensure it satisfies:@@ -13,7 +12,7 @@  infixr 6 <#> -class Pointable t (->) => Representable t where+class Representable t where 	{-# MINIMAL (<#>), tabulate #-} 	type Representation t :: * 	-- | Infix and flipped version of 'index'

@@ -2,5 +2,5 @@  import Pandora.Pattern.Semigroupoid (Semigroupoid) -class Semigroupoid p => Semimonoidal t p source target where-	multiply_ :: p (source (t a) (t b)) (t (target a b))+class Semigroupoid p => Semimonoidal p source target t where+	multiply :: p (source (t a) (t b)) (t (target a b))

@@ -1,13 +1,12 @@ module Pandora.Pattern.Functor.Traversable where  import Pandora.Pattern.Functor.Covariant (Covariant)-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal)-import Pandora.Pattern.Functor.Pointable (Pointable)+import Pandora.Pattern.Functor.Monoidal (Monoidal) 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+> Let p :: (Monoidal u category category (:*:) (:*:), Monoidal u category category (:*:) (:*:)) => t a -> u a  > When providing a new instance, you should ensure it satisfies: > * Numeratority of traversing: g . (f <<--) ≡ (g . f <<--)@@ -18,10 +17,10 @@  infixl 5 <<-, -<<-<<- -class Covariant t source target => Traversable t source target where-	(<<-) :: (Covariant u source target, Pointable u target, Semimonoidal u target (:*:) (:*:)) => source a (u b) -> target (t a) (u (t b))+class Covariant source target t => Traversable source target t where+	(<<-) :: (Covariant source target u, Monoidal source target (:*:) (:*:) u) => source a (u b) -> target (t a) (u (t b))  (-<<-<<-) :: forall t u v category a b .-	(Traversable t category category, Covariant u category category, Pointable u category, Semimonoidal u category (:*:) (:*:), Traversable v category category)+	(Traversable category category t, Covariant category category u, Monoidal category category (:*:) (:*:) u, Traversable category category v)  	=> category a (u b) -> category (v (t a)) (u (v (t b)))-(-<<-<<-) f = ((<<-) ((<<-) @t @category @category f))+(-<<-<<-) f = ((<<-) ((<<-) @category @category @t f))

@@ -13,7 +13,7 @@  class Hoistable t where 	{-# MINIMAL (/|\) #-}-	(/|\) :: (Covariant u (->) (->)) => u ~> v -> t u ~> t v+	(/|\) :: (Covariant (->) (->) u) => u ~> v -> t u ~> t v -	hoist :: (Covariant u (->) (->)) => u ~> v -> t u ~> t v+	hoist :: (Covariant (->) (->) u) => u ~> v -> t u ~> t v 	hoist = (/|\)

@@ -1,6 +1,5 @@ module Pandora.Pattern.Transformer.Liftable (Liftable (..)) where -import Pandora.Core.Functor (type (~>)) import Pandora.Pattern.Functor.Covariant (Covariant)  {- |@@ -8,5 +7,5 @@ > * Interchange: lift . point ≡ point -} -class Liftable t where-	lift :: (Covariant u (->) (->)) => u ~> t u+class Liftable cat t where+	lift :: Covariant cat cat u => cat (u a) (t u a)

@@ -8,5 +8,5 @@ > * Interchange: extract . lower ≡ extract -} -class Lowerable t where-	lower :: (Covariant u (->) (->)) => t u ~> u+class Lowerable cat t where+	lower :: Covariant cat cat u => cat (t u a) (u a)

@@ -1,5 +1,5 @@ name:                pandora-version:             0.4.5+version:             0.4.6 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@@ -32,6 +32,8 @@     Pandora.Paradigm.Primary.Algebraic.Exponential     Pandora.Paradigm.Primary.Algebraic.Product     Pandora.Paradigm.Primary.Algebraic.Sum+    Pandora.Paradigm.Primary.Algebraic.Zero+    Pandora.Paradigm.Primary.Algebraic.One     Pandora.Paradigm.Primary.Object.Boolean     Pandora.Paradigm.Primary.Object.Ordering     Pandora.Paradigm.Primary.Object.Numerator@@ -137,16 +139,15 @@     Pandora.Pattern.Functor     Pandora.Pattern.Functor.Adjoint     Pandora.Pattern.Functor.Semimonoidal+    Pandora.Pattern.Functor.Monoidal     Pandora.Pattern.Functor.Bindable     Pandora.Pattern.Functor.Comonad     Pandora.Pattern.Functor.Contravariant     Pandora.Pattern.Functor.Covariant     Pandora.Pattern.Functor.Distributive     Pandora.Pattern.Functor.Extendable-    Pandora.Pattern.Functor.Extractable     Pandora.Pattern.Functor.Invariant     Pandora.Pattern.Functor.Monad-    Pandora.Pattern.Functor.Pointable     Pandora.Pattern.Functor.Representable     Pandora.Pattern.Functor.Traversable     Pandora.Pattern.Functor.Divariant