pandora 0.2.6 → 0.2.7

raw patch · 73 files changed

+1525/−1379 lines, 73 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• CHANGELOG.md +17/−1
• Pandora/Paradigm.hs +1/−1
• Pandora/Paradigm/Basis.hs +0/−55
• Pandora/Paradigm/Basis/Backwards.hs +0/−40
• Pandora/Paradigm/Basis/Conclusion.hs +0/−105
• Pandora/Paradigm/Basis/Constant.hs +0/−64
• Pandora/Paradigm/Basis/Continuation.hs +0/−43
• Pandora/Paradigm/Basis/Edges.hs +0/−23
• Pandora/Paradigm/Basis/Endo.hs +0/−17
• Pandora/Paradigm/Basis/Fix.hs +0/−16
• Pandora/Paradigm/Basis/Free.hs +0/−45
• Pandora/Paradigm/Basis/Identity.hs +0/−87
• Pandora/Paradigm/Basis/Jack.hs +0/−67
• Pandora/Paradigm/Basis/Jet.hs +0/−22
• Pandora/Paradigm/Basis/Kan.hs +0/−25
• Pandora/Paradigm/Basis/Maybe.hs +0/−117
• Pandora/Paradigm/Basis/Predicate.hs +0/−16
• Pandora/Paradigm/Basis/Product.hs +0/−87
• Pandora/Paradigm/Basis/Proxy.hs +0/−39
• Pandora/Paradigm/Basis/Tagged.hs +0/−96
• Pandora/Paradigm/Basis/Twister.hs +0/−68
• Pandora/Paradigm/Basis/Validation.hs +0/−60
• Pandora/Paradigm/Basis/Variation.hs +0/−26
• Pandora/Paradigm/Basis/Wye.hs +0/−27
• Pandora/Paradigm/Basis/Yoneda.hs +0/−41
• Pandora/Paradigm/Controlflow/Joint/Schemes.hs +34/−0
• Pandora/Paradigm/Controlflow/Joint/Schemes/TUT.hs +18/−0
• Pandora/Paradigm/Controlflow/Joint/Transformer/Comonadic.hs +2/−2
• Pandora/Paradigm/Controlflow/Joint/Transformer/Monadic.hs +2/−2
• Pandora/Paradigm/Controlflow/Observable.hs +1/−1
• Pandora/Paradigm/Controlflow/Pipeline.hs +1/−1
• Pandora/Paradigm/Inventory.hs +22/−0
• Pandora/Paradigm/Inventory/Accumulator.hs +1/−1
• Pandora/Paradigm/Inventory/Equipment.hs +1/−1
• Pandora/Paradigm/Inventory/Optics.hs +1/−8
• Pandora/Paradigm/Inventory/State.hs +6/−6
• Pandora/Paradigm/Inventory/Store.hs +1/−1
• Pandora/Paradigm/Primary.hs +4/−0
• Pandora/Paradigm/Primary/Functor.hs +47/−0
• Pandora/Paradigm/Primary/Functor/Conclusion.hs +105/−0
• Pandora/Paradigm/Primary/Functor/Constant.hs +64/−0
• Pandora/Paradigm/Primary/Functor/Edges.hs +26/−0
• Pandora/Paradigm/Primary/Functor/Endo.hs +17/−0
• Pandora/Paradigm/Primary/Functor/Fix.hs +16/−0
• Pandora/Paradigm/Primary/Functor/Identity.hs +87/−0
• Pandora/Paradigm/Primary/Functor/Maybe.hs +117/−0
• Pandora/Paradigm/Primary/Functor/Predicate.hs +16/−0
• Pandora/Paradigm/Primary/Functor/Product.hs +87/−0
• Pandora/Paradigm/Primary/Functor/Proxy.hs +39/−0
• Pandora/Paradigm/Primary/Functor/Tagged.hs +96/−0
• Pandora/Paradigm/Primary/Functor/Validation.hs +60/−0
• Pandora/Paradigm/Primary/Functor/Variation.hs +26/−0
• Pandora/Paradigm/Primary/Functor/Wye.hs +27/−0
• Pandora/Paradigm/Primary/Transformer.hs +11/−0
• Pandora/Paradigm/Primary/Transformer/Backwards.hs +52/−0
• Pandora/Paradigm/Primary/Transformer/Construction.hs +88/−0
• Pandora/Paradigm/Primary/Transformer/Continuation.hs +43/−0
• Pandora/Paradigm/Primary/Transformer/Instruction.hs +45/−0
• Pandora/Paradigm/Primary/Transformer/Jack.hs +67/−0
• Pandora/Paradigm/Primary/Transformer/Jet.hs +22/−0
• Pandora/Paradigm/Primary/Transformer/Kan.hs +28/−0
• Pandora/Paradigm/Primary/Transformer/Reverse.hs +52/−0
• Pandora/Paradigm/Primary/Transformer/Yoneda.hs +41/−0
• Pandora/Paradigm/Structure.hs +1/−1
• Pandora/Paradigm/Structure/Binary.hs +53/−64
• Pandora/Paradigm/Structure/Graph.hs +0/−29
• Pandora/Paradigm/Structure/Rose.hs +9/−0
• Pandora/Paradigm/Structure/Stack.hs +24/−43
• Pandora/Paradigm/Structure/Stream.hs +3/−3
• Pandora/Paradigm/Structure/Variation/Substructure.hs +3/−2
• Pandora/Pattern/Object.hs +1/−0
• Pandora/Pattern/Object/Ring.hs +10/−0
• pandora.cabal +30/−26

@@ -184,7 +184,7 @@ * Rename `Group`'s method from `inverse` to `invert` * Remove `not` method of `Boolean`, (use `invert` instead) * Remove `Injective` and `Has` type families-* Change superclasseses for `Liftable` and `Lowerable` classes to provide a law+* Change superclasses for `Liftable` and `Lowerable` classes to provide a law  # 0.2.6 * Change order of arguments for `TUT` joint schema@@ -200,3 +200,19 @@ * Remove `left_sub_tree` and `right_sub_tree` lenses of `Binary` tree * Define `this` and `that` methods from `Variation` to `Maybe` * Define `Backwards` type to run `Applicative` actions in reverse order++# 0.2.7+* Replace `Lan` and `Ran` with `Kan` data family+* Rename `Free` to `Instruction` and its constructors: `Pure` to `Enter` and `Impure` to `Instruct`+* Define `Ring` typeclass with `Group` superclass+* Define `Weighted` type family and define instance for `Graph`+* Add `Leap` to `Edges` to indicate a connection with only the first vertex+* Remove `Graph` structure and `Weighted` type family+* Define `Reverse` type to run `Traversable` in reverse order with `Backwards`+* Rename `Twister` to `Construction` (in contrast of `Instruction`)+* Split `Basis` on `Functor` and `Transformer` modules in `Primary`+* Rename `untwist` to `deconstruct` in `Construction`+* Define `Rose` tree structure+* Replace `UT` joint scheme with `TU` in data structures+* Change `sub` method of `Substructure` - it always returns `Tagged` value+* Rename `Construction` constructor of `Construction` to `Construct`

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

@@ -1,55 +0,0 @@-module Pandora.Paradigm.Basis (module Exports, note, hush, left, right, this, that) where--import Pandora.Paradigm.Basis.Twister as Exports-import Pandora.Paradigm.Basis.Free as Exports-import Pandora.Paradigm.Basis.Fix as Exports-import Pandora.Paradigm.Basis.Yoneda as Exports-import Pandora.Paradigm.Basis.Continuation as Exports-import Pandora.Paradigm.Basis.Predicate as Exports-import Pandora.Paradigm.Basis.Variation as Exports-import Pandora.Paradigm.Basis.Validation as Exports-import Pandora.Paradigm.Basis.Wye as Exports-import Pandora.Paradigm.Basis.Edges as Exports-import Pandora.Paradigm.Basis.Conclusion as Exports-import Pandora.Paradigm.Basis.Maybe as Exports-import Pandora.Paradigm.Basis.Endo as Exports-import Pandora.Paradigm.Basis.Kan as Exports-import Pandora.Paradigm.Basis.Jet as Exports-import Pandora.Paradigm.Basis.Jack as Exports-import Pandora.Paradigm.Basis.Proxy as Exports-import Pandora.Paradigm.Basis.Tagged as Exports-import Pandora.Paradigm.Basis.Product as Exports-import Pandora.Paradigm.Basis.Constant as Exports-import Pandora.Paradigm.Basis.Backwards as Exports-import Pandora.Paradigm.Basis.Identity as Exports--import Pandora.Core.Morphism ((!))-import Pandora.Core.Functor (type (~>))--note :: e -> Maybe ~> Conclusion e-note x = maybe (Failure x) Success--hush :: Conclusion e ~> Maybe-hush = conclusion (Nothing !) Just--left :: Wye ~> Maybe-left (Both ls _) = Just ls-left (Left ls) = Just ls-left (Right _) = Nothing-left End = Nothing--right :: Wye ~> Maybe-right (Both _ rs) = Just rs-right (Left _) = Nothing-right (Right rs) = Just rs-right End = Nothing--this :: Variation e ~> Maybe-this (This x) = Just x-this (That _) = Nothing-this (These _ x) = Just x--that :: Variation e a -> Maybe e-that (This _) = Nothing-that (That x) = Just x-that (These y _) = Just y

@@ -1,40 +0,0 @@-module Pandora.Paradigm.Basis.Backwards (Backwards (..)) where--import Pandora.Core.Morphism ((&))-import Pandora.Pattern.Category ((.))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))-import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))-import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))-import Pandora.Pattern.Functor.Divariant (($))-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))--newtype Backwards t a = Backwards (t a)--instance Covariant t => Covariant (Backwards t) where-	f <$> Backwards x = Backwards $ f <$> x--instance Pointable t => Pointable (Backwards t) where-	point = Backwards . point--instance Extractable t => Extractable (Backwards t) where-	extract (Backwards x) = extract x--instance Applicative t => Applicative (Backwards t) where-	Backwards f <*> Backwards x = Backwards ((&) <$> x <*> f)--instance Traversable t => Traversable (Backwards t) where-	Backwards x ->> f = Backwards <$> x ->> f--instance Distributive t => Distributive (Backwards t) where-	x >>- f = Backwards $ x >>- run . f--instance Contravariant t => Contravariant (Backwards t) where-	f >$< Backwards x = Backwards $ f >$< x--instance Interpreted (Backwards t) where-	type Primary (Backwards t) a = t a-	run (Backwards x) = x

@@ -1,105 +0,0 @@-module Pandora.Paradigm.Basis.Conclusion (Conclusion (..), Failable, conclusion, fail, failure) where--import Pandora.Core.Functor (type (~>))-import Pandora.Pattern.Category ((.))-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.Functor.Covariant (Covariant ((<$>), (<$$>)))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), apply))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-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 ((==)), Boolean (False))-import Pandora.Pattern.Object.Chain (Chain ((<=>)), Ordering (Less, Greater))-import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))--data Conclusion e a = Failure e | Success a--instance Covariant (Conclusion e) where-	f <$> Success x = Success $ f x-	_ <$> Failure y = Failure y--instance Pointable (Conclusion e) where-	point = Success--instance Applicative (Conclusion e) where-	Success f <*> x = f <$> x-	Failure y <*> _ = Failure y--instance Alternative (Conclusion e) where-	Failure _ <+> x = x-	Success x <+> _ = Success x--instance Traversable (Conclusion e) where-	Failure y ->> _ = point $ Failure y-	Success x ->> f = Success <$> f x--instance Bindable (Conclusion e) where-	Success x >>= f = f x-	Failure y >>= _ = Failure y--instance Monad (Conclusion e) where--instance Bivariant Conclusion where-    f <-> g = conclusion (Failure . f) (Success . g)--instance (Setoid e, Setoid a) => Setoid (Conclusion e a) where-	Success x == Success y = x == y-	Failure x == Failure y = x == y-	_ == _ = False--instance (Chain e, Chain a) => Chain (Conclusion e a) where-	Success x <=> Success y = x <=> y-	Failure x <=> Failure y = x <=> y-	Failure _ <=> Success _ = Less-	Success _ <=> Failure _ = Greater--instance (Semigroup e, Semigroup a) => Semigroup (Conclusion e a) where-	Success x + Success y = Success $ x + y-	Failure x + Failure y = Failure $ x + y-	Failure _ + Success y = Success y-	Success x + Failure _ = Success x--conclusion :: (e -> r) -> (a -> r) -> Conclusion e a -> r-conclusion f _ (Failure x) = f x-conclusion _ s (Success x) = s x--fail :: (e -> r) -> Conclusion e ~> Conclusion r-fail f (Failure x) = Failure $ f x-fail _ (Success y) = Success y--instance Interpreted (Conclusion e) where-	type Primary (Conclusion e) a = Conclusion e a-	run x = x--type instance Schematic Monad (Conclusion e) u = UT Covariant Covariant (Conclusion e) u--instance Monadic (Conclusion e) where-	lay x = TM . UT $ Success <$> x-	wrap x = TM . UT . point $ x--type Failable e = Adaptable (Conclusion e)--instance Covariant u => Covariant (UT Covariant Covariant (Conclusion e) u) where-	f <$> UT x = UT $ f <$$> x--instance Applicative u => Applicative (UT Covariant Covariant (Conclusion e) u) where-	UT f <*> UT x = UT $ apply <$> f <*> x--instance Pointable u => Pointable (UT Covariant Covariant (Conclusion e) u) where-	point = UT . point . point--instance (Pointable u, Bindable u) => Bindable (UT Covariant Covariant (Conclusion e) u) where-	UT x >>= f = UT $ x >>= conclusion (point . Failure) (run . f)--instance Monad u => Monad (UT Covariant Covariant (Conclusion e) u) where--failure :: Failable e t => e -> t a-failure = adapt . Failure

@@ -1,64 +0,0 @@-module Pandora.Paradigm.Basis.Constant (Constant (..)) where--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 ((+)))-import Pandora.Pattern.Object.Monoid (Monoid (zero))-import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))-import Pandora.Pattern.Object.Quasiring (Quasiring (one))-import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))-import Pandora.Pattern.Object.Lattice (Lattice)-import Pandora.Pattern.Object.Group (Group (invert))--newtype Constant a b = Constant a--instance Covariant (Constant a) where-	_ <$> Constant x = Constant x--instance Contravariant (Constant a) where-	_ >$< Constant x = Constant x--instance Invariant (Constant a) where-	invmap _ _ (Constant x) = Constant x--instance Traversable (Constant a) where-	Constant x ->> _ = point (Constant x)--instance Bivariant Constant where-	f <-> _ = \(Constant x) -> Constant $ f x--instance Setoid a => Setoid (Constant a b) where-	Constant x == Constant y = x == y--instance Chain a => Chain (Constant a b) where-	Constant x <=> Constant y = x <=> y--instance Semigroup a => Semigroup (Constant a b) where-	Constant x + Constant y = Constant $ x + y--instance Monoid a => Monoid (Constant a b) where-	 zero = Constant zero--instance Ringoid a => Ringoid (Constant a b) where-	Constant x * Constant y = Constant $ x * y--instance Quasiring a => Quasiring (Constant a b) where-	 one = Constant one--instance Infimum a => Infimum (Constant a b) where-	Constant x /\ Constant y = Constant $ x /\ y--instance Supremum a => Supremum (Constant a b) where-	Constant x \/ Constant y = Constant $ x \/ y--instance Lattice a => Lattice (Constant a b) where--instance Group a => Group (Constant a b) where-	invert (Constant x) = Constant $ invert x

@@ -1,43 +0,0 @@-module Pandora.Paradigm.Basis.Continuation (Continuation (..), cwcc, reset, shift) where--import Pandora.Core.Functor (type (:.), type (:=), type (::|:.))-import Pandora.Core.Morphism ((!), (%))-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 }--instance Covariant t => Covariant (Continuation r t) where-	f <$> Continuation continuation = Continuation $ continuation . (. f)--instance Covariant t => Pointable (Continuation r t) where-	point x = Continuation ($ x)--instance Covariant t => Applicative (Continuation r t) where-	f <*> x = Continuation $ \h -> continue f $ \g -> continue x (h . g)--instance Covariant t => Bindable (Continuation r t) where-	x >>= f = Continuation $ \g -> continue x $ \y -> continue (f y) g--instance Monad t => Monad (Continuation r t) where--instance (forall u . Bindable u) => Liftable (Continuation r) where-	lift = Continuation . (>>=)---- | Call with current continuation-cwcc :: ((a -> Continuation r t b) -> Continuation r t a) -> Continuation r t a-cwcc f = Continuation $ \g -> continue % g . f $ Continuation . (!) . g---- | Delimit the continuation of any 'shift'-reset :: (forall u . Bindable u, Bindable t, Pointable t) => Continuation r t r -> Continuation s t r-reset = lift . continue % point---- | Capture the continuation up to the nearest enclosing 'reset' and pass it-shift :: Pointable t => ((a -> t r) -> Continuation r t r) -> Continuation r t a-shift f = Continuation $ continue % point . f

@@ -1,23 +0,0 @@-module Pandora.Paradigm.Basis.Edges (Edges (..), edges) where--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 | Connect a | Overlay a--instance Covariant Edges where-	_ <$> Empty = Empty-	f <$> Connect x = Connect $ f x-	f <$> Overlay x = Overlay $ f x--instance Traversable Edges where-	Empty ->> _ = point Empty-	Connect x ->> f = Connect <$> f x-	Overlay x ->> f = Overlay <$> f x--edges :: r -> (a -> r) -> (a -> r) -> Edges a -> r-edges r _ _ Empty = r-edges _ f _ (Connect x) = f x-edges _ _ g (Overlay y) = g y

@@ -1,17 +0,0 @@-module Pandora.Paradigm.Basis.Endo (Endo (..)) where--import Pandora.Pattern.Category (identity, (.))-import Pandora.Pattern.Functor.Invariant (Invariant (invmap))-import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))-import Pandora.Pattern.Object.Monoid (Monoid (zero))--newtype Endo a = Endo { endo :: a -> a }--instance Invariant Endo where-	invmap f g (Endo x) = Endo (f . x . g)--instance Semigroup (Endo a) where-	Endo f + Endo g = Endo (g . f)--instance Monoid (Endo a) where-	zero = Endo identity

@@ -1,16 +0,0 @@-module Pandora.Paradigm.Basis.Fix (Fix (..), cata, ana, hylo) where--import Pandora.Core.Functor (type (<-|), type (|->))-import Pandora.Pattern.Category ((.))-import Pandora.Pattern.Functor.Covariant (Covariant (comap))--newtype Fix t = Fix { unfix :: t (Fix t) }--cata :: Covariant t => (a <-| t) -> Fix t -> a-cata f = f . comap (cata f) . unfix--ana :: Covariant t => (a |-> t) -> a -> Fix t-ana f = Fix . comap (ana f) . f--hylo :: Covariant t => (b <-| t) -> (a |-> t) -> (a -> b)-hylo phi psi = cata phi . ana psi

@@ -1,45 +0,0 @@-module Pandora.Paradigm.Basis.Free (Free (..)) where--import Pandora.Core.Functor (type (:.), type (:=))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))-import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))-import Pandora.Pattern.Transformer.Liftable (Liftable (lift))-import Pandora.Pattern.Functor.Divariant (($))--data Free t a = Pure a | Impure (t :. Free t := a)--instance Covariant t => Covariant (Free t) where-	f <$> Pure x = Pure $ f x-	f <$> Impure xs = Impure $ f <$$> xs--instance Covariant t => Pointable (Free t) where-	point = Pure--instance Alternative t => Alternative (Free t) where-	Pure x <+> _ = Pure x-	_ <+> Pure y = Pure y-	Impure xs <+> Impure ys = Impure $ xs <+> ys--instance Avoidable t => Avoidable (Free t) where-	empty = Impure empty--instance Covariant t => Applicative (Free t) where-	Pure f <*> Pure y = Pure $ f y-	Pure f <*> Impure y = Impure $ f <$$> y-	Impure f <*> y = Impure $ (<*> y) <$> f--instance Covariant t => Bindable (Free t) where-	Pure x >>= f = f x-	Impure xs >>= f = Impure $ (>>= f) <$> xs--instance Traversable t => Traversable (Free t) where-	Pure x ->> f = Pure <$> f x-	Impure xs ->> f = Impure <$> xs ->>> f--instance Liftable Free where-	lift x = Impure $ Pure <$> x

@@ -1,87 +0,0 @@-module Pandora.Paradigm.Basis.Identity (Identity (..)) where--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))-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))-import Pandora.Pattern.Functor.Monad (Monad)-import Pandora.Pattern.Functor.Comonad (Comonad)-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 ((+)))-import Pandora.Pattern.Object.Monoid (Monoid (zero))-import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))-import Pandora.Pattern.Object.Quasiring (Quasiring (one))-import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))-import Pandora.Pattern.Object.Lattice (Lattice)-import Pandora.Pattern.Object.Group (Group (invert))--newtype Identity a = Identity a--instance Covariant Identity where-	f <$> Identity x = Identity $ f x--instance Pointable Identity where-	point = Identity--instance Extractable Identity where-	extract (Identity x) = x--instance Applicative Identity where-	Identity f <*> Identity x = Identity $ f x--instance Traversable Identity where-	Identity x ->> f = Identity <$> f x--instance Distributive Identity where-	x >>- f = Identity $ extract . f <$> x--instance Bindable Identity where-	Identity x >>= f = f x--instance Monad Identity--instance Extendable Identity where-	x =>> f = Identity . f $ x--instance Comonad Identity--instance Adjoint Identity Identity where-	x -| f = Identity . f . Identity $ x-	x |- g = extract . extract . comap g $ x--instance Setoid a => Setoid (Identity a) where-	Identity x == Identity y = x == y--instance Chain a => Chain (Identity a) where-	Identity x <=> Identity y = x <=> y--instance Semigroup a => Semigroup (Identity a) where-	Identity x + Identity y = Identity $ x + y--instance Monoid a => Monoid (Identity a) where-	 zero = Identity zero--instance Ringoid a => Ringoid (Identity a) where-	Identity x * Identity y = Identity $ x * y--instance Quasiring a => Quasiring (Identity a) where-	 one = Identity one--instance Infimum a => Infimum (Identity a) where-	Identity x /\ Identity y = Identity $ x /\ y--instance Supremum a => Supremum (Identity a) where-	Identity x \/ Identity y = Identity $ x \/ y--instance Lattice a => Lattice (Identity a) where--instance Group a => Group (Identity a) where-	invert (Identity x) = Identity $ invert x

@@ -1,67 +0,0 @@-module Pandora.Paradigm.Basis.Jack (Jack (..), jack) where--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))-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))-import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>), 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 ((==)), Boolean (False))-import Pandora.Pattern.Object.Chain (Chain ((<=>)), Ordering (Less, Greater))--data Jack t a = It a | Other (t a)--instance Covariant t => Covariant (Jack t) where-	f <$> It x = It $ f x-	f <$> Other y = Other $ f <$> y--instance Covariant t => Pointable (Jack t) where-	point = It--instance Alternative t => Alternative (Jack t) where-	It x <+> _ = It x-	Other _ <+> It y = It y-	Other x <+> Other y = Other (x <+> y)--instance Avoidable t => Avoidable (Jack t) where-	empty = Other empty--instance Extractable t => Extractable (Jack t) where-	extract (It x) = x-	extract (Other y) = extract y--instance Applicative t => Applicative (Jack t) where-	It f <*> It x = It $ f x-	It f <*> Other y = Other $ f <$> y-	Other f <*> It x = Other $ ($ x) <$> f-	Other f <*> Other y = Other $ f <*> y--instance Traversable t => Traversable (Jack t) where-	It x ->> f = It <$> f x-	Other y ->> f = comap Other . traverse f $ y--instance Distributive t => Distributive (Jack t) where-	x >>- f = distribute $ f <$> x--instance Liftable Jack where-	lift = Other--instance (Setoid a, Setoid (t a)) => Setoid (Jack t a) where-	It x == It y = x == y-	Other x == Other y = x == y-	_ == _ = False--instance (Chain a, Chain (t a)) => Chain (Jack t a) where-	It _ <=> Other _ = Less-	Other _ <=> It _ = Greater-	It x <=> It y = x <=> y-	Other x <=> Other y = x <=> y--jack :: (a -> r) -> (t a -> r) -> Jack t a -> r-jack f _ (It x) = f x-jack _ g (Other y) = g y

@@ -1,22 +0,0 @@-module Pandora.Paradigm.Basis.Jet (Jet (..)) where--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.Applicative (Applicative ((<*>)))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))--data Jet t a = Jet a (Jet t (t a))--instance Covariant t => Covariant (Jet t) where-	f <$> Jet a as = Jet (f a) (f <$$> as)--instance Traversable t => Traversable (Jet t) where-	Jet a as ->> f = Jet <$> f a <*> as ->>> f--instance (forall u . Avoidable u) => Pointable (Jet t) where-	point x = Jet x empty--instance Covariant t => Extractable (Jet t) where-	extract (Jet x _) = x

@@ -1,25 +0,0 @@-module Pandora.Paradigm.Basis.Kan (Lan (..), Ran (..)) where--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))--newtype Lan t u b a = Lan ((t b -> a) -> u b)--instance Contravariant (Lan t u b) where-	f >$< Lan x = Lan $ x . (f .)--instance Interpreted (Lan t u b) where-	type Primary (Lan t u b) a = (t b -> a) -> u b-	run (Lan x) = x--newtype Ran t u b a = Ran ((a -> t b) -> u b)--instance Covariant (Ran t u b) where-	f <$> Ran x = Ran $ x . (. f)--instance Interpreted (Ran t u b) where-	type Primary (Ran t u b) a = (a -> t b) -> u b-	run (Ran x) = x

@@ -1,117 +0,0 @@-module Pandora.Paradigm.Basis.Maybe (Maybe (..), Optional, maybe, nothing) where--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.Functor.Covariant (Covariant ((<$>), (<$$>)))-import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), apply))-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 ((==)), Boolean (True, False))-import Pandora.Pattern.Object.Chain (Chain ((<=>)), Ordering (Less, Equal, Greater))-import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))-import Pandora.Pattern.Object.Monoid (Monoid (zero))-import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))-import Pandora.Pattern.Object.Lattice (Lattice)--data Maybe a = Nothing | Just a--instance Covariant Maybe where-	f <$> Just x = Just $ f x-	_ <$> Nothing = Nothing--instance Pointable Maybe where-	point = Just--instance Avoidable Maybe where-	empty = Nothing--instance Applicative Maybe where-	Just f <*> x = f <$> x-	Nothing <*> _ = Nothing--instance Alternative Maybe where-	Nothing <+> y = y-	Just x <+> _ = Just x--instance Traversable Maybe where-	Nothing ->> _ = point Nothing-	Just x ->> f = Just <$> f x--instance Bindable Maybe where-	Just x >>= f = f x-	Nothing >>= _ = Nothing--instance Monad Maybe where--instance Setoid a => Setoid (Maybe a) where-	Just x == Just y = x == y-	Nothing == Nothing = True-	_ == _ = False--instance Chain a => Chain (Maybe a) where-	Just x <=> Just y = x <=> y-	Nothing <=> Nothing = Equal-	Nothing <=> Just _ = Less-	Just _ <=> Nothing = Greater--instance Semigroup a => Semigroup (Maybe a) where-	Just x + Just y = Just $ x + y-	Nothing + x = x-	x + Nothing = x--instance Semigroup a => Monoid (Maybe a) where-	zero = Nothing--instance Infimum a => Infimum (Maybe a) where-	Just x /\ Just y = Just $ x /\ y-	_ /\ Nothing = Nothing-	Nothing /\ _ = Nothing--instance Supremum a => Supremum (Maybe a) where-	Just x \/ Just y = Just $ x \/ y-	x \/ Nothing = x-	Nothing \/ x = x--instance Lattice a => Lattice (Maybe a) where--maybe :: b -> (a -> b) -> Maybe a -> b-maybe x _ Nothing = x-maybe _ f (Just y) = f y--type instance Schematic Monad Maybe u = UT Covariant Covariant Maybe u--instance Interpreted Maybe where-	type Primary Maybe a = Maybe a-	run x = x--instance Monadic Maybe where-	lay x = TM . UT $ Just <$> x-	wrap x = TM . UT . point $ x--type Optional = Adaptable Maybe--instance Covariant u => Covariant (UT Covariant Covariant Maybe u) where-	f <$> UT x = UT $ f <$$> x--instance Applicative u => Applicative (UT Covariant Covariant Maybe u) where-	UT f <*> UT x = UT $ apply <$> f <*> x--instance Pointable u => Pointable (UT Covariant Covariant Maybe u) where-	point = UT . point . point--instance (Pointable u, Bindable u) => Bindable (UT Covariant Covariant Maybe u) where-	UT x >>= f = UT $ x >>= maybe (point Nothing) (run . f)--instance Monad u => Monad (UT Covariant Covariant Maybe u) where--nothing :: Optional t => t a-nothing = adapt Nothing

@@ -1,16 +0,0 @@-module Pandora.Paradigm.Basis.Predicate (Predicate (..)) where--import Pandora.Core.Morphism ((!))-import Pandora.Pattern.Category ((.))-import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))-import Pandora.Pattern.Functor.Determinable (Determinable (determine))-import Pandora.Pattern.Functor.Divariant (($))-import Pandora.Pattern.Object.Setoid (Boolean (True))--newtype Predicate a = Predicate { predicate :: a -> Boolean }--instance Contravariant Predicate where-	f >$< g = Predicate $ predicate g . f--instance Determinable Predicate where-	determine = Predicate (True !)

@@ -1,87 +0,0 @@-module Pandora.Paradigm.Basis.Product (Product (..), type (:*:)-	, delta, swap, attached, curry, uncurry) where--import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))-import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))-import Pandora.Pattern.Functor.Comonad (Comonad)-import Pandora.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))-import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))-import Pandora.Pattern.Object.Quasiring (Quasiring (one))-import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))-import Pandora.Pattern.Object.Lattice (Lattice)-import Pandora.Pattern.Object.Group (Group (invert))--infixr 1 :*:--data Product a b = a :*: b--type (:*:) = Product--instance Covariant (Product a) where-	f <$> (x :*: y) = x :*: f y--instance Extractable (Product a) where-	extract (_ :*: y) = y--instance Traversable (Product a) where-	(x :*: y) ->> f = (:*:) x <$> f y--instance Extendable (Product a) where-	(x :*: y) =>> f = (:*:) x $ f (x :*: y)--instance Comonad (Product a) where--instance Adjoint (Product a) ((->) a) where-	x -| f = \y -> f $ y :*: x-	(y :*: x) |- f = f x y--instance Bivariant Product where-	f <-> g = \(x :*: y) -> f x :*: g y--instance (Setoid a, Setoid b) => Setoid (Product a b) where-	(x :*: y) == (x' :*: y') = (x == x') * (y == y')--instance (Semigroup a, Semigroup b) => Semigroup (Product a b) where-	(x :*: y) + (x' :*: y') = x + x' :*: y + y'--instance (Monoid a, Monoid b) => Monoid (Product a b) where-	zero = zero :*: zero--instance (Ringoid a, Ringoid b) => Ringoid (Product a b) where-	(x :*: y) * (x' :*: y') = x * x' :*: y * y'--instance (Quasiring a, Quasiring b) => Quasiring (Product a b) where-	one = one :*: one--instance (Infimum a, Infimum b) => Infimum (Product a b) where-	(x :*: y) /\ (x' :*: y') = x /\ x' :*: y /\ y'--instance (Supremum a, Supremum b) => Supremum (Product a b) where-	(x :*: y) \/ (x' :*: y') = x \/ x' :*: y \/ y'--instance (Lattice a, Lattice b) => Lattice (Product a b) where--instance (Group a, Group b) => Group (Product a b) where-	invert (x :*: y) = invert x :*: invert y--delta :: a -> a :*: a-delta x = x :*: x--swap :: a :*: b -> b :*: a-swap (x :*: y) = y :*: x--attached :: a :*: b -> a-attached (x :*: _) = x--curry :: (a :*: b -> c) -> a -> b -> c-curry f x y = f $ x :*: y--uncurry :: (a -> b -> c) -> (a :*: b -> c)-uncurry f (x :*: y) = f x y

@@ -1,39 +0,0 @@-module Pandora.Paradigm.Basis.Proxy where--import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))-import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))-import Pandora.Pattern.Functor.Monad (Monad)--data Proxy a = Proxy--instance Covariant Proxy where-	_ <$> Proxy = Proxy--instance Contravariant Proxy where-	_ >$< _ = Proxy--instance Pointable Proxy where-	point _ = Proxy--instance Applicative Proxy where-	_ <*> _ = Proxy--instance Alternative Proxy where-	_ <+> _ = Proxy--instance Distributive Proxy where-	_ >>- _ = Proxy--instance Bindable Proxy where-	_ >>= _ = Proxy--instance Monad Proxy--instance Extendable Proxy where-	_ =>> _ = Proxy

@@ -1,96 +0,0 @@-module Pandora.Paradigm.Basis.Tagged (Tagged (..), retag, tagself, type (:#)) where--import Pandora.Core.Functor (type (|->), type (~>))-import Pandora.Pattern.Category ((.))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))-import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))-import Pandora.Pattern.Functor.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 ((+)))-import Pandora.Pattern.Object.Monoid (Monoid (zero))-import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))-import Pandora.Pattern.Object.Quasiring (Quasiring (one))-import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))-import Pandora.Pattern.Object.Lattice (Lattice)-import Pandora.Pattern.Object.Group (Group (invert))--newtype Tagged tag a = Tag a--infixr 0 :#-type (:#) tag = Tagged tag--instance Covariant (Tagged tag) where-	f <$> Tag x = Tag $ f x--instance Pointable (Tagged tag) where-	point = Tag--instance Extractable (Tagged tag) where-	extract (Tag x) = x--instance Applicative (Tagged tag) where-	Tag f <*> Tag x = Tag $ f x--instance Traversable (Tagged tag) where-	Tag x ->> f = Tag <$> f x--instance Distributive (Tagged tag) where-	x >>- f = Tag $ extract . f <$> x--instance Bindable (Tagged tag) where-	Tag x >>= f = f x--instance Monad (Tagged tag)--instance Extendable (Tagged tag) where-	x =>> f = Tag . f $ x--instance Comonad (Tagged tag)--instance Bivariant Tagged where-	_ <-> g = \(Tag x) -> Tag $ g x--instance Setoid a => Setoid (Tagged tag a) where-	Tag x == Tag y = x == y--instance Chain a => Chain (Tagged tag a) where-	Tag x <=> Tag y = x <=> y--instance Semigroup a => Semigroup (Tagged tag a) where-	Tag x + Tag y = Tag $ x + y--instance Monoid a => Monoid (Tagged tag a) where-	 zero = Tag zero--instance Ringoid a => Ringoid (Tagged tag a) where-	Tag x * Tag y = Tag $ x * y--instance Quasiring a => Quasiring (Tagged tag a) where-	one = Tag one--instance Infimum a => Infimum (Tagged tag a) where-	Tag x /\ Tag y = Tag $ x /\ y--instance Supremum a => Supremum (Tagged tag a) where-	Tag x \/ Tag y = Tag $ x \/ y--instance Lattice a => Lattice (Tagged tag a) where--instance Group a => Group (Tagged tag a) where-	invert (Tag x) = Tag $ invert x--retag :: Tagged old ~> Tagged new-retag (Tag x) = Tag x--tagself :: a |-> Tagged a-tagself = Tag

@@ -1,68 +0,0 @@-module Pandora.Paradigm.Basis.Twister (Twister (..), untwist, coiterate, section) where--import Pandora.Core.Functor (type (:.), type (:=), type (|->), type (~>))-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.Bindable (Bindable ((>>=)))-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>), extend))-import Pandora.Pattern.Functor.Monad (Monad)-import Pandora.Pattern.Functor.Comonad (Comonad)-import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))-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))--data Twister t a = Twister a (t :. Twister t := a)--instance Covariant t => Covariant (Twister t) where-	f <$> Twister x xs = Twister (f x) $ f <$$> xs--instance Avoidable t => Pointable (Twister t) where-	point x = Twister x empty--instance Covariant t => Extractable (Twister t) where-	extract (Twister x _) = x--instance Applicative t => Applicative (Twister t) where-	Twister f fs <*> Twister x xs = Twister (f x) $ fs <**> xs--instance Traversable t => Traversable (Twister t) where-	Twister x xs ->> f = Twister <$> f x <*> xs ->>> f--instance Alternative t => Bindable (Twister t) where-	Twister x xs >>= f = case f x of Twister y ys -> Twister y $ ys <+> (>>= f) <$> xs--instance Covariant t => Extendable (Twister t) where-	x =>> f = Twister (f x) $ extend f <$> untwist x--instance (Avoidable t, Alternative t) => Monad (Twister t) where--instance Covariant t => Comonad (Twister t) where--instance Lowerable Twister where-	lower (Twister _ xs) = extract <$> xs--instance (Setoid a, forall b . Setoid b => Setoid (t b)) => Setoid (Twister t a) where-	Twister x xs == Twister y ys = (x == y) * (xs == ys)--instance (Semigroup a, forall b . Semigroup b => Semigroup (t b)) => Semigroup (Twister t a) where-	Twister x xs + Twister y ys = Twister (x + y) $ xs + ys--instance (Monoid a, forall b . Semigroup b => Monoid (t b)) => Monoid (Twister t a) where-	zero = Twister zero zero--untwist :: Twister t a -> (t :. Twister t) a-untwist (Twister _ xs) = xs--coiterate :: Covariant t => a |-> t -> a |-> Twister t-coiterate coalgebra x = Twister x $ coiterate coalgebra <$> coalgebra x--section :: Comonad t => t ~> Twister t-section as = Twister (extract as) $ extend section as

@@ -1,60 +0,0 @@-module Pandora.Paradigm.Basis.Validation (Validation (..)) where--import Pandora.Pattern.Category ((.))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))-import Pandora.Pattern.Functor.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 ((==)), Boolean (False))-import Pandora.Pattern.Object.Chain (Chain ((<=>)), Ordering (Less, Greater))-import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))--data Validation e a = Flaws e | Validated a--instance Covariant (Validation e) where-	_ <$> Flaws e = Flaws e-	f <$> Validated x = Validated $ f x--instance Pointable (Validation e) where-	point = Validated--instance Semigroup e => Applicative (Validation e) where-	Flaws e <*> Flaws e' = Flaws $ e + e'-	Flaws e <*> Validated _ = Flaws e-	Validated _ <*> Flaws e' = Flaws e'-	Validated f <*> Validated x = Validated $ f x--instance Alternative (Validation e) where-	Flaws _ <+> x = x-	Validated x <+> _ = Validated x--instance Traversable (Validation e) where-	Validated x ->> f = Validated <$> f x-	Flaws e ->> _ = point $ Flaws e--instance Bivariant Validation where-    f <-> g = validation (Flaws . f) (Validated . g)--instance (Setoid e, Setoid a) => Setoid (Validation e a) where-	Validated x == Validated y = x == y-	Flaws x == Flaws y = x == y-	_ == _ = False--instance (Chain e, Chain a) => Chain (Validation e a) where-	Validated x <=> Validated y = x <=> y-	Flaws x <=> Flaws y = x <=> y-	Flaws _ <=> Validated _ = Less-	Validated _ <=> Flaws _ = Greater--instance (Semigroup e, Semigroup a) => Semigroup (Validation e a) where-	Validated x + Validated y = Validated $ x + y-	Flaws x + Flaws y = Flaws $ x + y-	Flaws _ + Validated y = Validated y-	Validated x + Flaws _ = Validated x--validation :: (e -> r) -> (a -> r) -> Validation e a -> r-validation f _ (Flaws x) = f x-validation _ s (Validated x) = s x

@@ -1,26 +0,0 @@-module Pandora.Paradigm.Basis.Variation (Variation (..), variation) where--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 Variation e a = This a | That e | These e a--instance Covariant (Variation e) where-	f <$> This x = This $ f x-	_ <$> That y = That y-	f <$> These y x = These y (f x)--instance Pointable (Variation e) where-	point = This--instance Traversable (Variation e) where-	This x ->> f = This <$> f x-	That y ->> _ = point $ That y-	These y x ->> f = These y <$> f x--variation :: (a -> r) -> (e -> r) -> (e -> a -> r) -> Variation e a -> r-variation f _ _ (This x) = f x-variation _ g _ (That y) = g y-variation _ _ h (These y x) = h y x

@@ -1,27 +0,0 @@-module Pandora.Paradigm.Basis.Wye (Wye (..), wye) where--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--instance Covariant Wye where-	_ <$> End = End-	f <$> Left x = Left $ f x-	f <$> Right y = Right $ f y-	f <$> Both x y = Both (f x) (f y)--instance Traversable Wye where-	End ->> _ = point End-	Left x ->> f = Left <$> f x-	Right y ->> f = Right <$> f y-	Both x y ->> f = Both <$> f x <*> f y--wye :: r -> (a -> r) -> (a -> r) -> (a -> a -> r) -> Wye a -> r-wye r _ _ _ End = r-wye _ f _ _ (Left x) = f x-wye _ _ g _ (Right y) = g y-wye _ _ _ h (Both x y) = h x y

@@ -1,41 +0,0 @@-module Pandora.Paradigm.Basis.Yoneda (Yoneda (..)) where--import Pandora.Core.Morphism ((!))-import Pandora.Pattern.Category (identity, (.))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))-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.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 }--instance Covariant (Yoneda t) where-	f <$> x = Yoneda (\k -> yoneda x (k . f))--instance Alternative t => Alternative (Yoneda t) where-	Yoneda f <+> Yoneda g = Yoneda (\k -> f k <+> g k)--instance Applicative t => Applicative (Yoneda t) where-	Yoneda f <*> Yoneda x = Yoneda (\g -> f (g .) <*> x identity)--instance Avoidable t => Avoidable (Yoneda t) where-	empty = Yoneda (empty !)--instance Pointable t => Pointable (Yoneda t) where-	point x = Yoneda (\f -> point $ f x)--instance Extractable t => Extractable (Yoneda t) where-	extract (Yoneda f) = extract $ f identity--instance Liftable Yoneda where-	lift x = Yoneda (\f -> f <$> x)--instance (Extractable t, Pointable t, Extractable u, Pointable u) => Adjoint (Yoneda t) (Yoneda u) where-	x -| f = point . f . point $ x-	x |- g = extract . extract $ g <$> x

@@ -1,3 +1,5 @@+{-# OPTIONS_GHC -fno-warn-orphans #-}+ module Pandora.Paradigm.Controlflow.Joint.Schemes (module Exports) where  import Pandora.Paradigm.Controlflow.Joint.Schemes.UTU as Exports@@ -5,3 +7,35 @@ 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,6 +1,16 @@ 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)@@ -8,3 +18,11 @@ 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)

@@ -3,8 +3,6 @@ module Pandora.Paradigm.Controlflow.Joint.Transformer.Comonadic (Comonadic (..), (:<) (..)) where  import Pandora.Core.Functor (type (~>))-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))-import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic) import Pandora.Pattern.Category ((.)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>))) import Pandora.Pattern.Functor.Pointable (Pointable (point))@@ -17,6 +15,8 @@ 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 #-}

@@ -3,8 +3,6 @@ module Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic (Monadic (..), (:>) (..)) where  import Pandora.Core.Functor (type (~>))-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))-import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic) import Pandora.Pattern.Category ((.)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>))) import Pandora.Pattern.Functor.Pointable (Pointable (point))@@ -17,6 +15,8 @@ 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 #-}

@@ -2,9 +2,9 @@ 	notify, follow, subscribe, watch, (.:~.), (.:~*), (*:~.), (*:~*)) where  import Pandora.Pattern.Category ((.))-import Pandora.Paradigm.Basis.Continuation (Continuation (Continuation, continue)) 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,11 +1,11 @@ module Pandora.Paradigm.Controlflow.Pipeline (Pipeline, await, yield, finish, impact, (=*=), pipeline) where -import Pandora.Paradigm.Basis.Continuation (Continuation (Continuation, continue)) 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 } 

@@ -1,3 +1,5 @@+{-# OPTIONS_GHC -fno-warn-orphans #-}+ module Pandora.Paradigm.Inventory (module Exports) where  import Pandora.Paradigm.Inventory.Optics as Exports@@ -7,3 +9,23 @@ import Pandora.Paradigm.Inventory.Equipment as Exports import Pandora.Paradigm.Inventory.Environment as Exports import Pandora.Paradigm.Inventory.Accumulator as Exports++import Pandora.Core.Morphism ((!), (%))+import Pandora.Pattern.Category ((.))+import Pandora.Pattern.Functor.Extractable (extract)+import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))+import Pandora.Pattern.Functor.Divariant (($))+import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)))+import Pandora.Paradigm.Controlflow.Joint.Interpreted (run)++instance Adjoint (Store s) (State s) where+	x -| f = State $ \s -> (:*:) s . f . Store $ s :*: (x !)+	Store (s :*: f) |- g = extract . run % s . g $ f s++instance Adjoint (Accumulator e) (Imprint e) where+	x -| f = Imprint $ x -| f . Accumulator+	x |- g = run x |- run . g++instance Adjoint (Equipment e) (Environment e) where+	x -| f = Environment $ x -| f . Equipment+	x |- g = run x |- run . g

@@ -2,7 +2,7 @@  module Pandora.Paradigm.Inventory.Accumulator (Accumulator (..), Accumulated, gather) where -import Pandora.Paradigm.Basis.Product (Product ((:*:)), type (:*:))+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)

@@ -2,7 +2,7 @@  module Pandora.Paradigm.Inventory.Equipment (Equipment (..), retrieve) where -import Pandora.Paradigm.Basis.Product (Product ((:*:)), type (:*:), attached)+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))

@@ -3,22 +3,15 @@ module Pandora.Paradigm.Inventory.Optics (Lens, type (:-.), (|>), view, set, over, zoom, (^.), (.~), (%~)) where  import Pandora.Core.Functor (type (|->))-import Pandora.Core.Morphism ((!), (%))-import Pandora.Paradigm.Basis.Product (Product ((:*:)))+import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:))) import Pandora.Paradigm.Controlflow.Joint.Adaptable (adapt)-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (run)) 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.Adjoint (Adjoint ((-|), (|-))) import Pandora.Pattern.Functor.Divariant (($)) import Pandora.Pattern.Functor.Bivariant ((<->))--instance Adjoint (Store s) (State s) where-	v -| f = State $ \s -> (:*:) s . f . Store $ s :*: (v !)-	Store (s :*: f) |- g = extract . run % s . g $ f s  infixr 0 :-. type (:-.) src tgt = Lens src tgt

@@ -6,7 +6,7 @@ import Pandora.Core.Morphism ((%)) import Pandora.Pattern.Category ((.)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), ($>), (<$$>)))-import Pandora.Pattern.Functor.Extractable (Extractable (extract))+import Pandora.Pattern.Functor.Extractable (extract) import Pandora.Pattern.Functor.Avoidable (Avoidable (empty)) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (*>)))@@ -14,6 +14,7 @@ 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.Pattern.Object.Setoid (bool) import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))@@ -21,8 +22,8 @@ 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.Paradigm.Basis.Predicate (Predicate (predicate))-import Pandora.Paradigm.Basis.Product (Product ((:*:)), type (:*:), attached, delta, uncurry)+import Pandora.Paradigm.Primary.Functor.Predicate (Predicate (predicate))+import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), delta)  newtype State s a = State ((->) s :. (:*:) s := a) @@ -31,15 +32,14 @@  instance Applicative (State s) where 	State f <*> State x = State $ \old ->-		let latest = attached . x $ old in-			latest :*: (extract (f old) . extract . x $ old)+		let (new :*: g) = f old in g <$> x new  instance Pointable (State s) where 	point x = State $ \s -> s :*: x  instance Bindable (State s) where 	State x >>= f = State $ \old ->-		uncurry (run %) $ f <$> x old+		(|- run) $ f <$> x old  instance Monad (State s) where 

@@ -10,7 +10,7 @@ import Pandora.Pattern.Functor.Extendable (Extendable ((=>>))) import Pandora.Pattern.Functor.Comonad (Comonad) import Pandora.Pattern.Functor.Divariant (($))-import Pandora.Paradigm.Basis.Product (Product ((:*:)), type (:*:), attached)+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)

@@ -0,0 +1,4 @@+module Pandora.Paradigm.Primary (module Exports) where++import Pandora.Paradigm.Primary.Functor as Exports+import Pandora.Paradigm.Primary.Transformer as Exports

@@ -0,0 +1,47 @@+module Pandora.Paradigm.Primary.Functor (module Exports, note, hush, left, right, this, that) where++import Pandora.Paradigm.Primary.Functor.Fix as Exports+import Pandora.Paradigm.Primary.Functor.Predicate as Exports+import Pandora.Paradigm.Primary.Functor.Variation as Exports+import Pandora.Paradigm.Primary.Functor.Validation as Exports+import Pandora.Paradigm.Primary.Functor.Wye as Exports+import Pandora.Paradigm.Primary.Functor.Edges as Exports+import Pandora.Paradigm.Primary.Functor.Conclusion as Exports+import Pandora.Paradigm.Primary.Functor.Maybe as Exports+import Pandora.Paradigm.Primary.Functor.Endo as Exports+import Pandora.Paradigm.Primary.Functor.Proxy as Exports+import Pandora.Paradigm.Primary.Functor.Tagged as Exports+import Pandora.Paradigm.Primary.Functor.Product as Exports+import Pandora.Paradigm.Primary.Functor.Constant as Exports+import Pandora.Paradigm.Primary.Functor.Identity as Exports++import Pandora.Core.Morphism ((!))+import Pandora.Core.Functor (type (~>))++note :: e -> Maybe ~> Conclusion e+note x = maybe (Failure x) Success++hush :: Conclusion e ~> Maybe+hush = conclusion (Nothing !) Just++left :: Wye ~> Maybe+left (Both ls _) = Just ls+left (Left ls) = Just ls+left (Right _) = Nothing+left End = Nothing++right :: Wye ~> Maybe+right (Both _ rs) = Just rs+right (Left _) = Nothing+right (Right rs) = Just rs+right End = Nothing++this :: Variation e ~> Maybe+this (This x) = Just x+this (That _) = Nothing+this (These _ x) = Just x++that :: Variation e a -> Maybe e+that (This _) = Nothing+that (That x) = Just x+that (These y _) = Just y

@@ -0,0 +1,105 @@+module Pandora.Paradigm.Primary.Functor.Conclusion (Conclusion (..), Failable, conclusion, fail, failure) where++import Pandora.Core.Functor (type (~>))+import Pandora.Pattern.Category ((.))+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.Functor.Covariant (Covariant ((<$>), (<$$>)))+import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), apply))+import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))+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 ((==)), Boolean (False))+import Pandora.Pattern.Object.Chain (Chain ((<=>)), Ordering (Less, Greater))+import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))++data Conclusion e a = Failure e | Success a++instance Covariant (Conclusion e) where+	f <$> Success x = Success $ f x+	_ <$> Failure y = Failure y++instance Pointable (Conclusion e) where+	point = Success++instance Applicative (Conclusion e) where+	Success f <*> x = f <$> x+	Failure y <*> _ = Failure y++instance Alternative (Conclusion e) where+	Failure _ <+> x = x+	Success x <+> _ = Success x++instance Traversable (Conclusion e) where+	Failure y ->> _ = point $ Failure y+	Success x ->> f = Success <$> f x++instance Bindable (Conclusion e) where+	Success x >>= f = f x+	Failure y >>= _ = Failure y++instance Monad (Conclusion e) where++instance Bivariant Conclusion where+    f <-> g = conclusion (Failure . f) (Success . g)++instance (Setoid e, Setoid a) => Setoid (Conclusion e a) where+	Success x == Success y = x == y+	Failure x == Failure y = x == y+	_ == _ = False++instance (Chain e, Chain a) => Chain (Conclusion e a) where+	Success x <=> Success y = x <=> y+	Failure x <=> Failure y = x <=> y+	Failure _ <=> Success _ = Less+	Success _ <=> Failure _ = Greater++instance (Semigroup e, Semigroup a) => Semigroup (Conclusion e a) where+	Success x + Success y = Success $ x + y+	Failure x + Failure y = Failure $ x + y+	Failure _ + Success y = Success y+	Success x + Failure _ = Success x++conclusion :: (e -> r) -> (a -> r) -> Conclusion e a -> r+conclusion f _ (Failure x) = f x+conclusion _ s (Success x) = s x++fail :: (e -> r) -> Conclusion e ~> Conclusion r+fail f (Failure x) = Failure $ f x+fail _ (Success y) = Success y++instance Interpreted (Conclusion e) where+	type Primary (Conclusion e) a = Conclusion e a+	run x = x++type instance Schematic Monad (Conclusion e) u = UT Covariant Covariant (Conclusion e) u++instance Monadic (Conclusion e) where+	lay x = TM . UT $ Success <$> x+	wrap x = TM . UT . point $ x++type Failable e = Adaptable (Conclusion e)++instance Covariant u => Covariant (UT Covariant Covariant (Conclusion e) u) where+	f <$> UT x = UT $ f <$$> x++instance Applicative u => Applicative (UT Covariant Covariant (Conclusion e) u) where+	UT f <*> UT x = UT $ apply <$> f <*> x++instance Pointable u => Pointable (UT Covariant Covariant (Conclusion e) u) where+	point = UT . point . point++instance (Pointable u, Bindable u) => Bindable (UT Covariant Covariant (Conclusion e) u) where+	UT x >>= f = UT $ x >>= conclusion (point . Failure) (run . f)++instance Monad u => Monad (UT Covariant Covariant (Conclusion e) u) where++failure :: Failable e t => e -> t a+failure = adapt . Failure

@@ -0,0 +1,64 @@+module Pandora.Paradigm.Primary.Functor.Constant (Constant (..)) where++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 ((+)))+import Pandora.Pattern.Object.Monoid (Monoid (zero))+import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))+import Pandora.Pattern.Object.Quasiring (Quasiring (one))+import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))+import Pandora.Pattern.Object.Lattice (Lattice)+import Pandora.Pattern.Object.Group (Group (invert))++newtype Constant a b = Constant a++instance Covariant (Constant a) where+	_ <$> Constant x = Constant x++instance Contravariant (Constant a) where+	_ >$< Constant x = Constant x++instance Invariant (Constant a) where+	invmap _ _ (Constant x) = Constant x++instance Traversable (Constant a) where+	Constant x ->> _ = point (Constant x)++instance Bivariant Constant where+	f <-> _ = \(Constant x) -> Constant $ f x++instance Setoid a => Setoid (Constant a b) where+	Constant x == Constant y = x == y++instance Chain a => Chain (Constant a b) where+	Constant x <=> Constant y = x <=> y++instance Semigroup a => Semigroup (Constant a b) where+	Constant x + Constant y = Constant $ x + y++instance Monoid a => Monoid (Constant a b) where+	 zero = Constant zero++instance Ringoid a => Ringoid (Constant a b) where+	Constant x * Constant y = Constant $ x * y++instance Quasiring a => Quasiring (Constant a b) where+	 one = Constant one++instance Infimum a => Infimum (Constant a b) where+	Constant x /\ Constant y = Constant $ x /\ y++instance Supremum a => Supremum (Constant a b) where+	Constant x \/ Constant y = Constant $ x \/ y++instance Lattice a => Lattice (Constant a b) where++instance Group a => Group (Constant a b) where+	invert (Constant x) = Constant $ invert x

@@ -0,0 +1,26 @@+module Pandora.Paradigm.Primary.Functor.Edges (Edges (..), edges) where++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++instance Covariant Edges where+	_ <$> Empty = Empty+	f <$> Connect x = Connect $ f x+	f <$> Overlay x = Overlay $ f x+	f <$> Leap x = Leap $ f x++instance Traversable Edges where+	Empty ->> _ = point Empty+	Connect x ->> f = Connect <$> f x+	Overlay x ->> f = Overlay <$> f x+	Leap x ->> f = Leap <$> f x++edges :: r -> (a -> r) -> (a -> r) -> (a -> r) -> Edges a -> r+edges r _ _ _ Empty = r+edges _ f _ _ (Connect x) = f x+edges _ _ g _ (Overlay y) = g y+edges _ _ _ h (Leap z) = h z

@@ -0,0 +1,17 @@+module Pandora.Paradigm.Primary.Functor.Endo (Endo (..)) where++import Pandora.Pattern.Category (identity, (.))+import Pandora.Pattern.Functor.Invariant (Invariant (invmap))+import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))+import Pandora.Pattern.Object.Monoid (Monoid (zero))++newtype Endo a = Endo { endo :: a -> a }++instance Invariant Endo where+	invmap f g (Endo x) = Endo (f . x . g)++instance Semigroup (Endo a) where+	Endo f + Endo g = Endo (g . f)++instance Monoid (Endo a) where+	zero = Endo identity

@@ -0,0 +1,16 @@+module Pandora.Paradigm.Primary.Functor.Fix (Fix (..), cata, ana, hylo) where++import Pandora.Core.Functor (type (<-|), type (|->))+import Pandora.Pattern.Category ((.))+import Pandora.Pattern.Functor.Covariant (Covariant (comap))++newtype Fix t = Fix { unfix :: t (Fix t) }++cata :: Covariant t => (a <-| t) -> Fix t -> a+cata f = f . comap (cata f) . unfix++ana :: Covariant t => (a |-> t) -> a -> Fix t+ana f = Fix . comap (ana f) . f++hylo :: Covariant t => (b <-| t) -> (a |-> t) -> (a -> b)+hylo phi psi = cata phi . ana psi

@@ -0,0 +1,87 @@+module Pandora.Paradigm.Primary.Functor.Identity (Identity (..)) where++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))+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))+import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))+import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))+import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))+import Pandora.Pattern.Functor.Monad (Monad)+import Pandora.Pattern.Functor.Comonad (Comonad)+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 ((+)))+import Pandora.Pattern.Object.Monoid (Monoid (zero))+import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))+import Pandora.Pattern.Object.Quasiring (Quasiring (one))+import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))+import Pandora.Pattern.Object.Lattice (Lattice)+import Pandora.Pattern.Object.Group (Group (invert))++newtype Identity a = Identity a++instance Covariant Identity where+	f <$> Identity x = Identity $ f x++instance Pointable Identity where+	point = Identity++instance Extractable Identity where+	extract (Identity x) = x++instance Applicative Identity where+	Identity f <*> Identity x = Identity $ f x++instance Traversable Identity where+	Identity x ->> f = Identity <$> f x++instance Distributive Identity where+	x >>- f = Identity $ extract . f <$> x++instance Bindable Identity where+	Identity x >>= f = f x++instance Monad Identity++instance Extendable Identity where+	x =>> f = Identity . f $ x++instance Comonad Identity++instance Adjoint Identity Identity where+	x -| f = Identity . f . Identity $ x+	x |- g = extract . extract . comap g $ x++instance Setoid a => Setoid (Identity a) where+	Identity x == Identity y = x == y++instance Chain a => Chain (Identity a) where+	Identity x <=> Identity y = x <=> y++instance Semigroup a => Semigroup (Identity a) where+	Identity x + Identity y = Identity $ x + y++instance Monoid a => Monoid (Identity a) where+	 zero = Identity zero++instance Ringoid a => Ringoid (Identity a) where+	Identity x * Identity y = Identity $ x * y++instance Quasiring a => Quasiring (Identity a) where+	 one = Identity one++instance Infimum a => Infimum (Identity a) where+	Identity x /\ Identity y = Identity $ x /\ y++instance Supremum a => Supremum (Identity a) where+	Identity x \/ Identity y = Identity $ x \/ y++instance Lattice a => Lattice (Identity a) where++instance Group a => Group (Identity a) where+	invert (Identity x) = Identity $ invert x

@@ -0,0 +1,117 @@+module Pandora.Paradigm.Primary.Functor.Maybe (Maybe (..), Optional, maybe, nothing) where++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.Functor.Covariant (Covariant ((<$>), (<$$>)))+import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))+import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), apply))+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 ((==)), Boolean (True, False))+import Pandora.Pattern.Object.Chain (Chain ((<=>)), Ordering (Less, Equal, Greater))+import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))+import Pandora.Pattern.Object.Monoid (Monoid (zero))+import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))+import Pandora.Pattern.Object.Lattice (Lattice)++data Maybe a = Nothing | Just a++instance Covariant Maybe where+	f <$> Just x = Just $ f x+	_ <$> Nothing = Nothing++instance Pointable Maybe where+	point = Just++instance Avoidable Maybe where+	empty = Nothing++instance Applicative Maybe where+	Just f <*> x = f <$> x+	Nothing <*> _ = Nothing++instance Alternative Maybe where+	Nothing <+> y = y+	Just x <+> _ = Just x++instance Traversable Maybe where+	Nothing ->> _ = point Nothing+	Just x ->> f = Just <$> f x++instance Bindable Maybe where+	Just x >>= f = f x+	Nothing >>= _ = Nothing++instance Monad Maybe where++instance Setoid a => Setoid (Maybe a) where+	Just x == Just y = x == y+	Nothing == Nothing = True+	_ == _ = False++instance Chain a => Chain (Maybe a) where+	Just x <=> Just y = x <=> y+	Nothing <=> Nothing = Equal+	Nothing <=> Just _ = Less+	Just _ <=> Nothing = Greater++instance Semigroup a => Semigroup (Maybe a) where+	Just x + Just y = Just $ x + y+	Nothing + x = x+	x + Nothing = x++instance Semigroup a => Monoid (Maybe a) where+	zero = Nothing++instance Infimum a => Infimum (Maybe a) where+	Just x /\ Just y = Just $ x /\ y+	_ /\ Nothing = Nothing+	Nothing /\ _ = Nothing++instance Supremum a => Supremum (Maybe a) where+	Just x \/ Just y = Just $ x \/ y+	x \/ Nothing = x+	Nothing \/ x = x++instance Lattice a => Lattice (Maybe a) where++maybe :: b -> (a -> b) -> Maybe a -> b+maybe x _ Nothing = x+maybe _ f (Just y) = f y++type instance Schematic Monad Maybe u = UT Covariant Covariant Maybe u++instance Interpreted Maybe where+	type Primary Maybe a = Maybe a+	run x = x++instance Monadic Maybe where+	lay x = TM . UT $ Just <$> x+	wrap x = TM . UT . point $ x++type Optional = Adaptable Maybe++instance Covariant u => Covariant (UT Covariant Covariant Maybe u) where+	f <$> UT x = UT $ f <$$> x++instance Applicative u => Applicative (UT Covariant Covariant Maybe u) where+	UT f <*> UT x = UT $ apply <$> f <*> x++instance Pointable u => Pointable (UT Covariant Covariant Maybe u) where+	point = UT . point . point++instance (Pointable u, Bindable u) => Bindable (UT Covariant Covariant Maybe u) where+	UT x >>= f = UT $ x >>= maybe (point Nothing) (run . f)++instance Monad u => Monad (UT Covariant Covariant Maybe u) where++nothing :: Optional t => t a+nothing = adapt Nothing

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

@@ -0,0 +1,87 @@+module Pandora.Paradigm.Primary.Functor.Product (Product (..), type (:*:)+	, delta, swap, attached, curry, uncurry) where++import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Extractable (Extractable (extract))+import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))+import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))+import Pandora.Pattern.Functor.Comonad (Comonad)+import Pandora.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))+import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))+import Pandora.Pattern.Object.Quasiring (Quasiring (one))+import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))+import Pandora.Pattern.Object.Lattice (Lattice)+import Pandora.Pattern.Object.Group (Group (invert))++infixr 1 :*:++data Product a b = a :*: b++type (:*:) = Product++instance Covariant (Product a) where+	f <$> (x :*: y) = x :*: f y++instance Extractable (Product a) where+	extract (_ :*: y) = y++instance Traversable (Product a) where+	(x :*: y) ->> f = (:*:) x <$> f y++instance Extendable (Product a) where+	(x :*: y) =>> f = (:*:) x $ f (x :*: y)++instance Comonad (Product a) where++instance Adjoint (Product a) ((->) a) where+	x -| f = \y -> f $ y :*: x+	(y :*: x) |- f = f x y++instance Bivariant Product where+	f <-> g = \(x :*: y) -> f x :*: g y++instance (Setoid a, Setoid b) => Setoid (Product a b) where+	(x :*: y) == (x' :*: y') = (x == x') * (y == y')++instance (Semigroup a, Semigroup b) => Semigroup (Product a b) where+	(x :*: y) + (x' :*: y') = x + x' :*: y + y'++instance (Monoid a, Monoid b) => Monoid (Product a b) where+	zero = zero :*: zero++instance (Ringoid a, Ringoid b) => Ringoid (Product a b) where+	(x :*: y) * (x' :*: y') = x * x' :*: y * y'++instance (Quasiring a, Quasiring b) => Quasiring (Product a b) where+	one = one :*: one++instance (Infimum a, Infimum b) => Infimum (Product a b) where+	(x :*: y) /\ (x' :*: y') = x /\ x' :*: y /\ y'++instance (Supremum a, Supremum b) => Supremum (Product a b) where+	(x :*: y) \/ (x' :*: y') = x \/ x' :*: y \/ y'++instance (Lattice a, Lattice b) => Lattice (Product a b) where++instance (Group a, Group b) => Group (Product a b) where+	invert (x :*: y) = invert x :*: invert y++delta :: a -> a :*: a+delta x = x :*: x++swap :: a :*: b -> b :*: a+swap (x :*: y) = y :*: x++attached :: a :*: b -> a+attached (x :*: _) = x++curry :: (a :*: b -> c) -> a -> b -> c+curry f x y = f $ x :*: y++uncurry :: (a -> b -> c) -> (a :*: b -> c)+uncurry f (x :*: y) = f x y

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

@@ -0,0 +1,96 @@+module Pandora.Paradigm.Primary.Functor.Tagged (Tagged (..), retag, tagself, type (:#)) where++import Pandora.Core.Functor (type (|->), type (~>))+import Pandora.Pattern.Category ((.))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Extractable (Extractable (extract))+import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))+import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))+import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))+import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))+import Pandora.Pattern.Functor.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 ((+)))+import Pandora.Pattern.Object.Monoid (Monoid (zero))+import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))+import Pandora.Pattern.Object.Quasiring (Quasiring (one))+import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))+import Pandora.Pattern.Object.Lattice (Lattice)+import Pandora.Pattern.Object.Group (Group (invert))++newtype Tagged tag a = Tag a++infixr 0 :#+type (:#) tag = Tagged tag++instance Covariant (Tagged tag) where+	f <$> Tag x = Tag $ f x++instance Pointable (Tagged tag) where+	point = Tag++instance Extractable (Tagged tag) where+	extract (Tag x) = x++instance Applicative (Tagged tag) where+	Tag f <*> Tag x = Tag $ f x++instance Traversable (Tagged tag) where+	Tag x ->> f = Tag <$> f x++instance Distributive (Tagged tag) where+	x >>- f = Tag $ extract . f <$> x++instance Bindable (Tagged tag) where+	Tag x >>= f = f x++instance Monad (Tagged tag)++instance Extendable (Tagged tag) where+	x =>> f = Tag . f $ x++instance Comonad (Tagged tag)++instance Bivariant Tagged where+	_ <-> g = \(Tag x) -> Tag $ g x++instance Setoid a => Setoid (Tagged tag a) where+	Tag x == Tag y = x == y++instance Chain a => Chain (Tagged tag a) where+	Tag x <=> Tag y = x <=> y++instance Semigroup a => Semigroup (Tagged tag a) where+	Tag x + Tag y = Tag $ x + y++instance Monoid a => Monoid (Tagged tag a) where+	 zero = Tag zero++instance Ringoid a => Ringoid (Tagged tag a) where+	Tag x * Tag y = Tag $ x * y++instance Quasiring a => Quasiring (Tagged tag a) where+	one = Tag one++instance Infimum a => Infimum (Tagged tag a) where+	Tag x /\ Tag y = Tag $ x /\ y++instance Supremum a => Supremum (Tagged tag a) where+	Tag x \/ Tag y = Tag $ x \/ y++instance Lattice a => Lattice (Tagged tag a) where++instance Group a => Group (Tagged tag a) where+	invert (Tag x) = Tag $ invert x++retag :: Tagged old ~> Tagged new+retag (Tag x) = Tag x++tagself :: a |-> Tagged a+tagself = Tag

@@ -0,0 +1,60 @@+module Pandora.Paradigm.Primary.Functor.Validation (Validation (..)) where++import Pandora.Pattern.Category ((.))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))+import Pandora.Pattern.Functor.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 ((==)), Boolean (False))+import Pandora.Pattern.Object.Chain (Chain ((<=>)), Ordering (Less, Greater))+import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))++data Validation e a = Flaws e | Validated a++instance Covariant (Validation e) where+	_ <$> Flaws e = Flaws e+	f <$> Validated x = Validated $ f x++instance Pointable (Validation e) where+	point = Validated++instance Semigroup e => Applicative (Validation e) where+	Flaws e <*> Flaws e' = Flaws $ e + e'+	Flaws e <*> Validated _ = Flaws e+	Validated _ <*> Flaws e' = Flaws e'+	Validated f <*> Validated x = Validated $ f x++instance Alternative (Validation e) where+	Flaws _ <+> x = x+	Validated x <+> _ = Validated x++instance Traversable (Validation e) where+	Validated x ->> f = Validated <$> f x+	Flaws e ->> _ = point $ Flaws e++instance Bivariant Validation where+    f <-> g = validation (Flaws . f) (Validated . g)++instance (Setoid e, Setoid a) => Setoid (Validation e a) where+	Validated x == Validated y = x == y+	Flaws x == Flaws y = x == y+	_ == _ = False++instance (Chain e, Chain a) => Chain (Validation e a) where+	Validated x <=> Validated y = x <=> y+	Flaws x <=> Flaws y = x <=> y+	Flaws _ <=> Validated _ = Less+	Validated _ <=> Flaws _ = Greater++instance (Semigroup e, Semigroup a) => Semigroup (Validation e a) where+	Validated x + Validated y = Validated $ x + y+	Flaws x + Flaws y = Flaws $ x + y+	Flaws _ + Validated y = Validated y+	Validated x + Flaws _ = Validated x++validation :: (e -> r) -> (a -> r) -> Validation e a -> r+validation f _ (Flaws x) = f x+validation _ s (Validated x) = s x

@@ -0,0 +1,26 @@+module Pandora.Paradigm.Primary.Functor.Variation (Variation (..), variation) where++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 Variation e a = This a | That e | These e a++instance Covariant (Variation e) where+	f <$> This x = This $ f x+	_ <$> That y = That y+	f <$> These y x = These y (f x)++instance Pointable (Variation e) where+	point = This++instance Traversable (Variation e) where+	This x ->> f = This <$> f x+	That y ->> _ = point $ That y+	These y x ->> f = These y <$> f x++variation :: (a -> r) -> (e -> r) -> (e -> a -> r) -> Variation e a -> r+variation f _ _ (This x) = f x+variation _ g _ (That y) = g y+variation _ _ h (These y x) = h y x

@@ -0,0 +1,27 @@+module Pandora.Paradigm.Primary.Functor.Wye (Wye (..), wye) where++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++instance Covariant Wye where+	_ <$> End = End+	f <$> Left x = Left $ f x+	f <$> Right y = Right $ f y+	f <$> Both x y = Both (f x) (f y)++instance Traversable Wye where+	End ->> _ = point End+	Left x ->> f = Left <$> f x+	Right y ->> f = Right <$> f y+	Both x y ->> f = Both <$> f x <*> f y++wye :: r -> (a -> r) -> (a -> r) -> (a -> a -> r) -> Wye a -> r+wye r _ _ _ End = r+wye _ f _ _ (Left x) = f x+wye _ _ g _ (Right y) = g y+wye _ _ _ h (Both x y) = h x y

@@ -0,0 +1,11 @@+module Pandora.Paradigm.Primary.Transformer (module Exports) where++import Pandora.Paradigm.Primary.Transformer.Yoneda 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+import Pandora.Paradigm.Primary.Transformer.Jack as Exports+import Pandora.Paradigm.Primary.Transformer.Instruction as Exports+import Pandora.Paradigm.Primary.Transformer.Construction as Exports+import Pandora.Paradigm.Primary.Transformer.Reverse as Exports+import Pandora.Paradigm.Primary.Transformer.Backwards as Exports

@@ -0,0 +1,52 @@+module Pandora.Paradigm.Primary.Transformer.Backwards (Backwards (..)) where++import Pandora.Core.Morphism ((&))+import Pandora.Pattern.Category ((.))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))+import Pandora.Pattern.Functor.Extractable (Extractable (extract))+import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.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))++newtype Backwards t a = Backwards (t a)++instance Covariant t => Covariant (Backwards t) where+	f <$> Backwards x = Backwards $ f <$> x++instance Pointable t => Pointable (Backwards t) where+	point = Backwards . point++instance Extractable t => Extractable (Backwards t) where+	extract (Backwards x) = extract x++instance Applicative t => Applicative (Backwards t) where+	Backwards f <*> Backwards x = Backwards ((&) <$> x <*> f)++instance Traversable t => Traversable (Backwards t) where+	Backwards x ->> f = Backwards <$> x ->> f++instance Distributive t => Distributive (Backwards t) where+	x >>- f = Backwards $ x >>- run . f++instance Contravariant t => Contravariant (Backwards t) where+	f >$< Backwards x = Backwards $ f >$< x++instance Interpreted (Backwards t) where+	type Primary (Backwards t) a = t a+	run (Backwards x) = x++instance Liftable Backwards where+	lift = Backwards++instance Lowerable Backwards where+	lower = run++instance Hoistable Backwards where+	hoist f (Backwards x) = Backwards $ f x

@@ -0,0 +1,88 @@+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.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.Bindable (Bindable ((>>=)))+import Pandora.Pattern.Functor.Extendable (Extendable ((=>>), extend))+import Pandora.Pattern.Functor.Monad (Monad)+import Pandora.Pattern.Functor.Comonad (Comonad)+import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))+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))++data Construction t a = Construct a (t :. Construction t := a)++instance Covariant t => Covariant (Construction t) where+	f <$> Construct x xs = Construct (f x) $ f <$$> xs++instance Avoidable t => Pointable (Construction t) where+	point x = Construct x empty++instance Covariant t => Extractable (Construction t) where+	extract (Construct x _) = x++instance Applicative t => Applicative (Construction t) where+	Construct f fs <*> Construct x xs = Construct (f x) $ fs <**> xs++instance Traversable t => Traversable (Construction t) where+	Construct x xs ->> f = Construct <$> f x <*> xs ->>> f++instance Alternative t => Bindable (Construction t) where+	Construct x xs >>= f = case f x of Construct y ys -> Construct y $ ys <+> (>>= f) <$> xs++instance Covariant t => Extendable (Construction t) where+	x =>> f = Construct (f x) $ extend f <$> deconstruct x++instance (Avoidable t, Alternative t) => Monad (Construction t) where++instance Covariant t => Comonad (Construction t) where++instance Lowerable Construction where+	lower (Construct _ xs) = extract <$> xs++instance (Setoid a, forall b . Setoid b => Setoid (t b)) => Setoid (Construction t a) where+	Construct x xs == Construct y ys = (x == y) * (xs == ys)++instance (Semigroup a, forall b . Semigroup b => Semigroup (t b)) => Semigroup (Construction t a) where+	Construct x xs + Construct y ys = Construct (x + y) $ xs + ys++instance (Monoid a, forall b . Semigroup b => Monoid (t b)) => Monoid (Construction t a) where+	zero = Construct zero zero++deconstruct :: Construction t a -> (t :. Construction t) a+deconstruct (Construct _ xs) = xs++coiterate :: Covariant t => a |-> t -> a |-> Construction t+coiterate coalgebra x = Construct x $ coiterate coalgebra <$> coalgebra x++section :: Comonad t => t ~> Construction t+section as = Construct (extract as) $ extend section as++instance (Covariant t, Covariant u) => Covariant (TU Covariant Covariant u (Construction t)) where+	f <$> TU g = TU $ f <$$> g++instance (Avoidable t, Pointable u) => Pointable (TU Covariant Covariant u (Construction t)) where+	point x = TU . point . Construct x $ empty++instance (Applicative t, Applicative u) => Applicative (TU Covariant Covariant u (Construction t)) where+	TU f <*> TU x = TU $ f <**> x++instance (Covariant t, Alternative u) => Alternative (TU Covariant Covariant u (Construction t)) where+	TU x <+> TU y = TU $ x <+> y++instance (Covariant t, Avoidable u) => Avoidable (TU Covariant Covariant u (Construction t)) where+	empty = TU empty++instance (Traversable t, Traversable u) => Traversable (TU Covariant Covariant u (Construction t)) where+	TU g ->> f = TU <$> g ->>> f

@@ -0,0 +1,43 @@+module Pandora.Paradigm.Primary.Transformer.Continuation (Continuation (..), cwcc, reset, shift) where++import Pandora.Core.Functor (type (:.), type (:=), type (::|:.))+import Pandora.Core.Morphism ((!), (%))+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 }++instance Covariant t => Covariant (Continuation r t) where+	f <$> Continuation continuation = Continuation $ continuation . (. f)++instance Covariant t => Pointable (Continuation r t) where+	point x = Continuation ($ x)++instance Covariant t => Applicative (Continuation r t) where+	f <*> x = Continuation $ \h -> continue f $ \g -> continue x (h . g)++instance Covariant t => Bindable (Continuation r t) where+	x >>= f = Continuation $ \g -> continue x $ \y -> continue (f y) g++instance Monad t => Monad (Continuation r t) where++instance (forall u . Bindable u) => Liftable (Continuation r) where+	lift = Continuation . (>>=)++-- | Call with current continuation+cwcc :: ((a -> Continuation r t b) -> Continuation r t a) -> Continuation r t a+cwcc f = Continuation $ \g -> continue % g . f $ Continuation . (!) . g++-- | Delimit the continuation of any 'shift'+reset :: (forall u . Bindable u, Bindable t, Pointable t) => Continuation r t r -> Continuation s t r+reset = lift . continue % point++-- | Capture the continuation up to the nearest enclosing 'reset' and pass it+shift :: Pointable t => ((a -> t r) -> Continuation r t r) -> Continuation r t a+shift f = Continuation $ continue % point . f

@@ -0,0 +1,45 @@+module Pandora.Paradigm.Primary.Transformer.Instruction (Instruction (..)) where++import Pandora.Core.Functor (type (:.), type (:=))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))+import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))+import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))+import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))+import Pandora.Pattern.Transformer.Liftable (Liftable (lift))+import Pandora.Pattern.Functor.Divariant (($))++data Instruction t a = Enter a | Instruct (t :. Instruction t := a)++instance Covariant t => Covariant (Instruction t) where+	f <$> Enter x = Enter $ f x+	f <$> Instruct xs = Instruct $ f <$$> xs++instance Covariant t => Pointable (Instruction t) where+	point = Enter++instance Alternative t => Alternative (Instruction t) where+	Enter x <+> _ = Enter x+	_ <+> Enter y = Enter y+	Instruct xs <+> Instruct ys = Instruct $ xs <+> ys++instance Avoidable t => Avoidable (Instruction t) where+	empty = Instruct empty++instance Covariant t => Applicative (Instruction t) where+	Enter f <*> Enter y = Enter $ f y+	Enter f <*> Instruct y = Instruct $ f <$$> y+	Instruct f <*> y = Instruct $ (<*> y) <$> f++instance Covariant t => Bindable (Instruction t) where+	Enter x >>= f = f x+	Instruct xs >>= f = Instruct $ (>>= f) <$> xs++instance Traversable t => Traversable (Instruction t) where+	Enter x ->> f = Enter <$> f x+	Instruct xs ->> f = Instruct <$> xs ->>> f++instance Liftable Instruction where+	lift x = Instruct $ Enter <$> x

@@ -0,0 +1,67 @@+module Pandora.Paradigm.Primary.Transformer.Jack (Jack (..), jack) where++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))+import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))+import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))+import Pandora.Pattern.Functor.Traversable (Traversable ((->>), 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 ((==)), Boolean (False))+import Pandora.Pattern.Object.Chain (Chain ((<=>)), Ordering (Less, Greater))++data Jack t a = It a | Other (t a)++instance Covariant t => Covariant (Jack t) where+	f <$> It x = It $ f x+	f <$> Other y = Other $ f <$> y++instance Covariant t => Pointable (Jack t) where+	point = It++instance Alternative t => Alternative (Jack t) where+	It x <+> _ = It x+	Other _ <+> It y = It y+	Other x <+> Other y = Other (x <+> y)++instance Avoidable t => Avoidable (Jack t) where+	empty = Other empty++instance Extractable t => Extractable (Jack t) where+	extract (It x) = x+	extract (Other y) = extract y++instance Applicative t => Applicative (Jack t) where+	It f <*> It x = It $ f x+	It f <*> Other y = Other $ f <$> y+	Other f <*> It x = Other $ ($ x) <$> f+	Other f <*> Other y = Other $ f <*> y++instance Traversable t => Traversable (Jack t) where+	It x ->> f = It <$> f x+	Other y ->> f = comap Other . traverse f $ y++instance Distributive t => Distributive (Jack t) where+	x >>- f = distribute $ f <$> x++instance Liftable Jack where+	lift = Other++instance (Setoid a, Setoid (t a)) => Setoid (Jack t a) where+	It x == It y = x == y+	Other x == Other y = x == y+	_ == _ = False++instance (Chain a, Chain (t a)) => Chain (Jack t a) where+	It _ <=> Other _ = Less+	Other _ <=> It _ = Greater+	It x <=> It y = x <=> y+	Other x <=> Other y = x <=> y++jack :: (a -> r) -> (t a -> r) -> Jack t a -> r+jack f _ (It x) = f x+jack _ g (Other y) = g y

@@ -0,0 +1,22 @@+module Pandora.Paradigm.Primary.Transformer.Jet (Jet (..)) where++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.Applicative (Applicative ((<*>)))+import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))++data Jet t a = Jet a (Jet t (t a))++instance Covariant t => Covariant (Jet t) where+	f <$> Jet a as = Jet (f a) (f <$$> as)++instance Traversable t => Traversable (Jet t) where+	Jet a as ->> f = Jet <$> f a <*> as ->>> f++instance (forall u . Avoidable u) => Pointable (Jet t) where+	point x = Jet x empty++instance Covariant t => Extractable (Jet t) where+	extract (Jet x _) = x

@@ -0,0 +1,28 @@+module Pandora.Paradigm.Primary.Transformer.Kan (Kan (..)) where++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.Primary.Functor.Wye (Wye (Left, Right))++data family Kan (v :: * -> k) (t :: * -> *) (u :: * -> *) b a++data instance Kan Left t u b a = Lan ((t b -> a) -> u b)++instance Contravariant (Kan Left t u b) where+	f >$< Lan x = Lan $ x . (f .)++instance Interpreted (Kan Left t u b) where+	type Primary (Kan Left t u b) a = (t b -> a) -> u b+	run (Lan x) = x++data instance Kan Right t u b a = Ran ((a -> t b) -> u b)++instance Covariant (Kan Right t u b) where+	f <$> Ran x = Ran $ x . (. f)++instance Interpreted (Kan Right t u b) where+	type Primary (Kan Right t u b) a = (a -> t b) -> u b+	run (Ran x) = x

@@ -0,0 +1,52 @@+module Pandora.Paradigm.Primary.Transformer.Reverse (Reverse (..)) where++import Pandora.Pattern.Category ((.))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))+import Pandora.Pattern.Functor.Extractable (Extractable (extract))+import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.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))++newtype Reverse t a = Reverse (t a)++instance Covariant t => Covariant (Reverse t) where+	f <$> Reverse x = Reverse $ f <$> x++instance Pointable t => Pointable (Reverse t) where+	point = Reverse . point++instance Extractable t => Extractable (Reverse t) where+	extract (Reverse x) = extract x++instance Applicative t => Applicative (Reverse t) where+	Reverse f <*> Reverse x = Reverse (f <*> x)++instance Traversable t => Traversable (Reverse t) where+	Reverse x ->> f = Reverse <$> run (x ->> Backwards . f)++instance Distributive t => Distributive (Reverse t) where+	x >>- f = Reverse $ x >>- run . f++instance Contravariant t => Contravariant (Reverse t) where+	f >$< Reverse x = Reverse $ f >$< x++instance Interpreted (Reverse t) where+	type Primary (Reverse t) a = t a+	run (Reverse x) = x++instance Liftable Reverse where+	lift = Reverse++instance Lowerable Reverse where+	lower = run++instance Hoistable Reverse where+	hoist f (Reverse x) = Reverse $ f x

@@ -0,0 +1,41 @@+module Pandora.Paradigm.Primary.Transformer.Yoneda (Yoneda (..)) where++import Pandora.Core.Morphism ((!))+import Pandora.Pattern.Category (identity, (.))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))+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.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 }++instance Covariant (Yoneda t) where+	f <$> x = Yoneda (\k -> yoneda x (k . f))++instance Alternative t => Alternative (Yoneda t) where+	Yoneda f <+> Yoneda g = Yoneda (\k -> f k <+> g k)++instance Applicative t => Applicative (Yoneda t) where+	Yoneda f <*> Yoneda x = Yoneda (\g -> f (g .) <*> x identity)++instance Avoidable t => Avoidable (Yoneda t) where+	empty = Yoneda (empty !)++instance Pointable t => Pointable (Yoneda t) where+	point x = Yoneda (\f -> point $ f x)++instance Extractable t => Extractable (Yoneda t) where+	extract (Yoneda f) = extract $ f identity++instance Liftable Yoneda where+	lift x = Yoneda (\f -> f <$> x)++instance (Extractable t, Pointable t, Extractable u, Pointable u) => Adjoint (Yoneda t) (Yoneda u) where+	x -| f = point . f . point $ x+	x |- g = extract . extract $ g <$> x

@@ -2,6 +2,6 @@  import Pandora.Paradigm.Structure.Variation.Substructure as Exports import Pandora.Paradigm.Structure.Variation.Nonempty as Exports+import Pandora.Paradigm.Structure.Rose as Exports import Pandora.Paradigm.Structure.Binary as Exports-import Pandora.Paradigm.Structure.Graph as Exports import Pandora.Paradigm.Structure.Stack as Exports

@@ -4,83 +4,72 @@  import Pandora.Core.Morphism ((&), (%), (!)) 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.Covariant (Covariant ((<$>))) import Pandora.Pattern.Functor.Extractable (extract) import Pandora.Pattern.Functor.Divariant (($)) import Pandora.Pattern.Object.Chain (Chain ((<=>)), order)-import Pandora.Paradigm.Basis.Maybe (Maybe (Just, Nothing), maybe)-import Pandora.Paradigm.Basis.Product (Product ((:*:)))-import Pandora.Paradigm.Basis.Wye (Wye (End, Left, Right, Both))-import Pandora.Paradigm.Basis.Twister (Twister (Twister))-import Pandora.Paradigm.Basis.Tagged (Tagged (Tag), type (:#))-import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))+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))+import Pandora.Paradigm.Controlflow.Joint.Schemes.TU (TU (TU)) import Pandora.Paradigm.Controlflow.Joint.Interpreted (run) import Pandora.Paradigm.Inventory.Store (Store (Store)) import Pandora.Paradigm.Inventory.Optics ((%~)) import Pandora.Paradigm.Structure.Variation.Nonempty (Nonempty) import Pandora.Paradigm.Structure.Variation.Substructure (Substructure (Output, sub)) -type Binary = UT Covariant Covariant (Twister Wye) Maybe--instance Covariant Binary where-	f <$> UT g = UT $ f <$$> g--instance Pointable Binary where-	point x = UT . Just . Twister x $ End--instance Traversable Binary where-	UT g ->> f = UT <$> g ->>> f+type Binary = TU Covariant Covariant Maybe (Construction Wye)  insert :: Chain a => a -> Binary a -> Binary a-insert x (UT Nothing) = point x-insert x tree@(UT (Just (Twister y _))) = x <=> y & order-	(sub @'Left %~ (insert x <$>) $ tree) tree-	(sub @'Right %~ (insert x <$>) $ tree)+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) -instance Substructure 'Left Binary where-	type Output 'Left Binary a = 'Left :# Binary a-	sub (UT Nothing) = Store $ (:*:) (Tag $ UT Nothing) $ (UT Nothing !)-	sub  t@(UT (Just (Twister x End))) = Store $ (:*:) (Tag $ UT Nothing) $-		maybe t (UT . Just . Twister x . Left) . run . extract-	sub (UT (Just (Twister x (Left lst)))) = Store $ (:*:) (Tag . UT . Just $ lst) $-		maybe (point x) (UT . Just . Twister x . Left) . run . extract-	sub t@(UT (Just (Twister x (Right rst)))) = Store $ (:*:) (Tag $ UT Nothing) $-		maybe t (UT . Just . Twister x . Both % rst) . run . extract-	sub  (UT (Just (Twister x (Both lst rst)))) = Store $ (:*:) (Tag . UT . Just $ lst) $-		maybe (UT (Just (Twister x (Right rst)))) (UT . Just . Twister x . Both % rst) . run . extract+instance Substructure Left Binary where+	type Output 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 -instance Substructure 'Right Binary where-	type Output 'Right Binary a = 'Right :# Binary a-	sub (UT Nothing) = Store $ Tag (UT Nothing) :*: (!) (UT Nothing)-	sub t@(UT (Just (Twister x End))) = Store $ (:*:) (Tag $ UT Nothing) $-		maybe t (UT . Just . Twister x . Right) . run . extract-	sub t@(UT (Just (Twister x (Left lst)))) = Store $ (:*:) (Tag $ UT Nothing) $-		maybe t (UT . Just . Twister x . Both lst) . run . extract-	sub (UT (Just (Twister x (Right rst)))) = Store $ (:*:) (Tag . UT . Just $ rst) $-		maybe (point x) (UT . Just . Twister x . Right) . run . extract-	sub (UT (Just (Twister x (Both lst rst)))) = Store $ (:*:) (Tag . UT . Just $ rst) $-		maybe (UT (Just (Twister x (Left lst)))) (UT . Just . Twister x . Both lst) . run . extract+instance Substructure Right Binary where+	type Output 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 -type instance Nonempty Binary = Twister Wye+type instance Nonempty Binary = Construction Wye -instance Substructure 'Left (Twister Wye) where-	type Output 'Left (Twister Wye) a = Maybe ('Left :# Twister Wye a)-	sub (Twister x End) = Store $ (:*:) Nothing $ (Twister x End !)-	sub (Twister x (Left lst)) = Store $ (:*:) (Just . Tag $ lst) $-		maybe (Twister x End) (Twister x . Left . extract)-	sub tree@(Twister x (Right rst)) = Store $ (:*:) Nothing $-		maybe tree (Twister x . Both % rst . extract)-	sub (Twister x (Both lst rst)) = Store $ (:*:) (Just . Tag $ lst) $-		maybe (Twister x $ Right rst) (Twister x . Both % rst . extract)+instance Substructure Left (Construction Wye) where+	type Output 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 -instance Substructure 'Right (Twister Wye) where-	type Output 'Right (Twister Wye) a = Maybe ('Right :# Twister Wye a)-	sub (Twister x End) = Store $ (:*:) Nothing $ (Twister x End !)-	sub tree@(Twister x (Left lst)) = Store $ (:*:) Nothing $-		maybe tree (Twister x . Both lst . extract)-	sub (Twister x (Right rst)) = Store $ (:*:) (Just . Tag $ rst) $-		maybe (Twister x End) (Twister x . Right . extract)-	sub (Twister x (Both lst rst)) = Store $ (:*:) (Just . Tag $ rst) $-		maybe (Twister x $ Left lst) (Twister x . Both lst . extract)+instance Substructure Right (Construction Wye) where+	type Output 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

@@ -1,29 +0,0 @@-{-# OPTIONS_GHC -fno-warn-orphans #-}--module Pandora.Paradigm.Structure.Graph (Graph, loose) where--import Pandora.Core.Functor (type (~>))-import Pandora.Pattern.Category ((.))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))-import Pandora.Pattern.Functor.Divariant (($))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))-import Pandora.Paradigm.Basis.Edges (Edges (Empty, Overlay))-import Pandora.Paradigm.Basis.Twister (Twister (Twister))-import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))-import Pandora.Paradigm.Inventory.State (fold)-import Pandora.Paradigm.Structure.Variation.Nonempty (Nonempty)---- | Directed acyclic graph structure-type Graph = UT Covariant Covariant (Twister Edges) Edges--type instance Nonempty Graph = Twister Edges--instance Covariant Graph where-	f <$> UT g = UT $ f <$$> g--instance Traversable Graph where-	UT g ->> f = UT <$> g ->>> f---- | Transform any traversable structure into all loose edges graph-loose :: Traversable t => t ~> Graph-loose = UT . fold Empty (\x -> Overlay . Twister x)

@@ -0,0 +1,9 @@+module Pandora.Paradigm.Structure.Rose (Rose) where++import Pandora.Pattern.Functor.Covariant (Covariant)+import Pandora.Paradigm.Primary.Functor.Maybe (Maybe)+import Pandora.Paradigm.Primary.Transformer.Construction (Construction)+import Pandora.Paradigm.Structure.Stack (Stack)+import Pandora.Paradigm.Controlflow.Joint.Schemes.TU (TU)++type Rose = TU Covariant Covariant Maybe (Construction Stack)

@@ -5,62 +5,43 @@ import Pandora.Core.Functor (type (~>)) import Pandora.Core.Morphism ((&)) import Pandora.Pattern.Category ((.))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))-import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (<**>)))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))+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.Object.Setoid (Setoid ((==)), (?)) import Pandora.Pattern.Object.Semigroup (Semigroup ((+))) import Pandora.Pattern.Object.Monoid (Monoid (zero))-import Pandora.Paradigm.Basis.Maybe (Maybe (Just, Nothing))-import Pandora.Paradigm.Basis.Predicate (Predicate (Predicate))-import Pandora.Paradigm.Basis.Product (Product ((:*:)))-import Pandora.Paradigm.Basis.Twister (Twister (Twister), untwist)+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.Transformer.Construction (Construction (Construct), deconstruct) import Pandora.Paradigm.Inventory.State (fold) import Pandora.Paradigm.Inventory.Store (Store (Store)) import Pandora.Paradigm.Inventory.Optics (type (:-.)) import Pandora.Paradigm.Controlflow.Joint.Interpreted (run)-import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))+import Pandora.Paradigm.Controlflow.Joint.Schemes.TU (TU (TU)) import Pandora.Paradigm.Structure.Variation.Nonempty (Nonempty)  -- | Linear data structure that serves as a collection of elements-type Stack = UT Covariant Covariant (Twister Maybe) Maybe--type instance Nonempty Stack = Twister Maybe--instance Covariant Stack where-	f <$> UT stack = UT $ f <$$> stack--instance Pointable Stack where-	point = UT . Just . point--instance Alternative Stack where-	UT x <+> UT y = UT $ x <+> y--instance Avoidable Stack where-	empty = UT Nothing--instance Applicative Stack where-	UT f <*> UT x = UT $ f <**> x+type Stack = TU Covariant Covariant Maybe (Construction Maybe) -instance Traversable Stack where-	UT stack ->> f = UT <$> stack ->>> f+type instance Nonempty Stack = Construction Maybe  instance Setoid a => Setoid (Stack a) where-	UT ls == UT rs = ls == rs+	TU ls == TU rs = ls == rs  instance Semigroup (Stack a) where-	UT Nothing + UT ys = UT ys-	UT (Just (Twister x xs)) + UT ys = UT . Just . Twister x . run-		$ UT @Covariant @Covariant xs + UT @Covariant @Covariant ys+	TU Nothing + TU ys = TU ys+	TU (Just (Construct x xs)) + TU ys = TU . Just . Construct x . run+		$ TU @Covariant @Covariant xs + TU @Covariant @Covariant ys  instance Monoid (Stack a) where-	zero = UT Nothing+	zero = TU Nothing  top :: Stack a :-. Maybe a top stack = Store $ (:*:) (extract <$> run stack) $ \case@@ -68,15 +49,15 @@     Nothing -> pop stack  push :: a -> Stack a -> Stack a-push x (UT stack) = UT $ (Twister x . Just <$> stack) <+> (point . point) x+push x (TU stack) = TU $ (Construct x . Just <$> stack) <+> (point . point) x  pop :: Stack ~> Stack-pop (UT stack) = UT $ stack >>= untwist+pop (TU stack) = TU $ stack >>= deconstruct  filter :: Predicate a -> Stack a -> Stack a-filter (Predicate p) = UT . fold empty-	(\now new -> p now ? Just (Twister now new) $ new)+filter (Predicate p) = TU . fold empty+	(\now new -> p now ? Just (Construct now new) $ new)  -- | Transform any traversable structure into a stack linearize :: Traversable t => t ~> Stack-linearize = UT . fold Nothing (\x -> Just . Twister x)+linearize = TU . fold Nothing (\x -> Just . Construct x)

@@ -1,6 +1,6 @@ module Pandora.Paradigm.Structure.Stream (Stream) where -import Pandora.Paradigm.Basis.Identity (Identity)-import Pandora.Paradigm.Basis.Twister (Twister)+import Pandora.Paradigm.Primary.Functor.Identity (Identity)+import Pandora.Paradigm.Primary.Transformer.Construction (Construction) -type Stream = Twister Identity+type Stream = Construction Identity

@@ -1,7 +1,8 @@ module Pandora.Paradigm.Structure.Variation.Substructure (Substructure (..)) where  import Pandora.Paradigm.Inventory.Optics (type (:-.))+import Pandora.Paradigm.Primary.Functor.Tagged (Tagged)  class Substructure f t where-	type Output (f :: * -> k) (t :: * -> *) a = r | r -> f t a-	sub :: t a :-. Output f t a+	type Output (f :: * -> k) (t :: * -> *) a+	sub :: t a :-. Tagged f (Output f t a)

@@ -2,6 +2,7 @@  import Pandora.Pattern.Object.Lattice as Exports import Pandora.Pattern.Object.Semilattice as Exports+import Pandora.Pattern.Object.Ring as Exports import Pandora.Pattern.Object.Group as Exports import Pandora.Pattern.Object.Monoid as Exports import Pandora.Pattern.Object.Quasiring as Exports

@@ -0,0 +1,10 @@+module Pandora.Pattern.Object.Ring (Ring) where++import Pandora.Pattern.Object.Group (Group)++{- |+> When providing a new instance, you should ensure it satisfies the one law:+> * Commutativity of addition: x + y ≡ y + x+-}++class Group a => Ring a where

@@ -1,5 +1,5 @@ name:                pandora-version:             0.2.6+version:             0.2.7 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@@ -26,29 +26,32 @@      Pandora.Paradigm     -- Basic constructions-    Pandora.Paradigm.Basis-    Pandora.Paradigm.Basis.Backwards-    Pandora.Paradigm.Basis.Conclusion-    Pandora.Paradigm.Basis.Constant-    Pandora.Paradigm.Basis.Continuation-    Pandora.Paradigm.Basis.Edges-    Pandora.Paradigm.Basis.Endo-    Pandora.Paradigm.Basis.Fix-    Pandora.Paradigm.Basis.Free-    Pandora.Paradigm.Basis.Identity-    Pandora.Paradigm.Basis.Jack-    Pandora.Paradigm.Basis.Jet-    Pandora.Paradigm.Basis.Kan-    Pandora.Paradigm.Basis.Maybe-    Pandora.Paradigm.Basis.Predicate-    Pandora.Paradigm.Basis.Product-    Pandora.Paradigm.Basis.Proxy-    Pandora.Paradigm.Basis.Tagged-    Pandora.Paradigm.Basis.Twister-    Pandora.Paradigm.Basis.Validation-    Pandora.Paradigm.Basis.Variation-    Pandora.Paradigm.Basis.Wye-    Pandora.Paradigm.Basis.Yoneda+    Pandora.Paradigm.Primary+    Pandora.Paradigm.Primary.Functor+    Pandora.Paradigm.Primary.Functor.Conclusion+    Pandora.Paradigm.Primary.Functor.Constant+    Pandora.Paradigm.Primary.Functor.Edges+    Pandora.Paradigm.Primary.Functor.Endo+    Pandora.Paradigm.Primary.Functor.Fix+    Pandora.Paradigm.Primary.Functor.Identity+    Pandora.Paradigm.Primary.Functor.Maybe+    Pandora.Paradigm.Primary.Functor.Predicate+    Pandora.Paradigm.Primary.Functor.Product+    Pandora.Paradigm.Primary.Functor.Proxy+    Pandora.Paradigm.Primary.Functor.Tagged+    Pandora.Paradigm.Primary.Functor.Validation+    Pandora.Paradigm.Primary.Functor.Variation+    Pandora.Paradigm.Primary.Functor.Wye+    Pandora.Paradigm.Primary.Transformer+    Pandora.Paradigm.Primary.Transformer.Backwards+    Pandora.Paradigm.Primary.Transformer.Reverse+    Pandora.Paradigm.Primary.Transformer.Continuation+    Pandora.Paradigm.Primary.Transformer.Construction+    Pandora.Paradigm.Primary.Transformer.Instruction+    Pandora.Paradigm.Primary.Transformer.Jack+    Pandora.Paradigm.Primary.Transformer.Jet+    Pandora.Paradigm.Primary.Transformer.Kan+    Pandora.Paradigm.Primary.Transformer.Yoneda     -- Control flow primitives     Pandora.Paradigm.Controlflow     -- Typeclassess about functor junctions@@ -80,8 +83,8 @@     Pandora.Paradigm.Structure     Pandora.Paradigm.Structure.Stream     Pandora.Paradigm.Structure.Stack-    Pandora.Paradigm.Structure.Graph     Pandora.Paradigm.Structure.Binary+    Pandora.Paradigm.Structure.Rose     Pandora.Paradigm.Structure.Variation.Nonempty     Pandora.Paradigm.Structure.Variation.Substructure @@ -116,6 +119,7 @@     Pandora.Pattern.Object.Lattice     Pandora.Pattern.Object.Monoid     Pandora.Pattern.Object.Quasiring+    Pandora.Pattern.Object.Ring     Pandora.Pattern.Object.Ringoid     Pandora.Pattern.Object.Semigroup     Pandora.Pattern.Object.Semilattice@@ -133,4 +137,4 @@     MultiParamTypeClasses, NoImplicitPrelude, PackageImports, PolyKinds, RankNTypes     ScopedTypeVariables, TypeApplications, TypeFamilies, TypeFamilyDependencies, TypeOperators   default-language: Haskell2010-  ghc-options: -Wall -fno-warn-tabs+  ghc-options: -Wall -fno-warn-tabs -fno-warn-unticked-promoted-constructors