pandora 0.4.2 → 0.4.3

raw patch · 78 files changed

+744/−318 lines, 78 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• CHANGELOG.md +28/−0
• Pandora/Paradigm/Controlflow/Effect/Adaptable.hs +52/−15
• Pandora/Paradigm/Controlflow/Effect/Interpreted.hs +2/−2
• Pandora/Paradigm/Controlflow/Effect/Transformer.hs +5/−5
• Pandora/Paradigm/Controlflow/Effect/Transformer/Comonadic.hs +8/−5
• Pandora/Paradigm/Controlflow/Effect/Transformer/Monadic.hs +8/−5
• Pandora/Paradigm/Controlflow/Pipeline.hs +8/−8
• Pandora/Paradigm/Inventory.hs +2/−2
• Pandora/Paradigm/Inventory/Accumulator.hs +7/−4
• Pandora/Paradigm/Inventory/Environment.hs +7/−4
• Pandora/Paradigm/Inventory/Equipment.hs +6/−3
• Pandora/Paradigm/Inventory/Imprint.hs +5/−2
• Pandora/Paradigm/Inventory/Optics.hs +3/−3
• Pandora/Paradigm/Inventory/State.hs +6/−3
• Pandora/Paradigm/Inventory/Store.hs +9/−5
• Pandora/Paradigm/Primary.hs +9/−4
• Pandora/Paradigm/Primary/Functor.hs +16/−2
• Pandora/Paradigm/Primary/Functor/Conclusion.hs +38/−6
• Pandora/Paradigm/Primary/Functor/Constant.hs +4/−1
• Pandora/Paradigm/Primary/Functor/Convergence.hs +4/−1
• Pandora/Paradigm/Primary/Functor/Edges.hs +7/−1
• Pandora/Paradigm/Primary/Functor/Function.hs +36/−16
• Pandora/Paradigm/Primary/Functor/Identity.hs +15/−6
• Pandora/Paradigm/Primary/Functor/Maybe.hs +29/−5
• Pandora/Paradigm/Primary/Functor/Predicate.hs +13/−6
• Pandora/Paradigm/Primary/Functor/Product.hs +18/−5
• Pandora/Paradigm/Primary/Functor/Proxy.hs +10/−3
• Pandora/Paradigm/Primary/Functor/Tagged.hs +11/−5
• Pandora/Paradigm/Primary/Functor/These.hs +11/−3
• Pandora/Paradigm/Primary/Functor/Validation.hs +35/−5
• Pandora/Paradigm/Primary/Functor/Wedge.hs +11/−3
• Pandora/Paradigm/Primary/Functor/Wye.hs +8/−2
• Pandora/Paradigm/Primary/Transformer.hs +9/−0
• Pandora/Paradigm/Primary/Transformer/Backwards.hs +10/−4
• Pandora/Paradigm/Primary/Transformer/Construction.hs +23/−14
• Pandora/Paradigm/Primary/Transformer/Continuation.hs +9/−6
• Pandora/Paradigm/Primary/Transformer/Day.hs +13/−8
• Pandora/Paradigm/Primary/Transformer/Flip.hs +0/−14
• Pandora/Paradigm/Primary/Transformer/Instruction.hs +7/−3
• Pandora/Paradigm/Primary/Transformer/Jack.hs +10/−4
• Pandora/Paradigm/Primary/Transformer/Jet.hs +8/−3
• Pandora/Paradigm/Primary/Transformer/Kan.hs +6/−6
• Pandora/Paradigm/Primary/Transformer/Outline.hs +10/−4
• Pandora/Paradigm/Primary/Transformer/Reverse.hs +8/−3
• Pandora/Paradigm/Primary/Transformer/Tap.hs +23/−9
• Pandora/Paradigm/Primary/Transformer/Yoneda.hs +12/−7
• Pandora/Paradigm/Schemes/TU.hs +9/−6
• Pandora/Paradigm/Schemes/TUT.hs +14/−11
• Pandora/Paradigm/Schemes/T_U.hs +6/−3
• Pandora/Paradigm/Schemes/UT.hs +12/−9
• Pandora/Paradigm/Structure.hs +4/−4
• Pandora/Paradigm/Structure/Ability/Monotonic.hs +2/−2
• Pandora/Paradigm/Structure/Ability/Substructure.hs +2/−2
• Pandora/Paradigm/Structure/Interface/Set.hs +2/−2
• Pandora/Paradigm/Structure/Modification/Comprehension.hs +8/−5
• Pandora/Paradigm/Structure/Modification/Prefixed.hs +5/−2
• Pandora/Paradigm/Structure/Some/Binary.hs +6/−1
• Pandora/Paradigm/Structure/Some/List.hs +0/−7
• Pandora/Paradigm/Structure/Some/Rose.hs +2/−2
• Pandora/Pattern/Functor/Adjoint.hs +6/−2
• Pandora/Pattern/Functor/Applicative.hs +4/−0
• Pandora/Pattern/Functor/Bindable.hs +4/−1
• Pandora/Pattern/Functor/Bivariant.hs +6/−1
• Pandora/Pattern/Functor/Comonad.hs +1/−1
• Pandora/Pattern/Functor/Contravariant.hs +5/−1
• Pandora/Pattern/Functor/Covariant.hs +27/−2
• Pandora/Pattern/Functor/Divariant.hs +7/−1
• Pandora/Pattern/Functor/Divisible.hs +4/−1
• Pandora/Pattern/Functor/Extendable.hs +4/−1
• Pandora/Pattern/Functor/Extractable.hs +3/−4
• Pandora/Pattern/Functor/Monad.hs +2/−1
• Pandora/Pattern/Functor/Pointable.hs +5/−6
• Pandora/Pattern/Functor/Representable.hs +1/−1
• Pandora/Pattern/Functor/Traversable.hs +6/−6
• Pandora/Pattern/Transformer/Hoistable.hs +3/−3
• Pandora/Pattern/Transformer/Liftable.hs +2/−2
• Pandora/Pattern/Transformer/Lowerable.hs +2/−2
• pandora.cabal +1/−1

@@ -460,3 +460,31 @@ * Change `Substructured` constraint - add paramater for `Available` * Define experimental `Impliable` typeclass * Remove `:-.` type operator in `Optics` module++# 0.4.3+* Rename `!` to `!.` in `Function` module+* Rename `!!` to `!..` in `Function` module+* Rename `!!!` to `!...` in `Function` module+* Define experimental `Covariant_` typeclass+* Define experimental `-<$$>-` method of `Covariant_` typeclass+* Define experimental `-.#..-` method in `Function` module+* Define experimental `Contravariant_` typeclass+* Define experimental `Pointable_` typeclass+* Define experimental `Bindable_` typeclass+* Define experimental `Bivariant_` typeclass+* Define experimental `Divariant_` typeclass+* Define experimental `Extendable_` typeclass+* Use experimental `Covariant_` as superclass of `Extractable`+* Define `Covariant_` superclasses for `Bivariant_`+* Define `Covariant_` and `Contravariant_` superclasses for `Divariant_`+* Define experimental `-<<$$>-` and `-<$$>>-` methods of `Covariant_` typeclass+* Use experimental `Covariant_` as superclass of `Pointable`+* Define experimental `Adjoint_` typeclass+* Define experimental `Applicative_` typeclass+* Define experimental `Divisible_` typeclass+* Define experimental `-<*>-` method+* Use experimental `Covariant_` as superclass of `Lowerable`+* Remove `Covariant` superclass of `Liftable`+* Remove `Covariant` superclass of `Hoistable`++# 0.4.4

@@ -4,23 +4,23 @@  import Pandora.Core.Functor (type (~>)) import Pandora.Pattern.Category (identity, (.))-import Pandora.Pattern.Functor.Covariant (Covariant)+import Pandora.Pattern.Functor.Covariant (Covariant, Covariant_) import Pandora.Pattern.Functor.Pointable (Pointable) import Pandora.Pattern.Functor.Extractable (Extractable) import Pandora.Pattern.Functor.Comonad (Comonad) import Pandora.Pattern.Functor.Monad (Monad) import Pandora.Pattern.Transformer (Liftable (lift), Lowerable (lower), Hoistable (hoist)) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic)-import Pandora.Paradigm.Controlflow.Effect.Transformer (Transformer, wrap, bring, (:>), (:<))+import Pandora.Paradigm.Controlflow.Effect.Transformer (Monadic, Comonadic, wrap, bring, (:>), (:<))  class Adaptable t u where 	{-# MINIMAL adapt #-} 	adapt :: t ~> u -type Lifting t u = (Transformer Monad t, Liftable (Schematic Monad t), Covariant u)-type Lowering t u = (Transformer Comonad t, Lowerable (Schematic Comonad t), Covariant u)-type Wrappable t u = (Transformer Monad t, Pointable u)-type Bringable t u = (Transformer Comonad t, Extractable u)+type Lifting t u = (Monadic t, Liftable (Schematic Monad t), Covariant u, Covariant_ u (->) (->))+type Lowering t u = (Comonadic t, Lowerable (Schematic Comonad t), Covariant u, Covariant_ u (->) (->))+type Wrappable t u = (Monadic t, Pointable u (->))+type Bringable t u = (Comonadic t, Extractable u (->))  instance Covariant t => Adaptable t t where 	adapt = identity@@ -41,6 +41,7 @@ 	( Covariant (t :> u :> v) 	, Liftable (Schematic Monad t) 	, Covariant (Schematic Monad u v)+	, Covariant_ (Schematic Monad u v) (->) (->) 	, Wrappable u v 	) => Adaptable u (t :> u :> v) where 	adapt = lift . wrap@@ -67,7 +68,8 @@ 	adapt = lower . lower  instance-	( Covariant (t :> u :> v :> w)+	( Covariant_ t (->) (->) + 	, Covariant (t :> u :> v :> w) 	, Liftable (Schematic Monad t) 	, Lifting t (Schematic Monad u (v :> w)) 	, Lifting u (Schematic Monad v w)@@ -321,13 +323,14 @@ 	) => 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, Covariant_ u (->) (->), Hoistable ((:>) t), Adaptable u u') => Adaptable (t :> u) (t :> u') where 	adapt = hoist adapt  instance 	( Covariant u-	, Covariant v+	, Covariant v, Covariant_ v (->) (->) 	, Covariant (Schematic Monad u v)+	, Covariant_ (Schematic Monad u v) (->) (->) 	, Hoistable ((:>) (t :> u)) 	, Hoistable (Schematic Monad t) 	, Hoistable (Schematic Monad u)@@ -336,10 +339,15 @@ 	adapt = hoist (hoist adapt)  instance-	( Covariant u, Covariant v, Covariant w+	( Covariant u, Covariant_ u (->) (->)+	, Covariant v, Covariant_ v (->) (->)+	, Covariant w, Covariant_ w (->) (->) 	, Covariant (Schematic Monad u v)+	, Covariant_ (Schematic Monad u v) (->) (->) 	, Covariant (Schematic Monad u (v :> w))+	, Covariant_ (Schematic Monad u (v :> w)) (->) (->) 	, Covariant (Schematic Monad v w)+	, Covariant_ (Schematic Monad v w) (->) (->) 	, Hoistable ((:>) (t :> u :> v)) 	, Hoistable (Schematic Monad t) 	, Hoistable (Schematic Monad u)@@ -349,12 +357,15 @@ 	adapt = hoist (hoist (hoist adapt))  instance-	( Covariant u, Covariant v, Covariant w, Covariant x+	( Covariant u, Covariant v, Covariant w, Covariant x, Covariant_ x (->) (->) 	, Covariant (Schematic Monad u v) 	, Covariant (Schematic Monad u (v :> w)) 	, Covariant (Schematic Monad u (v :> (w :> x)))+	, Covariant_ (Schematic Monad u (v :> (w :> x))) (->) (->) 	, Covariant (Schematic Monad v (w :> x))+	, Covariant_ (Schematic Monad v (w :> x)) (->) (->) 	, Covariant (Schematic Monad w x)+	, Covariant_ (Schematic Monad w x) (->) (->) 	, Hoistable ((:>) (t :> u :> v)) 	, Hoistable (Schematic Monad t) 	, Hoistable (Schematic Monad u)@@ -365,15 +376,20 @@ 	adapt = hoist (hoist (hoist (hoist adapt)))  instance-	( Covariant u, Covariant v, Covariant w, Covariant x, Covariant y+	( Covariant u, Covariant v, Covariant w, Covariant x+	, Covariant y, Covariant_ y (->) (->) 	, Covariant (Schematic Monad u v) 	, Covariant (Schematic Monad u (v :> w)) 	, Covariant (Schematic Monad u (v :> (w :> x))) 	, Covariant (Schematic Monad u (v :> (w :> (x :> y))))+	, Covariant_ (Schematic Monad u (v :> (w :> (x :> y)))) (->) (->) 	, Covariant (Schematic Monad v (w :> x)) 	, Covariant (Schematic Monad v (w :> (x :> y)))+	, Covariant_ (Schematic Monad v (w :> (x :> y))) (->) (->) 	, Covariant (Schematic Monad w (x :> y))+	, Covariant_ (Schematic Monad w (x :> y)) (->) (->) 	, Covariant (Schematic Monad x y)+	, Covariant_ (Schematic Monad x y) (->) (->) 	, Hoistable ((:>) (t :> u :> v :> w)) 	, Hoistable (Schematic Monad t) 	, Hoistable (Schematic Monad u)@@ -385,20 +401,26 @@ 	adapt = hoist (hoist (hoist (hoist (hoist adapt))))  instance-	( Covariant u, Covariant v, Covariant w, Covariant x, Covariant y, Covariant z+	( Covariant u, Covariant v, Covariant w, Covariant x, Covariant y+	, Covariant z, Covariant_ z (->) (->) 	, Covariant (Schematic Monad u v) 	, Covariant (Schematic Monad u (v :> w)) 	, Covariant (Schematic Monad u (v :> (w :> x))) 	, Covariant (Schematic Monad u (v :> (w :> (x :> y)))) 	, Covariant (Schematic Monad u (v :> (w :> (x :> (y :> z)))))+	, Covariant_ (Schematic Monad u (v :> (w :> (x :> (y :> z))))) (->) (->) 	, Covariant (Schematic Monad v (w :> x)) 	, Covariant (Schematic Monad v (w :> (x :> y))) 	, Covariant (Schematic Monad v (w :> (x :> (y :> z))))+	, Covariant_ (Schematic Monad v (w :> (x :> (y :> z)))) (->) (->) 	, Covariant (Schematic Monad w (x :> y)) 	, Covariant (Schematic Monad w (x :> (y :> z)))+	, Covariant_ (Schematic Monad w (x :> (y :> z))) (->) (->) 	, Covariant (Schematic Monad x y) 	, Covariant (Schematic Monad x (y :> z))+	, Covariant_ (Schematic Monad x (y :> z)) (->) (->) 	, Covariant (Schematic Monad y z)+	, Covariant_ (Schematic Monad y z) (->) (->) 	, Hoistable ((:>) (t :> u :> v :> w)) 	, Hoistable (Schematic Monad t) 	, Hoistable (Schematic Monad u)@@ -413,26 +435,33 @@  instance 	( Covariant u, Covariant v, Covariant w, Covariant x-	, Covariant y, Covariant z, Covariant f+	, Covariant y, Covariant z+	, Covariant f, Covariant_ f (->) (->) 	, Covariant (Schematic Monad u v) 	, Covariant (Schematic Monad u (v :> w)) 	, Covariant (Schematic Monad u (v :> (w :> x))) 	, Covariant (Schematic Monad u (v :> (w :> (x :> y)))) 	, Covariant (Schematic Monad u (v :> (w :> (x :> (y :> z))))) 	, Covariant (Schematic Monad u (v :> (w :> (x :> (y :> (z :> f))))))+	, Covariant_ (Schematic Monad u (v :> (w :> (x :> (y :> (z :> f)))))) (->) (->) 	, Covariant (Schematic Monad v (w :> x)) 	, Covariant (Schematic Monad v (w :> (x :> y))) 	, Covariant (Schematic Monad v (w :> (x :> (y :> z)))) 	, Covariant (Schematic Monad v (w :> (x :> (y :> (z :> f)))))+	, Covariant_ (Schematic Monad v (w :> (x :> (y :> (z :> f))))) (->) (->) 	, Covariant (Schematic Monad w (x :> y)) 	, Covariant (Schematic Monad w (x :> (y :> z))) 	, Covariant (Schematic Monad w (x :> (y :> (z :> f))))+	, Covariant_ (Schematic Monad w (x :> (y :> (z :> f)))) (->) (->) 	, Covariant (Schematic Monad x y) 	, Covariant (Schematic Monad x (y :> z)) 	, Covariant (Schematic Monad x (y :> (z :> f)))+	, Covariant_ (Schematic Monad x (y :> (z :> f))) (->) (->) 	, Covariant (Schematic Monad y z) 	, Covariant (Schematic Monad y (z :> f))+	, Covariant_ (Schematic Monad y (z :> f)) (->) (->) 	, Covariant (Schematic Monad z f)+	, Covariant_ (Schematic Monad z f) (->) (->) 	, Hoistable ((:>) (t :> u :> v :> w)) 	, Hoistable (Schematic Monad t) 	, Hoistable (Schematic Monad u)@@ -448,7 +477,8 @@  instance 	( Covariant u, Covariant v, Covariant w, Covariant x-	, Covariant y, Covariant z, Covariant f, Covariant h+	, Covariant y, Covariant z, Covariant f+	, Covariant h, Covariant_ h (->) (->) 	, Covariant (Schematic Monad u v) 	, Covariant (Schematic Monad u (v :> w)) 	, Covariant (Schematic Monad u (v :> (w :> x)))@@ -456,25 +486,32 @@ 	, Covariant (Schematic Monad u (v :> (w :> (x :> (y :> z))))) 	, Covariant (Schematic Monad u (v :> (w :> (x :> (y :> (z :> f)))))) 	, Covariant (Schematic Monad u (v :> (w :> (x :> (y :> (z :> (f :> h)))))))+	, Covariant_ (Schematic Monad u (v :> (w :> (x :> (y :> (z :> (f :> h))))))) (->) (->) 	, Covariant (Schematic Monad v (w :> x)) 	, Covariant (Schematic Monad v (w :> (x :> y))) 	, Covariant (Schematic Monad v (w :> (x :> (y :> z)))) 	, Covariant (Schematic Monad v (w :> (x :> (y :> (z :> f))))) 	, Covariant (Schematic Monad v (w :> (x :> (y :> (z :> (f :> h))))))+	, Covariant_ (Schematic Monad v (w :> (x :> (y :> (z :> (f :> h)))))) (->) (->) 	, Covariant (Schematic Monad w (x :> y)) 	, Covariant (Schematic Monad w (x :> (y :> z))) 	, Covariant (Schematic Monad w (x :> (y :> (z :> f)))) 	, Covariant (Schematic Monad w (x :> (y :> (z :> (f :> h)))))+	, Covariant_ (Schematic Monad w (x :> (y :> (z :> (f :> h))))) (->) (->) 	, Covariant (Schematic Monad x y) 	, Covariant (Schematic Monad x (y :> z)) 	, Covariant (Schematic Monad x (y :> (z :> f))) 	, Covariant (Schematic Monad x (y :> (z :> (f :> h))))+	, Covariant_ (Schematic Monad x (y :> (z :> (f :> h)))) (->) (->) 	, Covariant (Schematic Monad y z) 	, Covariant (Schematic Monad y (z :> f)) 	, Covariant (Schematic Monad y (z :> (f :> h)))+	, Covariant_ (Schematic Monad y (z :> (f :> h))) (->) (->) 	, Covariant (Schematic Monad z f) 	, Covariant (Schematic Monad z (f :> h))+	, Covariant_ (Schematic Monad z (f :> h)) (->) (->) 	, Covariant (Schematic Monad f h)+	, Covariant_ (Schematic Monad f h) (->) (->) 	, Hoistable ((:>) (t :> u :> v :> w)) 	, Hoistable (Schematic Monad t) 	, Hoistable (Schematic Monad u)

@@ -2,7 +2,7 @@  import Pandora.Core.Functor (type (:.), type (:=)) import Pandora.Pattern.Category ((.))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>), (<$$$>), (<$$$$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>), (<$$$>), (<$$$$>)), Covariant_) import Pandora.Pattern.Transformer.Liftable (Liftable (lift)) import Pandora.Paradigm.Primary.Functor.Function () @@ -54,6 +54,6 @@ 		=> (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, Covariant_ u (->) (->)) 	=> (t u a -> t v b) -> u a -> Primary (t v) b (-=:) f = run . f . lift

@@ -1,10 +1,10 @@-module Pandora.Paradigm.Controlflow.Effect.Transformer (module Exports, Transformer) where+module Pandora.Paradigm.Controlflow.Effect.Transformer (module Exports) where  import Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic as Exports import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic as Exports -import Pandora.Pattern.Functor (Monad, Comonad)+--import Pandora.Pattern.Functor (Monad, Comonad) -type family Transformer c t where-	Transformer Monad t = Monadic t-	Transformer Comonad t = Comonadic t+--type family Transformer c t where+--	Transformer Monad t = Monadic t+--	Transformer Comonad t = Comonadic t

@@ -4,7 +4,7 @@  import Pandora.Core.Functor (type (~>)) import Pandora.Pattern.Category ((.), ($))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))@@ -20,7 +20,7 @@  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 }@@ -28,10 +28,13 @@ 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+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+instance Extractable (Schematic Comonad t u) (->) => Extractable (t :< u) (->) where 	extract = extract . tc  instance Applicative (Schematic Comonad t u) => Applicative (t :< u) where@@ -52,7 +55,7 @@ instance Extendable (Schematic Comonad t u) => Extendable (t :< u) where 	TC x =>> f = TC $ x =>> f . TC -instance (Extractable (t :< u), Extendable (t :< u)) => Comonad (t :< u) where+instance (Extractable (t :< u) (->), Extendable (t :< u)) => Comonad (t :< u) (->) where  instance Lowerable (Schematic Comonad t) => Lowerable ((:<) t) where 	lower (TC x) = lower x

@@ -4,7 +4,7 @@  import Pandora.Core.Functor (type (~>)) import Pandora.Pattern.Category ((.), ($))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))@@ -21,7 +21,7 @@  class Interpreted t => Monadic t where 	{-# MINIMAL wrap #-}-	wrap :: Pointable u => t ~> t :> u+	wrap :: Pointable u (->) => t ~> t :> u  infixr 3 :> newtype (:>) t u a = TM { tm :: Schematic Monad t u a }@@ -29,10 +29,13 @@ 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+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+instance Extractable (Schematic Monad t u) (->) => Extractable (t :> u) (->) where 	extract = extract . tm  instance Applicative (Schematic Monad t u) => Applicative (t :> u) where@@ -56,7 +59,7 @@ instance Extendable (Schematic Monad t u) => Extendable (t :> u) where 	TM x =>> f = TM $ x =>> f . TM -instance (Pointable (t :> u), Bindable (t :> u)) => Monad (t :> u) where+instance (Covariant_ (Schematic Monad t u) (->) (->), Pointable (t :> u) (->), Bindable (t :> u)) => Monad (t :> u) where  instance Liftable (Schematic Monad t) => Liftable ((:>) t) where 	lift = TM . lift

@@ -3,7 +3,7 @@ import Pandora.Pattern.Category (($), (.), (#)) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))-import Pandora.Paradigm.Primary.Functor.Function ((!), (!!))+import Pandora.Paradigm.Primary.Functor.Function ((!.), (!..)) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite)) import Pandora.Paradigm.Primary.Transformer.Continuation (Continuation (Continuation)) @@ -40,23 +40,23 @@ 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 = Continuation (Pipe (point () !!) !)+finish :: Pointable 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 action = Continuation $ \next -> Pipe $ \i o -> action >>= \x -> pipe (next x) i o  -- | Compose two pipelines into one-(=*=) :: forall i e o t . Pointable 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+(=*=) :: forall i e o t . Pointable 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 () !!)+	end _ = Pipe (point () !..)  -- | Run pipeline and get result-pipeline :: Pointable t => Pipeline i o t () () -> t ()-pipeline p = pipe # run p (Pipe . (!!) . point) # i # o where+pipeline :: Pointable t (->) => Pipeline i o t () () -> t ()+pipeline p = pipe # run p (Pipe . (!..) . point) # i # o where  	i :: Producer i t () 	i = Producer $ \o' -> produce i o'

@@ -17,7 +17,7 @@ import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-))) import Pandora.Pattern.Functor.Extractable (extract) import Pandora.Pattern.Functor.Bivariant ((<->))-import Pandora.Paradigm.Primary.Functor.Function ((!), (%))+import Pandora.Paradigm.Primary.Functor.Function ((!.), (%)) import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity)) import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:))) import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)@@ -26,7 +26,7 @@  instance Adjoint (Store s) (State s) where 	(-|) :: a -> (Store s a -> b) -> State s b-	x -| f = State $ \s -> (:*:) s . f . Store $ s :*: (x !)+	x -| f = State $ \s -> (:*:) s . f . Store $ s :*: (x !.) 	(|-) :: Store s a -> (a -> State s b) -> b 	Store (s :*: f) |- g = extract . (run % s) . g $ f s 

@@ -3,7 +3,7 @@ module Pandora.Paradigm.Inventory.Accumulator (Accumulator (..), Accumulated, gather) where  import Pandora.Pattern.Category ((.), ($), (#))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>))) import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))@@ -21,11 +21,14 @@ instance Covariant (Accumulator e) where 	f <$> Accumulator x = Accumulator $ f <$> x +instance Covariant_ (Accumulator e) (->) (->) where+	f -<$>- Accumulator x = Accumulator $ f -<$>- x+ instance Semigroup e => Applicative (Accumulator e) where 	f <*> v = Accumulator $ k # run f # run v where 		k ~(e :*: g) ~(e' :*: w) = e + e' :*: g w -instance Monoid e => Pointable (Accumulator e) where+instance Monoid e => Pointable (Accumulator e) (->) where 	point = Accumulator . (zero :*:)  instance Semigroup e => Bindable (Accumulator e) where@@ -48,10 +51,10 @@ 	UT f <*> UT x = UT $ k <$> f <*> x where 		k ~(u :*: g) ~(v :*: y) = u + v :*: g y -instance {-# OVERLAPS #-} (Pointable u, Monoid e) => Pointable ((:*:) e <.:> u) where+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+instance {-# OVERLAPS #-} (Semigroup e, Pointable u (->), Bindable u) => Bindable ((:*:) e <.:> u) where 	UT x >>= f = UT $ x >>= \(acc :*: v) -> (\(acc' :*: y) -> (acc + acc' :*: y)) <$> run (f v)  gather :: Accumulated e t => e -> t ()

@@ -3,14 +3,14 @@ module Pandora.Paradigm.Inventory.Environment (Environment (..), Configured, env) where  import Pandora.Pattern.Category (identity, (.), ($))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>))) import Pandora.Pattern.Functor.Distributive (Distributive ((>>-))) import Pandora.Pattern.Functor.Bindable (Bindable ((>>=))) import Pandora.Pattern.Functor.Monad (Monad) import Pandora.Pattern.Functor.Divariant (Divariant ((>->)))-import Pandora.Paradigm.Primary.Functor.Function ((!), (%))+import Pandora.Paradigm.Primary.Functor.Function ((!.), (%)) 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))@@ -21,8 +21,11 @@ instance Covariant (Environment e) where 	f <$> Environment x = Environment $ f . x -instance Pointable (Environment e) where-	point x = Environment (x !)+instance Covariant_ (Environment e) (->) (->) where+	f -<$>- Environment x = Environment $ f . x++instance Pointable (Environment e) (->) where+	point x = Environment (x !.)  instance Applicative (Environment e) where 	f <*> x = Environment $ run f <*> run x

@@ -3,7 +3,7 @@ module Pandora.Paradigm.Inventory.Equipment (Equipment (..), retrieve) where  import Pandora.Pattern.Category ((.), ($))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Traversable (Traversable ((->>))) import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))@@ -19,7 +19,10 @@ instance Covariant (Equipment e) where 	f <$> Equipment x = Equipment $ f <$> x -instance Extractable (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@@ -43,7 +46,7 @@ instance {-# OVERLAPS #-} Extendable u => Extendable ((:*:) e <:.> u) where 	TU (e :*: x) =>> f = TU . (:*:) e $ x =>> f . TU . (:*:) e -instance Comonad (Equipment e) where+instance Comonad (Equipment e) (->) where  retrieve :: Equipped e t => t a -> e retrieve = attached . run @(Equipment _) . adapt

@@ -3,7 +3,7 @@ module Pandora.Paradigm.Inventory.Imprint (Imprint (..), Traceable) where  import Pandora.Pattern.Category ((.), ($))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Distributive (Distributive ((>>-))) import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))@@ -22,10 +22,13 @@ instance Covariant (Imprint e) where 	f <$> Imprint x = Imprint $ f . x +instance Covariant_ (Imprint e) (->) (->) where+	f -<$>- Imprint x = Imprint $ f . x+ instance Distributive (Imprint e) where 	g >>- f = Imprint $ g >>- (run <$> f) -instance Monoid e => Extractable (Imprint e) where+instance Monoid e => Extractable (Imprint e) (->) where 	extract (Imprint x) = x zero  instance Divariant Imprint where

@@ -12,7 +12,7 @@ import Pandora.Pattern.Object.Setoid (Setoid ((==))) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (run)) import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))-import Pandora.Paradigm.Primary.Functor.Function ((!), (%))+import Pandora.Paradigm.Primary.Functor.Function ((!.), (%)) import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing)) import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:))) import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))@@ -32,7 +32,7 @@ 	Convex Lens = Lens Identity  instance Category (Lens Identity) where-	identity = imply @(Convex Lens _ _) identity ((%) (!))+	identity = imply @(Convex Lens _ _) identity ((%) (!.)) 	P_Q_T to . P_Q_T from = P_Q_T $ \source -> source <$ (to . extract @Identity . position $ from source)  instance Impliable (P_Q_T (->) Store Identity source target) where@@ -51,7 +51,7 @@ instance Category (Lens Maybe) where 	identity = imply @(Obscure Lens _ _) # Just # resolve identity 	P_Q_T to . P_Q_T from = P_Q_T $ \source -> case position # from source of-		Nothing -> Store $ Nothing :*: (source !)+		Nothing -> Store $ Nothing :*: (source !.) 		Just between -> source <$ to between  -- Lens as natural transformation

@@ -4,7 +4,7 @@  import Pandora.Core.Functor (type (:.), type (:=)) import Pandora.Pattern.Category (identity, (.), ($))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Invariant (Invariant ((<$<))) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (*>)))@@ -27,10 +27,13 @@ instance Covariant (State s) where 	f <$> x = State $ (<$>) f . run x +instance Covariant_ (State s) (->) (->) where+	f -<$>- x = State $ (-<$>-) f . run x+ instance Applicative (State s) where 	f <*> x = State $ (|- (<$>)) . (run x <-> identity) . run f -instance Pointable (State s) where+instance Pointable (State s) (->) where 	point = State . (-| identity)  instance Bindable (State s) where@@ -68,7 +71,7 @@ reconcile :: (Bindable t, Stateful s t, Adaptable u t) => (s -> u s) -> t s reconcile f = current >>= adapt . f >>= replace -type Memorable s t = (Pointable t, Applicative t, Stateful s t)+type Memorable s t = (Pointable t (->), Applicative t, Stateful s t)  fold :: (Traversable t, Memorable s u) => (a -> s -> s) -> t a -> u s fold op struct = struct ->> modify . op *> current

@@ -4,7 +4,7 @@  import Pandora.Core (type (:.), type (:=), type (<:=), type (~>)) import Pandora.Pattern.Category (identity, (.), ($))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>), (.#..)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>), (.#..)), Covariant_ ((-<$>-)), (-<$$>-)) import Pandora.Pattern.Functor.Invariant (Invariant ((<$<))) import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))@@ -15,7 +15,8 @@ import Pandora.Paradigm.Primary.Functor.Function ((%)) import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), attached) import Pandora.Paradigm.Primary.Functor ()-import Pandora.Paradigm.Primary.Transformer.Flip (Flip)+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip))+--import Pandora.Paradigm.Primary.Transformer () import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt)) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (||=)), Schematic) import Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic (Comonadic (bring), (:<) (TC))@@ -27,16 +28,19 @@ instance Covariant (Store s) where 	f <$> Store x = Store $ f <$$> x -instance Extractable (Store s) where+instance Covariant_ (Store s) (->) (->) where+	f -<$>- Store x = Store $ f -<$$>- x++instance Extractable (Store s) (->) where 	extract = (|- ($)) . run  instance Extendable (Store s) where 	Store x =>> f = Store $ f <$$> Store .#.. (-| identity) <$> x -instance Comonad (Store s) where+instance Comonad (Store s) (->) where  instance Invariant (Flip Store r) where-	f <$< g = ((f <-> (g >-> identity) ||=) ||=)+	f <$< g = \(Flip x) -> Flip $ f <-> (g >-> identity) ||= x  instance Interpreted (Store s) where 	type Primary (Store s) a = (:*:) s :. (->) s := a

@@ -11,6 +11,7 @@ import Pandora.Pattern.Category (Category ((.), ($), (#), identity)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>))) import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))+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)@@ -31,12 +32,16 @@ instance Covariant (Flip (:*:) a) where 	f <$> (Flip (x :*: y)) = Flip $ f x :*: y -instance Extractable (Flip (:*:) a) where+instance Extractable (Flip (:*:) a) (->) where 	extract (Flip (x :*: _)) = x +instance Adjoint (Flip Product s) ((->) s) where+	x -| f = \s -> f $ Flip $ x :*: s+	Flip (x :*: s) |- f = f x s+ instance Morphable (Into Maybe) (Conclusion e) where 	type Morphing (Into Maybe) (Conclusion e) = Maybe-	morphing = conclusion (Nothing !) Just . premorph+	morphing = conclusion (Nothing !.) Just . premorph  instance Morphable (Into (Conclusion e)) Maybe where 	type Morphing (Into (Conclusion e)) Maybe = (->) e <:.> Conclusion e@@ -99,7 +104,7 @@ 	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 <$>)+		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@@ -107,6 +112,6 @@ 	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 <$>)+		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,6 +1,7 @@+{-# LANGUAGE AllowAmbiguousTypes #-} {-# OPTIONS_GHC -fno-warn-orphans #-} -module Pandora.Paradigm.Primary.Functor (module Exports, Equivalence, Comparison, match) where+module Pandora.Paradigm.Primary.Functor (module Exports, Equivalence, Comparison, match, (-<*>-)) where  import Pandora.Paradigm.Primary.Functor.Fix as Exports import Pandora.Paradigm.Primary.Functor.Convergence as Exports@@ -21,7 +22,8 @@ import Pandora.Paradigm.Primary.Functor.Function as Exports  import Pandora.Pattern.Category (($))-import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))+import Pandora.Pattern.Functor.Applicative (Applicative_ (multiply))+import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)), Adjoint_ ((--|-), (-|--))) import Pandora.Paradigm.Primary.Object.Boolean (Boolean, (?)) import Pandora.Paradigm.Primary.Object.Ordering (Ordering) @@ -34,5 +36,17 @@ 	(|-) :: (s :*: a) -> (a -> s -> b) -> b 	~(s :*: x) |- f = f x s +instance Adjoint_ (Product s) ((->) s) (->) (->) where+	(--|-) :: ((s :*: a) -> b) -> a -> (s -> b)+	f --|- x = \s -> f $ s :*: x+	(-|--) :: (a -> s -> b) -> (s :*: a) -> b+	f -|-- ~(s :*: x) = f x s++instance Applicative_ ((->) e) (:*:) (->) (->) where+	multiply f (g :*: h) = \x -> f $ g x :*: h x+ match :: Predicate a -> (a -> r) -> a -> r -> r :*: a match (Predicate p) f x r = p x ? (f x :*: x) $ r :*: x++(-<*>-) :: forall a b t v . (Applicative_ t v (->) (->), Adjoint_ (v (a -> b)) ((->) (a -> b)) (->) (->), Adjoint_ (v (t (a -> b))) ((->) (t (a -> b))) (->) (->)) => t (a -> b) -> t a -> t b+(-<*>-) = (%) ((--|-) @(v (t (a -> b))) (multiply @t @v @(->) @(->) ((&) -|--)))

@@ -2,19 +2,21 @@  import Pandora.Core.Functor (type (~>)) import Pandora.Pattern.Category (identity, (.), ($), (#))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))-import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))+import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_)) import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)), Applicative_ (multiply)) import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)), Bindable_ (join_)) import Pandora.Pattern.Functor.Monad (Monad)-import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))+import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)), Bivariant_ ((-<->-))) import Pandora.Pattern.Object.Setoid (Setoid ((==))) import Pandora.Pattern.Object.Chain (Chain ((<=>))) import Pandora.Pattern.Object.Semigroup (Semigroup ((+))) import Pandora.Paradigm.Primary.Object.Boolean (Boolean (False)) import Pandora.Paradigm.Primary.Object.Ordering (Ordering (Less, Greater))+import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:))+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip)) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite)) import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM)) import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))@@ -26,13 +28,35 @@ 	f <$> Success x = Success $ f x 	_ <$> Failure y = Failure y -instance Pointable (Conclusion e) where+instance Covariant_ (Conclusion e) (->) (->) where+	f -<$>- Success x = Success $ f x+	_ -<$>- Failure y = Failure y++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 Pointable_ (Conclusion e) (->) where+	point_ = Success+ instance Applicative (Conclusion e) where 	Success f <*> x = f <$> x 	Failure y <*> _ = Failure y +instance Applicative_ (Conclusion e) (:*:) (->) (->) where+	multiply f (Success x :*: Success y) = Success . f $ x :*: y+	multiply _ (Failure x :*: _) = Failure x+	multiply _ (_ :*: Failure x) = Failure x++instance Applicative_ (Conclusion e) Conclusion (->) (->) where+	multiply f (Failure (Success x)) = Success . f $ Failure x+	multiply f (Success (Success y)) = Success . f $ Success y+	multiply _ (Failure (Failure e)) = Failure e+	multiply _ (Success (Failure e)) = Failure e+ instance Alternative (Conclusion e) where 	Failure _ <+> x = x 	Success x <+> _ = Success x@@ -45,10 +69,18 @@ 	Success x >>= f = f x 	Failure y >>= _ = Failure y +instance Bindable_ (Conclusion e) (->) where+	join_ (Success (Success x)) = Success x+	join_ (Success (Failure y)) = Failure y+	join_ (Failure y) = Failure y+ instance Monad (Conclusion e) where  instance Bivariant Conclusion where 	f <-> g = conclusion # Failure . f # Success . g++instance Bivariant_ Conclusion (->) (->) (->) where+	f -<->- g = conclusion # Failure . f # Success . g  instance (Setoid e, Setoid a) => Setoid (Conclusion e a) where 	Success x == Success y = x == y

@@ -1,7 +1,7 @@ module Pandora.Paradigm.Primary.Functor.Constant where  import Pandora.Pattern.Category (($))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<))) import Pandora.Pattern.Functor.Invariant (Invariant ((<$<))) import Pandora.Pattern.Functor.Pointable (Pointable (point))@@ -22,6 +22,9 @@  instance Covariant (Constant a) where 	_ <$> Constant x = Constant x++instance Covariant_ (Constant a) (->) (->) where+	_ -<$>- Constant x = Constant x  instance Contravariant (Constant a) where 	_ >$< Constant x = Constant x

@@ -1,7 +1,7 @@ module Pandora.Paradigm.Primary.Functor.Convergence where  import Pandora.Pattern.Category (($), (#))-import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))+import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)), Contravariant_ ((->$<-))) import Pandora.Pattern.Functor.Divisible (Divisible ((>*<))) import Pandora.Pattern.Object.Ringoid (Ringoid ((*))) import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)))@@ -10,6 +10,9 @@  instance Contravariant (Convergence r) where 	f >$< Convergence g = Convergence $ \x y -> g # f x # f y++instance Contravariant_ (Convergence r) (->) (->) where+	f ->$<- Convergence g = Convergence $ \x y -> g # f x # f y  instance Ringoid r => Divisible (Convergence r) where 	Convergence g >*< Convergence h = Convergence $

@@ -1,7 +1,7 @@ module Pandora.Paradigm.Primary.Functor.Edges where  import Pandora.Pattern.Category (($))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Traversable (Traversable ((->>))) import Pandora.Paradigm.Primary.Functor.Function ()@@ -13,6 +13,12 @@ 	f <$> Connect x = Connect $ f x 	f <$> Overlay x = Overlay $ f x 	f <$> Leap x = Leap $ f x++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 	Empty ->> _ = point Empty

@@ -3,17 +3,19 @@ module Pandora.Paradigm.Primary.Functor.Function where  import Pandora.Pattern.Category (Category ((.), ($), (#), identity))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))+import Pandora.Pattern.Functor.Contravariant (Contravariant_ ((->$<-))) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>))) import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))+import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_))+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)), Bindable_ (join_)) import Pandora.Pattern.Functor.Representable (Representable (Representation, (<#>), tabulate))-import Pandora.Pattern.Functor.Divariant (Divariant ((>->)))+import Pandora.Pattern.Functor.Divariant (Divariant ((>->)), Divariant_ ((->->-))) import Pandora.Pattern.Object.Semigroup (Semigroup ((+))) import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip)) -infixr 2 !+infixr 2 !. infixr 9 % infixl 1 & @@ -24,18 +26,30 @@ instance Covariant ((->) a) where 	(<$>) = (.) +instance Covariant_ ((->) a) (->) (->) where+	(-<$>-) = (.)++instance Contravariant_ (Flip (->) a) (->) (->) where+	f ->$<- Flip g = Flip $ g . f+ instance Applicative ((->) e) where 	(<*>) f g x = f x $ g x  instance Distributive ((->) e) where 	g >>- f = \e -> (f % e) <$> g -instance Pointable ((->) e) where-	point = (!)+instance Pointable ((->) e) (->) where+	point = (!.) +instance Pointable_ ((->) e) (->) where+	point_ = (!.)+ instance Bindable ((->) e) where 	f >>= g = \x -> g # f x # x +instance Bindable_ ((->) e) (->) where+	join_ f = \x -> f x # x+ instance Representable ((->) e) where 	type Representation ((->) e) = e 	(<#>) = (identity %)@@ -44,23 +58,29 @@ instance Divariant ((->)) where 	(>->) ab cd bc = cd . bc . ab +instance Divariant_ ((->)) (->) (->) (->) where+	(->->-) ab cd bc = cd . bc . ab+ instance Semigroup r => Semigroup (e -> r) where 	f + g = \e -> f e + g e  instance Ringoid r => Ringoid (e -> r) where 	f * g = \e -> f e * g e -{-# INLINE (!) #-}-(!) :: a -> b -> a-x ! _ = x+(-.#..-) :: (Covariant_ (v a) (->) target, Category v) => v c d -> target (v a (v b c)) (v a (v b d))+(-.#..-) f = (-<$>-) (f .) -{-# INLINE (!!) #-}-(!!) :: a -> b -> c -> a-(!!) x _ _ = x+{-# INLINE (!.) #-}+(!.) :: a -> b -> a+x !. _ = x -{-# INLINE (!!!) #-}-(!!!) :: a -> b -> c -> d -> a-(!!!) x _ _ _ = x+{-# INLINE (!..) #-}+(!..) :: a -> b -> c -> a+(!..) x _ _ = x++{-# INLINE (!...) #-}+(!...) :: a -> b -> c -> d -> a+(!...) x _ _ _ = x  {-# INLINE (%) #-} (%) :: (a -> b -> c) -> b -> a -> c

@@ -1,13 +1,13 @@ module Pandora.Paradigm.Primary.Functor.Identity where  import Pandora.Pattern.Category ((.), ($))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), comap))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), comap), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_)) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>))) import Pandora.Pattern.Functor.Traversable (Traversable ((->>))) import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)), Bindable_ (join_)) import Pandora.Pattern.Functor.Extendable (Extendable ((=>>))) import Pandora.Pattern.Functor.Monad (Monad) import Pandora.Pattern.Functor.Comonad (Comonad)@@ -29,10 +29,16 @@ instance Covariant Identity where 	f <$> Identity x = Identity $ f x -instance Pointable Identity where+instance Covariant_ Identity (->) (->) where+	f -<$>- Identity x = Identity $ f x++instance Pointable Identity (->) where 	point = Identity -instance Extractable Identity where+instance Pointable_ Identity (->) where+	point_ = Identity++instance Extractable Identity (->) where 	extract (Identity x) = x  instance Applicative Identity where@@ -47,12 +53,15 @@ instance Bindable Identity where 	Identity x >>= f = f x +instance Bindable_ Identity (->) where+	join_ (Identity x) = x+ instance Monad Identity  instance Extendable Identity where 	x =>> f = Identity . f $ x -instance Comonad Identity+instance Comonad Identity (->)  instance Representable Identity where 	type Representation Identity = ()

@@ -2,13 +2,13 @@  import Pandora.Core.Functor (type (:.), type (:=)) import Pandora.Pattern.Category (identity, (.), ($))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))-import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_)) import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)), Applicative_ (multiply)) import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)), Bindable_ (join_)) import Pandora.Pattern.Functor.Monad (Monad) import Pandora.Pattern.Object.Setoid (Setoid ((==))) import Pandora.Pattern.Object.Chain (Chain ((<=>)))@@ -23,7 +23,9 @@ import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt)) import Pandora.Paradigm.Schemes.UT (UT (UT), type (<.:>)) import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (reduce))+import Pandora.Paradigm.Primary.Functor.Conclusion (Conclusion (Failure, Success)) import Pandora.Paradigm.Primary.Functor.Function ()+import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:))  data Maybe a = Nothing | Just a @@ -31,9 +33,16 @@ 	f <$> Just x = Just $ f x 	_ <$> Nothing = Nothing -instance Pointable Maybe where+instance Covariant_ Maybe (->) (->) where+	f -<$>- Just x = Just $ f x+	_ -<$>- Nothing = Nothing++instance Pointable Maybe (->) where 	point = Just +instance Pointable_ Maybe (->) where+	point_ = Just+ instance Avoidable Maybe where 	empty = Nothing @@ -41,6 +50,17 @@ 	Just f <*> x = f <$> x 	Nothing <*> _ = Nothing +instance Applicative_ Maybe (:*:) (->) (->) where+	multiply f (Just x :*: Just y) = Just . f $ x :*: y+	multiply _ (Nothing :*: _) = Nothing+	multiply _ (_ :*: Nothing) = Nothing++instance Applicative_ Maybe Conclusion (->) (->) where+	multiply f (Failure (Just x)) = Just . f $ Failure x+	multiply f (Success (Just y)) = Just . f $ Success y+	multiply _ (Failure Nothing) = Nothing+	multiply _ (Success Nothing) = Nothing+ instance Alternative Maybe where 	Nothing <+> y = y 	Just x <+> _ = Just x@@ -52,6 +72,10 @@ instance Bindable Maybe where 	Just x >>= f = f x 	Nothing >>= _ = Nothing++instance Bindable_ Maybe (->) where+	join_ (Just x) = x +	join_ Nothing = Nothing  instance Monad Maybe where 

@@ -2,16 +2,16 @@  import Pandora.Core.Functor (type (~>), type (:=>)) import Pandora.Pattern.Category ((.), ($))-import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))-import Pandora.Pattern.Functor.Divisible (Divisible ((>*<)))+import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)), Contravariant_ ((->$<-)))+import Pandora.Pattern.Functor.Divisible (Divisible ((>*<)), Divisible_ (divide)) import Pandora.Pattern.Functor.Determinable (Determinable (determine)) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Avoidable (Avoidable (empty)) import Pandora.Pattern.Object.Setoid (Setoid ((==))) import Pandora.Pattern.Object.Ringoid ((*)) import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False), bool, (?))-import Pandora.Paradigm.Primary.Functor.Function ((!))-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)))+import Pandora.Paradigm.Primary.Functor.Function ((!.))+import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:)) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))  newtype Predicate a = Predicate (a -> Boolean)@@ -24,16 +24,23 @@ instance Contravariant Predicate where 	f >$< Predicate g = Predicate $ g . f +instance Contravariant_ Predicate (->) (->) where+	f ->$<- Predicate g = Predicate $ g . f+ instance Divisible Predicate where 	Predicate g >*< Predicate h = Predicate $ \(b :*: c) -> g b * h c +instance Divisible_ Predicate (:*:) (->) (->) where+	divide f (Predicate g :*: Predicate h) = Predicate $ \r -> case f r of+		b :*: c -> g b * h c+ instance Determinable Predicate where-	determine = Predicate (True !)+	determine = Predicate (True !.)  equate :: Setoid a => a :=> Predicate equate x = Predicate (== x) -satisfy :: (Pointable t, Avoidable t) => Predicate a -> a -> t a+satisfy :: (Pointable t (->), Avoidable t) => Predicate a -> a -> t a satisfy p x = run p x ? point x $ empty  not :: Predicate ~> Predicate

@@ -2,13 +2,13 @@  import Pandora.Core.Functor (type (:=)) import Pandora.Pattern.Category (($), (#))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>))) import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))+import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)), Extendable_ (duplicate_)) import Pandora.Pattern.Functor.Comonad (Comonad)-import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))+import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)), Bivariant_ ((-<->-))) import Pandora.Pattern.Object.Setoid (Setoid ((==))) import Pandora.Pattern.Object.Semigroup (Semigroup ((+))) import Pandora.Pattern.Object.Monoid (Monoid (zero))@@ -17,6 +17,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.Transformer.Flip (Flip (Flip)) import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))  infixr 0 :*:@@ -28,7 +29,13 @@ instance Covariant (Product s) where 	f <$> x = attached x :*: f # extract x -instance Extractable (Product a) where+instance Covariant_ (Product s) (->) (->) where+	f -<$>- x = attached x :*: f # extract x++instance Covariant_ (Flip (:*:) a) (->) (->) where+	f -<$>- (Flip (x :*: y)) = Flip $ f x :*: y++instance Extractable (Product a) (->) where 	extract ~(_ :*: y) = y  instance Traversable (Product s) where@@ -37,10 +44,16 @@ instance Extendable (Product s) where 	x =>> f = attached x :*: f (attached x :*: extract x) -instance Comonad (Product s) where+instance Extendable_ (Product s) (->) where+	duplicate_ (s :*: x) = s :*: (s :*: x)  +instance Comonad (Product s) (->) where+ instance Bivariant Product where 	f <-> g = \ ~(s :*: x) -> f s :*: g x++instance Bivariant_ Product (->) (->) (->) where+	f -<->- g = \ ~(s :*: x) -> f s :*: g x  instance (Setoid s, Setoid a) => Setoid (s :*: a) where 	x == y = (attached x == attached y) * (extract x == extract y)

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

@@ -2,9 +2,9 @@  import Pandora.Core.Functor (type (:=>), type (~>)) import Pandora.Pattern.Category ((.), ($))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_)) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>))) import Pandora.Pattern.Functor.Traversable (Traversable ((->>))) import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))@@ -32,10 +32,16 @@ instance Covariant (Tagged tag) where 	f <$> Tag x = Tag $ f x -instance Pointable (Tagged tag) where+instance Covariant_ (Tagged tag) (->) (->) where+	f -<$>- Tag x = Tag $ f x++instance Pointable (Tagged tag) (->) where 	point = Tag -instance Extractable (Tagged tag) where+instance Pointable_ (Tagged tag) (->) where+	point_ = Tag++instance Extractable (Tagged tag) (->) where 	extract (Tag x) = x  instance Applicative (Tagged tag) where@@ -55,7 +61,7 @@ instance Extendable (Tagged tag) where 	x =>> f = Tag . f $ x -instance Comonad (Tagged tag)+instance Comonad (Tagged tag) (->)  instance Bivariant Tagged where 	_ <-> g = \(Tag x) -> Tag $ g x

@@ -1,8 +1,8 @@ module Pandora.Paradigm.Primary.Functor.These where  import Pandora.Pattern.Category (($), (#))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))-import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))+import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_)) import Pandora.Pattern.Functor.Traversable (Traversable ((->>))) import Pandora.Pattern.Object.Semigroup (Semigroup ((+))) import Pandora.Paradigm.Primary.Functor.Function ()@@ -14,8 +14,16 @@ 	_ <$> That y = That y 	f <$> These y x = These y $ f x -instance Pointable (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 Pointable_ (These e) (->) where+	point_ = This  instance Traversable (These e) where 	This x ->> f = This <$> f x

@@ -1,16 +1,18 @@ module Pandora.Paradigm.Primary.Functor.Validation where  import Pandora.Pattern.Category ((.), ($), (#))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))+import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_))+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)), Applicative_ (multiply)) import Pandora.Pattern.Functor.Alternative (Alternative ((<+>))) import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))+import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)), Bivariant_ ((-<->-))) import Pandora.Pattern.Object.Setoid (Setoid ((==))) import Pandora.Pattern.Object.Chain (Chain ((<=>))) import Pandora.Pattern.Object.Semigroup (Semigroup ((+))) import Pandora.Paradigm.Primary.Functor.Function ()+import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:))+import Pandora.Paradigm.Primary.Transformer.Flip (Flip (Flip)) import Pandora.Paradigm.Primary.Object.Boolean (Boolean (False)) import Pandora.Paradigm.Primary.Object.Ordering (Ordering (Less, Greater)) @@ -20,15 +22,40 @@ 	_ <$> Flaws e = Flaws e 	f <$> Validated x = Validated $ f x -instance Pointable (Validation e) where+instance Covariant_ (Validation e) (->) (->) where+	_ -<$>- Flaws e = Flaws e+	f -<$>- Validated x = Validated $ f x+	_ -<$>- Flaws e = Flaws e+	f -<$>- Validated x = Validated $ f x+	_ -<$>- Flaws e = Flaws e+	f -<$>- Validated x = Validated $ f x++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+	_ -<$>- Flip (Validated x) = Flip $ Validated x+	f -<$>- Flip (Flaws e) = Flip . Flaws $ f e+	_ -<$>- Flip (Validated x) = Flip $ Validated x++instance Pointable (Validation e) (->) where 	point = Validated +instance Pointable_ (Validation e) (->) where+	point_ = Validated+ instance Semigroup e => Applicative (Validation e) where 	Flaws e <*> Flaws e' = Flaws $ e + e' 	Flaws e <*> Validated _ = Flaws e 	Validated _ <*> Flaws e' = Flaws e' 	Validated f <*> Validated x = Validated $ f x +instance Semigroup e => Applicative_ (Validation e) (:*:) (->) (->) where+	multiply f (Validated x :*: Validated y) = Validated . f $ x :*: y+	multiply _ (Flaws x :*: Flaws y) = Flaws $ x + y+	multiply _ (Validated _ :*: Flaws y) = Flaws y+	multiply _ (Flaws x :*: Validated _) = Flaws x+ instance Alternative (Validation e) where 	Flaws _ <+> x = x 	Validated x <+> _ = Validated x@@ -39,6 +66,9 @@  instance Bivariant Validation where 	f <-> g = validation # Flaws . f # Validated . g++instance Bivariant_ Validation (->) (->) (->) where+	f -<->- g = validation # Flaws . f # Validated . g  instance (Setoid e, Setoid a) => Setoid (Validation e a) where 	Validated x == Validated y = x == y

@@ -1,8 +1,8 @@ module Pandora.Paradigm.Primary.Functor.Wedge where  import Pandora.Pattern.Category (($))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))-import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-)))+import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_)) import Pandora.Pattern.Functor.Traversable (Traversable ((->>))) import Pandora.Paradigm.Primary.Functor.Function () @@ -13,8 +13,16 @@ 	_ <$> Here x = Here x 	f <$> There x = There $ f x -instance Pointable (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 Pointable_ (Wedge e) (->) where+	point_ = There  instance Traversable (Wedge e) where 	Nowhere ->> _ = point Nowhere

@@ -2,9 +2,9 @@  import Pandora.Core.Functor (type (~>)) import Pandora.Pattern.Category ((#))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))+import Pandora.Pattern.Functor.Applicative ((<*>)) import Pandora.Pattern.Functor.Traversable (Traversable ((->>))) import Pandora.Pattern.Object.Semigroup (Semigroup ((+))) import Pandora.Pattern.Object.Monoid (Monoid (zero))@@ -17,6 +17,12 @@ 	f <$> Left x = Left # f x 	f <$> Right y = Right # f y 	f <$> Both x y = Both # f x # f y++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 Traversable Wye where 	End ->> _ = point End

@@ -1,3 +1,5 @@+{-# OPTIONS_GHC -fno-warn-orphans #-}+ module Pandora.Paradigm.Primary.Transformer (module Exports) where  import Pandora.Paradigm.Primary.Transformer.Yoneda as Exports@@ -13,3 +15,10 @@ import Pandora.Paradigm.Primary.Transformer.Reverse as Exports import Pandora.Paradigm.Primary.Transformer.Backwards as Exports import Pandora.Paradigm.Primary.Transformer.Flip as Exports++import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))++instance Interpreted (Flip v a) where+	type Primary (Flip v a) e = v e a+	run ~(Flip x) = x+	unite = Flip

@@ -1,10 +1,10 @@ module Pandora.Paradigm.Primary.Transformer.Backwards where  import Pandora.Pattern.Category ((.), ($), (#))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<))) import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_)) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>))) import Pandora.Pattern.Functor.Traversable (Traversable ((->>))) import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))@@ -19,10 +19,16 @@ instance Covariant t => Covariant (Backwards t) where 	f <$> Backwards x = Backwards $ f <$> x -instance Pointable t => Pointable (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+instance Pointable_ t (->) => Pointable_ (Backwards t) (->) where+	point_ = Backwards . point_++instance Extractable t (->) => Extractable (Backwards t) (->) where 	extract (Backwards x) = extract x  instance Applicative t => Applicative (Backwards t) where

@@ -4,14 +4,14 @@  import Pandora.Core.Functor (type (:.), type (:=), type (:=>), type (~>)) import Pandora.Pattern.Category ((.), ($), (#))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)), Covariant_ ((-<$>-)), (-<$$>-)) import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))-import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Pointable (Pointable (point), Pointable_ (point_)) import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Alternative (Alternative ((<+>))) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (<**>))) import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=), ($>>=)))+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=), ($>>=)) , Bindable_ (join_)) import Pandora.Pattern.Functor.Extendable (Extendable ((=>>), extend)) import Pandora.Pattern.Functor.Monad (Monad) import Pandora.Pattern.Functor.Comonad (Comonad)@@ -33,10 +33,16 @@ instance Covariant t => Covariant (Construction t) where 	f <$> ~(Construct x xs) = Construct # f x # f <$$> xs -instance Avoidable t => Pointable (Construction t) where+instance Covariant_ t (->) (->) => Covariant_ (Construction t) (->) (->) where+	f -<$>- ~(Construct x xs) = Construct # f x # f -<$$>- xs++instance (Avoidable t, Covariant_ t (->) (->)) => Pointable (Construction t) (->) where 	point x = Construct x empty -instance Covariant t => Extractable (Construction t) where+instance (Avoidable t, Covariant_ t (->) (->)) => Pointable_ (Construction t) (->) where+	point_ x = Construct x empty++instance Covariant_ t (->) (->) => Extractable (Construction t) (->) where 	extract ~(Construct x _) = x  instance Applicative t => Applicative (Construction t) where@@ -45,29 +51,32 @@ instance Traversable t => Traversable (Construction t) where 	~(Construct x xs) ->> f = Construct <$> f x <*> xs ->>> f -instance Alternative t => Bindable (Construction t) where+instance (Alternative t, Covariant_ t (->) (->)) => Bindable (Construction t) where 	~(Construct x xs) >>= f = Construct # extract (f x) # deconstruct (f x) <+> xs $>>= f +instance (Covariant_ t (->) (->), Alternative t) => Bindable_ (Construction t) (->) where+	join_ (Construct x xs) = Construct # extract x # deconstruct x <+> (join_ @_ @(->) -<$>- xs)+ instance Covariant t => Extendable (Construction t) where 	x =>> f = Construct # f x # extend f <$> deconstruct x -instance (Avoidable t, Alternative t) => Monad (Construction t) where+instance (Avoidable t, Alternative t, Covariant_ t (->) (->)) => Monad (Construction t) where -instance Covariant t => Comonad (Construction t) where+instance (Covariant t, Covariant_ t (->) (->)) => Comonad (Construction t) (->) where  instance Lowerable Construction where-	lower x = extract <$> deconstruct x+	lower x = extract @_ @(->) -<$>- deconstruct x  instance Hoistable Construction where-	f /|\ x = Construct # extract x $ f # hoist f <$> deconstruct x+	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, Covariant_ 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, Covariant_ 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, Covariant_ t (->) (->)) => Monoid (Construction t a) where 	zero = Construct zero zero  instance Monotonic a (t :. Construction t := a) => Monotonic a (Construction t a) where@@ -83,5 +92,5 @@ (.-+) :: Covariant t => a :=> t -> a :=> Construction t f .-+ x = Construct x $ (f .-+) <$> f x -section :: Comonad t => t ~> Construction t+section :: Comonad t (->) => t ~> Construction t section xs = Construct # extract xs $ xs =>> section

@@ -2,7 +2,7 @@  import Pandora.Core.Functor (type (:.), type (:=), type (::|:.)) import Pandora.Pattern.Category ((.), ($), (#))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>))) import Pandora.Pattern.Functor.Traversable (Traversable)@@ -10,7 +10,7 @@ import Pandora.Pattern.Functor.Monad (Monad) import Pandora.Pattern.Transformer.Liftable (Liftable (lift)) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))-import Pandora.Paradigm.Primary.Functor.Function ((!), (%))+import Pandora.Paradigm.Primary.Functor.Function ((!.), (%))  newtype Continuation r t a = Continuation ((->) ::|:. a :. t := r) @@ -22,7 +22,10 @@ instance Covariant t => Covariant (Continuation r t) where 	f <$> Continuation continuation = Continuation $ continuation . (. f) -instance Covariant t => Pointable (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 => Applicative (Continuation r t) where@@ -38,15 +41,15 @@  -- | Call with current continuation cwcc :: ((a -> Continuation r t b) -> Continuation r t a) -> Continuation r t a-cwcc f = Continuation $ \g -> (run % g) . f $ Continuation . (!) . g+cwcc f = Continuation $ \g -> (run % g) . f $ Continuation . (!.) . g  -- | Delimit the continuation of any 'shift' reset :: (forall u . Bindable u, Monad t, Traversable t) => Continuation r t r -> Continuation s t r reset = 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 :: Pointable 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 :: Pointable t (->) => ((a -> Continuation a t a) -> Continuation a t a) -> t a interruptable = (run % point) . cwcc

@@ -1,14 +1,16 @@+{-# LANGUAGE UndecidableInstances #-}+ module Pandora.Paradigm.Primary.Transformer.Day where  import Pandora.Pattern.Category (($), (#))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (.#..)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (.#..)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>))) import Pandora.Pattern.Functor.Extendable (Extendable ((=>>))) import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower)) import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))-import Pandora.Paradigm.Primary.Functor.Function ((!!))+import Pandora.Paradigm.Primary.Functor.Function ((!..), (-.#..-)) import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)))  data Day t u a = forall b c . Day (t b) (u c) (b -> c -> a)@@ -16,21 +18,24 @@ 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 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 (Applicative t, Applicative u) => Applicative (Day t u) where 	Day tb uc bcad <*> Day vb wc bca = Day # (:*:) <$> tb <*> vb # (:*:) <$> uc <*> wc 		$ \(b :*: b') (c :*: c') -> bcad b c $ bca b' c' -instance (Extractable t, Extractable u) => Extractable (Day t u) where+instance (Extractable t (->), Extractable u (->)) => Extractable (Day t u) (->) where 	extract (Day tb uc bcad) = bcad # extract tb # extract uc  instance (Extendable t, Extendable u) => Extendable (Day t u) where-	day@(Day tb uc _) =>> f = Day tb uc (f day !!)+	day@(Day tb uc _) =>> f = Day tb uc (f day !..) -instance Extractable t => Lowerable (Day t) where-	lower (Day tb uc bca) = bca (extract tb) <$> uc+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

@@ -1,17 +1,3 @@-{-# LANGUAGE UndecidableInstances #-}- module Pandora.Paradigm.Primary.Transformer.Flip where -import Pandora.Pattern.Functor.Covariant (Covariant)-import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (||=)))- newtype Flip (v :: * -> * -> *) a e = Flip (v e a)--instance Interpreted (Flip v a) where-	type Primary (Flip v a) e = v e a-	run ~(Flip x) = x-	unite = Flip--instance (forall i . Covariant (Flip v i), Bivariant v) => Bivariant (Flip v) where-	f <-> g = (g <-> f ||=)

@@ -4,7 +4,7 @@  import Pandora.Core.Functor (type (:.), type (:=)) import Pandora.Pattern.Category (($))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)), Covariant_ ((-<$>-)), (-<$$>-)) import Pandora.Pattern.Functor.Avoidable (Avoidable (empty)) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))@@ -23,7 +23,11 @@ 	f <$> Enter x = Enter $ f x 	f <$> Instruct xs = Instruct $ f <$$> xs -instance Covariant t => Pointable (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 Alternative t => Alternative (Instruction t) where@@ -48,7 +52,7 @@ 	Instruct xs ->> f = Instruct <$> xs ->>> f  instance Liftable Instruction where-	lift x = Instruct $ Enter <$> x+	lift x = Instruct $ Enter -<$>- x  instance (forall t . Monad t) => Lowerable Instruction where 	lower (Enter x) = point x

@@ -1,7 +1,9 @@+{-# LANGUAGE UndecidableInstances #-}+ module Pandora.Paradigm.Primary.Transformer.Jack where  import Pandora.Pattern.Category (identity, (.), ($), (#))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))@@ -25,7 +27,11 @@ 	f <$> It x = It $ f x 	f <$> Other y = Other $ f <$> y -instance Covariant t => Pointable (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 Alternative t => Alternative (Jack t) where@@ -36,7 +42,7 @@ instance Avoidable t => Avoidable (Jack t) where 	empty = Other empty -instance Extractable t => Extractable (Jack t) where+instance Extractable t (->) => Extractable (Jack t) (->) where 	extract (It x) = x 	extract (Other y) = extract y @@ -53,7 +59,7 @@ instance Distributive t => Distributive (Jack t) where 	x >>- f = distribute $ f <$> x -instance (Pointable t, Bindable t) => Bindable (Jack t) where+instance (Pointable t (->), Bindable t) => Bindable (Jack t) where 	It x >>= f = f x 	Other x >>= f = Other $ x >>= jack point identity . f 

@@ -1,6 +1,8 @@+{-# LANGUAGE UndecidableInstances #-}+ module Pandora.Paradigm.Primary.Transformer.Jet where -import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), (<$$>))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), (<$$>), Covariant_ ((-<$>-)), (-<$$>-)) import Pandora.Pattern.Functor.Avoidable (Avoidable (empty)) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Extractable (Extractable (extract))@@ -12,11 +14,14 @@ instance Covariant t => Covariant (Jet t) where 	f <$> Jet x xs = Jet (f x) (f <$$> xs) +instance Covariant_ t (->) (->) => Covariant_ (Jet t) (->) (->) where+	f -<$>- Jet x xs = Jet (f x) (f -<$$>- xs)+ instance Traversable t => Traversable (Jet t) where 	Jet x xs ->> f = Jet <$> f x <*> xs ->>> f -instance (forall u . Avoidable u) => Pointable (Jet t) where+instance (forall u . Avoidable u, Covariant_ t (->) (->)) => Pointable (Jet t) (->) where 	point x = Jet x empty -instance Covariant t => Extractable (Jet t) where+instance Covariant_ t (->) (->) => Extractable (Jet t) (->) where 	extract (Jet x _) = x

@@ -1,8 +1,8 @@ module Pandora.Paradigm.Primary.Transformer.Kan where  import Pandora.Pattern.Category ((.), ($))-import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Contravariant (Contravariant_ ((->$<-)))+import Pandora.Pattern.Functor.Covariant (Covariant_ ((-<$>-))) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite)) import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right)) @@ -10,8 +10,8 @@  data instance Kan Left t u b a = Lan ((t b -> a) -> u b) -instance Contravariant (Kan Left t u b) where-	f >$< Lan x = Lan $ x . (f .)+instance Contravariant_ (Kan Left t u b) (->) (->) where+	f ->$<- Lan x = Lan $ x . (f .)  instance Interpreted (Kan Left t u b) where 	type Primary (Kan Left t u b) a = (t b -> a) -> u b@@ -20,8 +20,8 @@  data instance Kan Right t u b a = Ran ((a -> t b) -> u b) -instance Covariant (Kan Right t u b) where-	f <$> Ran x = Ran $ x . (. f)+instance Covariant_ (Kan Right t u b) (->) (->) where+	f -<$>- Ran x = Ran $ x . (. f)  instance Interpreted (Kan Right t u b) where 	type Primary (Kan Right t u b) a = (a -> t b) -> u b

@@ -1,7 +1,9 @@+{-# LANGUAGE UndecidableInstances #-}+ module Pandora.Paradigm.Primary.Transformer.Outline where  import Pandora.Pattern.Category (identity, (.), ($), (#))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))@@ -18,10 +20,14 @@ 	f <$> Line a = Line $ f a 	f <$> Outlined x y = Outlined x # (.) f <$> y -instance Pointable (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+instance Extractable t (->) => Extractable (Outline t) (->) where 	extract (Line x) = x 	extract (Outlined x y) = extract y # extract x @@ -36,7 +42,7 @@ 	_ /|\ Line x = Line x 	f /|\ Outlined x y = Outlined # f x # f /|\ y -instance (Extractable t, Pointable t, Applicative t) => Interpreted (Outline t) where+instance (Extractable t (->), Pointable t (->), Applicative t) => Interpreted (Outline t) where 	type Primary (Outline t) a = t a 	run (Line x) = point x 	run (Outlined t f) = run f <*> t

@@ -1,7 +1,9 @@+{-# LANGUAGE UndecidableInstances #-}+ module Pandora.Paradigm.Primary.Transformer.Reverse where  import Pandora.Pattern.Category ((.), ($), (#))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<))) import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Pointable (Pointable (point))@@ -19,10 +21,13 @@ instance Covariant t => Covariant (Reverse t) where 	f <$> Reverse x = Reverse # f <$> x -instance Pointable t => Pointable (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 Extractable t => Extractable (Reverse t) where+instance Extractable t (->) => Extractable (Reverse t) (->) where 	extract (Reverse x) = extract x  instance Applicative t => Applicative (Reverse t) where

@@ -1,8 +1,10 @@+{-# LANGUAGE UndecidableInstances #-}+ module Pandora.Paradigm.Primary.Transformer.Tap where  import Pandora.Core.Functor (type (:=)) import Pandora.Pattern.Category ((.), ($), (#))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Avoidable (Avoidable (empty)) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Extractable (Extractable (extract))@@ -15,9 +17,11 @@ import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower)) import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\))) import Pandora.Paradigm.Inventory.Store (Store (Store))+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)  import Pandora.Paradigm.Primary.Functor.Function ((%)) import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:))+import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), twosome)+import Pandora.Paradigm.Primary.Transformer.Reverse (Reverse (Reverse)) import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right)) import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>)) import Pandora.Paradigm.Schemes.P_Q_T (P_Q_T (P_Q_T))@@ -29,10 +33,13 @@ instance Covariant t => Covariant (Tap t) where 	f <$> Tap x xs = Tap # f x # f <$> xs -instance Avoidable t => Pointable (Tap t) where+instance Covariant_ t (->) (->) => Covariant_ (Tap t) (->) (->) where+	f -<$>- Tap x xs = Tap # f x # f -<$>- xs++instance (Avoidable t, Covariant_ t (->) (->)) => Pointable (Tap t) (->) where 	point = Tap % empty -instance Covariant t => Extractable (Tap t) where+instance (Covariant t, Covariant_ t (->) (->))  => Extractable (Tap t) (->) where 	extract (Tap x _) = x  instance Applicative t => Applicative (Tap t) where@@ -41,10 +48,10 @@ instance Traversable t => Traversable (Tap t) where 	Tap x xs ->> f = Tap <$> f x <*> xs ->> f -instance (Extractable t, Alternative t, Bindable t) => Bindable (Tap t) where+instance (Extractable t (->), Alternative t, Bindable t) => Bindable (Tap t) where 	Tap x xs >>= f = case f x of ~(Tap y ys) -> Tap y $ ys <+> (xs >>= lower . f) -instance Extendable t => Extendable (Tap t) where+instance (Extendable t, Covariant_ t (->) (->)) => Extendable (Tap t) where 	x =>> f = Tap # f x $ lower x =>> f . Tap (extract x)  instance Lowerable Tap where@@ -53,19 +60,26 @@ instance Hoistable Tap where 	f /|\ Tap x xs = Tap x # f xs -instance Covariant t => Substructure Root (Tap (t <:.:> t := (:*:))) where+instance {-# OVERLAPS #-} Applicative t => Applicative (Tap (t <:.:> t := (:*:))) where+	Tap f (T_U (lfs :*: rfs)) <*> Tap x (T_U (ls :*: rs)) = Tap # f x # T_U (lfs <*> ls :*: rfs <*> rs)++instance {-# OVERLAPS #-} Traversable t => Traversable (Tap (t <:.:> t := (:*:))) where+	Tap x (T_U (future :*: past)) ->> f = (\past' x' future' -> Tap x' $ twosome # future' # run past')+		<$> Reverse past ->> f <*> f x <*> future ->> f++instance (Covariant t, 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, 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, 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

@@ -1,8 +1,10 @@+{-# LANGUAGE UndecidableInstances #-}+ module Pandora.Paradigm.Primary.Transformer.Yoneda where  import Pandora.Pattern.Category (identity, (.), ($), (#)) import Pandora.Pattern.Functor ((<*+>))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Alternative (Alternative ((<+>))) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>))) import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))@@ -10,7 +12,7 @@ import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-))) import Pandora.Pattern.Transformer.Liftable (Liftable (lift))-import Pandora.Paradigm.Primary.Functor.Function ((!))+import Pandora.Paradigm.Primary.Functor.Function ((!.))  newtype Yoneda t a = Yoneda 	{ yoneda :: forall b . (a -> b) -> t b }@@ -18,6 +20,9 @@ instance Covariant (Yoneda t) where 	f <$> x = Yoneda (\k -> yoneda x (k . f)) +instance Covariant_ (Yoneda t) (->) (->) where+	f -<$>- x = Yoneda (\k -> yoneda x (k . f))+ instance Alternative t => Alternative (Yoneda t) where 	Yoneda f <+> Yoneda g = Yoneda (f <*+> g) @@ -25,17 +30,17 @@ 	Yoneda f <*> Yoneda x = Yoneda (\g -> f (g .) <*> x identity)  instance Avoidable t => Avoidable (Yoneda t) where-	empty = Yoneda (empty !)+	empty = Yoneda (empty !.) -instance Pointable t => Pointable (Yoneda t) where+instance Pointable t (->) => Pointable (Yoneda t) (->) where 	point x = Yoneda (\f -> point $ f x) -instance Extractable t => Extractable (Yoneda t) where+instance Extractable t (->) => Extractable (Yoneda t) (->) where 	extract (Yoneda f) = extract $ f identity  instance Liftable Yoneda where-	lift x = Yoneda (<$> x)+	lift x = Yoneda (-<$>- x) -instance (Extractable t, Pointable t, Extractable u, Pointable u) => Adjoint (Yoneda t) (Yoneda u) where+instance (Extractable t (->), Pointable t (->), Extractable u (->) , Pointable u (->)) => Adjoint (Yoneda t) (Yoneda u) where 	x -| f = point . f . point # x 	x |- g = extract . extract # g <$> x

@@ -2,7 +2,7 @@  import Pandora.Core.Functor (type (:.), type (:=), type (~>)) import Pandora.Pattern.Category ((.), ($))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)), Covariant_ ((-<$>-)), (-<$$>-)) import Pandora.Pattern.Functor.Contravariant (Contravariant) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (<**>))) import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))@@ -34,6 +34,9 @@ instance (Covariant t, Covariant u) => Covariant (t <:.> u) where 	f <$> x = TU $ f <$$> run x +instance (Covariant_ t (->) (->), Covariant_ u (->) (->)) => Covariant_ (t <:.> u) (->) (->) where+	f -<$>- x = TU $ f -<$$>- run x+ instance (Applicative t, Applicative u) => Applicative (t <:.> u) where 	TU f <*> TU x = TU $ f <**> x @@ -43,10 +46,10 @@ instance (Covariant u, Avoidable t) => Avoidable (t <:.> u) where 	empty = TU empty -instance (Pointable t, Pointable u) => Pointable (t <:.> u) where+instance (Pointable t (->), Pointable u (->)) => Pointable (t <:.> u) (->) where 	point = TU . point . point -instance (Extractable t, Extractable u) => Extractable (t <:.> u) where+instance (Extractable t (->), Extractable u (->)) => Extractable (t <:.> u) (->) where 	extract = extract . extract . run  instance (Traversable t, Traversable u) => Traversable (t <:.> u) where@@ -55,11 +58,11 @@ instance (Bindable t, Distributive t, Bindable u) => Bindable (t <:.> u) where 	TU x >>= f = TU $ x >>= \i -> join <$> i >>- run . f -instance Pointable t => Liftable (TU Covariant Covariant t) where-	lift :: Covariant u => u ~> t <:.> u+instance Pointable t (->) => Liftable (TU Covariant Covariant t) where+	lift :: Covariant_ u (->) (->) => u ~> t <:.> u 	lift = TU . point -instance Extractable t => Lowerable (TU Covariant Covariant t) where+instance Extractable t (->) => Lowerable (TU Covariant Covariant t) where 	lower :: t <:.> u ~> u 	lower (TU x) = extract x 

@@ -3,7 +3,7 @@ import Pandora.Core.Functor (type (:.), type (:=), type (~>)) import Pandora.Pattern.Category (identity, (.), ($)) import Pandora.Pattern.Functor ((<*+>))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$$>)), Covariant_ ((-<$>-)), (-<$$$>-)) import Pandora.Pattern.Functor.Contravariant (Contravariant) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>))) import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))@@ -39,31 +39,34 @@ instance (Covariant t, Covariant t', Covariant u) => Covariant (t <:<.>:> t' := u) where 	f <$> TUT x = TUT $ f <$$$> x -instance (Adjoint t' t, Bindable u) => Applicative (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', Adjoint t' t, Bindable u) => Applicative (t <:<.>:> t' := u) where 	f <*> x = TUT $ (>>= (|- (<$$$> run x))) <$> run f  instance (Applicative t, Covariant t', Alternative u) => Alternative (t <:<.>:> t' := u) where 	x <+> y = TUT $ run x <*+> run y -instance (Pointable t, Applicative t, Covariant t', Avoidable u) => Avoidable (t <:<.>:> t' := u) where+instance (Pointable t (->), Applicative t, Covariant t', Avoidable u) => Avoidable (t <:<.>:> t' := u) where 	empty = TUT $ point empty -instance (Pointable u, Adjoint t' t) => Pointable (t <:<.>:> t' := u) where+instance (Covariant_ t (->) (->), Covariant_ t' (->) (->), Pointable u (->), Adjoint t' t) => Pointable (t <:<.>:> t' := u) (->) where 	point = unite . (-| point) -instance (Adjoint t' t, Bindable u) => Bindable (t <:<.>:> t' := u) where+instance (Covariant t, Covariant t', Adjoint t' t, Bindable u) => Bindable (t <:<.>:> t' := u) where 	x >>= f = TUT $ run x $>>= (|- run . f) -instance (Adjoint t' t, Extendable u) => Extendable (t' <:<.>:> t := u) where+instance (Covariant t', Covariant t, Adjoint t' t, Extendable u) => Extendable (t' <:<.>:> t := u) where 	x =>> f = TUT $ run x $=>> (-| f . unite) -instance (Adjoint t t', Extractable u) => Extractable (t <:<.>:> t' := u) where+instance (Covariant_ t (->) (->), Covariant_ t' (->) (->), Adjoint t t', Extractable u (->)) => Extractable (t <:<.>:> t' := u) (->) where 	extract = (|- extract) . run -instance (Adjoint t' t, Distributive t) => Liftable (t <:<.>:> t') where-	lift :: Covariant u => u ~> t <:<.>:> t' := u+instance (forall u . Covariant u, Adjoint t' t, Distributive t) => Liftable (t <:<.>:> t') where+	lift :: Covariant_ u (->) (->) => u ~> t <:<.>:> t' := u 	lift x = TUT $ x >>- (-| identity) -instance (Adjoint t t', Distributive t') => Lowerable (t <:<.>:> t') where-	lower :: Covariant u => (t <:<.>:> t' := u) ~> u+instance (forall u . Covariant u, Adjoint t t', Distributive t') => Lowerable (t <:<.>:> t') where+	lower :: Covariant_ u (->) (->) => (t <:<.>:> t' := u) ~> u 	lower (TUT x) = x |- (>>- identity)

@@ -1,10 +1,10 @@ module Pandora.Paradigm.Schemes.T_U where  import Pandora.Core.Functor (type (:=))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))-import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))-import Pandora.Pattern.Functor.Divariant (Divariant ((>->)))+import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)), Bivariant_ ((-<->-)))+import Pandora.Pattern.Functor.Divariant (Divariant ((>->)))  import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (||=)))  newtype T_U ct cu p t u a = T_U (p (t a) (u a))@@ -23,6 +23,9 @@  instance (forall i . Covariant (p i), Bivariant p, Covariant t, Covariant u) => Covariant (t <:.:> u := p) where 	f <$> x = (f <$>) <-> (f <$>) ||= x++instance (forall i . Covariant_ (p i) (->) (->), Bivariant_ p (->) (->) (->), Covariant_ t (->) (->), Covariant_ u (->) (->)) => Covariant_ (t <:.:> u := p) (->) (->) where+	f -<$>- x = (f -<$>-) -<->- (f -<$>-) ||= x  instance (Divariant p, Contravariant t, Covariant u) => Covariant (t >:.:> u := p) where 	f <$> x = (f >$<) >-> (f <$>) ||= x

@@ -2,7 +2,7 @@  import Pandora.Core.Functor (type (:.), type (:=), type (~>)) import Pandora.Pattern.Category ((.), ($))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)), Covariant_ ((-<$>-)), (-<$$>-)) import Pandora.Pattern.Functor.Contravariant (Contravariant) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (<**>))) import Pandora.Pattern.Functor.Pointable (Pointable (point))@@ -31,22 +31,25 @@ instance (Covariant t, Covariant u) => Covariant (t <.:> u) where 	f <$> UT x = UT $ f <$$> x +instance (Covariant_ t (->) (->), Covariant_ u (->) (->)) => Covariant_ (t <.:> u) (->) (->) where+	f -<$>- UT x = UT $ f -<$$>- x+ instance (Applicative t, Applicative u) => Applicative (t <.:> u) where 	UT f <*> UT x = UT $ f <**> x -instance (Pointable t, Pointable u) => Pointable (t <.:> u) where+instance (Pointable t (->), Pointable u (->)) => Pointable (t <.:> u) (->) where 	point = UT . point . point  instance (Traversable t, Bindable t, Applicative u, Monad u) => Bindable (t <.:> u) where 	UT x >>= f = UT $ x >>= \i -> join <$> i ->> run . f -instance (Extractable t, Extractable u) => Extractable (t <.:> u) where+instance (Extractable t (->), Extractable u (->)) => Extractable (t <.:> u) (->) where 	extract = extract . extract . run -instance Pointable t => Liftable (UT Covariant Covariant t) where-	lift :: Covariant u => u ~> t <.:> u-	lift x = UT $ point <$> x+instance Pointable t (->) => Liftable (UT Covariant Covariant t) where+	lift :: Covariant_ u (->) (->) => u ~> t <.:> u+	lift x = UT $ point @_ @(->) -<$>- x -instance Extractable t => Lowerable (UT Covariant Covariant t) where-	lower :: Covariant u => t <.:> u ~> u-	lower (UT x) = extract <$> x+instance Extractable t (->) => Lowerable (UT Covariant Covariant t) where+	lower :: Covariant_ u (->) (->) => t <.:> u ~> u+	lower (UT x) = extract @_ @(->) -<$>- x

@@ -9,7 +9,7 @@  import Pandora.Core.Functor (type (:=)) import Pandora.Pattern.Category (($), (.), (#))-import Pandora.Pattern.Functor.Covariant (Covariant (comap))+import Pandora.Pattern.Functor.Covariant (Covariant (comap), Covariant_) import Pandora.Pattern.Functor.Extractable (extract) import Pandora.Pattern.Functor.Pointable (point) import Pandora.Pattern.Transformer.Liftable (lift)@@ -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, 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, 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, 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

@@ -2,7 +2,7 @@  import Pandora.Pattern.Category ((#)) import Pandora.Pattern.Functor.Covariant ((.#..))-import Pandora.Paradigm.Primary.Functor.Function ((!))+import Pandora.Paradigm.Primary.Functor.Function ((!.))  class Monotonic a e where 	{-# MINIMAL reduce #-}@@ -10,7 +10,7 @@  	-- | Version of `reduce` which ignores accumulator 	resolve :: (a -> r) -> r -> e -> r-	resolve g = reduce # g .#.. (!)+	resolve g = reduce # g .#.. (!.)  instance Monotonic a a where 	reduce f r x = f x r

@@ -4,7 +4,7 @@ module Pandora.Paradigm.Structure.Ability.Substructure where  import Pandora.Core.Functor (type (:=))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_) import Pandora.Pattern.Functor.Divariant ((>->)) import Pandora.Pattern.Transformer.Liftable (lift) import Pandora.Pattern.Transformer.Lowerable (lower)@@ -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 :: (Covariant structure, Covariant_ structure (->) (->)) => structure #=@ Substance segment structure := Available segment structure 	sub = lift >-> (lower <$>) ||= substructure @segment @structure

@@ -8,7 +8,7 @@ import Pandora.Pattern.Object.Setoid (Setoid ((!=))) import Pandora.Pattern.Object.Semigroup ((+)) import Pandora.Pattern.Object.Quasiring (one)-import Pandora.Paradigm.Primary.Functor.Function ((!), (%))+import Pandora.Paradigm.Primary.Functor.Function ((!.), (%)) import Pandora.Paradigm.Primary.Functor.Convergence (Convergence (Convergence)) import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Nothing)) import Pandora.Paradigm.Primary.Functor.Predicate (Predicate, equate)@@ -26,4 +26,4 @@ subset = Convergence $ \s ss -> Nothing != ss ->> (find @f @t @Maybe % s) . equate  cardinality :: Traversable t => t a -> Numerator-cardinality s = attached . run @(State _) % Zero $ s ->> (modify @Numerator (+ one) !)+cardinality s = attached . run @(State _) % Zero $ s ->> (modify @Numerator (+ one) !.)

@@ -5,7 +5,7 @@  import Pandora.Core.Functor (type (:=)) import Pandora.Pattern.Category ((.), ($))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Contravariant ((>$<)) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))@@ -37,7 +37,10 @@ instance Covariant (t <:.> Construction t) => Covariant (Comprehension t) where 	f <$> Comprehension x = Comprehension $ f <$> x -instance (Avoidable t, Pointable t) => Pointable (Comprehension t) where+instance Covariant_ (t <:.> Construction t) (->) (->) => Covariant_ (Comprehension t) (->) (->) where+	f -<$>- Comprehension x = Comprehension $ f -<$>- x++instance (Avoidable t, Pointable t (->)) => Pointable (Comprehension t) (->) where 	point = Comprehension . TU . point . Construct % empty  instance Alternative t => Alternative (Comprehension t) where@@ -49,13 +52,13 @@ instance Traversable (t <:.> Construction t) => Traversable (Comprehension t) where 	Comprehension x ->> f = Comprehension <$> x ->> f -instance (forall a . Semigroup (t <:.> Construction t := a), Bindable t, Pointable t, Avoidable t) => Applicative (Comprehension t) where+instance (forall a . Semigroup (t <:.> Construction t := a), Bindable t, Pointable t (->), Avoidable t) => Applicative (Comprehension t) where 	fs <*> xs = fs >>= \f -> xs >>= Comprehension . TU . point . point . f  instance (forall a . Semigroup (t <:.> Construction t := a), Bindable t) => Bindable (Comprehension t) where 	Comprehension (TU t) >>= f = Comprehension . TU $ t >>= \(Construct x xs) -> run . run $ f x + (Comprehension (TU xs) >>= f) -instance (forall a . Semigroup (t <:.> Construction t := a), Pointable t, Avoidable t, Bindable t) => Monad (Comprehension t) where+instance (forall a . Semigroup (t <:.> Construction t := a), Pointable t (->), Avoidable t, Bindable t) => Monad (Comprehension t) where  instance Setoid (t <:.> Construction t := a) => Setoid (Comprehension t a) where 	Comprehension ls == Comprehension rs = ls == rs@@ -66,7 +69,7 @@ instance Monoid (t <:.> Construction t := a) => Monoid (Comprehension t a) where 	zero = Comprehension zero -instance Pointable t => Morphable Push (Comprehension t) where+instance (Covariant t, Covariant_ t (->) (->), Pointable 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 

@@ -5,7 +5,7 @@  import Pandora.Core.Functor (type (:.), type (:=)) import Pandora.Pattern.Category ((.), ($))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)), Covariant_ ((-<$>-)), (-<$$>-)) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>))) import Pandora.Pattern.Functor.Extractable (extract)@@ -27,10 +27,13 @@ instance Covariant t => Covariant (Prefixed t k) where 	f <$> Prefixed x = Prefixed $ f <$$> x +instance Covariant_ t (->) (->) => Covariant_ (Prefixed t k) (->) (->) where+	f -<$>- Prefixed x = Prefixed $ f -<$$>- x+ instance Traversable t => Traversable (Prefixed t k) where 	Prefixed x ->> f = Prefixed <$> x ->>> f -instance (Monoid k, Pointable t) => Pointable (Prefixed t k) where+instance (Monoid k, Pointable t (->)) => Pointable (Prefixed t k) (->) where 	point = Prefixed . point . (:*:) zero  instance Alternative t => Alternative (Prefixed t k) where

@@ -4,7 +4,7 @@  import Pandora.Core.Functor (type (:.), type (:=), type (:=>), type (:::)) import Pandora.Pattern.Category ((.), ($), (#))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), ($$$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), ($$$>)), Covariant_ ((-<$>-))) import Pandora.Pattern.Functor.Extractable (extract) import Pandora.Pattern.Functor.Avoidable (empty) import Pandora.Pattern.Functor.Bindable ((>>=))@@ -168,6 +168,11 @@ 	_ <$> Top = Top 	f <$> Leftward l = Leftward $ f l 	f <$> Rightward r = Rightward $ f r++instance Covariant_ Biforked (->) (->) where+	_ -<$>- Top = Top+	f -<$>- Leftward l = Leftward $ f l+	f -<$>- Rightward r = Rightward $ f r  type Bifurcation = Biforked <:.> Construction Biforked 

@@ -210,13 +210,6 @@  type instance Zipper (Construction Maybe) (Left ::: Right) = Tap (Construction Maybe <:.:> Construction Maybe := (:*:)) -instance {-# OVERLAPS #-} Applicative (Tap (Construction Maybe <:.:> Construction Maybe := (:*:))) where-	Tap f (T_U (lfs :*: rfs)) <*> Tap x (T_U (ls :*: rs)) = Tap # f x # T_U (lfs <*> ls :*: rfs <*> rs)--instance {-# OVERLAPS #-} Traversable (Tap (Construction Maybe <:.:> Construction Maybe := (:*:))) where-	Tap x (T_U (future :*: past)) ->> f = (\past' x' future' -> Tap x' $ twosome # future' # run past')-		<$> Reverse past ->> f <*> f x <*> future ->> f- instance Morphable (Rotate Left) (Tap (Construction Maybe <:.:> Construction Maybe := (:*:))) where 	type Morphing (Rotate Left) (Tap (Construction Maybe <:.:> Construction Maybe := (:*:))) = 		Maybe <:.> Tap (Construction Maybe <:.:> Construction Maybe := (:*:))

@@ -13,7 +13,7 @@ import Pandora.Pattern.Transformer.Lowerable (lower) import Pandora.Pattern.Object.Setoid (Setoid ((==), (!=))) import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False), (?))-import Pandora.Paradigm.Primary.Functor.Function ((!), (%))+import Pandora.Paradigm.Primary.Functor.Function ((!.), (%)) import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity)) import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing)) import Pandora.Paradigm.Primary.Functor.Predicate (Predicate (Predicate), equate)@@ -50,7 +50,7 @@ 	type Available Just Rose = Identity 	type Substance Just Rose = List <:.> Construction List 	substructure = P_Q_T $ \rose -> case run . extract . run # rose of-		Nothing -> Store $ Identity empty :*: (lift empty !)+		Nothing -> Store $ Identity empty :*: (lift empty !.) 		Just (Construct x xs) -> Store $ Identity (TU xs) :*: lift . lift . Construct x . run . extract  --------------------------------------- Non-empty rose tree ----------------------------------------

@@ -1,7 +1,7 @@ module Pandora.Pattern.Functor.Adjoint where  import Pandora.Core.Functor (type (:.), type (:=))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>), (<$$$>), (<$$$$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>), (<$$$>), (<$$$$>)), Covariant_)  type (-|) = Adjoint @@ -15,7 +15,7 @@ > * Right adjunction interchange: psi f ≡ epsilon . comap f -} -class (Covariant t, Covariant u) => Adjoint t u where+class Adjoint t u where 	{-# MINIMAL (-|), (|-) #-} 	-- | Left adjunction 	(-|) :: a -> (t a -> b) -> u b@@ -50,3 +50,7 @@ 	($$$$|-) :: (Covariant v, Covariant w, Covariant x, Covariant y) => 		v :. w :. x :. y :. t := a -> (a -> u b) -> v :. w :. x :. y := b 	x $$$$|- f = (|- f) <$$$$> x++class (Covariant_ t target source, Covariant_ u source target) => Adjoint_ t u source target where+	(--|-) :: source (t a) b -> target a (u b)+	(-|--) :: target a (u b) -> source (t a) b

@@ -2,6 +2,7 @@  import Pandora.Core.Functor (type (:.), type (:=)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$)))+import Pandora.Pattern.Functor.Bivariant (Bivariant)  infixl 4 <*>, <*, *> infixl 3 <**>@@ -45,3 +46,6 @@ 		-> t :. u :. v :. w := a 		-> t :. u :. v :. w := b 	f <****> x = (<***>) <$> f <*> x++class Bivariant v => Applicative_ t v source target where+	multiply :: source (v a b) r -> target (v (t a) (t b)) (t r)

@@ -1,7 +1,7 @@ module Pandora.Pattern.Functor.Bindable where  import Pandora.Core.Functor (type (:.), type (:=))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_)  infixl 1 >>= infixr 1 =<<, <=<, >=>@@ -34,3 +34,6 @@  	($>>=) :: Covariant u => u :. t := a -> (a -> t b) -> u :. t := b 	x $>>= f = (>>= f) <$> x++class Covariant_ t source source => Bindable_ t source where+	join_ :: source (t (t a)) (t a)

@@ -1,6 +1,7 @@ module Pandora.Pattern.Functor.Bivariant where -import Pandora.Pattern.Functor.Covariant (Covariant)+import Pandora.Pattern.Functor.Covariant (Covariant, Covariant_)+import Pandora.Paradigm.Primary.Transformer.Flip (Flip)  infixl 4 <-> @@ -17,3 +18,7 @@ 	-- | Prefix version of '<->' 	bimap :: (forall i . Covariant (v i)) => (a -> b) -> (c -> d) -> v a c -> v b d 	bimap f g x = (f <-> g) x++class (forall i . Covariant_ (v i) left target, forall i . Covariant_ (Flip v i) right target)+	=> Bivariant_ v left right target where+	(-<->-) :: left a b -> right c d -> target (v a c) (v b d) 

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

@@ -1,8 +1,9 @@ module Pandora.Pattern.Functor.Contravariant where  import Pandora.Core.Functor (type (:.), type (:=))+import Pandora.Pattern.Category (Category) -infixl 4 >$<, $<, >$+infixl 4 >$<, ->$<-, $<, >$  {- | > When providing a new instance, you should ensure it satisfies:@@ -50,3 +51,6 @@ 	(>&&&&<) :: (Contravariant u, Contravariant v, Contravariant w) 		=> t :. u :. v :. w := a -> (a -> b) -> t :. u :. v :. w := b 	x >&&&&< f = f >$$$$< x++class (Category source, Category target) => Contravariant_ t source target where+	(->$<-) :: source a b -> target (t b) (t a)

@@ -3,8 +3,8 @@ import Pandora.Core.Functor (type (:.), type (:=), type (<:=)) import Pandora.Pattern.Category (Category ((.))) -infixl 4 <$>, <$, $>-infixl 3 <$$>+infixl 4 <$>, -<$>-, <$, $>+infixl 3 <$$>, -<<$$>-, -<$$>>- infixl 2 <$$$> infixl 1 <$$$$> @@ -94,3 +94,28 @@  	($$$$>) :: (Covariant u, Covariant v, Covariant w) => t :. u :. v :. w := a -> b -> t :. u :. v :. w := b 	s $$$$> x = (\_-> x) <$$$$> s++class (Category source, Category target) => Covariant_ t source target where+	(-<$>-) :: source a b -> target (t a) (t b)+	+(-<$$>-) :: forall t u category a b +	. (Covariant_ u category category, Covariant_ t category category) +	=> category a b -> category (t (u a)) (t (u b))+(-<$$>-) s = ((-<$>-) ((-<$>-) @u @category @category s))++(-<<$$>-) :: forall t u source target a b +	. (Covariant_ u source source, Covariant_ t source target) +	=> source a b -> target (t (u a)) (t (u b))+(-<<$$>-) s = ((-<$>-) ((-<$>-) @u @source @source s))++(-<$$>>-) :: forall t u source target a b +	. (Covariant_ u source target, Covariant_ t target target) +	=> source a b -> target (t (u a)) (t (u b))+(-<$$>>-) s = ((-<$>-) ((-<$>-) @u @source @target s))++-- TODO: Figure out how to work with hidden type variables+-- to put intermediate category `between`+(-<$$$>-) :: forall t u v source target a b+	. (Covariant_ u source source, Covariant_ t source target, Covariant_ v target target) +	=> source a b -> target (v (t (u a))) (v (t (u b)))+(-<$$$>-) s = ((-<$>-) ((-<$>-) @t @source @target ((-<$>-) @u @source @source s)))

@@ -1,6 +1,8 @@ module Pandora.Pattern.Functor.Divariant where -import Pandora.Pattern.Functor.Covariant (Covariant)+import Pandora.Pattern.Functor.Covariant (Covariant, Covariant_)+import Pandora.Pattern.Functor.Contravariant (Contravariant_)+import Pandora.Paradigm.Primary.Transformer.Flip (Flip)  infixl 4 >-> @@ -16,3 +18,7 @@ 	-- | Prefix version of '>->' 	dimap :: (a -> b) -> (c -> d) -> v b c -> v a d 	dimap f g x = (f >-> g) x++class (forall i . Contravariant_ (Flip v i) left target, forall i . Covariant_ (v i) right target) +	=> Divariant_ v left right target where+	(->->-) :: left a b -> right c d -> target (v b c) (v a d)

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

@@ -1,7 +1,7 @@ module Pandora.Pattern.Functor.Extendable where  import Pandora.Core.Functor (type (:.), type (:=))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), Covariant_)  infixl 1 =>> infixr 1 <<=, =<=, =>=@@ -39,3 +39,6 @@ 	x $=>> f = (=>> f) <$> x 	(<<=$) :: Covariant u => u :. t := a -> (t a -> b) -> u :. t := b 	x <<=$ f = (=>> f) <$> x++class Covariant_ t source source => Extendable_ t source where+	duplicate_ :: source (t a) (t (t a))

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

@@ -1,5 +1,6 @@ module Pandora.Pattern.Functor.Monad where +import Pandora.Pattern.Functor.Covariant (Covariant_) import Pandora.Pattern.Functor.Bindable (Bindable ((>>=))) import Pandora.Pattern.Functor.Pointable (Pointable (point)) @@ -17,7 +18,7 @@ infixl 1 >>=-, ->>= infixr 1 -=<<, =<<- -class (Pointable t, Bindable t) => Monad t where+class (Covariant_ t (->) (->), Pointable t (->), Bindable t) => Monad t where 	(>>=-) :: t a -> t b -> t a 	(>>=-) x y = x >>= \r -> y >>= \_ -> point r 	(->>=) :: t a -> t b -> t b

@@ -1,11 +1,10 @@ module Pandora.Pattern.Functor.Pointable where -import Pandora.Core.Functor (type (:=>))-import Pandora.Pattern.Functor.Covariant (Covariant)+import Pandora.Pattern.Functor.Covariant (Covariant_) -class Covariant t => Pointable t where+class Covariant_ t source source => Pointable t source where 	{-# MINIMAL point #-}-	point :: a :=> t+	point :: source a (t a) -	pass :: t ()-	pass = point ()+class Pointable_ t target where+	point_ :: target a (t a)

@@ -13,7 +13,7 @@  infixr 6 <#> -class Pointable t => Representable t where+class Pointable t (->) => Representable t where 	{-# MINIMAL (<#>), tabulate #-} 	type Representation t :: * 	-- | Infix and flipped version of 'index'

@@ -21,22 +21,22 @@ class Covariant t => Traversable t where 	{-# MINIMAL (->>) #-} 	-- | Infix version of 'traverse'-	(->>) :: (Pointable u, Applicative u) => t a -> (a -> u b) -> u :. t := b+	(->>) :: (Pointable u (->), Applicative u) => t a -> (a -> u b) -> u :. t := b  	-- | Prefix version of '->>'-	traverse :: (Pointable u, Applicative u) => (a -> u b) -> t a -> u :. t := b+	traverse :: (Pointable u (->), Applicative u) => (a -> u b) -> t a -> u :. t := b 	traverse f t = t ->> f 	-- | The dual of 'distribute'-	sequence :: (Pointable u, Applicative u) => t :. u := a -> u :. t := a+	sequence :: (Pointable u (->), Applicative u) => t :. u := a -> u :. t := a 	sequence t = t ->> (\x -> x)  	-- | Infix versions of `traverse` with various nesting levels-	(->>>) :: (Pointable u, Applicative u, Traversable v)+	(->>>) :: (Pointable u (->), Applicative u, Traversable v) 		=> v :. t := a -> (a -> u b) -> u :. v :. t := b 	x ->>> f = x ->> (->> f)-	(->>>>) :: (Pointable u, Applicative u, Traversable v, Traversable w)+	(->>>>) :: (Pointable u (->), Applicative u, Traversable v, Traversable w) 		=> w :. v :. t := a -> (a -> u b) -> u :. w :. v :. t := b 	x ->>>> f = x ->> (->> (->> f))-	(->>>>>) :: (Pointable u, Applicative u, Traversable v, Traversable w, Traversable j)+	(->>>>>) :: (Pointable u (->), Applicative u, Traversable v, Traversable w, Traversable j) 		=> j :. w :. v :. t := a -> (a -> u b) -> u :. j :. w :. v :. t := b 	x ->>>>> f = x ->> (->> (->> (->> f)))

@@ -1,7 +1,7 @@ module Pandora.Pattern.Transformer.Hoistable (Hoistable (..)) where  import Pandora.Core.Functor (type (~>))-import Pandora.Pattern.Functor.Covariant (Covariant)+import Pandora.Pattern.Functor.Covariant (Covariant_)  {- | > When providing a new instance, you should ensure it satisfies one law:@@ -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,7 +1,7 @@ module Pandora.Pattern.Transformer.Liftable (Liftable (..)) where  import Pandora.Core.Functor (type (~>))-import Pandora.Pattern.Functor.Covariant (Covariant)+import Pandora.Pattern.Functor.Covariant (Covariant_)  {- | > When providing a new instance, you should ensure it satisfies one law:@@ -9,4 +9,4 @@ -}  class Liftable t where-	lift :: Covariant u => u ~> t u+	lift :: (Covariant_ u (->) (->)) => u ~> t u

@@ -1,7 +1,7 @@ module Pandora.Pattern.Transformer.Lowerable (Lowerable (..)) where  import Pandora.Core.Functor (type (~>))-import Pandora.Pattern.Functor.Covariant (Covariant)+import Pandora.Pattern.Functor.Covariant (Covariant_)  {- | > When providing a new instance, you should ensure it satisfies one law:@@ -9,4 +9,4 @@ -}  class Lowerable t where-	lower :: Covariant u => t u ~> u+	lower :: (Covariant_ u (->) (->)) => t u ~> u

@@ -1,5 +1,5 @@ name:                pandora-version:             0.4.2+version:             0.4.3 synopsis:            A box of patterns and paradigms description:         Humble attempt to define a library for problem solving based on math abstractions. homepage:            https://github.com/iokasimov/pandora