pandora 0.2.8 → 0.2.9

raw patch · 94 files changed

+1074/−927 lines, 94 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• CHANGELOG.md +16/−1
• Pandora/Paradigm/Controlflow.hs +1/−1
• Pandora/Paradigm/Controlflow/Effect.hs +7/−0
• Pandora/Paradigm/Controlflow/Effect/Adaptable.hs +319/−0
• Pandora/Paradigm/Controlflow/Effect/Interpreted.hs +6/−0
• Pandora/Paradigm/Controlflow/Effect/Schematic.hs +3/−0
• Pandora/Paradigm/Controlflow/Effect/Transformer.hs +10/−0
• Pandora/Paradigm/Controlflow/Effect/Transformer/Comonadic.hs +59/−0
• Pandora/Paradigm/Controlflow/Effect/Transformer/Monadic.hs +59/−0
• Pandora/Paradigm/Controlflow/Joint.hs +0/−7
• Pandora/Paradigm/Controlflow/Joint/Adaptable.hs +0/−320
• Pandora/Paradigm/Controlflow/Joint/Interpreted.hs +0/−6
• Pandora/Paradigm/Controlflow/Joint/Schematic.hs +0/−3
• Pandora/Paradigm/Controlflow/Joint/Schemes.hs +0/−41
• Pandora/Paradigm/Controlflow/Joint/Schemes/TU.hs +0/−27
• Pandora/Paradigm/Controlflow/Joint/Schemes/TUT.hs +0/−28
• Pandora/Paradigm/Controlflow/Joint/Schemes/TUVW.hs +0/−10
• Pandora/Paradigm/Controlflow/Joint/Schemes/UT.hs +0/−22
• Pandora/Paradigm/Controlflow/Joint/Schemes/UTU.hs +0/−10
• Pandora/Paradigm/Controlflow/Joint/Transformer.hs +0/−10
• Pandora/Paradigm/Controlflow/Joint/Transformer/Comonadic.hs +0/−60
• Pandora/Paradigm/Controlflow/Joint/Transformer/Monadic.hs +0/−60
• Pandora/Paradigm/Controlflow/Observable.hs +1/−2
• Pandora/Paradigm/Controlflow/Pipeline.hs +1/−1
• Pandora/Paradigm/Inventory.hs +2/−3
• Pandora/Paradigm/Inventory/Accumulator.hs +12/−13
• Pandora/Paradigm/Inventory/Environment.hs +12/−13
• Pandora/Paradigm/Inventory/Equipment.hs +11/−12
• Pandora/Paradigm/Inventory/Imprint.hs +11/−12
• Pandora/Paradigm/Inventory/Optics.hs +6/−7
• Pandora/Paradigm/Inventory/State.hs +21/−23
• Pandora/Paradigm/Inventory/Store.hs +19/−21
• Pandora/Paradigm/Primary/Functor/Conclusion.hs +6/−7
• Pandora/Paradigm/Primary/Functor/Constant.hs +1/−1
• Pandora/Paradigm/Primary/Functor/Edges.hs +2/−1
• Pandora/Paradigm/Primary/Functor/Identity.hs +1/−2
• Pandora/Paradigm/Primary/Functor/Maybe.hs +6/−7
• Pandora/Paradigm/Primary/Functor/Predicate.hs +1/−2
• Pandora/Paradigm/Primary/Functor/Product.hs +1/−1
• Pandora/Paradigm/Primary/Functor/Tagged.hs +2/−3
• Pandora/Paradigm/Primary/Functor/These.hs +1/−1
• Pandora/Paradigm/Primary/Functor/Validation.hs +1/−2
• Pandora/Paradigm/Primary/Functor/Wedge.hs +1/−1
• Pandora/Paradigm/Primary/Functor/Wye.hs +1/−1
• Pandora/Paradigm/Primary/Transformer.hs +1/−0
• Pandora/Paradigm/Primary/Transformer/Backwards.hs +2/−3
• Pandora/Paradigm/Primary/Transformer/Construction.hs +2/−3
• Pandora/Paradigm/Primary/Transformer/Continuation.hs +1/−2
• Pandora/Paradigm/Primary/Transformer/Instruction.hs +1/−1
• Pandora/Paradigm/Primary/Transformer/Jack.hs +1/−2
• Pandora/Paradigm/Primary/Transformer/Kan.hs +2/−3
• Pandora/Paradigm/Primary/Transformer/Outline.hs +2/−3
• Pandora/Paradigm/Primary/Transformer/Reverse.hs +2/−3
• Pandora/Paradigm/Primary/Transformer/Tap.hs +44/−0
• Pandora/Paradigm/Primary/Transformer/Yoneda.hs +2/−3
• Pandora/Paradigm/Schemes.hs +40/−0
• Pandora/Paradigm/Schemes/TU.hs +32/−0
• Pandora/Paradigm/Schemes/TUT.hs +35/−0
• Pandora/Paradigm/Schemes/TUVW.hs +10/−0
• Pandora/Paradigm/Schemes/UT.hs +28/−0
• Pandora/Paradigm/Schemes/UTU.hs +21/−0
• Pandora/Paradigm/Structure/Ability.hs +2/−0
• Pandora/Paradigm/Structure/Ability/Focusable.hs +15/−6
• Pandora/Paradigm/Structure/Ability/Nonempty.hs +1/−1
• Pandora/Paradigm/Structure/Ability/Rotatable.hs +13/−0
• Pandora/Paradigm/Structure/Ability/Substructure.hs +11/−3
• Pandora/Paradigm/Structure/Ability/Zipper.hs +3/−0
• Pandora/Paradigm/Structure/Binary.hs +79/−57
• Pandora/Paradigm/Structure/Rose.hs +22/−24
• Pandora/Paradigm/Structure/Stack.hs +32/−23
• Pandora/Paradigm/Structure/Stream.hs +1/−1
• Pandora/Pattern/Category.hs +4/−0
• Pandora/Pattern/Functor/Adjoint.hs +1/−1
• Pandora/Pattern/Functor/Alternative.hs +1/−1
• Pandora/Pattern/Functor/Applicative.hs +1/−1
• Pandora/Pattern/Functor/Avoidable.hs +1/−1
• Pandora/Pattern/Functor/Bindable.hs +1/−1
• Pandora/Pattern/Functor/Bivariant.hs +2/−2
• Pandora/Pattern/Functor/Comonad.hs +1/−1
• Pandora/Pattern/Functor/Contravariant.hs +1/−1
• Pandora/Pattern/Functor/Covariant.hs +14/−2
• Pandora/Pattern/Functor/Determinable.hs +1/−1
• Pandora/Pattern/Functor/Distributive.hs +1/−1
• Pandora/Pattern/Functor/Divariant.hs +2/−6
• Pandora/Pattern/Functor/Extendable.hs +8/−2
• Pandora/Pattern/Functor/Extractable.hs +1/−1
• Pandora/Pattern/Functor/Invariant.hs +1/−1
• Pandora/Pattern/Functor/Monad.hs +1/−1
• Pandora/Pattern/Functor/Pointable.hs +1/−1
• Pandora/Pattern/Functor/Representable.hs +1/−1
• Pandora/Pattern/Functor/Traversable.hs +1/−1
• Pandora/Pattern/Transformer/Liftable.hs +2/−2
• Pandora/Pattern/Transformer/Lowerable.hs +2/−2
• pandora.cabal +20/−16

@@ -222,7 +222,7 @@ * Define `Delta` datatype * Define `Wedge` datatype * Rename `Variation` to `These`-* Define two experimental methods in `Bindable` class - `$>>=` and `>>=$`+* Define experimental methods in `Bindable` class - `$>>=` and `>>=$` * Define `here` and `there` methods from `Wedge` to `Maybe` * Move `Boolean` definition to its own module * Move `Ordering` definition to its own module@@ -230,3 +230,18 @@ * Define `Focusable` typeclass for getting root and creating singleton * Replace `top` method of `Stack` structure with `Focusable` instance * Add `Covariant` constraint on `natural transformation` in `Hoistable` typeclass++# 0.2.9+* Define `Zipper` type family to walk datastructures with context+* Define `Tap` datatype for context dependent values+* Define type synonyms for `TU`, `UT`, `TUT` and `UTU` joint schemes+* Move `Schemes` module to `Paradigm` submodule+* Move `$` definition from `Divariant` to `Category`+* Define generalized point free combinators in `Covariant` module+* Rename `Joint` module To `Effect`+* Define left and right `zig`, `zig-zig` and `zig-zag` `Splay` rotations for `Binary` tree+* Define experimental methods in `Extendable` class - `$=>>` and `<<=$`+* Define `Rotatable` typeclass to rotate trees+* Rename `sub` method of `Substructure` typeclass to `substructure`+* Define `sub` method which doesn't involve `Tagged`+* Change `Focusable` typeclass - now it's possible to point not only top/root

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

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

@@ -0,0 +1,319 @@+{-# LANGUAGE UndecidableInstances #-}++module Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (..)) where++import Pandora.Core.Functor (type (~>))+import Pandora.Pattern.Category (identity, (.))+import Pandora.Pattern.Functor.Covariant (Covariant)+import Pandora.Pattern.Functor.Pointable (Pointable)+import Pandora.Pattern.Functor.Extractable (Extractable)+import Pandora.Pattern.Functor.Comonad (Comonad)+import Pandora.Pattern.Functor.Monad (Monad)+import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic)+import Pandora.Paradigm.Controlflow.Effect.Transformer (Transformer, lay, wrap, flick, bring, (:>), (:<))++class Adaptable t u where+	{-# MINIMAL adapt #-}+	adapt :: t ~> u++type Layable t u = (Transformer Monad t, Covariant u)+type Wrappable t u = (Transformer Monad t, Pointable u)+type Flickable t u = (Transformer Comonad t, Covariant u)+type Bringable t u = (Transformer Comonad t, Extractable u)++instance Covariant t => Adaptable t t where+	adapt = identity++instance (Covariant (t :> u), Layable t u) => Adaptable u (t :> u) where+	adapt = lay++instance (Covariant (t :> u), Wrappable t u) => Adaptable t (t :> u) where+	adapt = wrap++instance (Covariant (t :> u), Flickable t u) => Adaptable (t :< u) u where+	adapt = flick++instance (Covariant (t :< u), Bringable t u) => Adaptable (t :< u) t where+	adapt = bring++instance+	( Covariant (t :> u :> v)+	, Layable t (Schematic Monad u v)+	, Wrappable u v+	) => Adaptable u (t :> u :> v) where+	adapt = lay . wrap++instance+	( Covariant (t :> u :> v)+	, Layable t (Schematic Monad u v)+	, Layable u v+	) => Adaptable v (t :> u :> v) where+	adapt = lay . lay++instance+	( Covariant (t :< u :< v)+	, Flickable t (Schematic Comonad u v)+	, Bringable u v+	) => Adaptable (t :< u :< v) u where+	adapt = bring . flick++instance+	( Covariant (t :< u :< v)+	, Flickable t (Schematic Comonad u v)+	, Flickable u v+	) => Adaptable (t :< u :< v) v where+	adapt = flick . flick++instance+	( Covariant (t :> u :> v :> w)+	, Layable t (Schematic Monad u (v :> w))+	, Layable u (Schematic Monad v w)+	, Wrappable v w+	) => Adaptable v (t :> u :> v :> w) where+	adapt = lay . lay . wrap++instance+	( Covariant (t :> u :> v :> w)+	, Layable t (Schematic Monad u v)+	, Layable t (Schematic Monad u (v :> w))+	, Layable u (Schematic Monad v w)+	, Layable v w+	) => Adaptable w (t :> u :> v :> w) where+	adapt = lay . lay . lay++instance+	( Covariant (t :< u :< v :< w)+	, Flickable t (Schematic Comonad u (v :< w))+	, Flickable u (Schematic Comonad v w)+	, Bringable v w+	) => Adaptable (t :< u :< v :< w) v where+	adapt = bring . flick . flick++instance+	( Covariant (t :< u :< v :< w)+	, Flickable t (Schematic Comonad u v)+	, Flickable t (Schematic Comonad u (v :< w))+	, Flickable u (Schematic Comonad v w)+	, Flickable v w+	) => Adaptable (t :< u :< v :< w) w where+	adapt = flick . flick . flick++instance+	( Covariant (t :> u :> v :> w :> x)+	, Layable t (Schematic Monad u (v :> w :> x))+	, Layable u (Schematic Monad v (w :> x))+	, Layable v (Schematic Monad w x)+	, Layable w x+	) => Adaptable x (t :> u :> v :> w :> x) where+	adapt = lay . lay . lay . lay++instance+	( Covariant (t :> u :> v :> w :> x)+	, Layable t (Schematic Monad u (v :> w :> x))+	, Layable u (Schematic Monad v (w :> x))+	, Layable v (Schematic Monad w x)+	, Wrappable w x+	) => Adaptable w (t :> u :> v :> w :> x) where+	adapt = lay . lay . lay . wrap++instance+	( Covariant (t :< u :< v :< w :< x)+	, Flickable t (Schematic Comonad u (v :< w :< x))+	, Flickable u (Schematic Comonad v (w :< x))+	, Flickable v (Schematic Comonad w x)+	, Flickable w x+	) => Adaptable (t :< u :< v :< w :< x) x where+	adapt = flick . flick . flick . flick++instance+	( Covariant (t :< u :< v :< w :< x)+	, Flickable t (Schematic Comonad u (v :< w :< x))+	, Flickable u (Schematic Comonad v (w :< x))+	, Flickable v (Schematic Comonad w x)+	, Bringable w x+	) => Adaptable (t :< u :< v :< w :< x) w where+	adapt = bring . flick . flick . flick++instance+	( Covariant (t :> u :> v :> w :> x :> y)+	, Layable t (Schematic Monad u (v :> w :> x :> y))+	, Layable u (Schematic Monad v (w :> x :> y))+	, Layable v (Schematic Monad w (x :> y))+	, Layable w (Schematic Monad x y)+	, Layable x y+	) => Adaptable y (t :> u :> v :> w :> x :> y) where+	adapt = lay . lay . lay . lay . lay++instance+	( Covariant (t :> u :> v :> w :> x :> y)+	, Layable t (Schematic Monad u (v :> w :> x :> y))+	, Layable u (Schematic Monad v (w :> x :> y))+	, Layable v (Schematic Monad w (x :> y))+	, Layable w (Schematic Monad x y)+	, Wrappable x y+	) => Adaptable x (t :> u :> v :> w :> x :> y) where+	adapt = lay . lay . lay . lay . wrap++instance+	( Covariant (t :< u :< v :< w :< x :< y)+	, Flickable t (Schematic Comonad u (v :< w :< x :< y))+	, Flickable u (Schematic Comonad v (w :< x :< y))+	, Flickable v (Schematic Comonad w (x :< y))+	, Flickable w (Schematic Comonad x y)+	, Flickable x y+	) => Adaptable (t :< u :< v :< w :< x :< y) y where+	adapt = flick . flick . flick . flick . flick++instance+	( Covariant (t :< u :< v :< w :< x :< y)+	, Flickable t (Schematic Comonad u (v :< w :< x :< y))+	, Flickable u (Schematic Comonad v (w :< x :< y))+	, Flickable v (Schematic Comonad w (x :< y))+	, Flickable w (Schematic Comonad x y)+	, Bringable x y+	) => Adaptable (t :< u :< v :< w :< x :< y) x where+	adapt = bring . flick . flick . flick . flick++instance+	( Covariant (t :> u :> v :> w :> x :> y :> z)+	, Layable t (Schematic Monad u (v :> w :> x :> y :> z))+	, Layable u (Schematic Monad v (w :> x :> y :> z))+	, Layable v (Schematic Monad w (x :> y :> z))+	, Layable w (Schematic Monad x (y :> z))+	, Layable x (Schematic Monad y z)+	, Layable y z+	) => Adaptable z (t :> u :> v :> w :> x :> y :> z) where+	adapt = lay . lay . lay . lay . lay . lay++instance+	( Covariant (t :> u :> v :> w :> x :> y :> z)+	, Layable t (Schematic Monad u (v :> w :> x :> y :> z))+	, Layable u (Schematic Monad v (w :> x :> y :> z))+	, Layable v (Schematic Monad w (x :> y :> z))+	, Layable w (Schematic Monad x (y :> z))+	, Layable x (Schematic Monad y z)+	, Wrappable y z+	) => Adaptable y (t :> u :> v :> w :> x :> y :> z) where+	adapt = lay . lay . lay . lay . lay . wrap++instance+	( Covariant (t :< u :< v :< w :< x :< y :< z)+	, Flickable t (Schematic Comonad u (v :< w :< x :< y :< z))+	, Flickable u (Schematic Comonad v (w :< x :< y :< z))+	, Flickable v (Schematic Comonad w (x :< y :< z))+	, Flickable w (Schematic Comonad x (y :< z))+	, Flickable x (Schematic Comonad y z)+	, Flickable y z+	) => Adaptable (t :< u :< v :< w :< x :< y :< z) z where+	adapt = flick . flick . flick . flick . flick . flick++instance+	( Covariant (t :< u :< v :< w :< x :< y :< z)+	, Flickable t (Schematic Comonad u (v :< w :< x :< y :< z))+	, Flickable u (Schematic Comonad v (w :< x :< y :< z))+	, Flickable v (Schematic Comonad w (x :< y :< z))+	, Flickable w (Schematic Comonad x (y :< z))+	, Flickable x (Schematic Comonad y z)+	, Bringable y z+	) => Adaptable (t :< u :< v :< w :< x :< y :< z) y where+	adapt = bring . flick . flick . flick . flick . flick++instance+	( Covariant (t :> u :> v :> w :> x :> y :> z :> f)+	, Layable t (Schematic Monad u (v :> w :> x :> y :> z :> f))+	, Layable u (Schematic Monad v (w :> x :> y :> z :> f))+	, Layable v (Schematic Monad w (x :> y :> z :> f))+	, Layable w (Schematic Monad x (y :> z :> f))+	, Layable x (Schematic Monad y (z :> f))+	, Layable y (Schematic Monad z f)+	, Layable z f+	) => Adaptable f (t :> u :> v :> w :> x :> y :> z :> f) where+	adapt = lay . lay . lay . lay . lay . lay . lay++instance+	( Covariant (t :> u :> v :> w :> x :> y :> z :> f)+	, Layable t (Schematic Monad u (v :> w :> x :> y :> z :> f))+	, Layable u (Schematic Monad v (w :> x :> y :> z :> f))+	, Layable v (Schematic Monad w (x :> y :> z :> f))+	, Layable w (Schematic Monad x (y :> z :> f))+	, Layable x (Schematic Monad y (z :> f))+	, Layable y (Schematic Monad z f)+	, Wrappable z f+	) => Adaptable z (t :> u :> v :> w :> x :> y :> z :> f) where+	adapt = lay . lay . lay . lay . lay . lay . wrap++instance+	( Covariant (t :< u :< v :< w :< x :< y :< z :< f)+	, Flickable t (Schematic Comonad u (v :< w :< x :< y :< z :< f))+	, Flickable u (Schematic Comonad v (w :< x :< y :< z :< f))+	, Flickable v (Schematic Comonad w (x :< y :< z :< f))+	, Flickable w (Schematic Comonad x (y :< z :< f))+	, Flickable x (Schematic Comonad y (z :< f))+	, Flickable y (Schematic Comonad z f)+	, Flickable z f+	) => Adaptable (t :< u :< v :< w :< x :< y :< z :< f) f where+	adapt = flick . flick . flick . flick . flick . flick . flick++instance+	( Covariant (t :< u :< v :< w :< x :< y :< z :< f)+	, Flickable t (Schematic Comonad u (v :< w :< x :< y :< z :< f))+	, Flickable u (Schematic Comonad v (w :< x :< y :< z :< f))+	, Flickable v (Schematic Comonad w (x :< y :< z :< f))+	, Flickable w (Schematic Comonad x (y :< z :< f))+	, Flickable x (Schematic Comonad y (z :< f))+	, Flickable y (Schematic Comonad z f)+	, Bringable z f+	) => Adaptable (t :< u :< v :< w :< x :< y :< z :< f) z where+	adapt = bring . flick . flick . flick . flick . flick . flick++instance+	( Covariant (t :> u :> v :> w :> x :> y :> z :> f :> h)+	, Layable t (Schematic Monad u (v :> w :> x :> y :> z :> f :> h))+	, Layable u (Schematic Monad v (w :> x :> y :> z :> f :> h))+	, Layable v (Schematic Monad w (x :> y :> z :> f :> h))+	, Layable w (Schematic Monad x (y :> z :> f :> h))+	, Layable x (Schematic Monad y (z :> f :> h))+	, Layable y (Schematic Monad z (f :> h))+	, Layable z (Schematic Monad f h)+	, Layable f h+	) => Adaptable h (t :> u :> v :> w :> x :> y :> z :> f :> h) where+	adapt = lay . lay . lay . lay . lay . lay . lay . lay++instance+	( Covariant (t :> u :> v :> w :> x :> y :> z :> f :> h)+	, Layable t (Schematic Monad u (v :> w :> x :> y :> z :> f :> h))+	, Layable u (Schematic Monad v (w :> x :> y :> z :> f :> h))+	, Layable v (Schematic Monad w (x :> y :> z :> f :> h))+	, Layable w (Schematic Monad x (y :> z :> f :> h))+	, Layable x (Schematic Monad y (z :> f :> h))+	, Layable y (Schematic Monad z (f :> h))+	, Layable z (Schematic Monad f h)+	, Wrappable f h+	) => Adaptable f (t :> u :> v :> w :> x :> y :> z :> f :> h) where+	adapt = lay . lay . lay . lay . lay . lay . lay . wrap++instance+	( Covariant (t :< u :< v :< w :< x :< y :< z :< f :< h)+	, Flickable t (Schematic Comonad u (v :< w :< x :< y :< z :< f :< h))+	, Flickable u (Schematic Comonad v (w :< x :< y :< z :< f :< h))+	, Flickable v (Schematic Comonad w (x :< y :< z :< f :< h))+	, Flickable w (Schematic Comonad x (y :< z :< f :< h))+	, Flickable x (Schematic Comonad y (z :< f :< h))+	, Flickable y (Schematic Comonad z (f :< h))+	, Flickable z (Schematic Comonad f h)+	, Flickable f h+	) => Adaptable (t :< u :< v :< w :< x :< y :< z :< f :< h) h where+	adapt = flick . flick . flick . flick . flick . flick . flick . flick++instance+	( Covariant (t :< u :< v :< w :< x :< y :< z :< f :< h)+	, Flickable t (Schematic Comonad u (v :< w :< x :< y :< z :< f :< h))+	, Flickable u (Schematic Comonad v (w :< x :< y :< z :< f :< h))+	, Flickable v (Schematic Comonad w (x :< y :< z :< f :< h))+	, Flickable w (Schematic Comonad x (y :< z :< f :< h))+	, Flickable x (Schematic Comonad y (z :< f :< h))+	, Flickable y (Schematic Comonad z (f :< h))+	, Flickable z (Schematic Comonad f h)+	, Bringable f h+	) => Adaptable (t :< u :< v :< w :< x :< y :< z :< f :< h) f where+	adapt = bring . flick . flick . flick . flick . flick . flick . flick

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

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

@@ -0,0 +1,10 @@+module Pandora.Paradigm.Controlflow.Effect.Transformer (module Exports, Transformer) 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)++type family Transformer c t where+	Transformer Monad t = Monadic t+	Transformer Comonad t = Comonadic t

@@ -0,0 +1,59 @@+{-# LANGUAGE UndecidableInstances #-}++module Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic (Comonadic (..), (:<) (..)) where++import Pandora.Core.Functor (type (~>))+import Pandora.Pattern.Category ((.), ($))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Extractable (Extractable (extract))+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))+import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))+import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))+import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))+import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))+import Pandora.Pattern.Functor.Comonad (Comonad)+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))+import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic)++class Interpreted t => Comonadic t where+	{-# MINIMAL flick, bring #-}+	flick :: Covariant u => t :< u ~> u+	bring :: Extractable u => t :< u ~> t++infixr 3 :<+newtype (:<) t u a = TC { tc :: Schematic Comonad t u a }++instance Covariant (Schematic Comonad t u) => Covariant (t :< u) where+	f <$> TC x = TC $ f <$> x++instance Pointable (Schematic Comonad t u) => Pointable (t :< u) where+	point = TC . point++instance Extractable (Schematic Comonad t u) => Extractable (t :< u) where+	extract = extract . tc++instance Applicative (Schematic Comonad t u) => Applicative (t :< u) where+	TC f <*> TC x = TC $ f <*> x++instance Alternative (Schematic Comonad t u) => Alternative (t :< u) where+	TC x <+> TC y = TC $ x <+> y++instance Traversable (Schematic Comonad t u) => Traversable (t :< u) where+	TC x ->> f = TC <$> x ->> f++instance Distributive (Schematic Comonad t u) => Distributive (t :< u) where+	x >>- f = TC $ x >>- tc . f++instance Bindable (Schematic Comonad t u) => Bindable (t :< u) where+	TC x >>= f = TC $ x >>= tc . f++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 (Interpreted (Schematic Comonad t u)) => Interpreted (t :< u) where+	type Primary (t :< u) a = Primary (Schematic Comonad t u) a+	run (TC x) = run x

@@ -0,0 +1,59 @@+{-# LANGUAGE UndecidableInstances #-}++module Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (..), (:>) (..)) where++import Pandora.Core.Functor (type (~>))+import Pandora.Pattern.Category ((.), ($))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Extractable (Extractable (extract))+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))+import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))+import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))+import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))+import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))+import Pandora.Pattern.Functor.Monad (Monad)+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))+import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic)++class Interpreted t => Monadic t where+	{-# MINIMAL lay, wrap #-}+	lay :: Covariant u => u ~> t :> u+	wrap :: Pointable u => t ~> t :> u++infixr 3 :>+newtype (:>) t u a = TM { tm :: Schematic Monad t u a }++instance Covariant (Schematic Monad t u) => Covariant (t :> u) where+	f <$> TM x = TM $ f <$> x++instance Pointable (Schematic Monad t u) => Pointable (t :> u) where+	point = TM . point++instance Extractable (Schematic Monad t u) => Extractable (t :> u) where+	extract = extract . tm++instance Applicative (Schematic Monad t u) => Applicative (t :> u) where+	TM f <*> TM x = TM $ f <*> x++instance Alternative (Schematic Monad t u) => Alternative (t :> u) where+	TM x <+> TM y = TM $ x <+> y++instance Traversable (Schematic Monad t u) => Traversable (t :> u) where+	TM x ->> f = TM <$> x ->> f++instance Distributive (Schematic Monad t u) => Distributive (t :> u) where+	x >>- f = TM $ x >>- tm . f++instance Bindable (Schematic Monad t u) => Bindable (t :> u) where+	TM x >>= f = TM $ x >>= tm . f++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 (Interpreted (Schematic Monad t u)) => Interpreted (t :> u) where+	type Primary (t :> u) a = Primary (Schematic Monad t u) a+	run (TM x) = run x

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

@@ -1,320 +0,0 @@-{-# LANGUAGE UndecidableInstances #-}--module Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (..)) where--import Pandora.Core.Functor (type (~>))-import Pandora.Pattern.Category (identity, (.))-import Pandora.Pattern.Functor.Covariant (Covariant)-import Pandora.Pattern.Functor.Pointable (Pointable)-import Pandora.Pattern.Functor.Extractable (Extractable)-import Pandora.Pattern.Functor.Comonad (Comonad)-import Pandora.Pattern.Functor.Monad (Monad)-import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)-import Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic (Monadic (lay, wrap), (:>))-import Pandora.Paradigm.Controlflow.Joint.Transformer.Comonadic (Comonadic (flick, bring), (:<))--class Adaptable t u where-	{-# MINIMAL adapt #-}-	adapt :: t ~> u--type Layable t u = (Monadic t, Covariant u)-type Wrappable t u = (Monadic t, Pointable u)-type Flickable t u = (Comonadic t, Covariant u)-type Bringable t u = (Comonadic t, Extractable u)--instance Covariant t => Adaptable t t where-	adapt = identity--instance (Covariant (t :> u), Layable t u) => Adaptable u (t :> u) where-	adapt = lay--instance (Covariant (t :> u), Wrappable t u) => Adaptable t (t :> u) where-	adapt = wrap--instance (Covariant (t :> u), Flickable t u) => Adaptable (t :< u) u where-	adapt = flick--instance (Covariant (t :< u), Bringable t u) => Adaptable (t :< u) t where-	adapt = bring--instance-	( Covariant (t :> u :> v)-	, Layable t (Schematic Monad u v)-	, Wrappable u v-	) => Adaptable u (t :> u :> v) where-	adapt = lay . wrap--instance-	( Covariant (t :> u :> v)-	, Layable t (Schematic Monad u v)-	, Layable u v-	) => Adaptable v (t :> u :> v) where-	adapt = lay . lay--instance-	( Covariant (t :< u :< v)-	, Flickable t (Schematic Comonad u v)-	, Bringable u v-	) => Adaptable (t :< u :< v) u where-	adapt = bring . flick--instance-	( Covariant (t :< u :< v)-	, Flickable t (Schematic Comonad u v)-	, Flickable u v-	) => Adaptable (t :< u :< v) v where-	adapt = flick . flick--instance-	( Covariant (t :> u :> v :> w)-	, Layable t (Schematic Monad u (v :> w))-	, Layable u (Schematic Monad v w)-	, Wrappable v w-	) => Adaptable v (t :> u :> v :> w) where-	adapt = lay . lay . wrap--instance-	( Covariant (t :> u :> v :> w)-	, Layable t (Schematic Monad u v)-	, Layable t (Schematic Monad u (v :> w))-	, Layable u (Schematic Monad v w)-	, Layable v w-	) => Adaptable w (t :> u :> v :> w) where-	adapt = lay . lay . lay--instance-	( Covariant (t :< u :< v :< w)-	, Flickable t (Schematic Comonad u (v :< w))-	, Flickable u (Schematic Comonad v w)-	, Bringable v w-	) => Adaptable (t :< u :< v :< w) v where-	adapt = bring . flick . flick--instance-	( Covariant (t :< u :< v :< w)-	, Flickable t (Schematic Comonad u v)-	, Flickable t (Schematic Comonad u (v :< w))-	, Flickable u (Schematic Comonad v w)-	, Flickable v w-	) => Adaptable (t :< u :< v :< w) w where-	adapt = flick . flick . flick--instance-	( Covariant (t :> u :> v :> w :> x)-	, Layable t (Schematic Monad u (v :> w :> x))-	, Layable u (Schematic Monad v (w :> x))-	, Layable v (Schematic Monad w x)-	, Layable w x-	) => Adaptable x (t :> u :> v :> w :> x) where-	adapt = lay . lay . lay . lay--instance-	( Covariant (t :> u :> v :> w :> x)-	, Layable t (Schematic Monad u (v :> w :> x))-	, Layable u (Schematic Monad v (w :> x))-	, Layable v (Schematic Monad w x)-	, Wrappable w x-	) => Adaptable w (t :> u :> v :> w :> x) where-	adapt = lay . lay . lay . wrap--instance-	( Covariant (t :< u :< v :< w :< x)-	, Flickable t (Schematic Comonad u (v :< w :< x))-	, Flickable u (Schematic Comonad v (w :< x))-	, Flickable v (Schematic Comonad w x)-	, Flickable w x-	) => Adaptable (t :< u :< v :< w :< x) x where-	adapt = flick . flick . flick . flick--instance-	( Covariant (t :< u :< v :< w :< x)-	, Flickable t (Schematic Comonad u (v :< w :< x))-	, Flickable u (Schematic Comonad v (w :< x))-	, Flickable v (Schematic Comonad w x)-	, Bringable w x-	) => Adaptable (t :< u :< v :< w :< x) w where-	adapt = bring . flick . flick . flick--instance-	( Covariant (t :> u :> v :> w :> x :> y)-	, Layable t (Schematic Monad u (v :> w :> x :> y))-	, Layable u (Schematic Monad v (w :> x :> y))-	, Layable v (Schematic Monad w (x :> y))-	, Layable w (Schematic Monad x y)-	, Layable x y-	) => Adaptable y (t :> u :> v :> w :> x :> y) where-	adapt = lay . lay . lay . lay . lay--instance-	( Covariant (t :> u :> v :> w :> x :> y)-	, Layable t (Schematic Monad u (v :> w :> x :> y))-	, Layable u (Schematic Monad v (w :> x :> y))-	, Layable v (Schematic Monad w (x :> y))-	, Layable w (Schematic Monad x y)-	, Wrappable x y-	) => Adaptable x (t :> u :> v :> w :> x :> y) where-	adapt = lay . lay . lay . lay . wrap--instance-	( Covariant (t :< u :< v :< w :< x :< y)-	, Flickable t (Schematic Comonad u (v :< w :< x :< y))-	, Flickable u (Schematic Comonad v (w :< x :< y))-	, Flickable v (Schematic Comonad w (x :< y))-	, Flickable w (Schematic Comonad x y)-	, Flickable x y-	) => Adaptable (t :< u :< v :< w :< x :< y) y where-	adapt = flick . flick . flick . flick . flick--instance-	( Covariant (t :< u :< v :< w :< x :< y)-	, Flickable t (Schematic Comonad u (v :< w :< x :< y))-	, Flickable u (Schematic Comonad v (w :< x :< y))-	, Flickable v (Schematic Comonad w (x :< y))-	, Flickable w (Schematic Comonad x y)-	, Bringable x y-	) => Adaptable (t :< u :< v :< w :< x :< y) x where-	adapt = bring . flick . flick . flick . flick--instance-	( Covariant (t :> u :> v :> w :> x :> y :> z)-	, Layable t (Schematic Monad u (v :> w :> x :> y :> z))-	, Layable u (Schematic Monad v (w :> x :> y :> z))-	, Layable v (Schematic Monad w (x :> y :> z))-	, Layable w (Schematic Monad x (y :> z))-	, Layable x (Schematic Monad y z)-	, Layable y z-	) => Adaptable z (t :> u :> v :> w :> x :> y :> z) where-	adapt = lay . lay . lay . lay . lay . lay--instance-	( Covariant (t :> u :> v :> w :> x :> y :> z)-	, Layable t (Schematic Monad u (v :> w :> x :> y :> z))-	, Layable u (Schematic Monad v (w :> x :> y :> z))-	, Layable v (Schematic Monad w (x :> y :> z))-	, Layable w (Schematic Monad x (y :> z))-	, Layable x (Schematic Monad y z)-	, Wrappable y z-	) => Adaptable y (t :> u :> v :> w :> x :> y :> z) where-	adapt = lay . lay . lay . lay . lay . wrap--instance-	( Covariant (t :< u :< v :< w :< x :< y :< z)-	, Flickable t (Schematic Comonad u (v :< w :< x :< y :< z))-	, Flickable u (Schematic Comonad v (w :< x :< y :< z))-	, Flickable v (Schematic Comonad w (x :< y :< z))-	, Flickable w (Schematic Comonad x (y :< z))-	, Flickable x (Schematic Comonad y z)-	, Flickable y z-	) => Adaptable (t :< u :< v :< w :< x :< y :< z) z where-	adapt = flick . flick . flick . flick . flick . flick--instance-	( Covariant (t :< u :< v :< w :< x :< y :< z)-	, Flickable t (Schematic Comonad u (v :< w :< x :< y :< z))-	, Flickable u (Schematic Comonad v (w :< x :< y :< z))-	, Flickable v (Schematic Comonad w (x :< y :< z))-	, Flickable w (Schematic Comonad x (y :< z))-	, Flickable x (Schematic Comonad y z)-	, Bringable y z-	) => Adaptable (t :< u :< v :< w :< x :< y :< z) y where-	adapt = bring . flick . flick . flick . flick . flick--instance-	( Covariant (t :> u :> v :> w :> x :> y :> z :> f)-	, Layable t (Schematic Monad u (v :> w :> x :> y :> z :> f))-	, Layable u (Schematic Monad v (w :> x :> y :> z :> f))-	, Layable v (Schematic Monad w (x :> y :> z :> f))-	, Layable w (Schematic Monad x (y :> z :> f))-	, Layable x (Schematic Monad y (z :> f))-	, Layable y (Schematic Monad z f)-	, Layable z f-	) => Adaptable f (t :> u :> v :> w :> x :> y :> z :> f) where-	adapt = lay . lay . lay . lay . lay . lay . lay--instance-	( Covariant (t :> u :> v :> w :> x :> y :> z :> f)-	, Layable t (Schematic Monad u (v :> w :> x :> y :> z :> f))-	, Layable u (Schematic Monad v (w :> x :> y :> z :> f))-	, Layable v (Schematic Monad w (x :> y :> z :> f))-	, Layable w (Schematic Monad x (y :> z :> f))-	, Layable x (Schematic Monad y (z :> f))-	, Layable y (Schematic Monad z f)-	, Wrappable z f-	) => Adaptable z (t :> u :> v :> w :> x :> y :> z :> f) where-	adapt = lay . lay . lay . lay . lay . lay . wrap--instance-	( Covariant (t :< u :< v :< w :< x :< y :< z :< f)-	, Flickable t (Schematic Comonad u (v :< w :< x :< y :< z :< f))-	, Flickable u (Schematic Comonad v (w :< x :< y :< z :< f))-	, Flickable v (Schematic Comonad w (x :< y :< z :< f))-	, Flickable w (Schematic Comonad x (y :< z :< f))-	, Flickable x (Schematic Comonad y (z :< f))-	, Flickable y (Schematic Comonad z f)-	, Flickable z f-	) => Adaptable (t :< u :< v :< w :< x :< y :< z :< f) f where-	adapt = flick . flick . flick . flick . flick . flick . flick--instance-	( Covariant (t :< u :< v :< w :< x :< y :< z :< f)-	, Flickable t (Schematic Comonad u (v :< w :< x :< y :< z :< f))-	, Flickable u (Schematic Comonad v (w :< x :< y :< z :< f))-	, Flickable v (Schematic Comonad w (x :< y :< z :< f))-	, Flickable w (Schematic Comonad x (y :< z :< f))-	, Flickable x (Schematic Comonad y (z :< f))-	, Flickable y (Schematic Comonad z f)-	, Bringable z f-	) => Adaptable (t :< u :< v :< w :< x :< y :< z :< f) z where-	adapt = bring . flick . flick . flick . flick . flick . flick--instance-	( Covariant (t :> u :> v :> w :> x :> y :> z :> f :> h)-	, Layable t (Schematic Monad u (v :> w :> x :> y :> z :> f :> h))-	, Layable u (Schematic Monad v (w :> x :> y :> z :> f :> h))-	, Layable v (Schematic Monad w (x :> y :> z :> f :> h))-	, Layable w (Schematic Monad x (y :> z :> f :> h))-	, Layable x (Schematic Monad y (z :> f :> h))-	, Layable y (Schematic Monad z (f :> h))-	, Layable z (Schematic Monad f h)-	, Layable f h-	) => Adaptable h (t :> u :> v :> w :> x :> y :> z :> f :> h) where-	adapt = lay . lay . lay . lay . lay . lay . lay . lay--instance-	( Covariant (t :> u :> v :> w :> x :> y :> z :> f :> h)-	, Layable t (Schematic Monad u (v :> w :> x :> y :> z :> f :> h))-	, Layable u (Schematic Monad v (w :> x :> y :> z :> f :> h))-	, Layable v (Schematic Monad w (x :> y :> z :> f :> h))-	, Layable w (Schematic Monad x (y :> z :> f :> h))-	, Layable x (Schematic Monad y (z :> f :> h))-	, Layable y (Schematic Monad z (f :> h))-	, Layable z (Schematic Monad f h)-	, Wrappable f h-	) => Adaptable f (t :> u :> v :> w :> x :> y :> z :> f :> h) where-	adapt = lay . lay . lay . lay . lay . lay . lay . wrap--instance-	( Covariant (t :< u :< v :< w :< x :< y :< z :< f :< h)-	, Flickable t (Schematic Comonad u (v :< w :< x :< y :< z :< f :< h))-	, Flickable u (Schematic Comonad v (w :< x :< y :< z :< f :< h))-	, Flickable v (Schematic Comonad w (x :< y :< z :< f :< h))-	, Flickable w (Schematic Comonad x (y :< z :< f :< h))-	, Flickable x (Schematic Comonad y (z :< f :< h))-	, Flickable y (Schematic Comonad z (f :< h))-	, Flickable z (Schematic Comonad f h)-	, Flickable f h-	) => Adaptable (t :< u :< v :< w :< x :< y :< z :< f :< h) h where-	adapt = flick . flick . flick . flick . flick . flick . flick . flick--instance-	( Covariant (t :< u :< v :< w :< x :< y :< z :< f :< h)-	, Flickable t (Schematic Comonad u (v :< w :< x :< y :< z :< f :< h))-	, Flickable u (Schematic Comonad v (w :< x :< y :< z :< f :< h))-	, Flickable v (Schematic Comonad w (x :< y :< z :< f :< h))-	, Flickable w (Schematic Comonad x (y :< z :< f :< h))-	, Flickable x (Schematic Comonad y (z :< f :< h))-	, Flickable y (Schematic Comonad z (f :< h))-	, Flickable z (Schematic Comonad f h)-	, Bringable f h-	) => Adaptable (t :< u :< v :< w :< x :< y :< z :< f :< h) f where-	adapt = bring . flick . flick . flick . flick . flick . flick . flick

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

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

@@ -1,41 +0,0 @@-{-# OPTIONS_GHC -fno-warn-orphans #-}--module Pandora.Paradigm.Controlflow.Joint.Schemes (module Exports) where--import Pandora.Paradigm.Controlflow.Joint.Schemes.UTU as Exports-import Pandora.Paradigm.Controlflow.Joint.Schemes.UT as Exports-import Pandora.Paradigm.Controlflow.Joint.Schemes.TUVW as Exports-import Pandora.Paradigm.Controlflow.Joint.Schemes.TUT as Exports-import Pandora.Paradigm.Controlflow.Joint.Schemes.TU as Exports--import Pandora.Pattern.Category ((.))-import Pandora.Pattern.Functor.Covariant (Covariant)-import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))-import Pandora.Pattern.Functor.Divariant (($))-import Pandora.Paradigm.Controlflow.Joint.Interpreted (run)--instance (Covariant (TU Covariant Covariant v t), Covariant (TU Covariant Covariant u w), Adjoint t u, Adjoint v w)-	=> Adjoint (TU Covariant Covariant v t) (TU Covariant Covariant u w) where-		TU y |- g = y |- (|- run . g)-		x -| f = TU $ x -| (-| f . TU)--instance (Covariant (TU Covariant Covariant v t), Covariant (UT Covariant Covariant w u), Adjoint t u, Adjoint v w)-	=> Adjoint (TU Covariant Covariant v t) (UT Covariant Covariant w u) where-		TU t |- g = t |- (|- run . g)-		x -| f = UT $ x -| (-| f . TU)--instance (Covariant (UT Covariant Covariant t v), Covariant (UT Covariant Covariant w u), Adjoint t u, Adjoint v w)-	=> Adjoint (UT Covariant Covariant t v) (UT Covariant Covariant w u) where-		UT t |- g = t |- (|- run . g)-		x -| f = UT $ x -| (-| f . UT)--instance (Covariant (UT Covariant Covariant t v), Covariant (TU Covariant Covariant w u) , Adjoint v u, Adjoint t w)-	=> Adjoint (UT Covariant Covariant t v) (TU Covariant Covariant w u) where-		UT t |- g = t |- (|- run . g)-		x -| f = TU $ x -| (-| f . UT)--instance (Covariant (TUT Covariant Covariant Covariant t u t'), Covariant (TUT Covariant Covariant Covariant v w v')-	, Adjoint t w, Adjoint t' v', Adjoint t v, Adjoint u v, Adjoint v' t')-	=> Adjoint (TUT Covariant Covariant Covariant t u t') (TUT Covariant Covariant Covariant v w v') where-		TUT t |- g = t |- (|- (|- run . g))-		x -| f = TUT $ x -| (-| (-| f . TUT))

@@ -1,27 +0,0 @@-module Pandora.Paradigm.Controlflow.Joint.Schemes.TU (TU (..)) where--import Pandora.Core.Functor (type (:.), type (:=))-import Pandora.Pattern.Category ((.))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Divariant (($))-import Pandora.Pattern.Transformer.Liftable (Liftable (lift))-import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))-import Pandora.Pattern.Transformer.Hoistable (Hoistable (hoist))-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))--newtype TU ct cu t u a = TU (t :. u := a)--instance Interpreted (TU ct cu t u) where-	type Primary (TU ct cu t u) a = t :. u := a-	run (TU x) = x--instance Pointable t => Liftable (TU Covariant Covariant t) where-	lift = TU . point--instance Extractable t => Lowerable (TU Covariant Covariant t) where-	lower (TU x) = extract x--instance Covariant t => Hoistable (TU Covariant Covariant t) where-	hoist f (TU x) = TU $ f <$> x

@@ -1,28 +0,0 @@-module Pandora.Paradigm.Controlflow.Joint.Schemes.TUT (TUT (..)) where--import Pandora.Pattern.Category (identity)-import Pandora.Core.Functor (type (:.), type (:=))-import Pandora.Pattern.Functor.Covariant (Covariant)-import Pandora.Pattern.Functor.Pointable (Pointable)-import Pandora.Pattern.Functor.Applicative (Applicative)-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))-import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))-import Pandora.Pattern.Functor.Divariant (($))-import Pandora.Pattern.Transformer.Liftable (Liftable (lift))-import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))--newtype TUT ct ct' cu t t' u a = TUT (t :. u :. t' := a)--instance Interpreted (TUT ct ct' cu t t' u) where-	type Primary (TUT ct ct' cu t t' u) a = t :. u :. t' := a-	run (TUT x) = x--instance (Adjoint t' t, Applicative t, Pointable t, forall u . Traversable u)-	=> Liftable (TUT Covariant Covariant Covariant t t') where-		lift x = TUT $ x ->> (-| identity)--instance (Adjoint t t', Distributive t')-	=> Lowerable (TUT Covariant Covariant Covariant t t') where-		lower (TUT x) = x |- (>>- identity)

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

@@ -1,22 +0,0 @@-module Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (..)) where--import Pandora.Core.Functor (type (:.), type (:=))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Divariant (($))-import Pandora.Pattern.Transformer.Liftable (Liftable (lift))-import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))--newtype UT ct cu t u a = UT (u :. t := a)--instance Interpreted (UT ct cu t u) where-	type Primary (UT ct cu t u) a = u :. t := a-	run (UT x) = x--instance Pointable t => Liftable (UT Covariant Covariant t) where-	lift x = UT $ point <$> x--instance Extractable t => Lowerable (UT Covariant Covariant t) where-	lower (UT x) = extract <$> x

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

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

@@ -1,60 +0,0 @@-{-# LANGUAGE UndecidableInstances #-}--module Pandora.Paradigm.Controlflow.Joint.Transformer.Comonadic (Comonadic (..), (:<) (..)) where--import Pandora.Core.Functor (type (~>))-import Pandora.Pattern.Category ((.))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))-import Pandora.Pattern.Functor.Comonad (Comonad)-import Pandora.Pattern.Functor.Divariant (($))-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))-import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)--class Interpreted t => Comonadic t where-	{-# MINIMAL flick, bring #-}-	flick :: Covariant u => t :< u ~> u-	bring :: Extractable u => t :< u ~> t--infixr 3 :<-newtype (:<) t u a = TC { tc :: Schematic Comonad t u a }--instance Covariant (Schematic Comonad t u) => Covariant (t :< u) where-	f <$> TC x = TC $ f <$> x--instance Pointable (Schematic Comonad t u) => Pointable (t :< u) where-	point = TC . point--instance Extractable (Schematic Comonad t u) => Extractable (t :< u) where-	extract = extract . tc--instance Applicative (Schematic Comonad t u) => Applicative (t :< u) where-	TC f <*> TC x = TC $ f <*> x--instance Alternative (Schematic Comonad t u) => Alternative (t :< u) where-	TC x <+> TC y = TC $ x <+> y--instance Traversable (Schematic Comonad t u) => Traversable (t :< u) where-	TC x ->> f = TC <$> x ->> f--instance Distributive (Schematic Comonad t u) => Distributive (t :< u) where-	x >>- f = TC $ x >>- tc . f--instance Bindable (Schematic Comonad t u) => Bindable (t :< u) where-	TC x >>= f = TC $ x >>= tc . f--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 (Interpreted (Schematic Comonad t u)) => Interpreted (t :< u) where-	type Primary (t :< u) a = Primary (Schematic Comonad t u) a-	run (TC x) = run x

@@ -1,60 +0,0 @@-{-# LANGUAGE UndecidableInstances #-}--module Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic (Monadic (..), (:>) (..)) where--import Pandora.Core.Functor (type (~>))-import Pandora.Pattern.Category ((.))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))-import Pandora.Pattern.Functor.Monad (Monad)-import Pandora.Pattern.Functor.Divariant (($))-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))-import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)--class Interpreted t => Monadic t where-	{-# MINIMAL lay, wrap #-}-	lay :: Covariant u => u ~> t :> u-	wrap :: Pointable u => t ~> t :> u--infixr 3 :>-newtype (:>) t u a = TM { tm :: Schematic Monad t u a }--instance Covariant (Schematic Monad t u) => Covariant (t :> u) where-	f <$> TM x = TM $ f <$> x--instance Pointable (Schematic Monad t u) => Pointable (t :> u) where-	point = TM . point--instance Extractable (Schematic Monad t u) => Extractable (t :> u) where-	extract = extract . tm--instance Applicative (Schematic Monad t u) => Applicative (t :> u) where-	TM f <*> TM x = TM $ f <*> x--instance Alternative (Schematic Monad t u) => Alternative (t :> u) where-	TM x <+> TM y = TM $ x <+> y--instance Traversable (Schematic Monad t u) => Traversable (t :> u) where-	TM x ->> f = TM <$> x ->> f--instance Distributive (Schematic Monad t u) => Distributive (t :> u) where-	x >>- f = TM $ x >>- tm . f--instance Bindable (Schematic Monad t u) => Bindable (t :> u) where-	TM x >>= f = TM $ x >>= tm . f--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 (Interpreted (Schematic Monad t u)) => Interpreted (t :> u) where-	type Primary (t :> u) a = Primary (Schematic Monad t u) a-	run (TM x) = run x

@@ -1,9 +1,8 @@ module Pandora.Paradigm.Controlflow.Observable (Observable, observe, 	notify, follow, subscribe, watch, (.:~.), (.:~*), (*:~.), (*:~*)) where -import Pandora.Pattern.Category ((.))+import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Applicative (Applicative (forever))-import Pandora.Pattern.Functor.Divariant (($)) import Pandora.Paradigm.Primary.Transformer.Continuation (Continuation (Continuation, continue))  newtype Capture r t a = Capture { captured :: t r }

@@ -1,10 +1,10 @@ module Pandora.Paradigm.Controlflow.Pipeline (Pipeline, await, yield, finish, impact, (=*=), pipeline) where +import Pandora.Pattern.Category (($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>))) import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<))) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))-import Pandora.Pattern.Functor.Divariant (($)) import Pandora.Paradigm.Primary.Transformer.Continuation (Continuation (Continuation, continue))  newtype Producer i t r = Producer { produce :: Consumer i t r -> t r }

@@ -11,12 +11,11 @@ import Pandora.Paradigm.Inventory.Accumulator as Exports  import Pandora.Core.Morphism ((!), (%))-import Pandora.Pattern.Category ((.))+import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Extractable (extract) import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))-import Pandora.Pattern.Functor.Divariant (($)) import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)))-import Pandora.Paradigm.Controlflow.Joint.Interpreted (run)+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)  instance Adjoint (Store s) (State s) where 	x -| f = State $ \s -> (:*:) s . f . Store $ s :*: (x !)

@@ -2,21 +2,20 @@  module Pandora.Paradigm.Inventory.Accumulator (Accumulator (..), Accumulated, gather) where -import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:))-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))-import Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))-import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)-import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))-import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))-import Pandora.Pattern.Category ((.))+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.Bindable (Bindable ((>>=)))-import Pandora.Pattern.Functor.Divariant (($)) import Pandora.Pattern.Functor.Monad (Monad) import Pandora.Pattern.Object.Monoid (Monoid (zero)) import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))+import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:))+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))+import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))+import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic)+import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))+import Pandora.Paradigm.Schemes.UT (UT (UT), type (<.:>))  newtype Accumulator e a = Accumulator (e :*: a) @@ -34,7 +33,7 @@ 	Accumulator (e :*: x) >>= f = let (e' :*: b) = run $ f x in 		Accumulator $ e + e':*: b -type instance Schematic Monad (Accumulator e) u = UT Covariant Covariant ((:*:) e) u+type instance Schematic Monad (Accumulator e) u = (:*:) e <.:> u  instance Interpreted (Accumulator e) where 	type Primary (Accumulator e) a = e :*: a@@ -46,17 +45,17 @@  type Accumulated e t = Adaptable (Accumulator e) t -instance Covariant u => Covariant (UT Covariant Covariant ((:*:) e) u) where+instance Covariant u => Covariant ((:*:) e <.:> u) where 	f <$> UT x = UT $ f <$$> x -instance (Semigroup e, Applicative u) => Applicative (UT Covariant Covariant ((:*:) e) u) where+instance (Semigroup e, Applicative u) => Applicative ((:*:) e <.:> u) where 	UT f <*> UT x = UT $ k <$> f <*> x where 		k ~(u :*: g) ~(v :*: y) = u + v :*: g y -instance (Pointable u, Monoid e) => Pointable (UT Covariant Covariant ((:*:) e) u) where+instance (Pointable u, Monoid e) => Pointable ((:*:) e <.:> u) where 	point = UT . point . (zero :*:) -instance (Semigroup e, Pointable u, Bindable u) => Bindable (UT Covariant Covariant ((:*:) e) u) where+instance (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 ()

@@ -2,20 +2,19 @@  module Pandora.Paradigm.Inventory.Environment (Environment (..), Configured, env) where -import Pandora.Core.Morphism ((!), (%))-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))-import Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))-import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)-import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))-import Pandora.Paradigm.Controlflow.Joint.Schemes.TU (TU (TU))-import Pandora.Pattern.Category (identity, (.))+import Pandora.Pattern.Category (identity, (.), ($)) import Pandora.Pattern.Functor.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 (($))+import Pandora.Core.Morphism ((!), (%))+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))+import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))+import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic)+import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))+import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))  newtype Environment e a = Environment (e -> a) @@ -40,7 +39,7 @@ 	type Primary (Environment e) a = (->) e a 	run (Environment x) = x -type instance Schematic Monad (Environment e) u = TU Covariant Covariant ((->) e) u+type instance Schematic Monad (Environment e) u = (->) e <:.> u  instance Monadic (Environment e) where 	lay = TM . TU . (!)@@ -48,16 +47,16 @@  type Configured e = Adaptable (Environment e) -instance Covariant u => Covariant (TU Covariant Covariant ((->) e) u) where+instance Covariant u => Covariant ((->) e <:.> u) where 	f <$> TU x = TU $ f <$$> x -instance (Covariant u, Pointable u) => Pointable (TU Covariant Covariant ((->) e) u) where+instance (Covariant u, Pointable u) => Pointable ((->) e <:.> u) where 	point = TU . point . point -instance Applicative u => Applicative (TU Covariant Covariant ((->) e) u) where+instance Applicative u => Applicative ((->) e <:.> u) where 	TU f <*> TU x = TU $ f <**> x -instance Bindable u => Bindable (TU Covariant Covariant ((->) e) u) where+instance Bindable u => Bindable ((->) e <:.> u) where 	TU x >>= f = TU $ \e -> x e >>= ($ e) . run . f  env :: Configured e t => t e

@@ -2,18 +2,17 @@  module Pandora.Paradigm.Inventory.Equipment (Equipment (..), retrieve) where -import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), attached)-import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))-import Pandora.Paradigm.Controlflow.Joint.Transformer.Comonadic (Comonadic (flick, bring), (:<) (TC))-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))-import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)-import Pandora.Paradigm.Controlflow.Joint.Schemes.TU (TU (TU))-import Pandora.Pattern.Category ((.))+import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>))) import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Extendable (Extendable ((=>>))) import Pandora.Pattern.Functor.Comonad (Comonad)-import Pandora.Pattern.Functor.Divariant (($))+import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), attached)+import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))+import Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic (Comonadic (flick, bring), (:<) (TC))+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))+import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic)+import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))  newtype Equipment e a = Equipment (e :*: a) @@ -30,7 +29,7 @@ 	type Primary (Equipment e) a = e :*: a 	run (Equipment x) = x -type instance Schematic Comonad (Equipment e) u = TU Covariant Covariant ((:*:) e) u+type instance Schematic Comonad (Equipment e) u = (:*:) e <:.> u  instance Comonadic (Equipment e) where 	flick (TC (TU x)) = extract x@@ -38,13 +37,13 @@  type Equipped e t = Adaptable t (Equipment e) -instance Covariant u => Covariant (TU Covariant Covariant ((:*:) e) u) where+instance Covariant u => Covariant ((:*:) e <:.> u) where 	f <$> TU x = TU $ f <$$> x -instance Extractable u => Extractable (TU Covariant Covariant ((:*:) e) u) where+instance Extractable u => Extractable ((:*:) e <:.> u) where 	extract (TU x) = extract . extract $ x -instance Extendable u => Extendable (TU Covariant Covariant ((:*:) e) u) where+instance Extendable u => Extendable ((:*:) e <:.> u) where 	TU (e :*: x) =>> f = TU . (:*:) e $ x =>> f . TU . (:*:) e  instance Comonad (Equipment e) where

@@ -2,21 +2,20 @@  module Pandora.Paradigm.Inventory.Imprint (Imprint (..), Traceable) where -import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))-import Pandora.Paradigm.Controlflow.Joint.Transformer.Comonadic (Comonadic (flick, bring), (:<) (TC))-import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)-import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable)-import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))-import Pandora.Pattern.Category ((.))+import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>))) import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (<**>))) import Pandora.Pattern.Functor.Distributive (Distributive ((>>-))) import Pandora.Pattern.Functor.Extendable (Extendable ((=>>))) import Pandora.Pattern.Functor.Comonad (Comonad)-import Pandora.Pattern.Functor.Divariant (($)) import Pandora.Pattern.Object.Monoid (Monoid (zero)) import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))+import Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic (Comonadic (flick, bring), (:<) (TC))+import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic)+import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable)+import Pandora.Paradigm.Schemes.UT (UT (UT), type (<.:>))  newtype Imprint e a = Imprint (e -> a) @@ -36,22 +35,22 @@ 	type Primary (Imprint e) a = (->) e a 	run (Imprint x) = x -type instance Schematic Comonad (Imprint e) u = UT Covariant Covariant ((->) e) u+type instance Schematic Comonad (Imprint e) u = (->) e <.:> u  instance Monoid e => Comonadic (Imprint e) where 	flick (TC (UT x)) = extract <$> x 	bring (TC (UT x)) = Imprint . extract $ x -instance Covariant u => Covariant (UT Covariant Covariant ((->) e) u) where+instance Covariant u => Covariant ((->) e <.:> u) where 	f <$> UT x = UT $ f <$$> x -instance Applicative u => Applicative (UT Covariant Covariant ((->) e) u) where+instance Applicative u => Applicative ((->) e <.:> u) where 	UT f <*> UT x = UT $ f <**> x -instance (Monoid e, Extractable u) => Extractable (UT Covariant Covariant ((->) e) u) where+instance (Monoid e, Extractable u) => Extractable ((->) e <.:> u) where 	extract (UT x) = extract . extract $ x -instance (Semigroup e, Extendable u) => Extendable (UT Covariant Covariant ((->) e) u) where+instance (Semigroup e, Extendable u) => Extendable ((->) e <.:> u) where 	UT x =>> f = UT $ x =>> (\x' e -> f . UT . (<$>) (. (e +)) $ x')  type Traceable e t = Adaptable t (Imprint e)

@@ -3,15 +3,14 @@ module Pandora.Paradigm.Inventory.Optics (Lens, type (:-.), (|>), view, set, over, zoom, (^.), (.~), (%~)) where  import Pandora.Core.Functor (type (|->))+import Pandora.Pattern.Category (identity, (.), ($))+import Pandora.Pattern.Functor.Covariant ((<$))+import Pandora.Pattern.Functor.Extractable (Extractable (extract))+import Pandora.Pattern.Functor.Bivariant ((<->)) import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)))-import Pandora.Paradigm.Controlflow.Joint.Adaptable (adapt)+import Pandora.Paradigm.Controlflow.Effect.Adaptable (adapt) import Pandora.Paradigm.Inventory.State (State (State), Stateful) import Pandora.Paradigm.Inventory.Store (Store (Store), access, position, retrofit)-import Pandora.Pattern.Category (identity, (.))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$)))-import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Divariant (($))-import Pandora.Pattern.Functor.Bivariant ((<->))  infixr 0 :-. type (:-.) src tgt = Lens src tgt@@ -19,7 +18,7 @@ type Lens src tgt = src |-> Store tgt  -- | Lens composition infix operator-(|>) :: Lens src btw -> Lens btw tgt -> Lens src tgt+(|>) :: Lens src old -> Lens old new -> Lens src new from |> to = \x -> ((<$) x . to) . position . from $ x  -- | Get the target of a lens

@@ -4,8 +4,8 @@  import Pandora.Core.Functor (type (:.), type (:=)) import Pandora.Core.Morphism ((%))-import Pandora.Pattern.Category ((.))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), ($>), (<$$>)))+import Pandora.Pattern.Category (identity, (.), ($))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>))) import Pandora.Pattern.Functor.Extractable (extract) import Pandora.Pattern.Functor.Avoidable (Avoidable (empty)) import Pandora.Pattern.Functor.Pointable (Pointable (point))@@ -14,13 +14,12 @@ import Pandora.Pattern.Functor.Traversable (Traversable ((->>))) import Pandora.Pattern.Functor.Bindable (Bindable ((>>=))) import Pandora.Pattern.Functor.Monad (Monad)-import Pandora.Pattern.Functor.Adjoint ((|-))-import Pandora.Pattern.Functor.Divariant (($))-import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))-import Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))-import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)-import Pandora.Paradigm.Controlflow.Joint.Schemes.TUT (TUT (TUT))+import Pandora.Pattern.Functor.Adjoint ((-|), (|-))+import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))+import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))+import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic)+import Pandora.Paradigm.Schemes.TUT (TUT (TUT), type (<:<.>:>)) import Pandora.Paradigm.Primary.Object.Boolean (bool) import Pandora.Paradigm.Primary.Functor.Predicate (Predicate (predicate)) import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), delta)@@ -35,7 +34,7 @@ 		let (new :*: g) = f old in g <$> x new  instance Pointable (State s) where-	point x = State $ \s -> s :*: x+	point = State . (-| identity)  instance Bindable (State s) where 	State x >>= f = State $ \old ->@@ -44,18 +43,17 @@ instance Monad (State s) where  fold :: Traversable t => s -> (a -> s -> s) -> t a -> s-fold start op struct = extract . run @(State _) % start $-	struct ->> modify . op $> () *> current+fold start op struct = extract . run @(State _) % start+	$ struct ->> modify . op *> current  find :: (Pointable u, Avoidable u, Alternative u, Traversable t) => Predicate a -> t a -> u a-find p struct = fold empty (\x s -> (<+>) s . bool empty (point x) . predicate p $ x) struct+find p = fold empty (\x s -> (<+>) s . bool empty (point x) . predicate p $ x)  instance Interpreted (State s) where 	type Primary (State s) a = (->) s :. (:*:) s := a 	run (State x) = x -type instance Schematic Monad (State s) u =-	TUT Covariant Covariant Covariant ((->) s) ((:*:) s) u+type instance Schematic Monad (State s) u = (->) s <:<.>:> (:*:) s := u  instance Monadic (State s) where 	lay x = TM . TUT $ \s -> (s :*:) <$> x@@ -63,25 +61,25 @@  type Stateful s = Adaptable (State s) -instance Covariant u => Covariant (TUT Covariant Covariant Covariant ((->) s) ((:*:) s) u) where+instance Covariant u => Covariant ((->) s <:<.>:> (:*:) s := u) where 	f <$> TUT x = TUT $ \old -> f <$$> x old -instance Bindable u => Applicative (TUT Covariant Covariant Covariant ((->) s) ((:*:) s) u) where+instance Bindable u => Applicative ((->) s <:<.>:> (:*:) s := u) where 	TUT f <*> TUT x = TUT $ \old -> f old >>= \(new :*: g) -> g <$$> x new -instance Pointable u => Pointable (TUT Covariant Covariant Covariant ((->) s) ((:*:) s) u) where-	point x = TUT $ \s -> point $ s :*: x+instance Pointable u => Pointable ((->) s <:<.>:> (:*:) s := u) where+	point = TUT . (-| point) -instance Bindable u => Bindable (TUT Covariant Covariant Covariant ((->) s) ((:*:) s) u) where+instance Bindable u => Bindable ((->) s <:<.>:> (:*:) s := u) where 	TUT x >>= f = TUT $ \old -> x old >>= \(new :*: y) -> ($ new) . run . f $ y -instance Monad u => Monad (TUT Covariant Covariant Covariant ((->) s) ((:*:) s) u) where+instance Monad u => Monad ((->) s <:<.>:> (:*:) s := u) where  current :: Stateful s t => t s current = adapt $ State delta  modify :: Stateful s t => (s -> s) -> t ()-modify f = adapt $ State $ \s -> f s :*: ()+modify f = adapt . State $ (:*: ()) . f  replace :: Stateful s t => s -> t ()-replace s = adapt $ State $ \_ -> s :*: ()+replace s = adapt . State $ \_ -> s :*: ()

@@ -4,30 +4,29 @@  import Pandora.Core.Functor (type (:.), type (:=), type (<-|), type (~>)) import Pandora.Core.Morphism ((%))-import Pandora.Pattern.Category ((.))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))+import Pandora.Pattern.Category (identity, (.), ($))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>), (<$$$>)), (.|..)) import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))+import Pandora.Pattern.Functor.Extendable (Extendable ((=>>), (<<=$))) import Pandora.Pattern.Functor.Comonad (Comonad)-import Pandora.Pattern.Functor.Divariant (($))+import Pandora.Pattern.Functor.Adjoint ((-|), (|-)) import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), attached)-import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))-import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)-import Pandora.Paradigm.Controlflow.Joint.Schemes.TUT (TUT (TUT))-import Pandora.Paradigm.Controlflow.Joint.Transformer.Comonadic (Comonadic (flick, bring), (:<) (TC))+import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))+import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic)+import Pandora.Paradigm.Schemes.TUT (TUT (TUT), type (<:<.>:>))+import Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic (Comonadic (flick, bring), (:<) (TC))  newtype Store p a = Store ((:*:) p :. (->) p := a)  instance Covariant (Store p) where-	f <$> Store (p :*: x) = Store . (:*:) p $ f <$> x+	f <$> Store x = Store $ f <$$> x  instance Extractable (Store p) where-	extract (Store (p :*: f)) = f p+	extract = (|- ($)) . run  instance Extendable (Store p) where-	Store (old :*: x) =>> f = Store . (:*:) old-		$ \new -> f <$> Store $ new :*: x+	Store x =>> f = Store $ f <$$> (Store .|.. (-| identity)) <$> x  instance Comonad (Store p) where @@ -35,8 +34,7 @@ 	type Primary (Store p) a = (:*:) p :. (->) p := a 	run (Store x) = x -type instance Schematic Comonad (Store p) u =-	TUT Covariant Covariant Covariant ((:*:) p) ((->) p) u+type instance Schematic Comonad (Store p) u = (:*:) p <:<.>:> (->) p := u  instance Comonadic (Store p) where 	flick (TC (TUT (p :*: f))) = ($ p) <$> f@@ -44,14 +42,14 @@  type Storable s x = Adaptable x (Store s) -instance Covariant u => Covariant (TUT Covariant Covariant Covariant ((:*:) p) ((->) p) u) where-	f <$> TUT (p :*: x) = TUT . (:*:) p $ f <$$> x+instance Covariant u => Covariant ((:*:) p <:<.>:> (->) p := u) where+	f <$> TUT x = TUT $ f <$$$> x -instance Extractable u => Extractable (TUT Covariant Covariant Covariant ((:*:) p) ((->) p) u) where-	extract (TUT (p :*: x)) = extract x p+instance Extractable u => Extractable ((:*:) p <:<.>:> (->) p := u) where+	extract = (|- extract) . run -instance Extendable u => Extendable (TUT Covariant Covariant Covariant ((:*:) p) ((->) p) u) where-	TUT (old :*: x) =>> f = TUT . (:*:) old $ x =>> (\x' new -> f . TUT . (:*:) new $ x')+instance Extendable u => Extendable ((:*:) p <:<.>:> (->) p := u) where+	TUT x =>> f = TUT $ x <<=$ (\x' -> f . TUT . (x' -| identity))  position :: Storable s t => t a -> s position = attached . run @(Store _) . adapt

@@ -1,7 +1,7 @@ module Pandora.Paradigm.Primary.Functor.Conclusion (Conclusion (..), Failable, conclusion, fail, failure) where  import Pandora.Core.Functor (type (~>))-import Pandora.Pattern.Category ((.))+import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>))) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))@@ -10,17 +10,16 @@ import Pandora.Pattern.Functor.Bindable (Bindable ((>>=))) import Pandora.Pattern.Functor.Monad (Monad) import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))-import Pandora.Pattern.Functor.Divariant (($)) import Pandora.Pattern.Object.Setoid (Setoid ((==))) 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.Controlflow.Joint.Interpreted (Interpreted (Primary, run))-import Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))-import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)-import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))-import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))+import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))+import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic)+import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))+import Pandora.Paradigm.Schemes.UT (UT (UT))  data Conclusion e a = Failure e | Success a 

@@ -1,12 +1,12 @@ module Pandora.Paradigm.Primary.Functor.Constant (Constant (..)) where +import Pandora.Pattern.Category (($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>))) import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<))) import Pandora.Pattern.Functor.Invariant (Invariant (invmap)) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Traversable (Traversable ((->>))) import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))-import Pandora.Pattern.Functor.Divariant (($)) import Pandora.Pattern.Object.Setoid (Setoid ((==))) import Pandora.Pattern.Object.Chain (Chain ((<=>))) import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))

@@ -1,9 +1,10 @@ module Pandora.Paradigm.Primary.Functor.Edges (Edges (..), edges) where +import Pandora.Pattern.Category (($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>))) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Pattern.Functor.Divariant (($))+  data Edges a = Empty | Leap a | Connect a | Overlay a 

@@ -1,6 +1,6 @@ module Pandora.Paradigm.Primary.Functor.Identity (Identity (..)) where -import Pandora.Pattern.Category ((.))+import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), comap)) import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Pointable (Pointable (point))@@ -13,7 +13,6 @@ import Pandora.Pattern.Functor.Comonad (Comonad) import Pandora.Pattern.Functor.Representable (Representable (Representation, (<#>), tabulate)) import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))-import Pandora.Pattern.Functor.Divariant (($)) import Pandora.Pattern.Object.Setoid (Setoid ((==))) import Pandora.Pattern.Object.Chain (Chain ((<=>))) import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))

@@ -1,6 +1,6 @@ module Pandora.Paradigm.Primary.Functor.Maybe (Maybe (..), Optional, maybe, nothing) where -import Pandora.Pattern.Category ((.))+import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>))) import Pandora.Pattern.Functor.Avoidable (Avoidable (empty)) import Pandora.Pattern.Functor.Pointable (Pointable (point))@@ -9,7 +9,6 @@ import Pandora.Pattern.Functor.Traversable (Traversable ((->>))) import Pandora.Pattern.Functor.Bindable (Bindable ((>>=))) import Pandora.Pattern.Functor.Monad (Monad)-import Pandora.Pattern.Functor.Divariant (($)) import Pandora.Pattern.Object.Setoid (Setoid ((==))) import Pandora.Pattern.Object.Chain (Chain ((<=>))) import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))@@ -18,11 +17,11 @@ import Pandora.Pattern.Object.Lattice (Lattice) import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False)) import Pandora.Paradigm.Primary.Object.Ordering (Ordering (Less, Equal, Greater))-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))-import Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))-import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)-import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))-import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))+import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))+import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic)+import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))+import Pandora.Paradigm.Schemes.UT (UT (UT))  data Maybe a = Nothing | Just a 

@@ -1,10 +1,9 @@ module Pandora.Paradigm.Primary.Functor.Predicate (Predicate (..)) where  import Pandora.Core.Morphism ((!))-import Pandora.Pattern.Category ((.))+import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<))) import Pandora.Pattern.Functor.Determinable (Determinable (determine))-import Pandora.Pattern.Functor.Divariant (($)) import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True))  newtype Predicate a = Predicate { predicate :: a -> Boolean }

@@ -1,6 +1,7 @@ module Pandora.Paradigm.Primary.Functor.Product (Product (..), type (:*:) 	, delta, swap, attached, curry, uncurry) where +import Pandora.Pattern.Category (($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>))) import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))@@ -8,7 +9,6 @@ import Pandora.Pattern.Functor.Comonad (Comonad) import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-))) import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))-import Pandora.Pattern.Functor.Divariant (($)) import Pandora.Pattern.Object.Setoid (Setoid ((==))) import Pandora.Pattern.Object.Semigroup (Semigroup ((+))) import Pandora.Pattern.Object.Monoid (Monoid (zero))

@@ -1,7 +1,7 @@ module Pandora.Paradigm.Primary.Functor.Tagged (Tagged (..), retag, tagself, type (:#)) where  import Pandora.Core.Functor (type (|->), type (~>))-import Pandora.Pattern.Category ((.))+import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>))) import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Pointable (Pointable (point))@@ -13,7 +13,6 @@ import Pandora.Pattern.Functor.Monad (Monad) import Pandora.Pattern.Functor.Comonad (Comonad) import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))-import Pandora.Pattern.Functor.Divariant (($)) import Pandora.Pattern.Object.Setoid (Setoid ((==))) import Pandora.Pattern.Object.Chain (Chain ((<=>))) import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))@@ -89,7 +88,7 @@ instance Group a => Group (Tagged tag a) where 	invert (Tag x) = Tag $ invert x -retag :: Tagged old ~> Tagged new+retag :: forall new old . Tagged old ~> Tagged new retag (Tag x) = Tag x  tagself :: a |-> Tagged a

@@ -1,9 +1,9 @@ module Pandora.Paradigm.Primary.Functor.These (These (..), these) where +import Pandora.Pattern.Category (($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>))) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Pattern.Functor.Divariant (($))  data These e a = This a | That e | These e a 

@@ -1,13 +1,12 @@ module Pandora.Paradigm.Primary.Functor.Validation (Validation (..)) where -import Pandora.Pattern.Category ((.))+import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>))) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>))) import Pandora.Pattern.Functor.Alternative (Alternative ((<+>))) import Pandora.Pattern.Functor.Traversable (Traversable ((->>))) import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))-import Pandora.Pattern.Functor.Divariant (($)) import Pandora.Pattern.Object.Setoid (Setoid ((==))) import Pandora.Pattern.Object.Chain (Chain ((<=>))) import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))

@@ -1,9 +1,9 @@ module Pandora.Paradigm.Primary.Functor.Wedge (Wedge (..), wedge) where +import Pandora.Pattern.Category (($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>))) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Pattern.Functor.Divariant (($))  data Wedge e a = Nowhere | Here e | There a 

@@ -1,10 +1,10 @@ module Pandora.Paradigm.Primary.Functor.Wye (Wye (..), wye) 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.Traversable (Traversable ((->>)))-import Pandora.Pattern.Functor.Divariant (($))  data Wye a = End | Left a | Right a | Both a a 

@@ -1,6 +1,7 @@ module Pandora.Paradigm.Primary.Transformer (module Exports) where  import Pandora.Paradigm.Primary.Transformer.Yoneda as Exports+import Pandora.Paradigm.Primary.Transformer.Tap as Exports import Pandora.Paradigm.Primary.Transformer.Continuation as Exports import Pandora.Paradigm.Primary.Transformer.Kan as Exports import Pandora.Paradigm.Primary.Transformer.Jet as Exports

@@ -1,7 +1,7 @@ module Pandora.Paradigm.Primary.Transformer.Backwards (Backwards (..)) where  import Pandora.Core.Morphism ((&))-import Pandora.Pattern.Category ((.))+import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>))) import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<))) import Pandora.Pattern.Functor.Extractable (Extractable (extract))@@ -9,11 +9,10 @@ import Pandora.Pattern.Functor.Applicative (Applicative ((<*>))) import Pandora.Pattern.Functor.Traversable (Traversable ((->>))) import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))-import Pandora.Pattern.Functor.Divariant (($)) import Pandora.Pattern.Transformer.Liftable (Liftable (lift)) import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower)) import Pandora.Pattern.Transformer.Hoistable (Hoistable (hoist))-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))  newtype Backwards t a = Backwards (t a) 

@@ -1,7 +1,7 @@ module Pandora.Paradigm.Primary.Transformer.Construction (Construction (..), deconstruct, coiterate, section) where  import Pandora.Core.Functor (type (:.), type (:=), type (|->), type (~>))-import Pandora.Pattern.Category ((.))+import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>))) import Pandora.Pattern.Functor.Avoidable (Avoidable (empty)) import Pandora.Pattern.Functor.Pointable (Pointable (point))@@ -15,12 +15,11 @@ import Pandora.Pattern.Functor.Comonad (Comonad) import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower)) import Pandora.Pattern.Transformer.Hoistable (Hoistable (hoist))-import Pandora.Pattern.Functor.Divariant (($)) import Pandora.Pattern.Object.Setoid (Setoid ((==))) import Pandora.Pattern.Object.Semigroup (Semigroup ((+))) import Pandora.Pattern.Object.Ringoid ((*)) import Pandora.Pattern.Object.Monoid (Monoid (zero))-import Pandora.Paradigm.Controlflow.Joint.Schemes.TU (TU (TU))+import Pandora.Paradigm.Schemes.TU (TU (TU))  data Construction t a = Construct a (t :. Construction t := a) 

@@ -2,14 +2,13 @@  import Pandora.Core.Functor (type (:.), type (:=), type (::|:.)) import Pandora.Core.Morphism ((!), (%))-import Pandora.Pattern.Category ((.))+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.Bindable (Bindable ((>>=))) import Pandora.Pattern.Functor.Monad (Monad) import Pandora.Pattern.Transformer.Liftable (Liftable (lift))-import Pandora.Pattern.Functor.Divariant (($))  newtype Continuation r t a = Continuation { continue :: (->) ::|:. a :. t := r } 

@@ -1,6 +1,7 @@ module Pandora.Paradigm.Primary.Transformer.Instruction (Instruction (..)) where  import Pandora.Core.Functor (type (:.), type (:=))+import Pandora.Pattern.Category (($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>))) import Pandora.Pattern.Functor.Avoidable (Avoidable (empty)) import Pandora.Pattern.Functor.Pointable (Pointable (point))@@ -9,7 +10,6 @@ import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>))) import Pandora.Pattern.Functor.Bindable (Bindable ((>>=))) import Pandora.Pattern.Transformer.Liftable (Liftable (lift))-import Pandora.Pattern.Functor.Divariant (($))  data Instruction t a = Enter a | Instruct (t :. Instruction t := a) 

@@ -1,6 +1,6 @@ module Pandora.Paradigm.Primary.Transformer.Jack (Jack (..), jack) where -import Pandora.Pattern.Category ((.))+import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), comap) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Extractable (Extractable (extract))@@ -10,7 +10,6 @@ import Pandora.Pattern.Functor.Traversable (Traversable ((->>), traverse)) import Pandora.Pattern.Functor.Distributive (Distributive ((>>-), distribute)) import Pandora.Pattern.Transformer.Liftable (Liftable (lift))-import Pandora.Pattern.Functor.Divariant (($)) import Pandora.Pattern.Object.Setoid (Setoid ((==))) import Pandora.Pattern.Object.Chain (Chain ((<=>))) import Pandora.Paradigm.Primary.Object.Boolean (Boolean (False))

@@ -1,10 +1,9 @@ module Pandora.Paradigm.Primary.Transformer.Kan (Kan (..)) where -import Pandora.Pattern.Category ((.))+import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<))) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))-import Pandora.Pattern.Functor.Divariant (($))-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run)) import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))  data family Kan (v :: * -> k) (t :: * -> *) (u :: * -> *) b a

@@ -1,15 +1,14 @@ module Pandora.Paradigm.Primary.Transformer.Outline (Outline (..)) where  import Pandora.Core.Morphism ((%))-import Pandora.Pattern.Category (identity, (.))+import Pandora.Pattern.Category (identity, (.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>))) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))-import Pandora.Pattern.Functor.Divariant (($)) import Pandora.Pattern.Transformer.Liftable (Liftable (lift)) import Pandora.Pattern.Transformer.Hoistable (Hoistable (hoist))-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))  data Outline t a where 	Line :: a -> Outline t a

@@ -1,6 +1,6 @@ module Pandora.Paradigm.Primary.Transformer.Reverse (Reverse (..)) where -import Pandora.Pattern.Category ((.))+import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>))) import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<))) import Pandora.Pattern.Functor.Extractable (Extractable (extract))@@ -8,12 +8,11 @@ import Pandora.Pattern.Functor.Applicative (Applicative ((<*>))) import Pandora.Pattern.Functor.Traversable (Traversable ((->>))) import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))-import Pandora.Pattern.Functor.Divariant (($)) import Pandora.Pattern.Transformer.Liftable (Liftable (lift)) import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower)) import Pandora.Pattern.Transformer.Hoistable (Hoistable (hoist)) import Pandora.Paradigm.Primary.Transformer.Backwards (Backwards (Backwards))-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))  newtype Reverse t a = Reverse (t a) 

@@ -0,0 +1,44 @@+module Pandora.Paradigm.Primary.Transformer.Tap (Tap (..)) where++import Pandora.Core.Morphism ((%))+import Pandora.Pattern.Category ((.), ($))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))+import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Extractable (Extractable (extract))+import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))+import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))+import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))+import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))+import Pandora.Pattern.Transformer.Hoistable (Hoistable (hoist))++data Tap t a = Tap a (t a)++instance Covariant t => Covariant (Tap t) where+	f <$> Tap x xs = Tap (f x) $ f <$> xs++instance Avoidable t => Pointable (Tap t) where+	point = Tap % empty++instance Covariant t => Extractable (Tap t) where+	extract (Tap x _) = x++instance Applicative t => Applicative (Tap t) where+	Tap f fs <*> Tap x xs = Tap (f x) $ fs <*> xs++instance Traversable t => Traversable (Tap t) where+	Tap x xs ->> f = Tap <$> f x <*> xs ->> f++instance (Extractable t, Alternative t, Bindable t) => Bindable (Tap t) where+	Tap x xs >>= f = case f x of Tap y ys -> Tap y $ ys <+> (xs >>= lower . f)++instance (Extractable t, Extendable t) => Extendable (Tap t) where+	x =>> f = Tap (f x) $ lower x =>> f . Tap (extract x)++instance Lowerable Tap where+	lower (Tap _ xs) = xs++instance Hoistable Tap where+	hoist f (Tap x xs) = Tap x $ f xs

@@ -1,7 +1,7 @@ module Pandora.Paradigm.Primary.Transformer.Yoneda (Yoneda (..)) where  import Pandora.Core.Morphism ((!))-import Pandora.Pattern.Category (identity, (.))+import Pandora.Pattern.Category (identity, (.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>))) import Pandora.Pattern.Functor.Alternative (Alternative ((<+>))) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))@@ -10,7 +10,6 @@ import Pandora.Pattern.Functor.Extractable (Extractable (extract)) import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-))) import Pandora.Pattern.Transformer.Liftable (Liftable (lift))-import Pandora.Pattern.Functor.Divariant (($))  newtype Yoneda t a = Yoneda 	{ yoneda :: forall b . (a -> b) -> t b }@@ -34,7 +33,7 @@ 	extract (Yoneda f) = extract $ f identity  instance Liftable Yoneda where-	lift x = Yoneda (\f -> f <$> x)+	lift x = Yoneda (<$> x)  instance (Extractable t, Pointable t, Extractable u, Pointable u) => Adjoint (Yoneda t) (Yoneda u) where 	x -| f = point . f . point $ x

@@ -0,0 +1,40 @@+{-# OPTIONS_GHC -fno-warn-orphans #-}++module Pandora.Paradigm.Schemes (module Exports) where++import Pandora.Paradigm.Schemes.UTU as Exports+import Pandora.Paradigm.Schemes.UT as Exports+import Pandora.Paradigm.Schemes.TUVW as Exports+import Pandora.Paradigm.Schemes.TUT as Exports+import Pandora.Paradigm.Schemes.TU as Exports++import Pandora.Pattern.Category ((.), ($))+import Pandora.Pattern.Functor.Covariant (Covariant)+import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)++instance (Covariant (v <:.> t), Covariant (u <:.> w), Adjoint t u, Adjoint v w)+	=> Adjoint (v <:.> t) (u <:.> w) where+		TU y |- g = y |- (|- run . g)+		x -| f = TU $ x -| (-| f . TU)++instance (Covariant (v <:.> t), Covariant (w <.:> u), Adjoint t u, Adjoint v w)+	=> Adjoint (v <:.> t) (w <.:> u) where+		TU t |- g = t |- (|- run . g)+		x -| f = UT $ x -| (-| f . TU)++instance (Covariant (t <.:> v), Covariant (w <.:> u), Adjoint t u, Adjoint v w)+	=> Adjoint (t <.:> v) (w <.:> u) where+		UT t |- g = t |- (|- run . g)+		x -| f = UT $ x -| (-| f . UT)++instance (Covariant (t <.:> v), Covariant (w <:.> u) , Adjoint v u, Adjoint t w)+	=> Adjoint (t <.:> v) (w <:.> u) where+		UT t |- g = t |- (|- run . g)+		x -| f = TU $ x -| (-| f . UT)++instance (Covariant ((t <:<.>:> u) t'), Covariant ((v <:<.>:> w) v')+	, Adjoint t w, Adjoint t' v', Adjoint t v, Adjoint u v, Adjoint v' t')+	=> Adjoint ((t <:<.>:> u) t') ((v <:<.>:> w) v') where+		TUT t |- g = t |- (|- (|- run . g))+		x -| f = TUT $ x -| (-| (-| f . TUT))

@@ -0,0 +1,32 @@+module Pandora.Paradigm.Schemes.TU where++import Pandora.Core.Functor (type (:.), type (:=))+import Pandora.Pattern.Category ((.), ($))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Contravariant (Contravariant)+import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Extractable (Extractable (extract))+import Pandora.Pattern.Transformer.Liftable (Liftable (lift))+import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))+import Pandora.Pattern.Transformer.Hoistable (Hoistable (hoist))+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))++newtype TU ct cu t u a = TU (t :. u := a)++type (<:.>) = TU Covariant Covariant+type (>:.>) = TU Contravariant Covariant+type (<:.<) = TU Covariant Contravariant+type (>:.<) = TU Contravariant Contravariant++instance Interpreted (TU ct cu t u) where+	type Primary (TU ct cu t u) a = t :. u := a+	run (TU x) = x++instance Pointable t => Liftable (TU Covariant Covariant t) where+	lift = TU . point++instance Extractable t => Lowerable (TU Covariant Covariant t) where+	lower (TU x) = extract x++instance Covariant t => Hoistable (TU Covariant Covariant t) where+	hoist f (TU x) = TU $ f <$> x

@@ -0,0 +1,35 @@+module Pandora.Paradigm.Schemes.TUT where++import Pandora.Core.Functor (type (:.), type (:=))+import Pandora.Pattern.Category (identity, ($))+import Pandora.Pattern.Functor.Covariant (Covariant)+import Pandora.Pattern.Functor.Contravariant (Contravariant)+import Pandora.Pattern.Functor.Pointable (Pointable)+import Pandora.Pattern.Functor.Applicative (Applicative)+import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))+import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))+import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))+import Pandora.Pattern.Transformer.Liftable (Liftable (lift))+import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))++newtype TUT ct ct' cu t t' u a = TUT (t :. u :. t' := a)++type (<:<.>:>) = TUT Covariant Covariant Covariant+type (>:<.>:>) = TUT Contravariant Covariant Covariant+type (<:<.>:<) = TUT Covariant Covariant Contravariant+type (>:<.>:<) = TUT Contravariant Covariant Contravariant+type (<:>.<:>) = TUT Covariant Contravariant Covariant+type (>:>.<:>) = TUT Contravariant Contravariant Covariant+type (<:>.<:<) = TUT Covariant Contravariant Contravariant+type (>:>.<:<) = TUT Contravariant Contravariant Contravariant++instance Interpreted (TUT ct ct' cu t t' u) where+	type Primary (TUT ct ct' cu t t' u) a = t :. u :. t' := a+	run (TUT x) = x++instance (Adjoint t' t, Applicative t, Pointable t, forall u . Traversable u) => Liftable (t <:<.>:> t') where+	lift x = TUT $ x ->> (-| identity)++instance (Adjoint t t', Distributive t') => Lowerable (t <:<.>:> t') where+	lower (TUT x) = x |- (>>- identity)

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

@@ -0,0 +1,28 @@+module Pandora.Paradigm.Schemes.UT where++import Pandora.Core.Functor (type (:.), type (:=))+import Pandora.Pattern.Category (($))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Contravariant (Contravariant)+import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Extractable (Extractable (extract))+import Pandora.Pattern.Transformer.Liftable (Liftable (lift))+import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))++newtype UT ct cu t u a = UT (u :. t := a)++type (<.:>) = UT Covariant Covariant+type (>.:>) = UT Contravariant Covariant+type (<.:<) = UT Covariant Contravariant+type (>.:<) = UT Contravariant Contravariant++instance Interpreted (UT ct cu t u) where+	type Primary (UT ct cu t u) a = u :. t := a+	run (UT x) = x++instance (forall u . Covariant u, Pointable t) => Liftable (UT Covariant Covariant t) where+	lift x = UT $ point <$> x++instance Extractable t => Lowerable (UT Covariant Covariant t) where+	lower (UT x) = extract <$> x

@@ -0,0 +1,21 @@+module Pandora.Paradigm.Schemes.UTU where++import Pandora.Core.Functor (type (:.), type (:=))+import Pandora.Pattern.Functor.Covariant (Covariant)+import Pandora.Pattern.Functor.Contravariant (Contravariant)+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))++newtype UTU ct cu t u u' a = UTU (u :. t :. u' := a)++type (<.<:>.>) = UTU Covariant Covariant Covariant+type (>.<:>.>) = UTU Contravariant Covariant Covariant+type (<.<:>.<) = UTU Covariant Covariant Contravariant+type (>.<:>.<) = UTU Contravariant Covariant Contravariant+type (<.>:<.>) = UTU Covariant Contravariant Covariant+type (>.>:<.>) = UTU Contravariant Contravariant Covariant+type (<.>:<.<) = UTU Covariant Contravariant Contravariant+type (>.>:<.<) = UTU Contravariant Contravariant Contravariant++instance Interpreted (UTU ct cu t u u') where+	type Primary (UTU ct cu t u u') a = u :. t :. u' := a+	run (UTU x) = x

@@ -1,5 +1,7 @@ module Pandora.Paradigm.Structure.Ability (module Exports) where +import Pandora.Paradigm.Structure.Ability.Zipper as Exports import Pandora.Paradigm.Structure.Ability.Substructure as Exports+import Pandora.Paradigm.Structure.Ability.Rotatable as Exports import Pandora.Paradigm.Structure.Ability.Focusable as Exports import Pandora.Paradigm.Structure.Ability.Nonempty as Exports

@@ -1,9 +1,18 @@-module Pandora.Paradigm.Structure.Ability.Focusable (Focusable (..)) where+{-# LANGUAGE AllowAmbiguousTypes #-} -import Pandora.Core.Functor (type (|->))+module Pandora.Paradigm.Structure.Ability.Focusable where++import Pandora.Pattern.Category ((.))+import Pandora.Pattern.Functor.Covariant (comap)+import Pandora.Pattern.Functor.Extractable (extract) import Pandora.Paradigm.Inventory.Optics (type (:-.))+import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag)) -class Focusable t where-	type Focus (t :: * -> *) a-	top :: t a :-. Focus t a-	singleton :: a |-> t+class Focusable f t where+	type Focusing (f :: * -> k) (t :: * -> *) a+	focusing :: Tagged f (t a) :-. Focusing f t a++focus :: forall f t a . Focusable f t => t a :-. Focusing f t a+focus = comap extract . focusing . Tag @f++data Root a

@@ -1,4 +1,4 @@-module Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty) where+module Pandora.Paradigm.Structure.Ability.Nonempty where  -- | Type synonymous for at least one element data structure type family Nonempty (s :: * -> *) = (r :: * -> *) | r -> s

@@ -0,0 +1,13 @@+{-# LANGUAGE AllowAmbiguousTypes #-}++module Pandora.Paradigm.Structure.Ability.Rotatable where++import Pandora.Pattern.Category ((.))+import Pandora.Paradigm.Primary.Functor.Maybe (Maybe)+import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag))++class Rotatable (f :: k) t where+	rotation :: (Tagged f) (t a) -> Maybe (t a)++rotate :: forall f t a . Rotatable f t => t a -> Maybe (t a)+rotate = rotation . Tag @f

@@ -1,8 +1,16 @@-module Pandora.Paradigm.Structure.Ability.Substructure (Substructure (..)) where+{-# LANGUAGE AllowAmbiguousTypes #-} +module Pandora.Paradigm.Structure.Ability.Substructure where++import Pandora.Pattern.Category ((.))+import Pandora.Pattern.Functor.Covariant (comap)+import Pandora.Pattern.Functor.Extractable (extract) import Pandora.Paradigm.Inventory.Optics (type (:-.))-import Pandora.Paradigm.Primary.Functor.Tagged (Tagged)+import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag))  class Substructure f t where 	type Substructural (f :: * -> k) (t :: * -> *) a-	sub :: t a :-. Tagged f (Substructural f t a)+	substructure :: Tagged f (t a) :-. Substructural f t a++sub :: forall f t a . Substructure f t => t a :-. Substructural f t a+sub = comap extract . substructure . Tag @f

@@ -0,0 +1,3 @@+module Pandora.Paradigm.Structure.Ability.Zipper where++type family Zipper (s :: * -> *) = (r :: * -> *) | r -> s

@@ -1,35 +1,38 @@ {-# OPTIONS_GHC -fno-warn-orphans #-}+{-# LANGUAGE UndecidableInstances #-} -module Pandora.Paradigm.Structure.Binary (Binary, insert) where+module Pandora.Paradigm.Structure.Binary where  import Pandora.Core.Functor (type (:.), type (:=)) import Pandora.Core.Morphism ((&), (%), (!))-import Pandora.Pattern.Category ((.))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Category ((.), ($))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), comap)) import Pandora.Pattern.Functor.Extractable (extract)-import Pandora.Pattern.Functor.Divariant (($))+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))+import Pandora.Pattern.Transformer.Liftable (lift) import Pandora.Pattern.Object.Chain (Chain ((<=>))) import Pandora.Paradigm.Primary.Object.Ordering (order)+import Pandora.Paradigm.Primary.Functor (left, right) import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing), maybe) import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:))) import Pandora.Paradigm.Primary.Functor.Wye (Wye (End, Left, Right, Both)) import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag)) import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct)-import Pandora.Paradigm.Controlflow.Joint.Schemes.TU (TU (TU))-import Pandora.Paradigm.Controlflow.Joint.Interpreted (run)+import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run) import Pandora.Paradigm.Inventory.Store (Store (Store))-import Pandora.Paradigm.Inventory.Optics ((%~))+import Pandora.Paradigm.Inventory.Optics (type (:-.), (|>), (%~)) import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty)-import Pandora.Paradigm.Structure.Ability.Focusable (Focusable (Focus, top, singleton))-import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substructural, sub))+import Pandora.Paradigm.Structure.Ability.Focusable (Focusable (Focusing, focusing), Root)+import Pandora.Paradigm.Structure.Ability.Rotatable (Rotatable (rotation), rotate)+import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substructural, substructure), sub) -type Binary = TU Covariant Covariant Maybe (Construction Wye)+type Binary = Maybe <:.> Construction Wye  insert :: Chain a => a -> Binary a -> Binary a-insert x (TU Nothing) = TU . Just . Construct x $ End-insert x tree@(TU (Just (Construct y _))) = x <=> y & order-	(sub @Left %~ (insert x <$>) $ tree) tree-	(sub @Right %~ (insert x <$>) $ tree)+insert x (run -> Nothing) = lift . Construct x $ End+insert x tree@(run -> Just nonempty) = x <=> extract nonempty & order+	(sub @Left %~ insert x $ tree) tree (sub @Right %~ insert x $ tree)  rebalance :: Chain a => (Wye :. Construction Wye := a) -> Nonempty Binary a rebalance (Both x y) = extract x <=> extract y & order@@ -37,61 +40,80 @@ 	(Construct (extract x) $ Both (rebalance $ deconstruct x) (rebalance $ deconstruct y)) 	(Construct (extract x) $ Both (rebalance $ deconstruct x) y) -instance (forall a . Chain a) => Focusable Binary where-	type Focus Binary a = Maybe a-	top (TU Nothing) = Store . (:*:) Nothing $ TU . (<$>) (Construct % End)-	top (TU (Just x)) = Store . (:*:) (Just $ extract x) $ maybe-		(TU . Just . rebalance $ deconstruct x)-		(TU . Just . Construct % deconstruct x)-	singleton = TU . Just . Construct % End+instance (forall a . Chain a) => Focusable Root Binary where+	type Focusing Root Binary a = Maybe a+	focusing (run . extract -> Nothing) = Store $ Nothing :*: Tag . TU . comap (Construct % End)+	focusing (run . extract -> Just x) = Store $ Just (extract x) :*: Tag . lift . maybe (rebalance $ deconstruct x) (Construct % deconstruct x)  instance Substructure Left Binary where 	type Substructural Left Binary a = Binary a-	sub (TU Nothing) = Store $ (:*:) (Tag $ TU Nothing) $ (TU Nothing !)-	sub t@(TU (Just (Construct x End))) = Store $ (:*:) (Tag $ TU Nothing) $-		maybe t (TU . Just . Construct x . Left) . run . extract-	sub (TU (Just (Construct x (Left lst)))) = Store $ (:*:) (Tag . TU . Just $ lst) $-		maybe (TU . Just . Construct x $ End) (TU . Just . Construct x . Left) . run . extract-	sub t@(TU (Just (Construct x (Right rst)))) = Store $ (:*:) (Tag $ TU Nothing) $-		maybe t (TU . Just . Construct x . Both % rst) . run . extract-	sub (TU (Just (Construct x (Both lst rst)))) = Store $ (:*:) (Tag . TU . Just $ lst) $-		maybe (TU (Just (Construct x (Right rst)))) (TU . Just . Construct x . Both % rst) . run . extract+	substructure empty_tree@(run . extract -> Nothing) = Store $ extract empty_tree :*: (!) empty_tree+	substructure (run . extract -> Just tree) = Tag . lift <$> (sub @Left |> can_be_empty) tree  instance Substructure Right Binary where 	type Substructural Right Binary a = Binary a-	sub (TU Nothing) = Store $ Tag (TU Nothing) :*: (TU Nothing !)-	sub t@(TU (Just (Construct x End))) = Store $ Tag (TU Nothing)-		:*: maybe t (TU . Just . Construct x . Right) . run . extract-	sub t@(TU (Just (Construct x (Left lst)))) = Store $ Tag (TU Nothing)-		:*: maybe t (TU . Just . Construct x . Both lst) . run . extract-	sub (TU (Just (Construct x (Right rst)))) = Store $ (Tag . TU . Just $ rst)-		:*: maybe (TU . Just . Construct x $ End) (TU . Just . Construct x . Right) . run . extract-	sub (TU (Just (Construct x (Both lst rst)))) = Store $ (Tag . TU . Just $ rst)-		:*: maybe (TU . Just . Construct x $ Left lst) (TU . Just . Construct x . Both lst) . run . extract+	substructure empty_tree@(run . extract -> Nothing) = Store $ extract empty_tree :*: (!) empty_tree+	substructure (run . extract -> Just tree) = Tag . lift <$> (sub @Right |> can_be_empty) tree +can_be_empty :: Maybe (Construction Wye a) :-. Binary a+can_be_empty maybe_tree = Store $ TU maybe_tree :*: run+ type instance Nonempty Binary = Construction Wye -instance Focusable (Construction Wye) where-	type Focus (Construction Wye) a = a-	top (Construct x xs) = Store $ x :*: Construct % xs-	singleton = Construct % End+instance Focusable Root (Construction Wye) where+	type Focusing Root (Construction Wye) a = a+	focusing (extract -> Construct x xs) = Store $ x :*: Tag . Construct % xs  instance Substructure Left (Construction Wye) where 	type Substructural Left (Construction Wye) a = Maybe :. Construction Wye := a-	sub (Construct x End) = Store $ Tag Nothing :*: (Construct x End !)-	sub (Construct x (Left lst)) = Store $ Tag (Just lst)-		:*: maybe (Construct x End) (Construct x . Left) . extract-	sub tree@(Construct x (Right rst)) = Store $ Tag Nothing-		:*: maybe tree (Construct x . Both % rst) . extract-	sub (Construct x (Both lst rst)) = Store $ Tag (Just lst)-		:*: maybe (Construct x $ Right rst) (Construct x . Both % rst) . extract+	substructure empty_tree@(extract -> Construct _ End) = Store $ Nothing :*: (!) empty_tree+	substructure (extract -> Construct x (Left lst)) = Store $ Just lst :*: Tag . Construct x . maybe End Left+	substructure (extract -> Construct x (Right rst)) = Store $ Nothing :*: Tag . Construct x . maybe (Right rst) (Both % rst)+	substructure (extract -> Construct x (Both lst rst)) = Store $ Just lst :*: Tag . Construct x . maybe (Right rst) (Both % rst)  instance Substructure Right (Construction Wye) where 	type Substructural Right (Construction Wye) a = Maybe :. Construction Wye := a-	sub (Construct x End) = Store $ Tag Nothing :*: (Construct x End !)-	sub tree@(Construct x (Left lst)) = Store $ Tag Nothing-		:*: maybe tree (Construct x . Both lst) . extract-	sub (Construct x (Right rst)) = Store $ Tag (Just rst)-		:*: maybe (Construct x End) (Construct x . Right) . extract-	sub (Construct x (Both lst rst)) = Store $ Tag (Just rst)-		:*: maybe (Construct x $ Left lst) (Construct x . Both lst) . extract+	substructure emtpy_tree@(extract -> Construct _ End) = Store $ Nothing :*: (!) emtpy_tree+	substructure (extract -> Construct x (Left lst)) = Store $ Nothing :*: Tag . Construct x . maybe (Left lst) (Both lst)+	substructure (extract -> Construct x (Right rst)) = Store $ Just rst :*: Tag . Construct x . maybe End Right+	substructure (extract -> Construct x (Both lst rst)) = Store $ Just rst :*: Tag . Construct x . maybe (Left lst) (Both lst)++data Splay a = Zig a | Zag a++instance Rotatable (Left Zig) (Construction Wye) where+	rotation (Tag (Construct parent st)) = Construct % subtree <$> found where++		subtree = maybe_subtree a . Just . Construct parent $ maybe_subtree b c+		found = extract <$> left st+		a = deconstruct <$> left st >>= left+		b = deconstruct <$> left st >>= right+		c = right st++instance Rotatable (Right Zig) (Construction Wye) where+	rotation (Tag (Construct parent st)) = Construct % subtree <$> found where++		found = extract <$> right st+		subtree = maybe_subtree a . Just . Construct parent $ maybe_subtree b c+		a = left st+		b = deconstruct <$> right st >>= left+		c = deconstruct <$> right st >>= right++instance Rotatable (Left (Zig Zig)) (Construction Wye) where+	rotation (Tag tree) = rotate @(Left Zig) tree >>= rotate @(Left Zig)++instance Rotatable (Right (Zig Zig)) (Construction Wye) where+	rotation (Tag tree) = rotate @(Right Zig) tree >>= rotate @(Right Zig)++instance Rotatable (Left (Zig Zag)) (Construction Wye) where+	rotation (Tag tree) = rotate @(Left Zig)+		$ sub @Left %~ (>>= rotate @(Right Zig)) $ tree++instance Rotatable (Right (Zig Zag)) (Construction Wye) where+	rotation (Tag tree) = rotate @(Right Zig)+		$ sub @Right %~ (>>= rotate @(Left Zig)) $ tree++maybe_subtree :: Maybe a -> Maybe a -> Wye a+maybe_subtree (Just x) (Just y) = Both x y+maybe_subtree Nothing (Just y) = Right y+maybe_subtree (Just x) Nothing = Left x+maybe_subtree Nothing Nothing = End

@@ -1,47 +1,45 @@ {-# OPTIONS_GHC -fno-warn-orphans #-} -module Pandora.Paradigm.Structure.Rose (Rose) where+module Pandora.Paradigm.Structure.Rose where  import Pandora.Core.Functor (type (:.), type (:=)) import Pandora.Core.Morphism ((!), (%))-import Pandora.Pattern.Category ((.))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Category ((.), ($))+import Pandora.Pattern.Functor.Covariant (Covariant (comap)) import Pandora.Pattern.Functor.Extractable (extract) import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))-import Pandora.Pattern.Functor.Divariant (($))+import Pandora.Pattern.Transformer.Liftable (lift) import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing), maybe) import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:))) import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag)) import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct)-import Pandora.Paradigm.Controlflow.Joint.Schemes.TU (TU (TU))+import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run) import Pandora.Paradigm.Inventory.Store (Store (Store))-import Pandora.Paradigm.Structure.Stack (Stack) import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty)-import Pandora.Paradigm.Structure.Ability.Focusable (Focusable (Focus, top, singleton))-import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substructural, sub))+import Pandora.Paradigm.Structure.Ability.Focusable (Focusable (Focusing, focusing), Root)+import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substructural, substructure))+import Pandora.Paradigm.Structure.Stack (Stack) -type Rose = TU Covariant Covariant Maybe (Construction Stack)+type Rose = Maybe <:.> Construction Stack -instance Focusable Rose where-	type Focus Rose a = Maybe a-	top (TU Nothing) = Store $ Nothing :*: TU . (<$>) (Construct % empty)-	top (TU (Just x)) = Store $ Just (extract x) :*: maybe-		(TU $ Just x) -- TODO: Nothing at top's lens - should it remove something?-		(TU . Just . Construct % deconstruct x)-	singleton = TU . Just . Construct % empty+instance Focusable Root Rose where+	type Focusing Root Rose a = Maybe a+	focusing (run . extract -> Nothing) = Store $ Nothing :*: Tag . TU . comap (Construct % empty)+	focusing (run . extract -> Just rose) = Store $ Just (extract rose)+		:*: Tag . maybe (TU Nothing) (lift . Construct % deconstruct rose)  instance Substructure Just Rose where 	type Substructural Just Rose a = Stack :. Construction Stack := a-	sub (TU Nothing) = Store $ Tag (TU Nothing) :*: (TU Nothing !)-	sub (TU (Just (Construct x xs))) = Store $ Tag xs :*: TU . Just . Construct x . extract+	substructure (run . extract -> Nothing) = Store $ TU Nothing :*: (Tag (TU Nothing) !)+	substructure (run . extract -> Just (Construct x xs)) = Store $ xs :*: Tag . lift . Construct x  type instance Nonempty Rose = Construction Stack +instance Focusable Root (Construction Stack) where+	type Focusing Root (Construction Stack) a = a+	focusing (Tag rose) = Store $ extract rose :*: Tag . Construct % deconstruct rose+ instance Substructure Just (Construction Stack) where 	type Substructural Just (Construction Stack) a = Stack :. Construction Stack := a-	sub (Construct x xs) = Store $ Tag xs :*: Construct x . extract--instance Focusable (Construction Stack) where-	type Focus (Construction Stack) a = a-	top rose = Store $ extract rose :*: Construct % deconstruct rose-	singleton = Construct % empty+	substructure (Tag (Construct x xs)) = Store $ xs :*: Tag . Construct x

@@ -1,60 +1,57 @@ {-# OPTIONS_GHC -fno-warn-orphans #-} -module Pandora.Paradigm.Structure.Stack (Stack, push, pop, filter, linearize) where+module Pandora.Paradigm.Structure.Stack where  import Pandora.Core.Functor (type (~>)) import Pandora.Core.Morphism ((&), (%))-import Pandora.Pattern.Category ((.))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Category ((.), ($))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), (.|..)) import Pandora.Pattern.Functor.Alternative ((<+>)) import Pandora.Pattern.Functor.Avoidable (empty) import Pandora.Pattern.Functor.Pointable (point) import Pandora.Pattern.Functor.Extractable (extract) import Pandora.Pattern.Functor.Traversable (Traversable) import Pandora.Pattern.Functor.Bindable ((>>=))-import Pandora.Pattern.Functor.Divariant (($))+import Pandora.Pattern.Transformer.Liftable (lift) import Pandora.Pattern.Object.Setoid (Setoid ((==))) import Pandora.Pattern.Object.Semigroup (Semigroup ((+))) import Pandora.Pattern.Object.Monoid (Monoid (zero)) import Pandora.Paradigm.Primary.Object.Boolean ((?))+import Pandora.Paradigm.Primary.Functor.Delta (Delta ((:^:))) import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing)) import Pandora.Paradigm.Primary.Functor.Predicate (Predicate (Predicate)) import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)))+import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag)) import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct)+import Pandora.Paradigm.Primary.Transformer.Tap (Tap (Tap)) import Pandora.Paradigm.Inventory.State (fold) import Pandora.Paradigm.Inventory.Store (Store (Store))-import Pandora.Paradigm.Controlflow.Joint.Interpreted (run)-import Pandora.Paradigm.Controlflow.Joint.Schemes.TU (TU (TU))+import Pandora.Paradigm.Inventory.Optics ((^.))+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)+import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>)) import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty)-import Pandora.Paradigm.Structure.Ability.Focusable (Focusable (Focus, top, singleton))+import Pandora.Paradigm.Structure.Ability.Zipper (Zipper)+import Pandora.Paradigm.Structure.Ability.Focusable (Focusable (Focusing, focusing), Root, focus)  -- | Linear data structure that serves as a collection of elements-type Stack = TU Covariant Covariant Maybe (Construction Maybe)+type Stack = Maybe <:.> Construction Maybe  instance Setoid a => Setoid (Stack a) where 	TU ls == TU rs = ls == rs  instance Semigroup (Stack a) where 	TU Nothing + TU ys = TU ys-	TU (Just (Construct x xs)) + TU ys = TU . Just . Construct x . run+	TU (Just (Construct x xs)) + TU ys = lift . Construct x . run 		$ TU @Covariant @Covariant xs + TU @Covariant @Covariant ys  instance Monoid (Stack a) where 	zero = TU Nothing -instance Focusable Stack where-	type Focus Stack a = Maybe a-	top stack = Store $ (:*:) (extract <$> run stack) $ \case-		Just x -> stack & pop & push x-		Nothing -> pop stack-	singleton = TU . Just . Construct % Nothing--type instance Nonempty Stack = Construction Maybe--instance Focusable (Construction Maybe) where-	type Focus (Construction Maybe) a = a-	top stack = Store $ extract stack :*: Construct % deconstruct stack-	singleton = Construct % Nothing+instance Focusable Root Stack where+	type Focusing Root Stack a = Maybe a+	focusing (Tag stack) = Store $ extract <$> run stack :*: \case+		Just x -> stack & pop & push x & Tag+		Nothing -> Tag $ pop stack  push :: a -> Stack a -> Stack a push x (TU stack) = TU $ (Construct x . Just <$> stack) <+> (point . point) x@@ -68,4 +65,16 @@  -- | Transform any traversable structure into a stack linearize :: Traversable t => t ~> Stack-linearize = TU . fold Nothing (\x -> Just . Construct x)+linearize = TU . fold Nothing (Just .|.. Construct)++type instance Nonempty Stack = Construction Maybe++instance Focusable Root (Construction Maybe) where+	type Focusing Root (Construction Maybe) a = a+	focusing (Tag stack) = Store $ extract stack :*: Tag . Construct % deconstruct stack++type instance Zipper Stack = Tap (Delta <:.> Stack)++forward, backward :: Zipper Stack a -> Maybe (Zipper Stack a)+forward (Tap x (TU (bs :^: fs))) = Tap % (TU $ push x bs :^: pop fs) <$> focus @Root ^. fs+backward (Tap x (TU (bs :^: fs))) = Tap % (TU $ pop bs :^: push x fs) <$> focus @Root ^. bs

@@ -1,4 +1,4 @@-module Pandora.Paradigm.Structure.Stream (Stream) where+module Pandora.Paradigm.Structure.Stream where  import Pandora.Paradigm.Primary.Functor.Identity (Identity) import Pandora.Paradigm.Primary.Transformer.Construction (Construction)

@@ -1,10 +1,14 @@ module Pandora.Pattern.Category (Category (..)) where  infixr 8 .+infixr 0 $  class Category (m :: * -> * -> *) where 	identity :: m a a 	(.) :: m b c -> m a b -> m a c++	($) :: m a b -> m a b+	($) f = identity . f  instance Category (->) where 	identity x = x

@@ -1,4 +1,4 @@-module Pandora.Pattern.Functor.Adjoint (Adjoint (..), type (-|)) where+module Pandora.Pattern.Functor.Adjoint where  import Pandora.Core.Functor (type (:.), type (:=)) import Pandora.Pattern.Category (identity)

@@ -1,4 +1,4 @@-module Pandora.Pattern.Functor.Alternative (Alternative (..)) where+module Pandora.Pattern.Functor.Alternative where  import Pandora.Pattern.Functor.Covariant (Covariant) 

@@ -1,4 +1,4 @@-module Pandora.Pattern.Functor.Applicative (Applicative (..)) where+module Pandora.Pattern.Functor.Applicative where  import Pandora.Core.Functor (type (:.), type (:=)) import Pandora.Pattern.Category (identity)

@@ -1,4 +1,4 @@-module Pandora.Pattern.Functor.Avoidable (Avoidable (..)) where+module Pandora.Pattern.Functor.Avoidable where  import Pandora.Pattern.Functor.Alternative (Alternative) 

@@ -1,4 +1,4 @@-module Pandora.Pattern.Functor.Bindable (Bindable (..)) where+module Pandora.Pattern.Functor.Bindable where  import Pandora.Core.Functor (type (:.), type (:=)) import Pandora.Core.Morphism ((%))

@@ -1,6 +1,6 @@-module Pandora.Pattern.Functor.Bivariant (Bivariant (..)) where+module Pandora.Pattern.Functor.Bivariant where -import Pandora.Pattern.Functor.Divariant (($))+import Pandora.Pattern.Category (($))  infixl 4 <-> 

@@ -1,4 +1,4 @@-module Pandora.Pattern.Functor.Comonad (Comonad) where+module Pandora.Pattern.Functor.Comonad where  import Pandora.Pattern.Functor.Extractable (Extractable) import Pandora.Pattern.Functor.Extendable (Extendable)

@@ -1,4 +1,4 @@-module Pandora.Pattern.Functor.Contravariant (Contravariant (..)) where+module Pandora.Pattern.Functor.Contravariant where  import Pandora.Core.Functor (type (:.), type (:=)) import Pandora.Core.Morphism ((!), (%))

@@ -1,8 +1,8 @@-module Pandora.Pattern.Functor.Covariant (Covariant (..)) where+module Pandora.Pattern.Functor.Covariant where  import Pandora.Core.Functor (type (:.), type (:=), type (<-|)) import Pandora.Core.Morphism (fix, (!), (%))-import Pandora.Pattern.Category ((.))+import Pandora.Pattern.Category (Category ((.)))  infixl 4 <$>, <$, $> @@ -58,3 +58,15 @@  instance Covariant ((->) a) where 	(<$>) = (.)++(.|..) :: (Category v, Covariant (v a))+	=> v c d -> v a :. v b := c -> v a :. v b := d+f .|.. g = (f .) <$> g++(.|...) :: (Category v, Covariant (v a), Covariant (v b))+	=> v d e -> v a :. v b :. v c := d -> v a :. v b :. v c := e+f .|... g = (f .) <$$> g++(.|....) :: (Category v, Covariant (v a), Covariant (v b), Covariant (v c))+	=> v e f -> v a :. v b :. v c :. v d := e -> v a :. v b :. v c :. v d := f+f .|.... g = (f .) <$$$> g

@@ -1,4 +1,4 @@-module Pandora.Pattern.Functor.Determinable (Determinable (..)) where+module Pandora.Pattern.Functor.Determinable where  import Pandora.Pattern.Functor.Contravariant (Contravariant) 

@@ -1,4 +1,4 @@-module Pandora.Pattern.Functor.Distributive (Distributive (..)) where+module Pandora.Pattern.Functor.Distributive where  import Pandora.Core.Functor (type (:.), type (:=)) import Pandora.Core.Morphism ((%))

@@ -1,9 +1,8 @@-module Pandora.Pattern.Functor.Divariant (Divariant (..)) where+module Pandora.Pattern.Functor.Divariant where -import Pandora.Pattern.Category ((.))+import Pandora.Pattern.Category ((.), ($))  infixl 4 >->-infixr 0 $  {- | > When providing a new instance, you should ensure it satisfies the two laws:@@ -17,9 +16,6 @@ 	-- | Prefix version of '>->' 	dimap :: v a b -> v c d -> v b c -> v a d 	dimap f g x = f >-> g $ x-	-- Generalized function application-	($) :: v a b -> v a b-	($) f = f  instance Divariant ((->)) where 	(>->) ab cd bc = cd . bc . ab

@@ -1,9 +1,9 @@-module Pandora.Pattern.Functor.Extendable (Extendable (..)) where+module Pandora.Pattern.Functor.Extendable where  import Pandora.Core.Functor (type (:.), type (:=)) import Pandora.Core.Morphism ((%)) import Pandora.Pattern.Category (identity, (.))-import Pandora.Pattern.Functor.Covariant (Covariant)+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))  infixl 1 =>> infixr 1 <<=, =<=, =>=@@ -34,3 +34,9 @@ 	-- | Left-to-right Cokleisli composition 	(=>=) :: (t a -> b) -> (t b -> c) -> t a -> c 	f =>= g = g . extend f++	-- | Experimental methods+	($=>>) :: Covariant u => (t a -> b) -> u :. t := a -> u :. t := b+	f $=>> x = (=>> f) <$> x+	(<<=$) :: Covariant u => u :. t := a -> (t a -> b) -> u :. t := b+	x <<=$ f = (=>> f) <$> x

@@ -1,4 +1,4 @@-module Pandora.Pattern.Functor.Extractable (Extractable (..)) where+module Pandora.Pattern.Functor.Extractable where  import Pandora.Core.Functor (type (<-|)) import Pandora.Pattern.Functor.Covariant (Covariant)

@@ -1,4 +1,4 @@-module Pandora.Pattern.Functor.Invariant (Invariant (..)) where+module Pandora.Pattern.Functor.Invariant where  {- | > When providing a new instance, you should ensure it satisfies the two laws:

@@ -1,4 +1,4 @@-module Pandora.Pattern.Functor.Monad (Monad) where+module Pandora.Pattern.Functor.Monad where  import Pandora.Pattern.Functor.Bindable (Bindable) import Pandora.Pattern.Functor.Pointable (Pointable)

@@ -1,4 +1,4 @@-module Pandora.Pattern.Functor.Pointable (Pointable (..)) where+module Pandora.Pattern.Functor.Pointable where  import Pandora.Core.Functor (type (|->)) import Pandora.Core.Morphism ((!))

@@ -1,4 +1,4 @@-module Pandora.Pattern.Functor.Representable (Representable (..)) where+module Pandora.Pattern.Functor.Representable where  import Pandora.Core.Functor (type (<-|)) import Pandora.Core.Morphism ((%))

@@ -1,4 +1,4 @@-module Pandora.Pattern.Functor.Traversable (Traversable (..)) where+module Pandora.Pattern.Functor.Traversable where  import Pandora.Core.Functor (type (:.), type (:=)) import Pandora.Pattern.Category (identity, (.))

@@ -1,7 +1,7 @@ module Pandora.Pattern.Transformer.Liftable (Liftable (..)) where  import Pandora.Core.Functor (type (~>))-import Pandora.Pattern.Functor.Pointable (Pointable)+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 :: Pointable 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.Extractable (Extractable)+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 :: Extractable u => t u ~> u+	lower :: Covariant u => t u ~> u

@@ -1,5 +1,5 @@ name:                pandora-version:             0.2.8+version:             0.2.9 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@@ -54,27 +54,29 @@     Pandora.Paradigm.Primary.Transformer.Continuation     Pandora.Paradigm.Primary.Transformer.Construction     Pandora.Paradigm.Primary.Transformer.Instruction+    Pandora.Paradigm.Primary.Transformer.Tap     Pandora.Paradigm.Primary.Transformer.Outline     Pandora.Paradigm.Primary.Transformer.Jack     Pandora.Paradigm.Primary.Transformer.Jet     Pandora.Paradigm.Primary.Transformer.Kan     Pandora.Paradigm.Primary.Transformer.Yoneda+    -- Schemes of functor compositions+    Pandora.Paradigm.Schemes+    Pandora.Paradigm.Schemes.TU+    Pandora.Paradigm.Schemes.TUT+    Pandora.Paradigm.Schemes.TUVW+    Pandora.Paradigm.Schemes.UT+    Pandora.Paradigm.Schemes.UTU     -- Control flow primitives     Pandora.Paradigm.Controlflow     -- Typeclassess about functor junctions-    Pandora.Paradigm.Controlflow.Joint-    Pandora.Paradigm.Controlflow.Joint.Interpreted-    Pandora.Paradigm.Controlflow.Joint.Transformer-    Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic-    Pandora.Paradigm.Controlflow.Joint.Transformer.Comonadic-    Pandora.Paradigm.Controlflow.Joint.Schematic-    Pandora.Paradigm.Controlflow.Joint.Adaptable-    Pandora.Paradigm.Controlflow.Joint.Schemes-    Pandora.Paradigm.Controlflow.Joint.Schemes.TU-    Pandora.Paradigm.Controlflow.Joint.Schemes.TUT-    Pandora.Paradigm.Controlflow.Joint.Schemes.TUVW-    Pandora.Paradigm.Controlflow.Joint.Schemes.UT-    Pandora.Paradigm.Controlflow.Joint.Schemes.UTU+    Pandora.Paradigm.Controlflow.Effect+    Pandora.Paradigm.Controlflow.Effect.Interpreted+    Pandora.Paradigm.Controlflow.Effect.Transformer+    Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic+    Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic+    Pandora.Paradigm.Controlflow.Effect.Schematic+    Pandora.Paradigm.Controlflow.Effect.Adaptable     Pandora.Paradigm.Controlflow.Observable     Pandora.Paradigm.Controlflow.Pipeline     -- Tools for datastructures@@ -94,8 +96,10 @@     Pandora.Paradigm.Structure.Rose     Pandora.Paradigm.Structure.Ability     Pandora.Paradigm.Structure.Ability.Focusable-    Pandora.Paradigm.Structure.Ability.Nonempty+    Pandora.Paradigm.Structure.Ability.Rotatable     Pandora.Paradigm.Structure.Ability.Substructure+    Pandora.Paradigm.Structure.Ability.Nonempty+    Pandora.Paradigm.Structure.Ability.Zipper      Pandora.Pattern     -- Category typeclass@@ -142,7 +146,7 @@   default-extensions:     DataKinds, ConstraintKinds, ExistentialQuantification, GADTs, QuantifiedConstraints     FlexibleContexts, FlexibleInstances, KindSignatures, LiberalTypeSynonyms, LambdaCase-    MultiParamTypeClasses, NoImplicitPrelude, PackageImports, PolyKinds, RankNTypes+    MultiParamTypeClasses, NoImplicitPrelude, PackageImports, PolyKinds, RankNTypes, ViewPatterns     ScopedTypeVariables, TypeApplications, TypeFamilies, TypeFamilyDependencies, TypeOperators   default-language: Haskell2010   ghc-options: -Wall -fno-warn-tabs -fno-warn-unticked-promoted-constructors