pandora 0.5.3 → 0.5.4

raw patch · 75 files changed

+690/−570 lines, 75 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• CHANGELOG.md +24/−0
• Pandora/Core.hs +1/−0
• Pandora/Core/Functor.hs +39/−5
• Pandora/Core/Interpreted.hs +79/−0
• Pandora/Paradigm/Algebraic.hs +6/−3
• Pandora/Paradigm/Algebraic/Functor.hs +5/−4
• Pandora/Paradigm/Algebraic/Product.hs +7/−7
• Pandora/Paradigm/Algebraic/Sum.hs +5/−5
• Pandora/Paradigm/Controlflow/Effect.hs +0/−1
• Pandora/Paradigm/Controlflow/Effect/Adaptable.hs +2/−5
• Pandora/Paradigm/Controlflow/Effect/Interpreted.hs +0/−82
• Pandora/Paradigm/Controlflow/Effect/Transformer/Comonadic.hs +2/−1
• Pandora/Paradigm/Controlflow/Effect/Transformer/Monadic.hs +6/−5
• Pandora/Paradigm/Controlflow/Observable.hs +1/−1
• Pandora/Paradigm/Controlflow/Pipeline.hs +1/−1
• Pandora/Paradigm/Inventory.hs +6/−17
• Pandora/Paradigm/Inventory/Some/Accumulator.hs +2/−2
• Pandora/Paradigm/Inventory/Some/Equipment.hs +2/−2
• Pandora/Paradigm/Inventory/Some/Imprint.hs +2/−2
• Pandora/Paradigm/Inventory/Some/Optics.hs +7/−1
• Pandora/Paradigm/Inventory/Some/Provision.hs +4/−4
• Pandora/Paradigm/Inventory/Some/State.hs +12/−5
• Pandora/Paradigm/Inventory/Some/Store.hs +6/−6
• Pandora/Paradigm/Primary.hs +5/−4
• Pandora/Paradigm/Primary/Auxiliary.hs +5/−0
• Pandora/Paradigm/Primary/Functor/Conclusion.hs +16/−7
• Pandora/Paradigm/Primary/Functor/Endo.hs +1/−1
• Pandora/Paradigm/Primary/Functor/Exactly.hs +1/−1
• Pandora/Paradigm/Primary/Functor/Maybe.hs +4/−4
• Pandora/Paradigm/Primary/Functor/Predicate.hs +1/−1
• Pandora/Paradigm/Primary/Functor/Tagged.hs +1/−1
• Pandora/Paradigm/Primary/Functor/Validation.hs +1/−1
• Pandora/Paradigm/Primary/Functor/Wye.hs +19/−19
• Pandora/Paradigm/Primary/Transformer/Backwards.hs +1/−1
• Pandora/Paradigm/Primary/Transformer/Construction.hs +6/−8
• Pandora/Paradigm/Primary/Transformer/Continuation.hs +3/−4
• Pandora/Paradigm/Primary/Transformer/Instruction.hs +3/−3
• Pandora/Paradigm/Primary/Transformer/Kan.hs +3/−2
• Pandora/Paradigm/Primary/Transformer/Reverse.hs +1/−1
• Pandora/Paradigm/Primary/Transformer/Tap.hs +3/−3
• Pandora/Paradigm/Schemes.hs +4/−2
• Pandora/Paradigm/Schemes/PQ_.hs +1/−1
• Pandora/Paradigm/Schemes/PTU.hs +1/−1
• Pandora/Paradigm/Schemes/P_Q_T.hs +1/−1
• Pandora/Paradigm/Schemes/P_T.hs +1/−1
• Pandora/Paradigm/Schemes/TT.hs +5/−5
• Pandora/Paradigm/Schemes/TU.hs +5/−5
• Pandora/Paradigm/Schemes/TUT.hs +14/−14
• Pandora/Paradigm/Schemes/TUVW.hs +4/−4
• Pandora/Paradigm/Schemes/T_U.hs +6/−5
• Pandora/Paradigm/Schemes/UT.hs +4/−4
• Pandora/Paradigm/Schemes/UTU.hs +4/−4
• Pandora/Paradigm/Schemes/U_T.hs +1/−1
• Pandora/Paradigm/Structure.hs +34/−34
• Pandora/Paradigm/Structure/Ability.hs +1/−1
• Pandora/Paradigm/Structure/Ability/Morphable.hs +9/−13
• Pandora/Paradigm/Structure/Ability/Nonempty.hs +0/−4
• Pandora/Paradigm/Structure/Ability/Slidable.hs +10/−0
• Pandora/Paradigm/Structure/Ability/Substructure.hs +10/−2
• Pandora/Paradigm/Structure/Interface/Set.hs +3/−3
• Pandora/Paradigm/Structure/Interface/Stack.hs +6/−8
• Pandora/Paradigm/Structure/Interface/Zipper.hs +3/−9
• Pandora/Paradigm/Structure/Modification.hs +1/−0
• Pandora/Paradigm/Structure/Modification/Comprehension.hs +9/−9
• Pandora/Paradigm/Structure/Modification/Nonempty.hs +4/−0
• Pandora/Paradigm/Structure/Modification/Prefixed.hs +2/−29
• Pandora/Paradigm/Structure/Modification/Tape.hs +53/−38
• Pandora/Paradigm/Structure/Modification/Turnover.hs +1/−1
• Pandora/Paradigm/Structure/Some/Binary.hs +24/−23
• Pandora/Paradigm/Structure/Some/List.hs +49/−47
• Pandora/Paradigm/Structure/Some/Rose.hs +49/−57
• Pandora/Paradigm/Structure/Some/Splay.hs +39/−7
• Pandora/Paradigm/Structure/Some/Stream.hs +32/−12
• Pandora/Pattern/Morphism/Flip.hs +1/−1
• pandora.cabal +6/−4

@@ -734,3 +734,27 @@ * Move `Tape` to `Structure.Modification.Tape` module  # 0.5.4+* Define `<` length encoding type operators in `Functor` module+* Change precedence for `::|:.`, `::|.:`, `::|::`, `.:`, `:.`, `:::`+* Define `>` length encoding type operators in `Functor` module+* Change precedence for `<:.>`, `>:.>`, `<:.<`, `>:.<`,  `<::>`, `>::>`, `<::<`, `>::<`+* Rename `.-+-` `Alternative` operator to `-+-`+* Change `Prefixed` definition - from newtype to type alias+* Remove `Breadcrumbed` type synonymous+* Change `Zipper` definition - remove tagging+* Rename `.-+` `Construction` operator to `constitute`+* Define `Slidable` typeclass for data structures+* Define `current` and `change` methods in `State`+* Remove `Zoomable` typeclass, leave `zoom` method+* Change `zoom` definition - not an adaptable effect+* Change `change` method of `State` - return an old value+* Define `transwrap` lens for underlying effect in transformer+* Change `pop` method in `Stack` typeclass: returns not `Maybe` but `Topping t`+* Remove `Pushing` and `Popping` type familes from `Stack` typeclass+* Move `Interpreted` module to `Core`+* Move `Schematic` type family to `Schemes` module+* Move `Vertical` and `Horizontal` datatypes to `Auxiliary` module+* Rename `Horizontal` constructors to `Left` and `Right`+* Move `Nonempty` from `Ability` to `Modification` module++# 0.5.5

@@ -1,4 +1,5 @@ module Pandora.Core (module Exports) where +import Pandora.Core.Interpreted as Exports import Pandora.Core.Impliable as Exports import Pandora.Core.Functor as Exports

@@ -1,17 +1,51 @@ module Pandora.Core.Functor where -infixl 0 <-infixr 0 >+infixl 9 <+infixl 8 <<+infixl 7 <<<+infixl 6 <<<<+infixl 5 <<<<<+infixl 4 <<<<<<+infixl 3 <<<<<<<+infixl 2 <<<<<<<<+infixl 1 <<<<<<<<<++infixr 9 >+infixr 8 >>+infixr 7 >>>+infixr 6 >>>>+infixr 5 >>>>>+infixr 4 >>>>>>+infixr 3 >>>>>>>+infixr 2 >>>>>>>>+infixr 1 >>>>>>>>>+ infixr 0 <:=, :=>, :=:=>, ~>-infixr 1 .:, :.-infixr 2 ::|:., ::|.:, ::|::-infixr 9 :::+infixr 8 .:, :.+infixr 5 ::|:., ::|.:, ::|::+infixr 7 :::  -- | Arguments consuming type (<) t a = t a+type (<<) t a = t a+type (<<<) t a = t a+type (<<<<) t a = t a+type (<<<<<) t a = t a+type (<<<<<<) t a = t a+type (<<<<<<<) t a = t a+type (<<<<<<<<) t a = t a+type (<<<<<<<<<) t a = t a  -- | Type application type (>) t a = t a+type (>>) t a = t a+type (>>>) t a = t a+type (>>>>) t a = t a+type (>>>>>) t a = t a+type (>>>>>>) t a = t a+type (>>>>>>>) t a = t a+type (>>>>>>>>) t a = t a+type (>>>>>>>>>) t a = t a  -- | Functors composition type (:.) t u a = t (u a)

@@ -0,0 +1,79 @@+module Pandora.Core.Interpreted where++import Pandora.Core.Functor (type (<), type (>))+import Pandora.Pattern.Morphism.Straight (Straight (Straight))+import Pandora.Pattern.Morphism.Flip (Flip (Flip))+import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))+import Pandora.Pattern.Transformer.Liftable (Liftable (lift))++infixr 2 =#-, -#=++infixl 1 <~~~~~~~~+infixl 2 <~~~~~~~+infixl 3 <~~~~~~+infixl 4 <~~~~~+infixl 5 <~~~~+infixl 6 <~~~+infixl 7 <~~+infixl 8 <~++class Interpreted m t where+	{-# MINIMAL run, unite #-}+	type Primary t a :: *+	run :: m < t a < Primary t a+	unite :: m < Primary t a < t a++	(<~~~~~~~~), (<~~~~~~~), (<~~~~~~), (<~~~~~), (<~~~~), (<~~~), (<~~), (<~) :: m < t a < Primary t a+	(<~~~~~~~~) = run+	(<~~~~~~~) = run+	(<~~~~~~) = run+	(<~~~~~) = run+	(<~~~~) = run+	(<~~~) = run+	(<~~) = run+	(<~) = run++	(=#-) :: (Semigroupoid m, Interpreted m u) => m < Primary t a < Primary u b -> m < t a < u b+	(=#-) f = unite . f . run++	(-#=) :: (Semigroupoid m, Interpreted m u) => m < t a < u b -> m < Primary t a < Primary u b+	(-#=) f = run . f . unite++	(<$=#-) :: (Semigroupoid m, Covariant m m j, Interpreted m u)+                => m < Primary t a < Primary u b -> m (j > t a) (j > u b)+	(<$=#-) f = (<-|-) ((=#-) f)++	--(<$$=#-) :: (Semigroupoid m, Covariant m m j, Covariant m m k, Interpreted m u)+	--	=> m (Primary t a) (Primary u b) -> m (j :. k > t a) (j :. k > u b)+	--(<$$=#-) f = (<$$>) @m @m ((=#-) f)++	--(<$$$=#-) :: (Semigroupoid m, Covariant m m j, Covariant m m k, Covariant m m l, Interpreted m u)+	--	=> m (Primary t a) (Primary u b) -> m (j :. k :. l > t a) (j :. k :. l > u b)+	--(-<$$$=#-) f = (<$$$>) @m @m @m ((=#-) f)++	(-#=$>) :: (Covariant m m j, Interpreted m u)+		=> m < t a < u b -> m (j > Primary t a) (j > Primary u b)+	(-#=$>) f = (<-|-) ((-#=) f)++	--(-#=$$>) :: (Covariant m m j, Covariant m m k, Interpreted m u)+	--	=> m (t a) (u b) -> m (j :. k > Primary t a) (j :. k > Primary u b)+	--(-#=$$>) f = (<$$>) @m @m ((-#=) f)++	--(-#=$$$>) :: (Covariant m m j, Covariant m m k, Covariant m m l, Interpreted m u)+	--	=> m (t a) (u b) -> m (j :. k :. l > Primary t a) (j :. k :. l > Primary u b)+	--(-#=$$$>) f = (<$$$>) @m @m @m ((-#=) f)++(-=:) :: (Liftable m t, Interpreted m > t u, Interpreted m > t v, Covariant m m u)+	=> m < t u a < t v b -> m < u a < Primary (t v) b+(-=:) f = run . f . lift++instance Interpreted (->) (Flip v a) where+	type Primary (Flip v a) e = v e a+	run ~(Flip x) = x+	unite = Flip++instance Interpreted (->) (Straight v e) where+	type Primary (Straight v e) a = v e a+	run ~(Straight x) = x+	unite = Straight

@@ -9,18 +9,18 @@ import Pandora.Paradigm.Algebraic.One as Exports  import Pandora.Core.Functor (type (>))+import Pandora.Core.Interpreted (Interpreted ((<~))) import Pandora.Pattern.Morphism.Flip (Flip (Flip)) import Pandora.Pattern.Morphism.Straight (Straight (Straight)) import Pandora.Pattern.Semigroupoid ((.))-import Pandora.Pattern.Category ((<--), (<---), identity)+import Pandora.Pattern.Category ((<--), (<---), (<----), identity) import Pandora.Pattern.Kernel (constant)-import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))+import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|--))) import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult)) import Pandora.Pattern.Functor.Monoidal (Monoidal (unit)) import Pandora.Pattern.Functor.Comonad (Comonad) import Pandora.Pattern.Functor.Traversable (Traversable ((<<-))) import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted ((<~)))  instance (Semimonoidal (<--) (:*:) (:*:) t, Semimonoidal (<--) (:*:) (:*:) u) => Semimonoidal (<--) (:*:) (:*:) (t <:*:> u) where 	mult = Flip <-- \(T_U lrxys) ->@@ -38,6 +38,9 @@ instance (Monoidal (-->) (-->) (:*:) (:+:) t, Monoidal (-->) (-->) (:*:) (:+:) u) 	=> Monoidal (-->) (-->) (:*:) (:+:) (t <:*:> u) where 		unit _ = Straight <-- \_ -> empty <:*:> empty++instance (Traversable (->) (->) t, Traversable (->) (->) u) => Traversable (->) (->) (t <:*:> u) where+	f <<- T_U (xs :*: ys) = T_U <-|-- (:*:) <-|- f <<- xs <-*- f <<- ys  instance Traversable (->) (->) ((:*:) s) where 	f <<- x = (attached x :*:) <-|- f (extract x)

@@ -1,6 +1,7 @@ {-# OPTIONS_GHC -fno-warn-orphans #-} module Pandora.Paradigm.Algebraic.Functor where +import Pandora.Core.Interpreted (Interpreted ((<~), (<~~~), (-#=))) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category ((<--)) import Pandora.Pattern.Kernel (constant)@@ -17,14 +18,14 @@ import Pandora.Paradigm.Algebraic.Zero (Zero, absurd) import Pandora.Paradigm.Algebraic.One (One (One)) import Pandora.Paradigm.Primary.Functor.Proxy (Proxy (Proxy))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted ((<~), (<~~~), (-#=)))  infixl 1 <-*------, .-*------, <-||-----, >-||----- infixl 2 <-*-----, .-*-----, <-||----, >-||---- infixl 3 <-*----, .-*----, <-||---, >-||--- infixl 4 <-*---, .-*---, <-*-*-, <-||--, >-||-- infixl 5 <-*--, .-*--, .-*-*-, <-||-, >-||--infixl 6 <-*-, .-*-, <-+-, .-+-+infixl 6 <-*-, .-*-, <-+-+infixl 7 -+-  infixl 6 <-|-<-|-, <-|->-|-, >-|-<-|-, >-|->-|- @@ -71,8 +72,8 @@ (<-+-) :: (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:+:) t) => t b -> t a -> (a :+: b -> r) -> t r y <-+- x = \f -> f <-|--- mult @(-->) <~~~ x :*: y -(.-+-) :: (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:+:) t) => t a -> t a -> t a-y .-+- x = (\r -> case r of Option rx -> rx; Adoption ry -> ry) <-|--- mult @(-->) <~~~ x :*: y+(-+-) :: (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:+:) t) => t a -> t a -> t a+y -+- x = (\r -> case r of Option rx -> rx; Adoption ry -> ry) <-|--- mult @(-->) <~~~ x :*: y  loop :: (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t) => t a -> t b loop x = let r = r .-*- x in r

@@ -1,6 +1,6 @@ module Pandora.Paradigm.Algebraic.Product where -import Pandora.Core.Functor (type (>))+import Pandora.Core.Functor (type (>>>>>>)) import Pandora.Pattern.Category ((<---)) import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-))) import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))@@ -13,9 +13,9 @@ import Pandora.Pattern.Object.Lattice (Lattice) import Pandora.Pattern.Object.Group (Group (invert)) import Pandora.Pattern.Morphism.Flip (Flip (Flip))-import Pandora.Paradigm.Controlflow.Effect.Interpreted () import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>), type (>:.:>), type (<:.:<), type (>:.:<)) +-- TODO: Change precedence to 7 infixr 8 :*: infixr 5 <:*:> @@ -65,10 +65,10 @@ attached :: a :*: b -> a attached ~(x :*: _) = x -type (<:*:>) t u = t <:.:> u > (:*:)-type (>:*:>) t u = t >:.:> u > (:*:)-type (<:*:<) t u = t <:.:< u > (:*:)-type (>:*:<) t u = t >:.:< u > (:*:)+type (<:*:>) t u = t <:.:> u >>>>>> (:*:)+type (>:*:>) t u = t >:.:> u >>>>>> (:*:)+type (<:*:<) t u = t <:.:< u >>>>>> (:*:)+type (>:*:<) t u = t >:.:< u >>>>>> (:*:) -(<:*:>) :: t a -> u a -> t <:*:> u > a+(<:*:>) :: t a -> u a -> t <:*:> u >>>>>> a (<:*:>) xs ys = T_U <--- xs :*: ys

@@ -1,6 +1,6 @@ module Pandora.Paradigm.Algebraic.Sum where -import Pandora.Core.Functor (type (>))+import Pandora.Core.Functor (type (>>>>>>)) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category ((<--)) import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))@@ -29,7 +29,7 @@ bitraverse_sum f _ (Option x) = Option <-|- f x bitraverse_sum _ g (Adoption x) = Adoption <-|- g x -type (<:+:>) t u = t <:.:> u > (:+:)-type (>:+:>) t u = t >:.:> u > (:+:)-type (<:+:<) t u = t <:.:< u > (:+:)-type (>:+:<) t u = t >:.:< u > (:+:)+type (<:+:>) t u = t <:.:> u >>>>>> (:+:)+type (>:+:>) t u = t >:.:> u >>>>>> (:+:)+type (<:+:<) t u = t <:.:< u >>>>>> (:+:)+type (>:+:<) t u = t >:.:< u >>>>>> (:+:)

@@ -1,5 +1,4 @@ module Pandora.Paradigm.Controlflow.Effect (module Exports) where  import Pandora.Paradigm.Controlflow.Effect.Transformer as Exports-import Pandora.Paradigm.Controlflow.Effect.Interpreted as Exports import Pandora.Paradigm.Controlflow.Effect.Adaptable as Exports

@@ -1,7 +1,7 @@ {-# LANGUAGE UndecidableInstances #-} module Pandora.Paradigm.Controlflow.Effect.Adaptable where -import Pandora.Core.Functor (type (>), type (<))+import Pandora.Core.Functor (type (>), type (>>>), type (<)) import Pandora.Pattern.Semigroupoid (Semigroupoid ((.))) import Pandora.Pattern.Category (Category (identity)) import Pandora.Pattern.Functor.Covariant (Covariant)@@ -20,11 +20,8 @@ instance Category m => Adaptable t m t where 	adapt = identity @m -instance {-# OVERLAPS #-} Monoidal (-->) (-->) (:*:) (:*:) u => Adaptable u (->) Exactly where-	adapt = point . extract- class Effectful m v t u where-	effect :: m (v a) (t :> u > a)+	effect :: m (v a) (t :> u >>> a)  instance (Pointable u, Monadic m t) => Effectful m t t u where 	effect = wrap

@@ -1,82 +0,0 @@-module Pandora.Paradigm.Controlflow.Effect.Interpreted where--import Pandora.Core.Functor (type (<), type (>))-import Pandora.Pattern.Morphism.Straight (Straight (Straight))-import Pandora.Pattern.Morphism.Flip (Flip (Flip))-import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))-import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))-import Pandora.Pattern.Transformer.Liftable (Liftable (lift))-import Pandora.Paradigm.Algebraic.Exponential ()--infixr 2 =#-, -#=--infixl 1 <~~~~~~~~-infixl 2 <~~~~~~~-infixl 3 <~~~~~~-infixl 4 <~~~~~-infixl 5 <~~~~-infixl 6 <~~~-infixl 7 <~~-infixl 8 <~--type family Schematic (c :: (* -> * -> *) -> (* -> *) -> k) (t :: * -> *) = (r :: (* -> *) -> * -> *) | r -> t--class Interpreted m t where-	{-# MINIMAL run, unite #-}-	type Primary t a :: *-	run :: m < t a < Primary t a-	unite :: m < Primary t a < t a--	(<~~~~~~~~), (<~~~~~~~), (<~~~~~~), (<~~~~~), (<~~~~), (<~~~), (<~~), (<~) :: m < t a < Primary t a-	(<~~~~~~~~) = run-	(<~~~~~~~) = run-	(<~~~~~~) = run-	(<~~~~~) = run-	(<~~~~) = run-	(<~~~) = run-	(<~~) = run-	(<~) = run--	(=#-) :: (Semigroupoid m, Interpreted m u) => m < Primary t a < Primary u b -> m < t a < u b-	(=#-) f = unite . f . run--	(-#=) :: (Semigroupoid m, Interpreted m u) => m < t a < u b -> m < Primary t a < Primary u b-	(-#=) f = run . f . unite--	(<$=#-) :: (Semigroupoid m, Covariant m m j, Interpreted m u)-                => m < Primary t a < Primary u b -> m (j > t a) (j > u b)-	(<$=#-) f = (<-|-) ((=#-) f)--	--(<$$=#-) :: (Semigroupoid m, Covariant m m j, Covariant m m k, Interpreted m u)-	--	=> m (Primary t a) (Primary u b) -> m (j :. k > t a) (j :. k > u b)-	--(<$$=#-) f = (<$$>) @m @m ((=#-) f)--	--(<$$$=#-) :: (Semigroupoid m, Covariant m m j, Covariant m m k, Covariant m m l, Interpreted m u)-	--	=> m (Primary t a) (Primary u b) -> m (j :. k :. l > t a) (j :. k :. l > u b)-	--(-<$$$=#-) f = (<$$$>) @m @m @m ((=#-) f)--	(-#=$>) :: (Covariant m m j, Interpreted m u)-		=> m < t a < u b -> m (j > Primary t a) (j > Primary u b)-	(-#=$>) f = (<-|-) ((-#=) f)--	--(-#=$$>) :: (Covariant m m j, Covariant m m k, Interpreted m u)-	--	=> m (t a) (u b) -> m (j :. k > Primary t a) (j :. k > Primary u b)-	--(-#=$$>) f = (<$$>) @m @m ((-#=) f)--	--(-#=$$$>) :: (Covariant m m j, Covariant m m k, Covariant m m l, Interpreted m u)-	--	=> m (t a) (u b) -> m (j :. k :. l > Primary t a) (j :. k :. l > Primary u b)-	--(-#=$$$>) f = (<$$$>) @m @m @m ((-#=) f)--(-=:) :: (Liftable m t, Interpreted m > t u, Interpreted m > t v, Covariant m m u)-	=> m < t u a < t v b -> m < u a < Primary (t v) b-(-=:) f = run . f . lift--instance Interpreted (->) (Flip v a) where-	type Primary (Flip v a) e = v e a-	run ~(Flip x) = x-	unite = Flip--instance Interpreted (->) (Straight v e) where-	type Primary (Straight v e) a = v e a-	run ~(Straight x) = x-	unite = Straight

@@ -2,6 +2,7 @@ module Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic (Comonadic (..), (:<) (..)) where  import Pandora.Core.Functor (type (<))+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (<~~~))) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category ((<--), (<---), (<----)) import Pandora.Pattern.Morphism.Straight (Straight (Straight))@@ -19,7 +20,7 @@ import Pandora.Paradigm.Algebraic.Product ((:*:)((:*:))) import Pandora.Paradigm.Algebraic.One (One (One)) import Pandora.Paradigm.Algebraic (Extractable, point)-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite, (<~~~)))+import Pandora.Paradigm.Schemes (Schematic)  class Interpreted m t => Comonadic m t where 	{-# MINIMAL bring #-}

@@ -2,16 +2,17 @@ module Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (..), (:>) (..)) where  import Pandora.Core.Functor (type (<))+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (<~~~))) import Pandora.Pattern.Morphism.Straight (Straight (Straight)) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category ((<--), (<---), (<----)) import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-))) import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult)) import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))-import Pandora.Pattern.Functor.Distributive (Distributive ((-<<), (--<<)))+import Pandora.Pattern.Functor.Distributive (Distributive ((-<<))) import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))-import Pandora.Pattern.Functor.Bindable (Bindable ((=<<), (==<<)))-import Pandora.Pattern.Functor.Extendable (Extendable ((<<=), (<<==)))+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))+import Pandora.Pattern.Functor.Extendable (Extendable ((<<=))) import Pandora.Pattern.Functor.Monad (Monad) import Pandora.Pattern.Transformer.Liftable (Liftable (lift)) import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))@@ -20,13 +21,13 @@ import Pandora.Paradigm.Algebraic.Sum ((:+:)) import Pandora.Paradigm.Algebraic.One (One (One)) import Pandora.Paradigm.Algebraic (Pointable, point)-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite, (<~~~)))+import Pandora.Paradigm.Schemes (Schematic)  class Interpreted m t => Monadic m t where 	{-# MINIMAL wrap #-} 	wrap :: Pointable u => m < t a < (t :> u) a -infixr 3 :>+infixr 8 :> newtype (:>) t u a = TM { tm :: Schematic Monad t u a }  instance Covariant (->) (->) (Schematic Monad t u) => Covariant (->) (->) (t :> u) where

@@ -2,11 +2,11 @@ 	notify, follow, subscribe, watch, (.:~.), (.:~*), (*:~.), (*:~*)) where  import Pandora.Core.Functor (type (<))+import Pandora.Core.Interpreted ((<~~)) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category ((<--), (<---)) import Pandora.Paradigm.Algebraic (Applicative, loop) import Pandora.Paradigm.Primary.Transformer.Continuation (Continuation (Continuation))-import Pandora.Paradigm.Controlflow.Effect.Interpreted ((<~~))  newtype Capture r t a = Capture { captured :: t r } 

@@ -1,5 +1,6 @@ module Pandora.Paradigm.Controlflow.Pipeline (Pipeline, await, yield, finish, impact, (=*=), pipeline) where +import Pandora.Core.Interpreted (Interpreted (Primary, run, unite)) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category ((<--)) import Pandora.Pattern.Kernel (constant)@@ -8,7 +9,6 @@ import Pandora.Paradigm.Algebraic.Exponential (type (-->)) import Pandora.Paradigm.Algebraic.Product ((:*:)) import Pandora.Paradigm.Algebraic (point)-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite)) import Pandora.Paradigm.Primary.Transformer.Continuation (Continuation (Continuation))  newtype Producer i t r = Producer { produce :: Consumer i t r -> t r }

@@ -1,11 +1,12 @@ {-# LANGUAGE AllowAmbiguousTypes #-} {-# OPTIONS_GHC -fno-warn-orphans #-}-module Pandora.Paradigm.Inventory (module Exports, Zoomable (zoom), overlook, (=<>), (~<>)) where+module Pandora.Paradigm.Inventory (module Exports, zoom, overlook, (=<>), (~<>)) where  import Pandora.Paradigm.Inventory.Ability as Exports import Pandora.Paradigm.Inventory.Some as Exports  import Pandora.Core.Functor (type (~>))+import Pandora.Core.Interpreted (run, (<~)) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category ((<--), (<---), (<----)) import Pandora.Pattern.Kernel (constant)@@ -19,7 +20,6 @@ import Pandora.Paradigm.Algebraic.Exponential ((%), type (<--)) import Pandora.Paradigm.Algebraic (Pointable, extract) import Pandora.Paradigm.Primary (Simplification)-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (<~)) import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))  instance Adjoint (->) (->) (Store s) (State s) where@@ -36,22 +36,11 @@ 	f -| x = Provision <--- f . Equipment --| x 	g |- x = run . g |-- run x -class Zoomable (tool :: * -> * -> *) (available :: * -> *) where-	zoom :: forall bg ls t . Adaptable t (->) (tool bg) => Lens available bg ls -> tool (Simplification available ls) ~> t--instance Zoomable State Exactly where-	zoom :: forall bg ls t result . Stateful bg t => Convex Lens bg ls -> State ls result -> t result-	zoom lens less = adapt . State <-- \source -> restruct |- run (lens <~ source) where--		restruct :: (Exactly ls -> bg) -> Exactly ls -> bg :*: result-		restruct to (Exactly target) = run <---- to . Exactly <-|- Flip (less <~ target)--instance Zoomable State Maybe where-	zoom :: forall bg ls t result . Stateful bg t => Obscure Lens bg ls -> State (Maybe ls) result -> t result-	zoom lens less = adapt . State <-- \source -> restruct |- run (lens <~ source) where+zoom :: forall bg ls u result . Lens u bg ls -> State (u ls) result -> State bg result+zoom lens less = State <-- \source -> restruct |- run (lens <~ source) where -		restruct :: (Maybe ls -> bg) -> Maybe ls -> bg :*: result-		restruct to target = run (to <-|-- Flip <-- run less target)+	restruct :: (u ls -> bg) -> u ls -> bg :*: result+	restruct to target = run @(->) <---- to <-|- Flip (less <~ target)  overlook :: (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t) => State s result -> State (t s) (t result) overlook (State state) = State <-- \ts -> mult @(<--) @(:*:) @(:*:) <~ (state <-|- ts)

@@ -1,6 +1,7 @@ {-# OPTIONS_GHC -fno-warn-orphans #-} module Pandora.Paradigm.Inventory.Some.Accumulator (Accumulator (..), Accumulated, gather) where +import Pandora.Core.Interpreted (Interpreted (Primary, run, unite)) import Pandora.Pattern.Morphism.Straight (Straight (Straight)) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category ((<--), (<---), (<----))@@ -13,10 +14,9 @@ import Pandora.Paradigm.Algebraic.Exponential (type (-->)) import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:))) import Pandora.Paradigm.Algebraic (point)-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite)) import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM)) import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))-import Pandora.Paradigm.Schemes.UT (UT (UT), type (<.:>))+import Pandora.Paradigm.Schemes (Schematic, UT (UT), type (<.:>))  newtype Accumulator e a = Accumulator (e :*: a) 

@@ -1,6 +1,7 @@ {-# OPTIONS_GHC -fno-warn-orphans #-} module Pandora.Paradigm.Inventory.Some.Equipment (Equipment (..), retrieve) where +import Pandora.Core.Interpreted (Interpreted (Primary, run, unite)) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category ((<---), (<----)) import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|--)))@@ -10,9 +11,8 @@ import Pandora.Paradigm.Algebraic () import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), attached) import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite)) import Pandora.Paradigm.Inventory.Ability.Gettable (Gettable (Getting, get))-import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))+import Pandora.Paradigm.Schemes (Schematic, TU (TU), type (<:.>))  newtype Equipment e a = Equipment (e :*: a) 

@@ -1,6 +1,7 @@ {-# OPTIONS_GHC -fno-warn-orphans #-} module Pandora.Paradigm.Inventory.Some.Imprint (Imprint (..), Traceable) where +import Pandora.Core.Interpreted (Interpreted (Primary, run, unite)) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category ((<--), (<---)) import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))@@ -11,9 +12,8 @@ import Pandora.Pattern.Object.Semigroup (Semigroup ((+))) import Pandora.Paradigm.Algebraic () import Pandora.Pattern.Morphism.Flip (Flip (Flip))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite)) import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable)-import Pandora.Paradigm.Schemes.UT (UT (UT), type (<.:>))+import Pandora.Paradigm.Schemes (Schematic, UT (UT), type (<.:>))  newtype Imprint e a = Imprint (e -> a) 

@@ -2,7 +2,9 @@ {-# LANGUAGE UndecidableInstances #-} module Pandora.Paradigm.Inventory.Some.Optics where +import Pandora.Core.Functor (type (<)) import Pandora.Core.Impliable (Impliable (Arguments, imply))+import Pandora.Core.Interpreted (Interpreted (run, (<~))) import Pandora.Pattern.Semigroupoid (Semigroupoid ((.))) import Pandora.Pattern.Category (Category (identity, (<--), (<---), (<----), (<-----), (<-------))) import Pandora.Pattern.Kernel (Kernel (constant))@@ -10,8 +12,9 @@ import Pandora.Pattern.Functor.Invariant (Invariant ((<!<))) import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult)) import Pandora.Pattern.Functor.Representable (Representable (Representation, (<#>), tabulate))+import Pandora.Pattern.Transformer.Liftable (Liftable (lift))+import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower)) import Pandora.Pattern.Object.Setoid (Setoid ((?=)))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (run, (<~))) import Pandora.Paradigm.Inventory.Ability.Gettable (Gettable (Getting, get)) import Pandora.Paradigm.Inventory.Ability.Settable (Settable (Setting, set)) import Pandora.Paradigm.Inventory.Ability.Modifiable (Modifiable (Modification, modify))@@ -134,3 +137,6 @@  mutate :: (i target -> i target) -> Lens i source target -> source -> source mutate mut lens source = extract . retrofit mut <-- lens <~ source++transwrap :: (Covariant (->) (->) u, Liftable (->) t, Lowerable (->) t) => Lens u < t u e < e+transwrap = P_Q_T <-- \origin -> Store <--- lower origin :*: lift

@@ -1,13 +1,14 @@ {-# OPTIONS_GHC -fno-warn-orphans #-} module Pandora.Paradigm.Inventory.Some.Provision where +import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (<~))) import Pandora.Pattern.Semigroupoid ((.))-import Pandora.Pattern.Category (identity, (<--), (<---), (<----), (<-----))+import Pandora.Pattern.Category (identity, (<--), (<---), (<----)) import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-))) import Pandora.Pattern.Functor.Contravariant (Contravariant ((>-|-))) import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult)) import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))-import Pandora.Pattern.Functor.Distributive (Distributive ((-<<), (---<<)))+import Pandora.Pattern.Functor.Distributive (Distributive ((-<<))) import Pandora.Pattern.Functor.Bindable (Bindable ((=<<))) import Pandora.Pattern.Functor.Monad (Monad) import Pandora.Paradigm.Algebraic.Exponential (type (-->), (%))@@ -17,11 +18,10 @@ import Pandora.Paradigm.Algebraic (point) import Pandora.Pattern.Morphism.Flip (Flip (Flip)) import Pandora.Pattern.Morphism.Straight (Straight (Straight))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite, (<~))) import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM)) import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt)) import Pandora.Paradigm.Inventory.Ability.Gettable (Gettable (Getting, get))-import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))+import Pandora.Paradigm.Schemes (Schematic, TU (TU), type (<:.>))  newtype Provision e a = Provision (e -> a) 

@@ -1,9 +1,10 @@ {-# OPTIONS_GHC -fno-warn-orphans #-} module Pandora.Paradigm.Inventory.Some.State where +import Pandora.Core.Functor (type (:.), type (>>>))+import Pandora.Core.Interpreted (Interpreted (Primary, run, (<~), unite, (=#-))) import Pandora.Pattern.Morphism.Flip (Flip) import Pandora.Pattern.Morphism.Straight (Straight (Straight))-import Pandora.Core.Functor (type (:.), type (>)) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category ((<--), (<---), (<----), identity) import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))@@ -15,19 +16,18 @@ import Pandora.Pattern.Functor.Monad (Monad) import Pandora.Pattern.Functor.Adjoint ((-|), (|-)) import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, (<~), unite, (=#-)), Schematic) import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM)) import Pandora.Paradigm.Inventory.Ability.Gettable (Gettable (Getting, get)) import Pandora.Paradigm.Inventory.Ability.Settable (Settable (Setting, set)) import Pandora.Paradigm.Inventory.Ability.Modifiable (Modifiable (Modification, modify))-import Pandora.Paradigm.Schemes.TUT (TUT (TUT), type (<:<.>:>)) import Pandora.Paradigm.Algebraic.Exponential (type (-->)) import Pandora.Paradigm.Algebraic ((:*:) ((:*:)), (.-*-), delta) import Pandora.Paradigm.Algebraic.One (One (One)) import Pandora.Paradigm.Algebraic (Pointable, point, (<-||-), (>-||-))+import Pandora.Paradigm.Schemes (Schematic, TUT (TUT), type (<:<.>:>))  -- | Effectful computation with a variable-newtype State s a = State ((->) s :. (:*:) s > a)+newtype State s a = State ((->) s :. (:*:) s >>> a)  instance Covariant (->) (->) (State s) where 	f <-|- x = State <--- (<-|-) f . run x@@ -50,7 +50,7 @@ 	f <!< g = (((g >-||-) . ((f <-||-) <-|-) =#-) =#-)  instance Interpreted (->) (State s) where-	type Primary (State s) a = (->) s :. (:*:) s > a+	type Primary (State s) a = (->) s :. (:*:) s >>> a 	run ~(State x) = x 	unite = State @@ -60,6 +60,13 @@ 	wrap x = TM . TUT <---- point <-|- run x  type Stateful s t = Adaptable t (->) (State s)++current :: Stateful s t => t s+current = adapt <-- State delta++-- Modify the state, state is new value, return old value+change :: Stateful s t => (s -> s) -> t s+change f = adapt . State <-- \s -> f s :*: s  reconcile :: (Bindable (->) t, Stateful s t, Adaptable t (->) u) => (s -> u s) -> t s reconcile f = adapt . set @State ==<< adapt . f ==<< adapt <-- get @State

@@ -1,9 +1,10 @@ {-# OPTIONS_GHC -fno-warn-orphans #-} module Pandora.Paradigm.Inventory.Some.Store where -import Pandora.Core (type (:.), type (>), type (<:=), type (~>))+import Pandora.Core (type (:.), type (>>>), type (<:=), type (~>))+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (=#-))) import Pandora.Pattern.Semigroupoid ((.))-import Pandora.Pattern.Category ((<--), (<---), (<----), (<-----), (<------), identity)+import Pandora.Pattern.Category ((<--), (<---), (<------), identity) import Pandora.Pattern.Kernel (constant) import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|--), (<-|-|-))) import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))@@ -18,12 +19,11 @@ import Pandora.Pattern.Morphism.Flip (Flip (Flip)) import Pandora.Pattern.Morphism.Straight (Straight (Straight)) import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (=#-)), Schematic) import Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic (Comonadic (bring), (:<) (TC))-import Pandora.Paradigm.Schemes.TUT (TUT (TUT), type (<:<.>:>))+import Pandora.Paradigm.Schemes (Schematic, TUT (TUT), type (<:<.>:>))  -- | Context based computation on value-newtype Store s a = Store ((:*:) s :. (->) s > a)+newtype Store s a = Store ((:*:) s :. (->) s >>> a)  -- TODO: Try to generalize (->) here instance Covariant (->) (->) (Store s) where@@ -47,7 +47,7 @@ 	f <!< g = (((f <-||-) . ((g >-||-) <-|-) =#-) =#-)  instance Interpreted (->) (Store s) where-	type Primary (Store s) a = (:*:) s :. (->) s > a+	type Primary (Store s) a = (:*:) s :. (->) s >>> a 	run ~(Store x) = x 	unite = Store 

@@ -1,13 +1,14 @@ {-# OPTIONS_GHC -fno-warn-orphans #-} module Pandora.Paradigm.Primary (module Exports, Simplification) where +import Pandora.Paradigm.Primary.Auxiliary as Exports import Pandora.Paradigm.Primary.Linear as Exports import Pandora.Paradigm.Primary.Transformer as Exports import Pandora.Paradigm.Primary.Functor as Exports import Pandora.Paradigm.Primary.Object as Exports  import Pandora.Pattern.Morphism.Flip (Flip (Flip))-import Pandora.Core.Functor (type (:.), type (>))+import Pandora.Core.Functor (type (:.), type (>>>)) import Pandora.Pattern.Semigroupoid (Semigroupoid ((.))) import Pandora.Pattern.Category ((<---)) import Pandora.Pattern.Functor.Adjoint (Adjoint ((|-), (-|)))@@ -20,8 +21,8 @@  type family Simplification (t :: * -> *) (a :: *) where 	Simplification Exactly a = a-	Simplification (TU _ _ t u) a = t :. u > a-	Simplification (UT _ _ t u) a = u :. t > a-	Simplification (TUT _ _ _ t t' u) a = t :. u :. t' > a+	Simplification (TU _ _ t u) a = t :. u >>> a+	Simplification (UT _ _ t u) a = u :. t >>> a+	Simplification (TUT _ _ _ t t' u) a = t :. u :. t' >>> a 	Simplification (T_U _ _ p t u) a = p (t a) (u a) 	Simplification t a = t a

@@ -0,0 +1,5 @@+module Pandora.Paradigm.Primary.Auxiliary where++data Vertical a = Up a | Down a++data Horizontal a = Left a | Right a

@@ -1,9 +1,10 @@ module Pandora.Paradigm.Primary.Functor.Conclusion where  import Pandora.Core.Functor (type (~>))+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (<~))) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Morphism.Straight (Straight (Straight))-import Pandora.Pattern.Category (identity, (<--), (<---))+import Pandora.Pattern.Category (identity, (<--), (<---), (<----)) import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-))) import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult)) import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))@@ -18,13 +19,12 @@ import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:))) import Pandora.Paradigm.Algebraic.Sum ((:+:) (Option, Adoption)) import Pandora.Pattern.Morphism.Flip (Flip (Flip))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite, (<~))) import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM)) import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))-import Pandora.Paradigm.Schemes.UT (UT (UT), type (<.:>)) import Pandora.Paradigm.Algebraic.Exponential (type (-->)) import Pandora.Paradigm.Algebraic.One (One (One)) import Pandora.Paradigm.Algebraic (point)+import Pandora.Paradigm.Schemes (Schematic, UT (UT), type (<.:>))  data Conclusion e a = Failure e | Success a @@ -32,10 +32,6 @@ 	f <-|- Success x = Success <-- f x 	_ <-|- Failure y = Failure y -instance Covariant (->) (->) (Flip Conclusion e) where-	_ <-|- Flip (Success x) = Flip <-- Success x-	f <-|- Flip (Failure y) = Flip . Failure <-- f y- instance Semimonoidal (-->) (:*:) (:*:) (Conclusion e) where 	mult = Straight <-- \case 		Success x :*: Success y -> Success <--- x :*: y@@ -112,3 +108,16 @@ instance (Monoidal (-->) (-->) (:*:) (:*:) u, Bindable (->) u) => Catchable e (Conclusion e <.:> u) where 	catch (UT x) handle = let conclude = conclusion <-- run . handle <-- point . Success 		in UT <--- conclude =<< x++instance Covariant (->) (->) (Flip Conclusion a) where+	_ <-|- Flip (Success x) = Flip <-- Success x+	f <-|- Flip (Failure y) = Flip . Failure <-- f y++instance Semimonoidal (-->) (:*:) (:*:) (Flip Conclusion a) where+	mult = Straight <-- \case+		Flip (Failure x) :*: Flip (Failure y) -> Flip <---- Failure <--- x :*: y+		Flip (Success x) :*: _ -> Flip <-- Success x+		_ :*: Flip (Success x) -> Flip <-- Success x++instance Monoidal (-->) (-->) (:*:) (:*:) (Flip Conclusion a) where+	unit _ = Straight <--- Flip . Failure . (<~ One)

@@ -1,11 +1,11 @@ module Pandora.Paradigm.Primary.Functor.Endo where +import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (=#-))) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category (identity, (<--)) import Pandora.Pattern.Functor.Invariant (Invariant ((<!<))) import Pandora.Pattern.Object.Semigroup (Semigroup ((+))) import Pandora.Pattern.Object.Monoid (Monoid (zero))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (=#-))) import Pandora.Paradigm.Algebraic.Exponential () import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:))) import Pandora.Paradigm.Algebraic ((>-|-<-|-))

@@ -1,5 +1,6 @@ module Pandora.Paradigm.Primary.Functor.Exactly where +import Pandora.Core.Interpreted ((<~)) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category ((<--), (<---), (<----)) import Pandora.Pattern.Morphism.Flip (Flip (Flip))@@ -27,7 +28,6 @@ import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:))) import Pandora.Paradigm.Algebraic.One (One (One)) import Pandora.Paradigm.Algebraic (extract, (<-||-))-import Pandora.Paradigm.Controlflow.Effect.Interpreted ((<~))  newtype Exactly a = Exactly a 

@@ -1,6 +1,7 @@ module Pandora.Paradigm.Primary.Functor.Maybe where -import Pandora.Core.Functor (type (:.), type (>))+import Pandora.Core.Functor (type (:.), type (>>>))+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (<~))) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category (identity, (<--), (<---)) import Pandora.Pattern.Morphism.Flip (Flip (Flip))@@ -19,16 +20,15 @@ import Pandora.Pattern.Object.Lattice (Lattice) import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False)) import Pandora.Paradigm.Primary.Object.Ordering (Ordering (Less, Equal, Greater))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite, (<~))) import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM)) import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))-import Pandora.Paradigm.Schemes.UT (UT (UT), type (<.:>)) import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (reduce)) import Pandora.Paradigm.Algebraic.Exponential (type (<--), type (-->)) import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:))) import Pandora.Paradigm.Algebraic.Sum ((:+:) (Option, Adoption)) import Pandora.Paradigm.Algebraic.One (One (One)) import Pandora.Paradigm.Algebraic (point)+import Pandora.Paradigm.Schemes (Schematic, UT (UT), type (<.:>))  data Maybe a = Nothing | Just a @@ -115,7 +115,7 @@ 	reduce f r (Just x) = f x r 	reduce _ r Nothing = r -instance Monotonic a (t a) => Monotonic a (Maybe :. t > a) where+instance Monotonic a (t a) => Monotonic a (Maybe :. t >>> a) where 	reduce f r (Just x) = reduce f r x 	reduce _ r Nothing = r 

@@ -1,6 +1,7 @@ module Pandora.Paradigm.Primary.Functor.Predicate where  import Pandora.Core.Functor (type (~>), type (:=>))+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite)) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category ((<--)) import Pandora.Pattern.Morphism.Straight (Straight (Straight))@@ -13,7 +14,6 @@ import Pandora.Paradigm.Algebraic.Product ((:*:)((:*:))) import Pandora.Paradigm.Algebraic.Sum ((:+:)(Option, Adoption)) import Pandora.Paradigm.Algebraic.Exponential (type (-->), type (<--))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))  newtype Predicate a = Predicate (a -> Boolean) 

@@ -1,6 +1,7 @@ module Pandora.Paradigm.Primary.Functor.Tagged where  import Pandora.Core.Functor (type (:=>), type (~>))+import Pandora.Core.Interpreted ((<~)) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category ((<--), (<---), (<----)) import Pandora.Pattern.Morphism.Flip (Flip (Flip))@@ -27,7 +28,6 @@ import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:))) import Pandora.Paradigm.Algebraic.One (One (One)) import Pandora.Paradigm.Algebraic (extract, (<-||-))-import Pandora.Paradigm.Controlflow.Effect.Interpreted ((<~))  newtype Tagged tag a = Tag a 

@@ -1,5 +1,6 @@ module Pandora.Paradigm.Primary.Functor.Validation where +import Pandora.Core.Interpreted ((<~)) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category ((<--), (<---)) import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))@@ -18,7 +19,6 @@ import Pandora.Pattern.Morphism.Straight (Straight (Straight)) import Pandora.Paradigm.Primary.Object.Boolean (Boolean (False)) import Pandora.Paradigm.Primary.Object.Ordering (Ordering (Less, Greater))-import Pandora.Paradigm.Controlflow.Effect.Interpreted ((<~))  data Validation e a = Flaws e | Validated a 

@@ -11,38 +11,38 @@ import Pandora.Pattern.Morphism.Flip (Flip (Flip)) import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (reduce)) -data Wye a = End | Left a | Right a | Both a a+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 <-|- Left_ x = Left_ <-- f x+	f <-|- Right_ y = Right_ <-- f y 	f <-|- Both x y = Both <-- f x <-- f y  -- instance Semimonoidal (<--) (:*:) (:*:) Wye where -- 	mult = Flip <-- \case -- 		End -> End :*: End--- 		Left (x :*: y) -> Left x :*: Left y--- 		Right (x :*: y) -> Right x :*: Right y+-- 		Left_ (x :*: y) -> Left_ x :*: Left_ y+-- 		Right_ (x :*: y) -> Right_ x :*: Right_ y -- 		Both (x :*: y) (x' :*: y') -> Both x x' :*: Both y y'  instance Monotonic a (Wye a) where-	reduce f r (Left x) = f x r-	reduce f r (Right x) = f x r+	reduce f r (Left_ x) = f x r+	reduce f r (Right_ x) = f x r 	reduce f r (Both x y) = f y <-- f x r 	reduce _ r End = r  instance Semigroup a => Semigroup (Wye a) where 	End + x = x 	x + End = x-	Left x + Left x' = Left <-- x + x'-	Left x + Right y = Both <-- x <-- y-	Left x + Both x' y = Both <-- x + x' <-- y-	Right y + Left x = Both <-- x <-- y-	Right y + Right y' = Right <-- y + y'-	Right y + Both x y' = Both <-- x <-- y + y'-	Both x y + Left x' = Both <-- x + x' <-- y-	Both x y + Right y' = Both <-- x <-- y + y'+	Left_ x + Left_ x' = Left_ <-- x + x'+	Left_ x + Right_ y = Both <-- x <-- y+	Left_ x + Both x' y = Both <-- x + x' <-- y+	Right_ y + Left_ x = Both <-- x <-- y+	Right_ y + Right_ y' = Right_ <-- y + y'+	Right_ y + Both x y' = Both <-- x <-- y + y'+	Both x y + Left_ x' = Both <-- x + x' <-- y+	Both x y + Right_ y' = Both <-- x <-- y + y' 	Both x y + Both x' y' = Both <-- x + x' <-- y + y'  instance Semigroup a => Monoid (Wye a) where@@ -50,12 +50,12 @@  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 _ f _ _ (Left_ x) = f x+wye _ _ g _ (Right_ y) = g y wye _ _ _ h (Both x y) = h x y  swop :: Wye ~> Wye swop End = End swop (Both l r) = Both r l-swop (Left l) = Right l-swop (Right r) = Left r+swop (Left_ l) = Right_ l+swop (Right_ r) = Left_ r

@@ -18,7 +18,7 @@ import Pandora.Paradigm.Algebraic (point, extract, (<-||-)) import Pandora.Pattern.Morphism.Flip (Flip (Flip)) import Pandora.Pattern.Morphism.Straight (Straight (Straight))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (<~)))+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (<~)))  newtype Backwards t a = Backwards (t a) 

@@ -1,7 +1,7 @@ {-# LANGUAGE UndecidableInstances #-} module Pandora.Paradigm.Primary.Transformer.Construction where -import Pandora.Core.Functor (type (:.), type (>), type (:=>), type (~>))+import Pandora.Core.Functor (type (:.), type (>>>), type (:=>), type (~>)) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category ((<--), (<---), (<----), (<-----), (<------)) import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|--), (<-|----), (<-|-|-)))@@ -24,11 +24,9 @@ import Pandora.Paradigm.Algebraic (empty, (<-||-)) import Pandora.Pattern.Morphism.Flip (Flip (Flip)) import Pandora.Pattern.Morphism.Straight (Straight (Straight))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (<~), (<~~~), (<~~~~))--infixr 7 .-++import Pandora.Core.Interpreted (run, (<~), (<~~~), (<~~~~)) -data Construction t a = Construct a (t :. Construction t > a)+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@@ -76,12 +74,12 @@ -- instance Monotonic a (t :. Construction t > a) => Monotonic a (t <::> Construction t > a) where -- 	reduce f r = reduce f r . run -deconstruct :: Construction t a -> t :. Construction t > a+deconstruct :: Construction t a -> t :. Construction t >>> a deconstruct ~(Construct _ xs) = xs  -- Generate a construction from seed using effectful computation-(.-+) :: Covariant (->) (->) t => a :=> t -> a :=> Construction t-f .-+ x = Construct x <---- (f .-+) <-|- f x+constitute :: Covariant (->) (->) t => (a -> t a) -> a -> Construction t a+constitute f x = Construct x <---- constitute f <-|- f x  section :: (Comonad (->) t, Monoidal (<--) (-->) (:*:) (:*:) t) => t ~> Construction t section xs = Construct <--- extract xs <--- section <<= xs

@@ -1,7 +1,6 @@ {-# LANGUAGE UndecidableInstances #-} module Pandora.Paradigm.Primary.Transformer.Continuation where -import Pandora.Core.Functor (type (:.), type (>), type (::|:.)) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category ((<--)) import Pandora.Pattern.Kernel (constant)@@ -10,15 +9,15 @@ import Pandora.Pattern.Functor.Bindable (Bindable ((=<<))) import Pandora.Pattern.Functor.Monad (Monad) import Pandora.Pattern.Transformer.Liftable (Liftable (lift))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (<~)))+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (<~))) import Pandora.Paradigm.Algebraic.Exponential ((%), type (-->)) import Pandora.Paradigm.Algebraic.Product ((:*:)) import Pandora.Paradigm.Algebraic (point) -newtype Continuation r t a = Continuation ((->) ::|:. a :. t > r)+newtype Continuation r t a = Continuation ((->) ((->) a (t r)) (t r))  instance Interpreted (->) (Continuation r t) where-	type Primary (Continuation r t) a = (->) ::|:. a :. t > r+	type Primary (Continuation r t) a = ((->) ((->) a (t r)) (t r)) 	run ~(Continuation x) = x 	unite = Continuation 

@@ -1,7 +1,7 @@ {-# LANGUAGE UndecidableInstances #-} module Pandora.Paradigm.Primary.Transformer.Instruction where -import Pandora.Core.Functor (type (:.), type (>))+import Pandora.Core.Functor (type (:.), type (>>>)) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category ((<--), (<---), (<----), (<-----), (<------)) import Pandora.Pattern.Morphism.Straight (Straight (Straight))@@ -18,9 +18,9 @@ import Pandora.Paradigm.Algebraic.Product ((:*:)((:*:))) import Pandora.Paradigm.Algebraic.One (One (One)) import Pandora.Paradigm.Algebraic (point)-import Pandora.Paradigm.Controlflow.Effect.Interpreted ((<~), (<~~~))+import Pandora.Core.Interpreted ((<~), (<~~~)) -data Instruction t a = Enter a | Instruct (t :. Instruction t > a)+data Instruction t a = Enter a | Instruct (t :. Instruction t >>> a)  instance Covariant (->) (->) t => Covariant (->) (->) (Instruction t) where 	f <-|- Enter x = Enter <-- f x

@@ -1,11 +1,12 @@ module Pandora.Paradigm.Primary.Transformer.Kan where +import Pandora.Core.Interpreted (Interpreted (Primary, run, unite)) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category ((<--)) import Pandora.Pattern.Functor.Contravariant (Contravariant ((>-|-))) import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))-import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))+import Pandora.Paradigm.Primary.Auxiliary (Horizontal (Left, Right))+import Pandora.Paradigm.Algebraic.Exponential ()  data family Kan (v :: * -> k) (t :: * -> *) (u :: * -> *) b a 

@@ -20,7 +20,7 @@ import Pandora.Paradigm.Algebraic (point, extract, empty, (<-||-)) import Pandora.Pattern.Morphism.Flip (Flip (Flip)) import Pandora.Pattern.Morphism.Straight (Straight (Straight))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (<~), (<~~~)))+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (<~), (<~~~)))  newtype Reverse t a = Reverse (t a) 

@@ -1,7 +1,7 @@ {-# LANGUAGE UndecidableInstances #-} module Pandora.Paradigm.Primary.Transformer.Tap where -import Pandora.Core.Functor (type (>))+import Pandora.Core.Functor (type (>>>>>>)) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category ((<--), (<---), (<----), (<------)) import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|-)))@@ -11,7 +11,7 @@ import Pandora.Pattern.Functor.Extendable (Extendable ((<<=), (<<==))) import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower)) import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))-import Pandora.Paradigm.Controlflow.Effect.Interpreted ((<~), (<~~~))+import Pandora.Core.Interpreted ((<~), (<~~~)) import Pandora.Paradigm.Algebraic ((<-*-), (<-||--), extract) import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), (<:*:>)) import Pandora.Paradigm.Algebraic.Exponential (type (<--), type (-->))@@ -45,6 +45,6 @@ instance Hoistable (->) Tap where 	f /|\ Tap x xs = Tap x <-- f xs -instance {-# OVERLAPS #-} Semimonoidal (-->) (:*:) (:*:) t => Semimonoidal (-->) (:*:) (:*:) (Tap (t <:.:> t > (:*:))) where+instance {-# OVERLAPS #-} Semimonoidal (-->) (:*:) (:*:) t => Semimonoidal (-->) (:*:) (:*:) (Tap (t <:.:> t >>>>>> (:*:))) where 	mult = Straight <-- \(Tap x (T_U (xls :*: xrs)) :*: Tap y (T_U (yls :*: yrs))) -> 		Tap (x :*: y) <------ (mult @(-->) <~~~ xls :*: yls) <:*:> (mult @(-->) <~~~ xrs :*: yrs)

@@ -1,5 +1,5 @@ {-# OPTIONS_GHC -fno-warn-orphans #-}-module Pandora.Paradigm.Schemes (module Exports) where+module Pandora.Paradigm.Schemes (module Exports, Schematic) where  import Pandora.Paradigm.Schemes.PQ_ as Exports import Pandora.Paradigm.Schemes.P_Q_T as Exports@@ -14,11 +14,13 @@ import Pandora.Paradigm.Schemes.TU as Exports import Pandora.Paradigm.Schemes.TT as Exports +import Pandora.Core.Interpreted (run) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category ((<--)) import Pandora.Pattern.Functor.Covariant (Covariant) import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)++type family Schematic (c :: (* -> * -> *) -> (* -> *) -> k) (t :: * -> *) = (r :: (* -> *) -> * -> *) | r -> t  instance (Covariant (->) (->) (v <:.> t), Covariant (->) (->) (u <:.> w), Adjoint (->) (->) t u, Adjoint (->) (->) v w) 	=> Adjoint (->) (->) (v <:.> t) (u <:.> w) where

@@ -1,6 +1,6 @@ module Pandora.Paradigm.Schemes.PQ_ where -import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite))  newtype PQ_ p q a b = PQ_ (p a (q b a)) 

@@ -1,6 +1,6 @@ module Pandora.Paradigm.Schemes.PTU where -import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite))  newtype PTU p t u a b = PTU (p (t a) (u b)) 

@@ -1,6 +1,6 @@ module Pandora.Paradigm.Schemes.P_Q_T where -import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite))  newtype P_Q_T (p :: * -> * -> *) (q :: * -> * -> *) (t :: * -> *) (a :: *) (b :: *) = P_Q_T (p a (q (t b) a)) 

@@ -1,6 +1,6 @@ module Pandora.Paradigm.Schemes.P_T where -import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite))  newtype P_T p t a b = P_T (p (t a) b) 

@@ -1,7 +1,8 @@ {-# LANGUAGE UndecidableInstances #-} module Pandora.Paradigm.Schemes.TT where -import Pandora.Core.Functor (type (:.), type (>), type (~>))+import Pandora.Core.Functor (type (:.), type (>), type (>>>), type (~>))+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (<~), (<~~~), (<~~~~), (=#-))) import Pandora.Pattern.Betwixt (Betwixt) import Pandora.Pattern.Semigroupoid (Semigroupoid ((.))) import Pandora.Pattern.Category (identity, (<--), (<---), (<----), (<-----))@@ -16,7 +17,6 @@ import Pandora.Pattern.Transformer.Liftable (Liftable (lift)) import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower)) import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (<~), (<~~~), (<~~~~), (=#-))) import Pandora.Paradigm.Algebraic.Exponential (type (<--), type (-->)) import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:))) import Pandora.Paradigm.Algebraic.Sum ((:+:), bitraverse_sum)@@ -25,9 +25,9 @@ import Pandora.Pattern.Morphism.Flip (Flip (Flip)) import Pandora.Pattern.Morphism.Straight (Straight (Straight)) -newtype TT ct ct' t t' a = TT (t :. t' > a)+newtype TT ct ct' t t' a = TT (t :. t' >>> a) -infixr 3 <::>, >::>, <::<, >::<+infixr 6 <::>, >::>, <::<, >::<  type (<::>) = TT Covariant Covariant type (>::>) = TT Contravariant Covariant@@ -35,7 +35,7 @@ type (>::<) = TT Contravariant Contravariant  instance Interpreted (->) (TT ct ct' t t') where-	type Primary (TT ct ct' t t') a = t :. t' > a+	type Primary (TT ct ct' t t') a = t :. t' >>> a 	run ~(TT x) = x 	unite = TT 

@@ -1,7 +1,8 @@ {-# LANGUAGE UndecidableInstances #-} module Pandora.Paradigm.Schemes.TU where -import Pandora.Core.Functor (type (:.), type (>), type (~>))+import Pandora.Core.Functor (type (:.), type (>), type (>>>), type (~>))+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (<~), (<~~~), (<~~~~), (=#-))) import Pandora.Pattern.Betwixt (Betwixt) import Pandora.Pattern.Semigroupoid (Semigroupoid ((.))) import Pandora.Pattern.Category (identity, (<--), (<---), (<----), (<-----))@@ -15,7 +16,6 @@ import Pandora.Pattern.Transformer.Liftable (Liftable (lift)) import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower)) import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (<~), (<~~~), (<~~~~), (=#-))) import Pandora.Paradigm.Algebraic.Exponential (type (<--), type (-->)) import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:))) import Pandora.Paradigm.Algebraic.Sum ((:+:))@@ -24,9 +24,9 @@ import Pandora.Pattern.Morphism.Flip (Flip (Flip)) import Pandora.Pattern.Morphism.Straight (Straight (Straight)) -newtype TU ct cu t u a = TU (t :. u > a)+newtype TU ct cu t u a = TU (t :. u >>> a) -infixr 3 <:.>, >:.>, <:.<, >:.<+infixr 6 <:.>, >:.>, <:.<, >:.<  type (<:.>) = TU Covariant Covariant type (>:.>) = TU Contravariant Covariant@@ -34,7 +34,7 @@ type (>:.<) = TU Contravariant Contravariant  instance Interpreted (->) (TU ct cu t u) where-	type Primary (TU ct cu t u) a = t :. u > a+	type Primary (TU ct cu t u) a = t :. u >>> a 	run ~(TU x) = x 	unite = TU 

@@ -1,7 +1,8 @@ {-# LANGUAGE UndecidableInstances #-} module Pandora.Paradigm.Schemes.TUT where -import Pandora.Core.Functor (type (:.), type (>), type (~>))+import Pandora.Core.Functor (type (:.), type (>), type (>>>), type (>>>>>>>>), type (~>))+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (<~), (<~~~), (=#-))) import Pandora.Pattern.Betwixt (Betwixt) import Pandora.Pattern.Semigroupoid (Semigroupoid ((.))) import Pandora.Pattern.Category (identity, (<--), (<---), (<----), (<------))@@ -22,9 +23,8 @@ import Pandora.Paradigm.Algebraic (point, extract, (<-||-)) import Pandora.Pattern.Morphism.Flip (Flip (Flip)) import Pandora.Pattern.Morphism.Straight (Straight (Straight))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (<~), (<~~~), (=#-))) -newtype TUT ct ct' cu t t' u a = TUT (t :. u :. t' > a)+newtype TUT ct ct' cu t t' u a = TUT (t :. u :. t' >>> a)  infix 3 <:<.>:>, >:<.>:>, <:<.>:<, >:<.>:<, <:>.<:>, >:>.<:>, <:>.<:<, >:>.<:< @@ -38,24 +38,24 @@ type (>:>.<:<) = TUT Contravariant Contravariant Contravariant  instance Interpreted (->) (TUT ct ct' cu t t' u) where-	type Primary (TUT ct ct' cu t t' u) a = t :. u :. t' > a+	type Primary (TUT ct ct' cu t t' u) a = t :. u :. t' >>> a 	run ~(TUT x) = x 	unite = TUT -instance (Semigroupoid m, Covariant m m t, Covariant (Betwixt (Betwixt m m) m) m t, Covariant (Betwixt m (Betwixt m m)) (Betwixt (Betwixt m m) m) u, Covariant m (Betwixt m (Betwixt m m)) t', Interpreted m (t <:<.>:> t' > u)) => Covariant m m (t <:<.>:> t' > u) where+instance (Semigroupoid m, Covariant m m t, Covariant (Betwixt (Betwixt m m) m) m t, Covariant (Betwixt m (Betwixt m m)) (Betwixt (Betwixt m m) m) u, Covariant m (Betwixt m (Betwixt m m)) t', Interpreted m (t <:<.>:> t' >>>>>>>> u)) => Covariant m m (t <:<.>:> t' >>>>>>>> u) where 	(<-|-) f = (=#-) ((<-|-|-|-) f) -instance (Adjoint (->) (->) t' t, Bindable (->) u) => Semimonoidal (-->) (:*:) (:*:) (t <:<.>:> t' > u) where+instance (Adjoint (->) (->) t' t, Bindable (->) u) => Semimonoidal (-->) (:*:) (:*:) (t <:<.>:> t' >>>>>>>> u) where 	mult = Straight <-- \(TUT x :*: TUT y) -> TUT ((((\r -> (<-|-|-|-) (r :*:) y) |-) =<<) <-|- x) -instance (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t, Covariant (->) (->) u, Semimonoidal (<--) (:*:) (:*:) u, Covariant (->) (->) t', Semimonoidal (<--) (:*:) (:*:) t') => Semimonoidal (<--) (:*:) (:*:) (t <:<.>:> t' > u) where+instance (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t, Covariant (->) (->) u, Semimonoidal (<--) (:*:) (:*:) u, Covariant (->) (->) t', Semimonoidal (<--) (:*:) (:*:) t') => Semimonoidal (<--) (:*:) (:*:) (t <:<.>:> t' >>>>>>>> u) where 	mult = Flip <-- (TUT <-||-) . (TUT <-|-) . (mult @(<--) <~) . (<-|-) (mult @(<--) <~) . (<-|-|-) @_ @(->) (mult @(<--) <~) . run -instance (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (<--) (:*:) (:*:) t, Semimonoidal (<--) (:*:) (:*:) t', Monoidal (<--) (-->) (:*:) (:*:) u, Adjoint (->) (->) t t') => Monoidal (<--) (-->) (:*:) (:*:) (t <:<.>:> t' > u) where+instance (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (<--) (:*:) (:*:) t, Semimonoidal (<--) (:*:) (:*:) t', Monoidal (<--) (-->) (:*:) (:*:) u, Adjoint (->) (->) t t') => Monoidal (<--) (-->) (:*:) (:*:) (t <:<.>:> t' >>>>>>>> u) where 	unit _ = Flip <-- \(TUT xys) -> Straight (\_ -> (extract |-) xys)  -- TODO: generalize on (->) and (:*:)-instance {-# OVERLAPS #-} (Covariant (->) (->) u, Semimonoidal (-->) (:*:) (:+:) u) => Semimonoidal (-->) (:*:) (:+:) ((->) s <:<.>:> (:*:) s > u) where+instance {-# OVERLAPS #-} (Covariant (->) (->) u, Semimonoidal (-->) (:*:) (:+:) u) => Semimonoidal (-->) (:*:) (:+:) ((->) s <:<.>:> (:*:) s >>>>>>>> u) where  mult = Straight <-- \(TUT x :*: TUT y) -> TUT 	<------ product_over_sum 		<-|-|- mult @(-->) @(:*:) @(:+:)@@ -66,19 +66,19 @@ product_over_sum (Option (s :*: x)) = s :*: Option x product_over_sum (Adoption (s :*: y)) = s :*: Adoption y -instance (Covariant (->) (->) t, Covariant (->) (->) t', Adjoint (->) (->) t' t, Bindable (->) u) => Bindable (->) (t <:<.>:> t' > u) where+instance (Covariant (->) (->) t, Covariant (->) (->) t', Adjoint (->) (->) t' t, Bindable (->) u) => Bindable (->) (t <:<.>:> t' >>>>>>>> u) where 	f =<< x = TUT <---- ((run . f |--) =<<) <-|- run x -instance (Bindable (->) u, Monoidal (-->) (-->) (:*:) (:*:) u, Adjoint (->) (->) t' t) => Monoidal (-->) (-->) (:*:) (:*:) (t <:<.>:> t' > u) where+instance (Bindable (->) u, Monoidal (-->) (-->) (:*:) (:*:) u, Adjoint (->) (->) t' t) => Monoidal (-->) (-->) (:*:) (:*:) (t <:<.>:> t' >>>>>>>> u) where 	unit _ = Straight <-- unite . (point -|) . (<~ One) -instance (Adjoint (->) (->) t' t, Extendable (->) u) => Extendable (->) (t' <:<.>:> t > u) where+instance (Adjoint (->) (->) t' t, Extendable (->) u) => Extendable (->) (t' <:<.>:> t >>>>>>>> u) where 	f <<= x = TUT <---- ((f . unite --|) <<=) <-|- run x  instance (Adjoint (->) (->) t' t, Distributive (->) (->) t) => Liftable (->) (t <:<.>:> t') where-	lift :: Covariant (->) (->) u => u ~> t <:<.>:> t' > u+	lift :: Covariant (->) (->) u => u ~> t <:<.>:> t' >>>>>>>> u 	lift x = TUT <--- (identity @(->) -|) -<< x  instance (Adjoint (->) (->) t t', Distributive (->) (->) t') => Lowerable (->) (t <:<.>:> t') where-	lower :: Covariant (->) (->) u => (t <:<.>:> t' > u) ~> u+	lower :: Covariant (->) (->) u => (t <:<.>:> t' >>>>>>>> u) ~> u 	lower (TUT x) = (identity @(->) -<<) |- x

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

@@ -1,16 +1,17 @@ {-# LANGUAGE UndecidableInstances #-} module Pandora.Paradigm.Schemes.T_U where -import Pandora.Core.Functor (type (>))+import Pandora.Core.Functor (type (>>>>>>))+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (=#-), (-#=))) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Morphism.Flip (Flip) import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|-|-))) import Pandora.Pattern.Functor.Contravariant (Contravariant ((>-|-|-)))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (=#-), (-#=)))+import Pandora.Paradigm.Algebraic.Exponential ()  newtype T_U ct cu p t u a = T_U (p (t a) (u a)) -infixr 2 <:.:>, >:.:>, <:.:<, >:.:<+infixr 5 <:.:>, >:.:>, <:.:<, >:.:<  type (<:.:>) t u p = T_U Covariant Covariant p t u type (>:.:>) t u p = T_U Contravariant Covariant p t u@@ -23,9 +24,9 @@ 	unite = T_U  -- TODO: generalize over (->)-instance (forall i . Covariant (->) (->) (p i), forall o . Covariant (->) (->) (Flip p o), Covariant (->) (->) t, Covariant (->) (->) u) => Covariant (->) (->) (t <:.:> u > p) where+instance (forall i . Covariant (->) (->) (p i), forall o . Covariant (->) (->) (Flip p o), Covariant (->) (->) t, Covariant (->) (->) u) => Covariant (->) (->) (t <:.:> u >>>>>> p) where 	f <-|- x = ((-#=) @_ @(Flip _ _) ((<-|-|-) f) . ((<-|-|-) f)) =#- x  -- TODO: generalize over (->)-instance (Contravariant (->) (->) t, forall a . Covariant (->) (->) (p (t a)), Covariant (->) (->) u, forall b . Contravariant (->) (->) (Flip p (u b))) => Covariant (->) (->) (t >:.:> u > p) where+instance (Contravariant (->) (->) t, forall a . Covariant (->) (->) (p (t a)), Covariant (->) (->) u, forall b . Contravariant (->) (->) (Flip p (u b))) => Covariant (->) (->) (t >:.:> u >>>>>> p) where 	(<-|-) f = (=#-) ((-#=) @_ @(Flip _ _) ((>-|-|-) f) . ((<-|-|-) f))

@@ -1,7 +1,8 @@ {-# LANGUAGE UndecidableInstances #-} module Pandora.Paradigm.Schemes.UT where -import Pandora.Core.Functor (type (:.), type (>), type (~>))+import Pandora.Core.Functor (type (:.), type (>>>), type (~>))+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (<~), (<~~~), (<~~~~), (=#-))) import Pandora.Pattern.Betwixt (Betwixt) import Pandora.Pattern.Semigroupoid (Semigroupoid ((.))) import Pandora.Pattern.Category (identity, (<--), (<---), (<----), (<-----))@@ -14,7 +15,6 @@ import Pandora.Pattern.Functor.Traversable (Traversable ((<<--))) import Pandora.Pattern.Transformer.Liftable (Liftable (lift)) import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (<~), (<~~~), (<~~~~), (=#-))) import Pandora.Paradigm.Algebraic.Exponential (type (<--), type (-->)) import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:))) import Pandora.Paradigm.Algebraic.Sum ((:+:))@@ -22,7 +22,7 @@ import Pandora.Paradigm.Algebraic (point, extract, (<-||-), (<-||---)) import Pandora.Pattern.Morphism.Flip (Flip (Flip)) -newtype UT ct cu t u a = UT (u :. t > a)+newtype UT ct cu t u a = UT (u :. t >>> a)  infixr 3 <.:>, >.:>, <.:<, >.:< @@ -32,7 +32,7 @@ type (>.:<) = UT Contravariant Contravariant  instance Interpreted (->) (UT ct cu t u) where-	type Primary (UT ct cu t u) a = u :. t > a+	type Primary (UT ct cu t u) a = u :. t >>> a 	run ~(UT x) = x 	unite = UT 

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

@@ -1,6 +1,6 @@ module Pandora.Paradigm.Schemes.U_T where -import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite))  newtype U_T ct cu t p u a = U_T (p (u a) (t a)) 

@@ -7,6 +7,7 @@ import Pandora.Paradigm.Structure.Modification as Exports import Pandora.Paradigm.Structure.Some as Exports +import Pandora.Core.Interpreted (run, (<~)) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category ((<--), (<---), identity) import Pandora.Pattern.Kernel (constant)@@ -14,7 +15,6 @@ import Pandora.Pattern.Transformer.Liftable (lift) import Pandora.Pattern.Transformer.Lowerable (lower) import Pandora.Pattern.Object.Semigroup ((+))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (<~)) import Pandora.Paradigm.Inventory.Some.Optics () import Pandora.Paradigm.Inventory.Some.Store (Store (Store)) import Pandora.Paradigm.Algebraic.Exponential ((%))@@ -24,7 +24,7 @@ import Pandora.Paradigm.Primary.Functor.Exactly (Exactly (Exactly)) import Pandora.Paradigm.Primary.Functor.Conclusion (Conclusion (Failure, Success), conclusion) import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))-import Pandora.Paradigm.Primary.Functor.Wye (Wye (Both, Left, Right, End))+import Pandora.Paradigm.Primary.Functor.Wye (Wye (Both, Left_, Right_, End)) import Pandora.Paradigm.Primary.Functor.Wedge (Wedge (Nowhere, Here, There)) import Pandora.Paradigm.Primary.Functor.These (These (This, That, These)) import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct))@@ -52,18 +52,18 @@ 	morphing (run . premorph -> Just x) = TU <-- \_ -> Flip <-- Failure x 	morphing (run . premorph -> Nothing) = TU <-- Flip . Success -instance Morphable (Into (Left Maybe)) Wye where-	type Morphing (Into (Left Maybe)) Wye = Maybe+instance Morphable (Into (Left_ Maybe)) Wye where+	type Morphing (Into (Left_ Maybe)) Wye = Maybe 	morphing (premorph -> Both ls _) = Just ls-	morphing (premorph -> Left ls) = Just ls-	morphing (premorph -> Right _) = Nothing+	morphing (premorph -> Left_ ls) = Just ls+	morphing (premorph -> Right_ _) = Nothing 	morphing (premorph -> End) = Nothing -instance Morphable (Into (Right Maybe)) Wye where-	type Morphing (Into (Right Maybe)) Wye = Maybe+instance Morphable (Into (Right_ Maybe)) Wye where+	type Morphing (Into (Right_ Maybe)) Wye = Maybe 	morphing (premorph -> Both _ rs) = Just rs-	morphing (premorph -> Left _) = Nothing-	morphing (premorph -> Right rs) = Just rs+	morphing (premorph -> Left_ _) = Nothing+	morphing (premorph -> Right_ rs) = Just rs 	morphing (premorph -> End) = Nothing  instance Morphable (Into (This Maybe)) (These e) where@@ -93,25 +93,25 @@ instance Morphable (Into Wye) (Maybe <:*:> Maybe) where 	type Morphing (Into Wye) (Maybe <:*:> Maybe) = Wye 	morphing (run . premorph -> Just x :*: Just y) = Both x y-	morphing (run . premorph -> Nothing :*: Just y) = Right y-	morphing (run . premorph -> Just x :*: Nothing) = Left x+	morphing (run . premorph -> Nothing :*: Just y) = Right_ y+	morphing (run . premorph -> Just x :*: Nothing) = Left_ x 	morphing (run . premorph -> Nothing :*: Nothing) = End -instance Substructure Left Wye where-	type Substance Left Wye = Maybe+instance Substructure Left_ Wye where+	type Substance Left_ Wye = Maybe 	substructure = P_Q_T <-- \new -> case lower new of-		End -> Store <--- Nothing :*: lift . resolve Left End-		Left x -> Store <--- Just x :*: lift . resolve Left End-		Right y -> Store <--- Nothing :*: lift . constant (Right y)-		Both x y -> Store <--- Just x :*: lift . resolve (Both % y) (Right y)+		End -> Store <--- Nothing :*: lift . resolve Left_ End+		Left_ x -> Store <--- Just x :*: lift . resolve Left_ End+		Right_ y -> Store <--- Nothing :*: lift . constant (Right_ y)+		Both x y -> Store <--- Just x :*: lift . resolve (Both % y) (Right_ y) -instance Substructure Right Wye where-	type Substance Right Wye = Maybe+instance Substructure Right_ Wye where+	type Substance Right_ Wye = Maybe 	substructure = P_Q_T <-- \new -> case lower new of-		End -> Store <--- Nothing :*: lift . resolve Right End-		Left x -> Store <--- Nothing :*: lift . constant (Left x)-		Right y -> Store <--- Just y :*: lift . resolve Right End-		Both x y -> Store <--- Just y :*: lift . resolve (Both x) (Left x)+		End -> Store <--- Nothing :*: lift . resolve Right_ End+		Left_ x -> Store <--- Nothing :*: lift . constant (Left_ x)+		Right_ y -> Store <--- Just y :*: lift . resolve Right_ End+		Both x y -> Store <--- Just y :*: lift . resolve (Both x) (Left_ x)  instance (Covariant (->) (->) t) => Substructure Rest (Tap t) where 	type Substance Rest (Tap t) = t@@ -122,37 +122,37 @@ 	type Morphing (Into (Preorder (Construction Maybe))) (Construction Wye) = Construction Maybe 	morphing nonempty_binary = case premorph nonempty_binary of 		Construct x End -> Construct x Nothing-		Construct x (Left lst) -> Construct x . Just <-- into @(Preorder (Nonempty List)) lst-		Construct x (Right rst) -> Construct x . Just <-- into @(Preorder (Nonempty List)) rst+		Construct x (Left_ lst) -> Construct x . Just <-- into @(Preorder (Nonempty List)) lst+		Construct x (Right_ rst) -> Construct x . Just <-- into @(Preorder (Nonempty List)) rst 		Construct x (Both lst rst) -> Construct x . Just <-- into @(Preorder (Nonempty List)) lst + into @(Preorder (Nonempty List)) rst  instance Morphable (Into (Inorder (Construction Maybe))) (Construction Wye) where 	type Morphing (Into (Inorder (Construction Maybe))) (Construction Wye) = Construction Maybe 	morphing nonempty_binary = case premorph nonempty_binary of 		Construct x End -> Construct x Nothing-		Construct x (Left lst) -> into @(Inorder (Nonempty List)) lst + Construct x Nothing-		Construct x (Right rst) -> Construct x Nothing + into @(Inorder (Nonempty List)) rst+		Construct x (Left_ lst) -> into @(Inorder (Nonempty List)) lst + Construct x Nothing+		Construct x (Right_ rst) -> Construct x Nothing + into @(Inorder (Nonempty List)) rst 		Construct x (Both lst rst) -> into @(Inorder (Nonempty List)) lst + Construct x Nothing + into @(Inorder (Nonempty List)) rst  instance Morphable (Into (Postorder (Construction Maybe))) (Construction Wye) where 	type Morphing (Into (Postorder (Construction Maybe))) (Construction Wye) = Construction Maybe 	morphing nonempty_binary = case premorph nonempty_binary of 		Construct x End -> Construct x Nothing-		Construct x (Left lst) -> into @(Postorder (Nonempty List)) lst + Construct x Nothing-		Construct x (Right rst) -> into @(Postorder (Nonempty List)) rst + Construct x Nothing+		Construct x (Left_ lst) -> into @(Postorder (Nonempty List)) lst + Construct x Nothing+		Construct x (Right_ rst) -> into @(Postorder (Nonempty List)) rst + Construct x Nothing 		Construct x (Both lst rst) -> into @(Postorder (Nonempty List)) lst + into @(Postorder (Nonempty List)) rst + Construct x Nothing  -- instance Morphable (Into (o ds)) (Construction Wye) => Morphable (Into (o ds)) Binary where 	-- type Morphing (Into (o ds)) Binary = Maybe <:.> Morphing (Into (o ds)) (Construction Wye) 	-- morphing (premorph -> xs) = (into @(o ds) <-|-) =#- xs -instance Substructure Left (Flip (:*:) a) where-	type Substance Left (Flip (:*:) a) = Exactly+instance Substructure Left_ (Flip (:*:) a) where+	type Substance Left_ (Flip (:*:) a) = Exactly 	substructure = P_Q_T <-- \product -> case run <-- lower product of 		s :*: x -> Store <--- Exactly s :*: lift . Flip . (:*: x) . extract -instance Substructure Right ((:*:) s) where-	type Substance Right ((:*:) s) = Exactly+instance Substructure Right_ ((:*:) s) where+	type Substance Right_ ((:*:) s) = Exactly 	substructure = P_Q_T <-- \product -> case lower product of 		s :*: x -> Store <--- Exactly x :*: lift . (s :*:) . extract 

@@ -1,8 +1,8 @@ module Pandora.Paradigm.Structure.Ability (module Exports) where +import Pandora.Paradigm.Structure.Ability.Slidable as Exports import Pandora.Paradigm.Structure.Ability.Monotonic as Exports import Pandora.Paradigm.Structure.Ability.Substructure as Exports import Pandora.Paradigm.Structure.Ability.Morphable as Exports import Pandora.Paradigm.Structure.Ability.Possible as Exports import Pandora.Paradigm.Structure.Ability.Accessible as Exports-import Pandora.Paradigm.Structure.Ability.Nonempty as Exports

@@ -1,7 +1,8 @@ {-# LANGUAGE AllowAmbiguousTypes #-} module Pandora.Paradigm.Structure.Ability.Morphable where -import Pandora.Core.Functor (type (>), type (~>), type (:=:=>))+import Pandora.Core.Functor (type (>>>>>>), type (>>>>>>>), type (~>), type (:=:=>))+import Pandora.Core.Interpreted (run) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category ((<--)) import Pandora.Pattern.Object.Chain (Chain ((<=>)))@@ -14,7 +15,6 @@ import Pandora.Paradigm.Primary.Functor.Maybe (Maybe) import Pandora.Paradigm.Primary.Functor.Predicate (Predicate, equate) import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run) import Pandora.Paradigm.Schemes.TT (TT (TT), type (<::>)) import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>)) @@ -37,36 +37,32 @@  data Occurrence a = All a | First a -data Vertical a = Up a | Down a--data Horizontal a = Leftward a | Rightward a- rotate :: forall mod struct . Morphable (Rotate mod) struct => struct ~> Morphing (Rotate mod) struct rotate = morphing . TT . Tag @(Rotate mod)  into :: forall mod struct . Morphable (Into mod) struct => struct ~> Morphing (Into mod) struct into = morphing . TT . Tag @(Into mod) -insert :: forall mod struct a . Morphed (Insert mod) struct (Exactly <:.:> struct > (->)) => a :=:=> struct+insert :: forall mod struct a . Morphed (Insert mod) struct (Exactly <:.:> struct >>>>>> (->)) => a :=:=> struct insert new xs = run <-- morph @(Insert mod) xs <-- Exactly new -item :: forall mod struct a . Morphed mod struct (Exactly <:.:> struct > (->)) => a :=:=> struct+item :: forall mod struct a . Morphed mod struct (Exactly <:.:> struct >>>>>> (->)) => a :=:=> struct item new xs = run <-- morph @mod xs <-- Exactly new -collate :: forall mod struct a . (Chain a, Morphed mod struct ((Exactly <:.:> Comparison > (:*:)) <:.:> struct > (->))) => a :=:=> struct+collate :: forall mod struct a . (Chain a, Morphed mod struct ((Exactly <:.:> Comparison >>>>>> (:*:)) <:.:> struct >>>>>> (->))) => a :=:=> struct collate new xs = run <-- morph @mod xs <-- T_U (Exactly new :*: Convergence (<=>)) -delete :: forall mod struct a . (Setoid a, Morphed (Delete mod) struct (Predicate <:.:> struct > (->))) => a :=:=> struct+delete :: forall mod struct a . (Setoid a, Morphed (Delete mod) struct (Predicate <:.:> struct >>>>>> (->))) => a :=:=> struct delete x xs = run <-- morph @(Delete mod) xs <-- equate x -filter :: forall mod struct a . (Morphed (Delete mod) struct (Predicate <:.:> struct > (->))) => Predicate a -> struct a -> struct a+filter :: forall mod struct a . (Morphed (Delete mod) struct (Predicate <:.:> struct >>>>>> (->))) => Predicate a -> struct a -> struct a filter p xs = run <-- morph @(Delete mod) xs <-- p -find :: forall mod struct result a . (Morphed (Find mod) struct (Predicate <:.:> result > (->))) => Predicate a -> struct a -> result a+find :: forall mod struct result a . (Morphed (Find mod) struct (Predicate <:.:> result >>>>>> (->))) => Predicate a -> struct a -> result a find p xs = run <-- morph @(Find mod) xs <-- p  lookup :: forall mod key struct a . (Morphed (Lookup mod) struct ((->) key <::> Maybe)) => key -> struct a -> Maybe a lookup key struct = run <-- morph @(Lookup mod) struct <-- key -vary :: forall mod key value struct . (Morphed (Vary mod) struct (((:*:) key <::> Exactly) <:.:> struct > (->))) => key -> value -> struct value -> struct value+vary :: forall mod key value struct . (Morphed (Vary mod) struct (((:*:) key <::> Exactly) <:.:> struct >>>>>>> (->))) => key -> value -> struct value -> struct value vary key value xs = run <-- morph @(Vary mod) @struct xs <-- TT (key :*: Exactly value)

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

@@ -0,0 +1,10 @@+{-# LANGUAGE AllowAmbiguousTypes #-}+module Pandora.Paradigm.Structure.Ability.Slidable where++import Pandora.Core.Functor (type (>>>), type (<))+import Pandora.Paradigm.Controlflow.Effect.Transformer ((:>))+import Pandora.Paradigm.Inventory.Some.State (State)++class Slidable d (s :: * -> *) where+	type Sliding d s :: * -> *+	slide :: State < s e :> Sliding d s >>> ()

@@ -2,20 +2,20 @@ {-# LANGUAGE UndecidableInstances #-} module Pandora.Paradigm.Structure.Ability.Substructure where +import Pandora.Core.Interpreted (run, unite, (=#-)) import Pandora.Pattern.Semigroupoid (Semigroupoid ((.))) import Pandora.Pattern.Category ((<--), (<---), (<----)) import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-|-))) import Pandora.Pattern.Transformer.Liftable (lift) import Pandora.Pattern.Transformer.Lowerable (lower)-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, unite, (=#-)) import Pandora.Paradigm.Inventory.Some.Store (Store (Store)) import Pandora.Paradigm.Inventory.Some.Optics (type (@>>>), view, replace) import Pandora.Paradigm.Algebraic.Exponential ((%)) import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), type (<:*:>), (<:*:>)) import Pandora.Paradigm.Algebraic ((>-||-), extract)+import Pandora.Paradigm.Primary.Auxiliary (Horizontal (Left, Right)) import Pandora.Paradigm.Primary.Functor.Exactly (Exactly (Exactly)) import Pandora.Paradigm.Primary.Functor.Tagged (Tagged)-import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right)) import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct)) import Pandora.Paradigm.Schemes.TU (type (<:.>)) import Pandora.Paradigm.Schemes.TT (type (<::>))@@ -45,6 +45,14 @@ 		ls :*: rs -> Store <--- rs :*: lift . (ls <:*:>)  data Segment a = Root a | Rest a | Branch a | Ancestors a | Forest a++instance Covariant (->) (->) t => Substructure Root (Exactly <:*:> t) where+	type Substance Root (Exactly <:*:> t) = Exactly+	substructure = (lower >-||-) . (lift @(->) <-|-|-) =#- sub @Left++instance Covariant (->) (->) t => Substructure Rest (Exactly <:*:> t) where+	type Substance Rest (Exactly <:*:> t) = t+	substructure = (lower >-||-) . (lift @(->) <-|-|-) =#- sub @Right  instance Covariant (->) (->) t => Substructure Root (Construction t) where 	type Substance Root (Construction t) = Exactly

@@ -1,7 +1,8 @@ {-# LANGUAGE AllowAmbiguousTypes #-} module Pandora.Paradigm.Structure.Interface.Set where -import Pandora.Core.Functor (type (>))+import Pandora.Core.Functor (type (>), type (>>>>>>))+import Pandora.Core.Interpreted ((<~~)) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category ((<--), (<---)) import Pandora.Pattern.Kernel (constant)@@ -21,11 +22,10 @@ import Pandora.Paradigm.Inventory.Ability.Modifiable (modify) import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing), Morph (Find), find) import Pandora.Paradigm.Inventory.Some.State (State)-import Pandora.Paradigm.Controlflow.Effect ((<~~))  type Set t f a = (Traversable (->) (->) t, Setoid a, Setoid (t a), Morphable (Find f) t) -subset :: forall t f a . (Set t f a, Morphing (Find f) t ~ (Predicate <:.:> Maybe > (->))) => Convergence Boolean > t a+subset :: forall t f a . (Set t f a, Morphing (Find f) t ~ (Predicate <:.:> Maybe >>>>>> (->))) => Convergence Boolean > t a subset = Convergence <-- \s ss -> Nothing != ((find @f @t @Maybe % s) . equate <<- ss)  cardinality :: Traversable (->) (->) t => t a -> Numerator

@@ -1,6 +1,7 @@ {-# LANGUAGE AllowAmbiguousTypes #-} module Pandora.Paradigm.Structure.Interface.Stack where +import Pandora.Core.Functor (type (<), type (<<)) import Pandora.Paradigm.Primary.Functor.Maybe (Maybe) import Pandora.Paradigm.Inventory.Some.State (State) import Pandora.Paradigm.Inventory.Some.Optics (Lens)@@ -10,11 +11,8 @@ > * Idempotency: item @Push x . morph @Pop ≡ identity -} -class Stack t where-	type Topping t :: * -> *-	type Popping t :: * -> *-	type Pushing t :: * -> *-	top :: Lens (Topping t) (t e) e-	-- TODO: In case of nonempty list we know that we return an element-	pop :: State ((Popping t) e) (Maybe e)-	push :: e -> State ((Pushing t) e) e+class Stack structure where+	type Topping structure :: * -> *+	top :: Lens < Topping structure < structure e < e+	pop :: State < structure e < Topping structure e+	push :: e -> State < structure e < e

@@ -4,6 +4,7 @@ module Pandora.Paradigm.Structure.Interface.Zipper where  import Pandora.Core.Functor (type (>), type (<), type (:.), type (:::))+import Pandora.Core.Interpreted (run, unite, (<~), (=#-)) import Pandora.Core.Impliable (Impliable (Arguments, imply)) import Pandora.Pattern.Morphism.Flip (Flip (Flip)) import Pandora.Pattern.Morphism.Straight (Straight (Straight))@@ -27,14 +28,12 @@ import Pandora.Paradigm.Inventory.Some.Store (Store (Store)) import Pandora.Paradigm.Structure.Ability.Morphable (Morphable, Morph (Rotate)) import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substance, substructure, sub), Segment (Root, Rest))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, unite, (<~), (=#-)) +-- TODO: Use Slidable superclass with Slides associated type family class Zippable (structure :: * -> *) where 	type Breadcrumbs structure :: * -> * -type Zipper (structure :: * -> *) = Tagged (Zippable structure) <:.> (Exactly <:*:> Breadcrumbs structure)--type Breadcrumbed structure t = (Zippable structure, Breadcrumbs structure ~ t)+type Zipper (structure :: * -> *) = Exactly <:*:> Breadcrumbs structure  instance {-# OVERLAPS #-} Semimonoidal (<--) (:*:) (:*:) t 	=> Semimonoidal (<--) (:*:) (:*:) (Exactly <:*:> t) where@@ -44,11 +43,6 @@  instance {-# OVERLAPS #-} Semimonoidal (<--) (:*:) (:*:) t => Monoidal (<--) (-->) (:*:) (:*:) (Exactly <:*:> t) where 	unit _ = Flip <-- \(T_U (Exactly x :*: _)) -> Straight (\_ -> x)--instance Covariant (->) (->) t => Substructure Root (Tagged (Zippable structure) <:.> (Exactly <:*:> t)) where-	type Substance Root (Tagged (Zippable structure) <:.> (Exactly <:*:> t)) = Exactly-	substructure = P_Q_T <-- \source -> case lower . lower <-- source of-		T_U (Exactly x :*: xs) -> Store <--- Exactly x :*: lift . lift . (<:*:> xs)  type family Fastenable structure rs where 	Fastenable structure (r ::: rs) = (Morphable < Rotate r < structure, Fastenable structure rs)

@@ -3,5 +3,6 @@ import Pandora.Paradigm.Structure.Modification.Turnover as Exports import Pandora.Paradigm.Structure.Modification.Tape as Exports import Pandora.Paradigm.Structure.Modification.Prefixed as Exports+import Pandora.Paradigm.Structure.Modification.Nonempty as Exports import Pandora.Paradigm.Structure.Modification.Comprehension as Exports import Pandora.Paradigm.Structure.Modification.Combinative as Exports

@@ -2,7 +2,8 @@ {-# LANGUAGE UndecidableInstances #-} module Pandora.Paradigm.Structure.Modification.Comprehension where -import Pandora.Core.Functor (type (>))+import Pandora.Core.Functor (type (>), type (>>>>>), type (>>>>>>))+import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (<~))) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category ((<--), (<---), (<----)) import Pandora.Pattern.Morphism.Straight (Straight (Straight))@@ -17,7 +18,6 @@ import Pandora.Pattern.Object.Setoid (Setoid ((==))) import Pandora.Paradigm.Primary.Functor.Exactly (Exactly (Exactly)) import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (<~))) import Pandora.Paradigm.Schemes.TT (TT (TT), type (<::>)) import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>)) import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), Morph (Push), premorph)@@ -26,10 +26,10 @@ import Pandora.Paradigm.Algebraic.Sum ((:+:)) import Pandora.Paradigm.Algebraic (empty, (<-|-<-|-)) -newtype Comprehension t a = Comprehension (t <::> Construction t > a)+newtype Comprehension t a = Comprehension (t <::> Construction t >>>>> a)  instance Interpreted (->) (Comprehension t) where-	type Primary (Comprehension t) a = t <::> Construction t > a+	type Primary (Comprehension t) a = t <::> Construction t >>>>> a 	run ~(Comprehension x) = x 	unite = Comprehension @@ -45,18 +45,18 @@ instance (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t, Semimonoidal (-->) (:*:) (:*:) (Construction t), Semimonoidal (-->) (:*:) (:+:) t, Semimonoidal (-->) (:*:) (:+:) (Construction t), Monoidal (-->) (-->) (:*:) (:+:) t) => Monoidal (-->) (-->) (:*:) (:+:) (Comprehension t) where 	unit _ = Straight <-- \_ -> Comprehension empty -instance (forall a . Semigroup (t <::> Construction t > a), Bindable (->) t) => Bindable (->) (Comprehension t) where+instance (forall a . Semigroup (t <::> Construction t >>>>> a), Bindable (->) t) => Bindable (->) (Comprehension t) where 	f =<< Comprehension (TT t) = Comprehension . TT <--- (\(Construct x xs) -> run . run @(->) <-- f x + (f ==<< Comprehension <-- TT xs)) =<< t -instance Setoid (t <::> Construction t > a) => Setoid (Comprehension t a) where+instance Setoid (t <::> Construction t >>>>> a) => Setoid (Comprehension t a) where 	Comprehension ls == Comprehension rs = ls == rs -instance Semigroup (t <::> Construction t > a) => Semigroup (Comprehension t a) where+instance Semigroup (t <::> Construction t >>>>> a) => Semigroup (Comprehension t a) where 	Comprehension x + Comprehension y = Comprehension <---- x + y -instance Monoid (t <::> Construction t > a) => Monoid (Comprehension t a) where+instance Monoid (t <::> Construction t >>>>> a) => Monoid (Comprehension t a) where 	zero = Comprehension zero  instance (Covariant (->) (->) t, Monoidal (-->) (-->) (:*:) (:*:) t) => Morphable Push (Comprehension t) where-	type Morphing Push (Comprehension t) = Exactly <:.:> Comprehension t > (->)+	type Morphing Push (Comprehension t) = Exactly <:.:> Comprehension t >>>>>> (->) 	morphing (run . premorph -> xs) = T_U <-- \(Exactly x) -> Comprehension . lift . Construct x . run <-- xs

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

@@ -1,33 +1,6 @@-{-# OPTIONS_GHC -fno-warn-orphans #-}-{-# LANGUAGE UndecidableInstances #-} module Pandora.Paradigm.Structure.Modification.Prefixed where -import Pandora.Core.Functor (type (:.), type (>))-import Pandora.Pattern.Semigroupoid ((.))-import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|----), (<-|-|-)))-import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (<<-<<-))-import Pandora.Paradigm.Algebraic (extract)+import Pandora.Paradigm.Schemes (type (<::>)) import Pandora.Paradigm.Algebraic.Product ((:*:))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (=#-)))-import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), Morph (Into), premorph)-import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty) -newtype Prefixed t k a = Prefixed (t :. (:*:) k > a)--instance Interpreted (->) (Prefixed t k) where-	type Primary (Prefixed t k) a = t :. (:*:) k > a-	run ~(Prefixed x) = x-	unite = Prefixed---- TODO: Try to generalize (->) here-instance Covariant (->) (->) t => Covariant (->) (->) (Prefixed t k) where-	(<-|-) f = (=#-) (f <-|-|-)--instance Traversable (->) (->) t => Traversable (->) (->) (Prefixed t k) where-	f <<- Prefixed x = Prefixed <-|---- f <<-<<- x--instance Covariant (->) (->) t => Morphable (Into t) (Prefixed t k) where-	type Morphing (Into t) (Prefixed t k) = t-	morphing (run . premorph -> prefixed) = extract <-|- prefixed--type instance Nonempty (Prefixed t k) = Prefixed (Nonempty t) k+type Prefixed t k = t <::> (:*:) k

@@ -1,78 +1,93 @@ {-# OPTIONS_GHC -fno-warn-orphans #-}+{-# LANGUAGE UndecidableInstances #-} module Pandora.Paradigm.Structure.Modification.Tape where +import Pandora.Core.Functor (type (>), type (>>>)) import Pandora.Core.Impliable (Impliable (Arguments, imply))+import Pandora.Core.Interpreted (run, (=#-)) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category ((<--), (<---), (<----), (<------))-import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|--), (<-|---)))+import Pandora.Pattern.Kernel (constant)+import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|--))) import Pandora.Pattern.Functor.Traversable (Traversable ((<<-), (<<---)))+import Pandora.Pattern.Functor.Bindable (Bindable ((====<<))) import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))-import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))+import Pandora.Pattern.Functor.Monoidal (Monoidal) import Pandora.Pattern.Transformer.Liftable (lift) import Pandora.Pattern.Transformer.Lowerable (lower)-import Pandora.Paradigm.Algebraic.Exponential (type (<--), type (-->), (%))+import Pandora.Paradigm.Algebraic.Exponential (type (-->), (%)) import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), type (<:*:>), (<:*:>))-import Pandora.Paradigm.Algebraic ((<-*-), (<-*--), (<-*---), (.-*-), extract, point)-import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))+import Pandora.Paradigm.Algebraic.Functor ((<-*--), extract, point, void) import Pandora.Paradigm.Schemes.TT (TT (TT), type (<::>))-import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))+import Pandora.Paradigm.Schemes.T_U (T_U (T_U)) import Pandora.Paradigm.Schemes.P_Q_T (P_Q_T (P_Q_T))+import Pandora.Paradigm.Primary.Auxiliary (Vertical (Up, Down), Horizontal (Left, Right)) import Pandora.Paradigm.Primary.Functor.Exactly (Exactly (Exactly))-import Pandora.Paradigm.Primary.Functor.Tagged (Tagged)-import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right)) import Pandora.Paradigm.Primary.Transformer.Reverse (Reverse (Reverse))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, unite, (<~), (=#-))-import Pandora.Paradigm.Structure.Ability.Morphable (Morphable, Morph (Rotate), Vertical (Up, Down), Occurrence (All))-import Pandora.Paradigm.Structure.Interface.Zipper (Zippable)-import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substance, substructure), Segment (Root), sub)+import Pandora.Paradigm.Controlflow.Effect.Adaptable (adapt)+import Pandora.Paradigm.Controlflow.Effect.Transformer ((:>), wrap)+import Pandora.Paradigm.Structure.Ability.Morphable (Occurrence (All))+import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substance, substructure), Segment (Root, Rest), sub)+import Pandora.Paradigm.Structure.Ability.Slidable (Slidable (Sliding, slide))+import Pandora.Paradigm.Structure.Interface.Stack (Stack (Topping, push, pop))+import Pandora.Paradigm.Inventory.Some.State (State, change) import Pandora.Paradigm.Inventory.Some.Store (Store (Store))-import Pandora.Paradigm.Inventory.Some.Optics (Lens, Convex, view, replace, mutate)+import Pandora.Paradigm.Inventory.Some.Optics (view, replace, mutate, transwrap)+import Pandora.Paradigm.Inventory (zoom, overlook) -type Tape structure = Tagged (Zippable structure)-	<:.> (Exactly <:*:> Reverse structure <:*:> structure)+type Tape structure = Exactly <:*:> Reverse structure <:*:> structure -instance {-# OVERLAPS #-} Traversable (->) (->) t => Traversable (->) (->) (Tape t) where-	f <<- z = (\ls x rs -> lift <------ x <:*:> ls <:*:> rs)-		<-|--- f <<--- view <-- sub @Left <-- z-		<-*--- f <<--- view <-- sub @Root <-- z-		<-*--- f <<--- view <-- sub @Right <-- z+-- TODO: No overlapping, let's use wrappers instead+-- instance {-# OVERLAPS #-} Traversable (->) (->) t => Traversable (->) (->) (Tape t) where+-- 	f <<- z = (\ls x rs -> lift <------ x <:*:> ls <:*:> rs)+-- 		<-|--- f <<--- view <-- sub @Left <-- z+-- 		<-*--- f <<--- view <-- sub @Root <-- z+-- 		<-*--- f <<--- view <-- sub @Right <-- z  instance Covariant (->) (->) t => Impliable (Tape t a) where 	type Arguments (Tape t a) = a -> t a -> t a -> Tape t a-	imply focused left right = lift <------ Exactly focused <:*:> Reverse left <:*:> right--instance Covariant (->) (->) t => Substructure Left (Tape t) where-	type Substance Left (Tape t) = Reverse t-	substructure = P_Q_T <-- \zipper -> case run . lower <-- lower zipper of-		Exactly x :*: T_U (ls :*: rs) -> Store <--- ls :*: lift . (imply @(Tape t _) x % rs) . run--instance Covariant (->) (->) t => Substructure Right (Tape t) where-	type Substance Right (Tape t) = t-	substructure = P_Q_T <-- \zipper -> case run . lower <-- lower zipper of-		Exactly x :*: T_U (Reverse ls :*: rs) -> Store <--- rs :*: lift . imply @(Tape t _) x ls+	imply focused left right = Exactly focused <:*:> Reverse left <:*:> right  instance Covariant (->) (->) t => Substructure Up (Tape t <::> Tape t) where 	type Substance Up (Tape t <::> Tape t) = t <::> Tape t-	substructure = P_Q_T <-- \x -> case run . lower . run . lower <-- x of+	substructure = P_Q_T <-- \x -> case run . run . lower <-- x of 		Exactly focused :*: T_U (Reverse d :*: u) -> 			Store <--- TT u :*: lift . TT . imply @(Tape t _) focused d . run  instance Covariant (->) (->) t => Substructure Down (Tape t <::> Tape t) where 	type Substance Down (Tape t <::> Tape t) = Reverse t <::> Tape t-	substructure = P_Q_T <-- \ii -> case run . lower . run . lower <-- ii of+	substructure = P_Q_T <-- \ii -> case run . run . lower <-- ii of 		Exactly focused :*: T_U (d :*: u) -> 			Store <--- TT d :*: lift . TT . (imply @(Tape t _) focused % u) . run . run  instance (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t) => Substructure (All Left) (Tape t <::> Tape t) where 	type Substance (All Left) (Tape t <::> Tape t) = Tape t <::> Reverse t 	substructure = P_Q_T <-- \source ->-		let target = (view (sub @Left) <-|-) =#- lower source in-		let updated new = replace % sub @Left <-|-- new <-*-- run <-- lower source in+		let target = (view (sub @Left) . view (sub @Rest) <-|-) =#- lower source in+		let updated new = (\trg src -> mutate (replace <-- trg <-- sub @Left) <-- sub @Rest <-- src) <-|-- new <-*-- run <-- lower source in 		Store <--- target :*: lift . (updated =#-)  instance (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t) => Substructure (All Right) (Tape t <::> Tape t) where 	type Substance (All Right) (Tape t <::> Tape t) = Tape t <::> t 	substructure = P_Q_T <-- \source ->-		let target = (view (sub @Right) <-|-) =#- lower source in-		let updated new = replace % sub @Right <-|-- new <-*-- run <-- lower source in-			Store <--- target :*: lift . (updated =#-)+		let target = (view (sub @Right) . view (sub @Rest) <-|-) =#- lower source in+		let updated new = (\trg src -> mutate (replace <-- trg <-- sub @Right) <-- sub @Rest <-- src) <-|-- new <-*-- run <-- lower source in+		Store <--- target :*: lift . (updated =#-)++instance (Covariant (->) (->) structure, Bindable (->) (Topping structure), Monoidal (-->) (-->) (:*:) (:*:) (Topping structure), Stack structure) => Slidable Left (Tape structure) where+	type Sliding Left (Tape structure) = Topping structure+	slide :: forall e . State > Tape structure e :> Topping structure >>> ()+	slide = void . wrap . zoom @(Tape structure e) (sub @Rest)+		. zoom (sub @Left) . zoom transwrap . push @structure . extract+			====<< wrap . zoom @(Tape structure e) (sub @Root) . overlook . change . constant+				====<< lift ====<< wrap <---- zoom @(Tape structure e) <--- sub @Rest+					<--- zoom <-- sub @Right <-- pop @structure++instance (Covariant (->) (->) structure, Stack structure, Bindable (->) (Topping structure), Monoidal (-->) (-->) (:*:) (:*:) (Topping structure)) => Slidable Right (Tape structure) where+	type Sliding Right (Tape structure) = Topping structure+	slide :: forall e . State > Tape structure e :> Topping structure >>> ()+	slide = void . wrap . zoom @(Tape structure e) (sub @Rest)+		. zoom (sub @Right) . push . extract+			====<< wrap . zoom @(Tape structure e) (sub @Root) . overlook . change . constant+				====<< lift ====<< wrap <---- zoom @(Tape structure e) <--- sub @Rest+					<--- zoom <-- sub @Left <-- zoom transwrap pop

@@ -1,11 +1,11 @@ {-# LANGUAGE UndecidableInstances #-} module Pandora.Paradigm.Structure.Modification.Turnover where +import Pandora.Core.Interpreted (Interpreted (Primary, run, unite, (=#-))) import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-))) import Pandora.Pattern.Transformer.Hoistable ((/|\)) import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:))) import Pandora.Paradigm.Algebraic ((>-|-<-|-))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (=#-))) import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substance, substructure))  newtype Turnover t a = Turnover (t a)

@@ -1,7 +1,8 @@ {-# OPTIONS_GHC -fno-warn-orphans #-} module Pandora.Paradigm.Structure.Some.Binary where -import Pandora.Core.Functor (type (~>), type (>), type (<), type (:=>))+import Pandora.Core.Functor (type (~>), type (>), type (>>>>>>), type (<), type (:=>))+import Pandora.Core.Interpreted (run, (<~)) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category ((<--), (<---), (<----), (<-----), (-->), (--->)) import Pandora.Pattern.Kernel (constant)@@ -14,27 +15,27 @@ import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), type (<:*:>), (<:*:>), attached) import Pandora.Paradigm.Algebraic.Exponential ((%), (&), (.:..)) import Pandora.Paradigm.Algebraic ((<-*-), (<-*--), (<-*-*-), extract, point, empty)+import Pandora.Paradigm.Primary.Auxiliary (Vertical (Up, Down), Horizontal (Left, Right)) import Pandora.Paradigm.Primary.Object.Ordering (order)+import Pandora.Paradigm.Primary.Auxiliary (Horizontal (Left, Right)) import Pandora.Paradigm.Primary.Functor (Comparison) import Pandora.Paradigm.Primary.Functor.Convergence (Convergence (Convergence)) import Pandora.Paradigm.Primary.Functor.Exactly (Exactly (Exactly)) import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))-import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right)) import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct)) import Pandora.Paradigm.Schemes (TT (TT), T_U (T_U), P_Q_T (P_Q_T), type (<::>), type (<:.:>))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (<~)) import Pandora.Paradigm.Inventory.Ability.Gettable (get) import Pandora.Paradigm.Inventory.Ability.Settable (set) import Pandora.Paradigm.Inventory.Ability.Modifiable (modify) import Pandora.Paradigm.Inventory.Some.Store (Store (Store)) import Pandora.Paradigm.Inventory.Some.Optics (Lens, Obscure, view, replace, mutate)-import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty)+import Pandora.Paradigm.Structure.Modification.Nonempty (Nonempty) import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (resolve)) import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), morph, premorph-	, Morph (Rotate, Into, Insert, Lookup, Key), Vertical (Up, Down), Horizontal (Leftward, Rightward), lookup)+	, Morph (Rotate, Into, Insert, Lookup, Key), lookup) import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substance, substructure), Segment (Root, Branch), sub) import Pandora.Paradigm.Structure.Interface.Zipper (Zippable (Breadcrumbs))-import Pandora.Paradigm.Structure.Modification.Prefixed (Prefixed (Prefixed))+import Pandora.Paradigm.Structure.Modification.Prefixed (Prefixed)  type Binary = Maybe <::> Construction (Maybe <:*:> Maybe) @@ -70,10 +71,10 @@  -------------------------------------- Non-empty binary tree --------------------------------------- -type instance Nonempty Binary = Construction > Maybe <:*:> Maybe+type instance Nonempty Binary = Construction (Maybe <:*:> Maybe) -instance Morphable (Into Binary) (Construction > Maybe <:*:> Maybe) where-	type Morphing (Into Binary) (Construction > Maybe <:*:> Maybe) = Binary+instance Morphable (Into Binary) (Construction (Maybe <:*:> Maybe)) where+	type Morphing (Into Binary) (Construction (Maybe <:*:> Maybe)) = Binary 	morphing = lift . premorph  -- instance Morphable Insert (Construction Wye) where@@ -111,8 +112,8 @@ 		Just tree -> TT <-- \key -> 			key <=> attached (extract tree) & order 				<--- Just --> extract --> extract tree-				<--- lookup @Key key . Prefixed =<< run (view <-- sub @(Left Branch) <-- tree)-				<--- lookup @Key key . Prefixed =<< run (view <-- sub @(Right Branch) <-- tree)+				<--- lookup @Key key . TT @Covariant @Covariant =<< run (view <-- sub @(Left Branch) <-- tree)+				<--- lookup @Key key . TT @Covariant @Covariant =<< run (view <-- sub @(Right Branch) <-- tree)  -- instance Chain k => Morphable (Vary Element) (Prefixed Binary k) where 	-- type Morphing (Vary Element) (Prefixed Binary k) = ((:*:) k <::> Exactly) <:.:> Prefixed Binary k > (->)@@ -132,8 +133,8 @@ 	morphing (run . premorph -> Construct x xs) = TT <-- \key -> 		key <=> attached x & order 			<---- Just <-- extract x-			<---- lookup @Key key . Prefixed ==<< get @(Obscure Lens) <-- sub @Left <-- xs-			<---- lookup @Key key . Prefixed ==<< get @(Obscure Lens) <-- sub @Left <-- xs+			<---- lookup @Key key . TT @Covariant @Covariant ==<< get @(Obscure Lens) <-- sub @Left <-- xs+			<---- lookup @Key key . TT @Covariant @Covariant ==<< get @(Obscure Lens) <-- sub @Left <-- xs  -------------------------------------- Zipper of binary tree --------------------------------------- 	{-@@ -141,13 +142,13 @@  instance Covariant (->) (->) Biforked where 	_ <-|- Top = Top-	f <-|- Horizontal (Leftward l) = Horizontal . Leftward <-- f l-	f <-|- Horizontal (Rightward r) = Horizontal . Rightward <-- f r+	f <-|- Horizontal (Left l) = Horizontal . Left <-- f l+	f <-|- Horizontal (Right r) = Horizontal . Right <-- f r  instance Traversable (->) (->) Biforked where 	_ <<- Top = point Top-	f <<- Horizontal (Leftward l) = Horizontal . Leftward <-|- f l-	f <<- Horizontal (Rightward r) = Horizontal . Rightward <-|- f r+	f <<- Horizontal (Left l) = Horizontal . Left <-|- f l+	f <<- Horizontal (Right r) = Horizontal . Right <-|- f r  type Bifurcation = Biforked <::> Construction Biforked @@ -163,12 +164,12 @@ 	type Morphing (Rotate Up) ((Exactly <:.:> Wye <::> Construction Wye > (:*:)) <:.:> (Bifurcation <::> Bicursor) > (:*:)) 		= Maybe <::> ((Exactly <:.:> Wye <::> Construction Wye > (:*:)) <:.:> Bifurcation <::> Bicursor > (:*:)) 	morphing struct = case run ---> premorph struct of-		focused :*: TT (TT (Horizontal (Rightward (Construct (T_U (Exactly parent :*: rest)) next)))) ->+		focused :*: TT (TT (Horizontal (Right (Construct (T_U (Exactly parent :*: rest)) next)))) -> 			lift . ((<:*:>) % TT (TT next)) . (<:*:>) (Exactly parent) . TT <---- resolve 				<--- Both <-- _focused_part_to_nonempty_binary_tree focused 				<--- Left <-- _focused_part_to_nonempty_binary_tree focused 				<--- run rest-		focused :*: TT (TT (Horizontal (Leftward (Construct (T_U (Exactly parent :*: rest)) next)))) ->+		focused :*: TT (TT (Horizontal (Left (Construct (T_U (Exactly parent :*: rest)) next)))) -> 			lift . ((<:*:>) % TT (TT next)) . (<:*:>) (Exactly parent) . TT <---- resolve 				<--- Both % _focused_part_to_nonempty_binary_tree focused 				<--- Right <-- _focused_part_to_nonempty_binary_tree focused@@ -184,12 +185,12 @@ 	morphing struct = case run ---> premorph struct of 		T_U (Exactly x :*: TT (Left lst)) :*: TT (TT next) -> 			lift . (<:*:>) (_nonempty_binary_tree_to_focused_part lst)-				. TT . TT . Horizontal . Leftward <------- Construct+				. TT . TT . Horizontal . Left <------- Construct 					<------ Exactly x <:*:> TT Nothing 					<------ next 		T_U (Exactly x :*: TT (Both lst rst)) :*: TT (TT next) -> 			lift . (<:*:>) (_nonempty_binary_tree_to_focused_part lst)-				. TT . TT . Horizontal . Leftward <------- Construct+				. TT . TT . Horizontal . Left <------- Construct 					<------ Exactly x <:*:> lift rst 					<------ next 		_ -> TT Nothing@@ -200,9 +201,9 @@ 	morphing struct = case run ---> premorph struct of 		T_U (Exactly x :*: TT (Right rst)) :*: TT (TT next) -> 			lift . (<:*:>) (_nonempty_binary_tree_to_focused_part rst)-				. TT . TT . Horizontal . Rightward <---- Construct (Exactly x <:*:> TT Nothing) next+				. TT . TT . Horizontal . Right <---- Construct (Exactly x <:*:> TT Nothing) next 		T_U (Exactly x :*: TT (Both lst rst)) :*: TT (TT next) -> 			lift . (<:*:>) (_nonempty_binary_tree_to_focused_part rst)-				. TT . TT . Horizontal . Rightward <---- Construct (Exactly x <:*:> lift lst) next+				. TT . TT . Horizontal . Right <---- Construct (Exactly x <:*:> lift lst) next 		_ -> TT Nothing -}

@@ -1,8 +1,9 @@ {-# OPTIONS_GHC -fno-warn-orphans #-} module Pandora.Paradigm.Structure.Some.List where -import Pandora.Core.Functor (type (:.), type (<), type (>))+import Pandora.Core.Functor (type (:.), type (<), type (>), type (>>>), type (>>>>>>)) import Pandora.Core.Impliable (imply)+import Pandora.Core.Interpreted (run, unite, (<~), (<~~~), (=#-)) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category ((<--), (<---), (<----), (<-----), (<------), (-->), (--->), (---->), identity) import Pandora.Pattern.Kernel (constant)@@ -16,41 +17,44 @@ import Pandora.Pattern.Object.Setoid (Setoid ((==), (?=))) import Pandora.Pattern.Object.Semigroup (Semigroup ((+))) import Pandora.Pattern.Object.Monoid (Monoid (zero))-import Pandora.Paradigm.Algebraic ((<-*-), (<-*--), (.-*-), (.-+-), (.:..), extract, point, empty, void)+import Pandora.Paradigm.Algebraic ((<-*-), (<-*--), (.-*-), (-+-), (.:..), extract, point, empty, void) import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), type (<:*:>), (<:*:>), attached) import Pandora.Paradigm.Algebraic.Exponential ((%)) import Pandora.Paradigm.Algebraic ((<-|-<-|-))+import Pandora.Paradigm.Primary.Auxiliary (Horizontal (Left, Right)) import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True)) import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing)) import Pandora.Paradigm.Primary.Functor.Exactly (Exactly (Exactly)) import Pandora.Paradigm.Primary.Functor.Predicate (Predicate (Predicate)) import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag))-import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))-import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct, (.-+))+import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct) import Pandora.Paradigm.Primary.Transformer.Reverse (Reverse (Reverse)) import Pandora.Paradigm.Primary ()-import Pandora.Paradigm.Inventory.Ability.Gettable (get)-import Pandora.Paradigm.Inventory.Ability.Settable (set)-import Pandora.Paradigm.Inventory.Ability.Modifiable (modify)-import Pandora.Paradigm.Inventory.Some.State (State, fold)-import Pandora.Paradigm.Inventory.Some.Store (Store (Store))-import Pandora.Paradigm.Inventory.Some.Optics (Convex, Obscure, Lens)-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (<~), (<~~~), (=#-))+import Pandora.Paradigm.Controlflow.Effect.Adaptable (adapt)+import Pandora.Paradigm.Controlflow.Effect.Transformer ((:>)) import Pandora.Paradigm.Schemes.TT (TT (TT), type (<::>)) import Pandora.Paradigm.Schemes.TU (TU (TU)) import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>)) import Pandora.Paradigm.Schemes.P_Q_T (P_Q_T (P_Q_T))-import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty)-import Pandora.Paradigm.Structure.Interface.Zipper (Zippable (Breadcrumbs), Zipper)+import Pandora.Paradigm.Inventory.Ability.Gettable (get)+import Pandora.Paradigm.Inventory.Ability.Settable (set)+import Pandora.Paradigm.Inventory.Ability.Modifiable (modify)+import Pandora.Paradigm.Inventory.Some.State (State, fold, current, change)+import Pandora.Paradigm.Inventory.Some.Store (Store (Store))+import Pandora.Paradigm.Inventory.Some.Optics (Convex, Obscure, Lens, transwrap)+import Pandora.Paradigm.Inventory (zoom, overlook)+import Pandora.Paradigm.Structure.Modification.Nonempty (Nonempty) import Pandora.Paradigm.Structure.Ability.Monotonic (resolve) import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing) 	, Morph (Rotate, Into, Push, Pop, Delete, Find, Lookup, Element, Key) 	, Occurrence (All, First), premorph, rotate, item, filter, find, lookup, into)+import Pandora.Paradigm.Structure.Ability.Slidable (Slidable (Sliding, slide)) import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substance, substructure, sub), Segment (Root, Rest))-import Pandora.Paradigm.Structure.Interface.Stack (Stack (Popping, Pushing, Topping, push, pop, top))+import Pandora.Paradigm.Structure.Interface.Stack (Stack (Topping, push, pop, top))+import Pandora.Paradigm.Structure.Interface.Zipper (Zippable (Breadcrumbs), Zipper) import Pandora.Paradigm.Structure.Modification.Combinative (Combinative) import Pandora.Paradigm.Structure.Modification.Comprehension (Comprehension (Comprehension))-import Pandora.Paradigm.Structure.Modification.Prefixed (Prefixed (Prefixed))+import Pandora.Paradigm.Structure.Modification.Prefixed (Prefixed) import Pandora.Paradigm.Structure.Modification.Tape (Tape) import Pandora.Paradigm.Structure.Modification.Turnover (Turnover (Turnover)) @@ -69,7 +73,7 @@ 	zero = empty  instance Morphable Push List where-	type Morphing Push List = Exactly <:.:> List > (->)+	type Morphing Push List = Exactly <:.:> List >>>>>> (->) 	morphing (premorph -> xs) = T_U <-- lift . (Construct % run xs) . extract  instance Morphable Pop List where@@ -77,7 +81,7 @@ 	morphing (premorph -> xs) = resolve deconstruct Nothing =#- xs  instance Morphable (Find Element) List where-	type Morphing (Find Element) List = Predicate <:.:> Maybe > (->)+	type Morphing (Find Element) List = Predicate <:.:> Maybe >>>>>> (->) 	morphing list = case run --> premorph list of 		Nothing -> T_U <-- \_ -> Nothing 		Just (Construct x xs) -> T_U <-- \p ->@@ -85,7 +89,7 @@ 				<---- find @Element @List @Maybe <-- p <-- TT xs  instance Morphable (Delete First) List where-	type Morphing (Delete First) List = Predicate <:.:> List > (->)+	type Morphing (Delete First) List = Predicate <:.:> List >>>>>> (->) 	morphing list = case run --> premorph list of 		Nothing -> T_U <-- constant empty 		Just (Construct x xs) -> T_U <-- \p ->@@ -93,7 +97,7 @@ 				<--- lift . Construct x . run . filter @First @List p <-- TT xs  instance Morphable (Delete All) List where-	type Morphing (Delete All) List = Predicate <:.:> List > (->)+	type Morphing (Delete All) List = Predicate <:.:> List >>>>>> (->) 	morphing list = case run <--- premorph list of 		Nothing -> T_U <-- constant empty 		Just (Construct x xs) -> T_U <-- \p -> (p <~ x) ?= True@@ -102,8 +106,6 @@  instance Stack List where 	type Topping List = Maybe-	type Popping List = List-	type Pushing List = List 	top = P_Q_T <-- \list -> case list of 		TT Nothing -> Store <--- Nothing :*: constant empty 		TT (Just xs) -> Store <--- Just (extract xs) :*: \new -> case new of@@ -126,7 +128,7 @@  -- | Transform any traversable structure into a list linearize :: forall t a . Traversable (->) (->) t => t a -> List a-linearize = TT . extract . (run @(->) @(State (Maybe :. Nonempty List > a)) % Nothing) . fold (Just .:.. Construct)+linearize = TT . extract . (run @(->) @(State (Maybe :. Nonempty List >>> a)) % Nothing) . fold (Just .:.. Construct)  ----------------------------------------- Non-empty list ------------------------------------------- @@ -137,7 +139,7 @@ 	Construct x (Just xs) + ys = Construct x . Just <-- xs + ys  instance Morphable (Find Element) (Construction Maybe) where-	type Morphing (Find Element) (Construction Maybe) = Predicate <:.:> Maybe > (->)+	type Morphing (Find Element) (Construction Maybe) = Predicate <:.:> Maybe >>>>>> (->) 	morphing (premorph -> Construct x xs) = T_U <-- \p -> (p <~ x) ?= True <----- Just x 		<----- find @Element @(Nonempty List) @Maybe <-- p ===<< xs @@ -154,16 +156,14 @@ 		Construct Nothing Nothing -> empty  instance Morphable Push (Construction Maybe) where-	type Morphing Push (Construction Maybe) = Exactly <:.:> Construction Maybe > (->)+	type Morphing Push (Construction Maybe) = Exactly <:.:> Construction Maybe >>>>>> (->) 	morphing (premorph -> xs) = T_U <-- \(Exactly x) -> Construct x <-- Just xs  instance Stack (Construction Maybe) where 	type Topping (Construction Maybe) = Exactly-	type Popping (Construction Maybe) = Construction Maybe-	type Pushing (Construction Maybe) = Construction Maybe 	top = P_Q_T <-- \xs -> Store <--- Exactly (extract xs) :*: \(Exactly new) -> Construct new <--- deconstruct xs 	-- It will never return you the last element-	pop = (\(Construct x xs) -> constant x <-|-|- set @State <<- xs) =<< get @State+	pop = (\(Construct x xs) -> constant <-- Exactly x <-|- change @(Nonempty List _) . constant <<- xs) =<< current @(Nonempty List _) 	push x = point x .-*- (modify @State <-- Construct x . Just)  ---------------------------------------- Combinative list ------------------------------------------@@ -175,23 +175,25 @@ instance Zippable List where 	type Breadcrumbs List = Reverse List <:*:> List +-- TODO: No overlapping, let's use wrappers instead instance {-# OVERLAPS #-} Traversable (->) (->) (Tape List) where-	f <<- TU (Tag (T_U (Exactly x :*: T_U (left :*: right)))) =-		(\past' x' left' -> lift <------ Exactly x' <:*:> left' <:*:> run past')+	f <<- T_U (Exactly x :*: T_U (left :*: right)) =+		(\past' x' left' -> Exactly x' <:*:> left' <:*:> run past') 			<-|- f <<- Reverse right <-*- f x <-*- f <<- left +-- TODO: Try to generalize to Extendable (Tape structure) -- instance {-# OVERLAPS #-} Extendable (->) (Tape List) where-	-- f <<= z = let move rtt = TT . deconstruct <----- run . rtt .-+ z in-		-- imply @(Tape List _)-			-- <---- f z-			-- <---- f <-|-- move <-- rotate @Left-			-- <---- f <-|-- move <-- rotate @Right+-- 	f <<= z = let move rtt = TT . deconstruct <----- run . rtt .-+ z in+-- 		imply @(Tape List _)+-- 			<---- f z+-- 			<---- f <-|-- move <-- rotate @Left+-- 			<---- f <-|-- move <-- rotate @Right  instance Morphable (Rotate Left) (Turnover < Tape List) where 	type Morphing (Rotate Left) (Turnover < Tape List) = Turnover < Tape List-	morphing s@(lower . run . premorph -> T_U (Exactly x :*: T_U (Reverse left :*: right))) =+	morphing s@(run . premorph -> T_U (Exactly x :*: T_U (Reverse left :*: right))) = 		resolve @(Tape List _) <--- Turnover <--- premorph s <-----			(rotate_over x <-|- run right) .-+- (rotate_left x right <-|- run left) where+			(rotate_over x <-|- run right) -+- (rotate_left x right <-|- run left) where  		rotate_left :: a -> List a -> Nonempty List a -> Tape List a 		rotate_left focused rs (Construct lx lxs) = imply @(Tape List _) <-- lx <-- TT lxs <-- item @Push focused rs@@ -200,14 +202,14 @@ 		rotate_over focused rs = let new_left = attached <--- (put_over <<- rs <~~~ point focused) in 			imply @(Tape List _) <--- extract new_left <--- TT <-- deconstruct new_left <--- empty -		put_over :: a -> State (Nonempty List a) ()+		put_over :: a -> State < Nonempty List a < () 		put_over = void . modify @State . item @Push  instance Morphable (Rotate Right) (Turnover < Tape List) where 	type Morphing (Rotate Right) (Turnover < Tape List) = Turnover < Tape List-	morphing s@(lower . run . premorph -> T_U (Exactly x :*: T_U (Reverse left :*: right))) =+	morphing s@(run . premorph -> T_U (Exactly x :*: T_U (Reverse left :*: right))) = 		resolve @(Tape List _) <--- Turnover <--- premorph s-			<---- (rotate_over x <-|- run left) .-+- (rotate_right x left <-|- run right) where+			<---- (rotate_over x <-|- run left) -+- (rotate_right x left <-|- run right) where  		rotate_right :: a -> List a -> Nonempty List a -> Tape List a 		rotate_right focused ls (Construct rx rxs) = imply @(Tape List _) <-- rx <-- item @Push focused ls <-- TT rxs@@ -225,13 +227,13 @@  instance Morphable (Into List) (Tape List) where 	type Morphing (Into List) (Tape List) = List-	morphing (lower . premorph -> T_U (Exactly x :*: T_U (Reverse left :*: right))) = attached <---- run @(->) @(State _)+	morphing (premorph -> T_U (Exactly x :*: T_U (Reverse left :*: right))) = attached <---- run @(->) @(State _) 		<--- modify @State . item @Push @List <<- right 		<--- item @Push x left  instance Morphable (Into > Comprehension Maybe) (Tape List) where 	type Morphing (Into > Comprehension Maybe) (Tape List) = Comprehension Maybe-	morphing (lower . premorph -> T_U (Exactly x :*: T_U (Reverse left :*: right))) = attached <---- run @(->) @(State _)+	morphing (premorph -> T_U (Exactly x :*: T_U (Reverse left :*: right))) = attached <---- run @(->) @(State _) 		<--- modify @State . item @Push @(Comprehension Maybe) <<- right 		<--- item @Push x <-- Comprehension left @@ -242,7 +244,7 @@  instance Morphable (Rotate Left) (Tape > Construction Maybe) where 	type Morphing (Rotate Left) (Tape > Construction Maybe) = Maybe <::> (Tape > Construction Maybe)-	morphing (lower . premorph -> T_U (Exactly x :*: T_U (Reverse left :*: right))) =+	morphing (premorph -> T_U (Exactly x :*: T_U (Reverse left :*: right))) = 		TT <----- imply @(Tape (Nonempty List) _) 			<-|-- point <-- extract left 			<-*-- deconstruct left@@ -250,8 +252,8 @@  instance Morphable (Rotate Right) (Tape > Construction Maybe) where 	type Morphing (Rotate Right) (Tape > Construction Maybe) = Maybe <::> Tape (Construction Maybe)-	morphing (lower . premorph -> T_U (Exactly x :*: T_U (Reverse left :*: right))) =-		TT <----- imply @(Tape (Nonempty List) _)+	morphing (premorph -> T_U (Exactly x :*: T_U (Reverse left :*: right))) =+		TT <----- imply @(Tape < Nonempty List < _) 			<-|-- point <-- extract right 			<-*-- point <-- item @Push x left 			<-*-- deconstruct right@@ -272,13 +274,13 @@  instance Morphable (Into > Construction Maybe) (Tape > Construction Maybe) where 	type Morphing (Into > Construction Maybe) (Tape > Construction Maybe) = Construction Maybe-	morphing (lower . premorph -> T_U (Exactly x :*: T_U (Reverse left :*: right))) = attached <---- run @(->) @(State _)+	morphing (premorph -> T_U (Exactly x :*: T_U (Reverse left :*: right))) = attached <---- run @(->) @(State _) 		<--- modify @State . item @Push @(Nonempty List) <<- right 		<--- item @Push x left  instance Morphable (Into List) (Tape > Construction Maybe) where 	type Morphing (Into List) (Tape > Construction Maybe) = List-	morphing (lower . premorph -> T_U (Exactly x :*: T_U (Reverse left :*: right))) = attached <---- run @(->) @(State _)+	morphing (premorph -> T_U (Exactly x :*: T_U (Reverse left :*: right))) = attached <---- run @(->) @(State _) 		<--- modify @State . item @Push @List <<- right 		<--- item @Push x <-- lift left @@ -291,7 +293,7 @@  instance Setoid key => Morphable (Lookup Key) (Prefixed List key) where 	type Morphing (Lookup Key) (Prefixed List key) = (->) key <::> Maybe-	morphing (run . premorph -> list) = TT <-- \key -> lookup @Key key ===<< Prefixed <-|- run list+	morphing (run . premorph -> list) = TT <-- \key -> lookup @Key key ===<< TT @Covariant @Covariant <-|- run list  ------------------------------------ Prefixed non-empty list --------------------------------------- 

@@ -1,44 +1,36 @@ {-# OPTIONS_GHC -fno-warn-orphans #-} module Pandora.Paradigm.Structure.Some.Rose where -import Pandora.Core.Functor (type (:.), type (>))+import Pandora.Core.Functor (type (:.), type (>>>))+import Pandora.Core.Interpreted (run, unite, (<~)) import Pandora.Pattern.Semigroupoid ((.))-import Pandora.Pattern.Category ((<--), (<---), (<----), (<-----))+import Pandora.Pattern.Category ((<--), (<---), (<----), (<-----), identity) import Pandora.Pattern.Kernel (constant)-import Pandora.Pattern.Functor.Covariant ((<-|-), (<-|-|-))+import Pandora.Pattern.Functor.Covariant ((<-|-)) import Pandora.Pattern.Functor.Contravariant ((>-|-))+import Pandora.Pattern.Functor.Traversable ((<<-)) import Pandora.Pattern.Functor.Bindable (Bindable ((=<<))) import Pandora.Pattern.Transformer.Liftable (lift) import Pandora.Pattern.Transformer.Lowerable (lower)-import Pandora.Pattern.Transformer.Hoistable ((/|\))-import Pandora.Pattern.Object.Setoid (Setoid ((==), (!=), (?=)))+import Pandora.Pattern.Object.Setoid (Setoid ((?=))) import Pandora.Pattern.Object.Semigroup ((+))-import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), attached) import Pandora.Paradigm.Algebraic.Exponential ((%))-import Pandora.Paradigm.Algebraic (extract, empty, (>-||-))-import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True)) import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), type (<:*:>), (<:*:>), attached)-import Pandora.Paradigm.Algebraic.Exponential ((%))-import Pandora.Paradigm.Algebraic (extract, point)-import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True))+import Pandora.Paradigm.Algebraic.Functor (extract, point, empty)+import Pandora.Paradigm.Primary.Auxiliary (Vertical (Up, Down), Horizontal (Left, Right)) import Pandora.Paradigm.Primary.Functor.Exactly (Exactly (Exactly)) import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing)) import Pandora.Paradigm.Primary.Functor.Predicate (equate)-import Pandora.Paradigm.Primary.Functor.Tagged (Tagged)-import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right)) import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct) import Pandora.Paradigm.Primary.Transformer.Reverse (Reverse) import Pandora.Paradigm.Schemes (TU (TU), TT (TT), T_U (T_U), P_Q_T (P_Q_T),  type (<::>), type (<:.>))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, unite, (<~), (=#-), (<~~~~)) import Pandora.Paradigm.Inventory.Some.Store (Store (Store)) import Pandora.Paradigm.Inventory.Some.Optics (view)-import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing)-	, Morph (Into, Rotate, Lookup, Element, Key), Vertical (Up, Down), premorph, find)-import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty)-import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substance, substructure)-	, Segment (Root, Rest, Forest), sub, tagstruct)+import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), Morph (Into, Rotate, Lookup, Element, Key), premorph, find)+import Pandora.Paradigm.Structure.Modification.Nonempty (Nonempty)+import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substance, substructure), Segment (Root, Rest, Forest), sub) import Pandora.Paradigm.Structure.Interface.Zipper (Zippable (Breadcrumbs))-import Pandora.Paradigm.Structure.Interface.Stack (Stack (pop, push))+import Pandora.Paradigm.Structure.Interface.Stack (Stack (pop)) import Pandora.Paradigm.Structure.Modification.Prefixed (Prefixed) import Pandora.Paradigm.Structure.Modification.Tape (Tape) import Pandora.Paradigm.Structure.Some.List (List)@@ -81,14 +73,14 @@ --		Construct key (Just keys) -> Prefixed ! attached x != key ? Construct x # lift subtree --			! Construct (key :*: value) . lift ! vary @Element @_ @_ @(Nonempty (Prefixed Rose k)) keys value -#=!> subtree -find_rose_sub_tree :: forall k a . Setoid k => Nonempty List k -> Nonempty Rose > k :*: a -> Maybe a+find_rose_sub_tree :: forall k a . Setoid k => Nonempty List k -> Nonempty Rose >>> k :*: a -> Maybe a find_rose_sub_tree (Construct k ks) tree = k ?= attached (extract tree) 	<----- case ks of 		Just keys -> find_rose_sub_tree keys =<< subtree keys 		Nothing -> Just <--- extract <-- extract tree 	<----- Nothing where -	subtree :: Nonempty List k -> Maybe :. Nonempty Rose > k :*: a+	subtree :: Nonempty List k -> Maybe :. Nonempty Rose >>> k :*: a 	subtree keys = find @Element 		<---- attached . extract 			>-|- equate <-- extract keys@@ -102,52 +94,52 @@ 	type Breadcrumbs (Construction List) = Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)  -- TODO: Try to use substructure @Right . substructure @Right . substructure @Right . substructure @Right here-instance Substructure (Up Forest) (Tagged (Zippable structure) <:.> Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) where-	type Substance (Up Forest) (Tagged (Zippable structure) <:.> Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) = List <::> Tape Roses-	substructure = P_Q_T <-- \zipper -> case run . lower <-- lower zipper of+instance Substructure (Up Forest) (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) where+	type Substance (Up Forest) (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) = List <::> Tape Roses+	substructure = P_Q_T <-- \zipper -> case run <-- lower zipper of 		Exactly x :*: T_U (down :*: T_U (left :*: T_U (right :*: up))) ->-			Store <--- up :*: lift . lift . (Exactly x <:*:>) . (down <:*:>) . (left <:*:>) . (right <:*:>)+			Store <--- up :*: lift . (Exactly x <:*:>) . (down <:*:>) . (left <:*:>) . (right <:*:>)  -- TODO: Try to use substructure @Left . substructure @Right here-instance Substructure (Down Forest) (Tagged (Zippable structure) <:.> Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) where-	type Substance (Down Forest) (Tagged (Zippable structure) <:.> Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) = Roses-	substructure = P_Q_T <-- \zipper -> case run . lower <-- lower zipper of+instance Substructure (Down Forest) (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) where+	type Substance (Down Forest) (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) = Roses+	substructure = P_Q_T <-- \zipper -> case run <-- lower zipper of 		Exactly x :*: T_U (down :*: rest) ->-			Store <--- down :*: lift . lift . (Exactly x <:*:>) . (<:*:> rest)+			Store <--- down :*: lift . (Exactly x <:*:>) . (<:*:> rest)  -- TODO: Try to use substructure @Left . substructure @Right . substructure @Right here-instance Substructure (Left Forest) (Tagged (Zippable structure) <:.> Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) where-	type Substance (Left Forest) (Tagged (Zippable structure) <:.> Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) = Reverse Roses-	substructure = P_Q_T <-- \zipper -> case run . lower <-- lower zipper of+instance Substructure (Left Forest) (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) where+	type Substance (Left Forest) (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) = Reverse Roses+	substructure = P_Q_T <-- \zipper -> case run <-- lower zipper of 		Exactly x :*: T_U (down :*: T_U (left :*: rest)) ->-			Store <--- left :*: lift . lift . (Exactly x <:*:>) . (down <:*:>) . (<:*:> rest)+			Store <--- left :*: lift . (Exactly x <:*:>) . (down <:*:>) . (<:*:> rest) --- TODO: Try to use substructure @Left . substructure @Right . substructure @Right . substructure @Right here-instance Substructure (Right Forest) (Tagged (Zippable structure) <:.> Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) where-	type Substance (Right Forest) (Tagged (Zippable structure) <:.> Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) = Roses-	substructure = P_Q_T <-- \zipper -> case run . lower <-- lower zipper of+-- TODO: Try to use substructure  @Left . substructure @Right . substructure @Right . substructure @Right here+instance Substructure (Right Forest) (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) where+	type Substance (Right Forest) (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) = Roses+	substructure = P_Q_T <-- \zipper -> case run <-- lower zipper of 		Exactly x :*: T_U (down :*: T_U (left :*: T_U (right :*: rest))) ->-			Store <--- right :*: lift . lift . (Exactly x <:*:>) . (down <:*:>) . (left <:*:>) . (<:*:> rest)+			Store <--- right :*: lift . (Exactly x <:*:>) . (down <:*:>) . (left <:*:>) . (<:*:> rest) -instance Morphable (Into (Tagged (Zippable structure) <:.> (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)))) (Construction List) where-	type Morphing (Into (Tagged (Zippable structure) <:.> (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)))) (Construction List) =-		Tagged (Zippable structure) <:.> (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses))+instance Morphable (Into (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses))) (Construction List) where+	type Morphing (Into (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses))) (Construction List) =+		Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses) 	morphing nonempty_rose_tree = case premorph nonempty_rose_tree of-		Construct x xs -> lift <----- Exactly x <:*:> unite xs <:*:> empty <:*:> empty <:*:> empty+		Construct x xs -> Exactly x <:*:> unite xs <:*:> empty <:*:> empty <:*:> empty -instance Morphable (Rotate Up) (Tagged (Zippable structure) <:.> (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses))) where-	type Morphing (Rotate Up) (Tagged (Zippable structure) <:.> (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses))) =-		Maybe <::> (Tagged (Zippable structure) <:.> (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)))-	morphing (premorph -> nonempty_rose_tree) = case pop @List <~ run (view <-- sub @(Up Forest) <-- nonempty_rose_tree) of-		-- TODO: Traversable for Maybe up over Product-		parents :*: Just parent ->-			let child_node = extract <--- view <-- sub @Root <-- nonempty_rose_tree in-			let central_children = run <--- view <-- sub @(Down Forest) <-- nonempty_rose_tree in-			let left_children = run @(->) <---- run <--- view <-- sub @(Left Forest) <-- nonempty_rose_tree in-			let right_children = run <--- view <-- sub @(Right Forest) <-- nonempty_rose_tree in-			lift . lift <----- view <-- sub @Root <-- parent+instance Morphable (Rotate Up) (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) where+	type Morphing (Rotate Up) (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses)) =+		Maybe <::> (Exactly <:*:> Roses <:*:> Reverse Roses <:*:> Roses <:*:> (List <::> Tape Roses))+	morphing (premorph -> z) = TT <---- restruct <-|- identity @(->) <<- pop @List <~ run (view <-- sub @(Up Forest) <-- z) where++		-- TODO: Add type declaration+		restruct (parents :*: parent) =+			let child_node = extract <--- view <-- sub @Root <-- z in+			let central_children = run <--- view <-- sub @(Down Forest) <-- z in+			let left_children = run @(->) <---- run <--- view <-- sub @(Left Forest) <-- z in+			let right_children = run <--- view <-- sub @(Right Forest) <-- z in+			view <-- sub @Root <-- parent 				<:*:> unite <-- left_children + point (Construct child_node central_children) + right_children-				<:*:> view <-- sub @Left <-- parent-				<:*:> view <-- sub @Right <-- parent+				<:*:> view <--- sub @Left <--- view <-- sub @Rest <-- parent+				<:*:> view <--- sub @Right <--- view <-- sub @Rest <-- parent 				<:*:> unite parents-		_ :*: Nothing -> empty

@@ -2,23 +2,30 @@ {-# LANGUAGE AllowAmbiguousTypes #-} module Pandora.Paradigm.Structure.Some.Splay where -import Pandora.Core.Functor (type (~>), type (>))+import Pandora.Core.Functor (type (~>), type (>), type (>>>), type (>>>>>>))+import Pandora.Core.Interpreted (run) import Pandora.Pattern.Semigroupoid ((.))-import Pandora.Pattern.Category ((<--), (<---), (<----), identity)+import Pandora.Pattern.Kernel (constant)+import Pandora.Pattern.Category ((<--), (<---), (<----), (<-----), identity) import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-), (<-|---)))-import Pandora.Pattern.Functor.Bindable (Bindable ((=<<), (==<<), (===<<)))+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<), (==<<), (===<<), (====<<)))+import Pandora.Pattern.Transformer.Liftable (lift) import Pandora.Pattern.Transformer.Hoistable ((/|\))-import Pandora.Paradigm.Algebraic ((<-*-), extract)+import Pandora.Paradigm.Algebraic.Functor ((<-*-), extract, point, void) import Pandora.Paradigm.Algebraic.Product (type (<:*:>), (<:*:>))+import Pandora.Paradigm.Primary.Auxiliary (Horizontal (Left, Right)) import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just))-import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right)) import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)+import Pandora.Paradigm.Controlflow.Effect.Adaptable (adapt)+import Pandora.Paradigm.Controlflow.Effect.Transformer ((:>), wrap) import Pandora.Paradigm.Inventory.Some.Optics (view, mutate)+import Pandora.Paradigm.Inventory.Some.State (State, change, current)+import Pandora.Paradigm.Inventory (zoom, overlook) import Pandora.Paradigm.Schemes (TT (TT), type (<::>)) import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), Morphed, Morph (Rotate), premorph, rotate)-import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty)+import Pandora.Paradigm.Structure.Modification.Nonempty (Nonempty) import Pandora.Paradigm.Structure.Ability.Substructure (Segment (Root, Branch), sub)+import Pandora.Paradigm.Structure.Ability.Slidable (Slidable (Sliding, slide)) import Pandora.Paradigm.Structure.Ability.Monotonic (resolve) import Pandora.Paradigm.Structure.Some.Binary (Binary) @@ -75,6 +82,31 @@ 					(run <--- view <-- sub @(Right Branch) <-- tree) 				) 			)++-- TODO: Slidable (Left Zig) (Construction (Maybe <:*:> Maybe))+-- TODO: Slidable (Left > Zig Zig) (Construction (Maybe <:*:> Maybe))+-- TODO: Slidable (Right > Zig Zig) (Construction (Maybe <:*:> Maybe))+-- TODO: Slidable (Left > Zig Zag) (Construction (Maybe <:*:> Maybe))+-- TODO: Slidable (Right > Zig Zag) (Construction (Maybe <:*:> Maybe))+-- TODO: Slidable (Left Zig) Binary+-- TODO: Slidable (Right Zig) Binary+-- TODO: Slidable (Left > Zig Zig) Binary+-- TODO: Slidable (Right > Zig Zig) Binary+-- TODO: Slidable (Left > Zig Zag) Binary+-- TODO: Slidable (Right > Zig Zag) Binary++instance Slidable (Right Zig) (Construction (Maybe <:*:> Maybe)) where+	type Sliding (Right Zig) (Construction (Maybe <:*:> Maybe)) = Maybe+	slide :: forall element . State > Nonempty Binary element :> Maybe >>> ()+	slide = void . point+		===<< adapt . zoom @(Nonempty Binary element) (sub @(Right Branch)) .+			zoom (sub @(Left Branch)) . change . constant+		===<< adapt . zoom @(Nonempty Binary element) (sub @(Right Branch))+			. change @(Binary element) . constant . lift+		===<< change . constant ===<< adapt . run+		===<< adapt <--- zoom @(Nonempty Binary element)+			<-- sub @(Left Branch)+			<-- current @(Binary element)  -- TODO: Morphing ... = Conclussion Error <::> Nonempty Binary instance Morphable (Rotate > Left > Zig Zig) (Construction (Maybe <:*:> Maybe)) where

@@ -2,43 +2,63 @@ module Pandora.Paradigm.Structure.Some.Stream where  import Pandora.Core.Impliable (imply)-import Pandora.Core.Functor (type (>), type (:=>))+import Pandora.Core.Functor (type (>), type (>>>), type (:=>))+import Pandora.Core.Interpreted (run) import Pandora.Pattern.Semigroupoid ((.)) import Pandora.Pattern.Category ((<--), (<---), (<----), (-->))-import Pandora.Pattern.Functor.Covariant (Covariant ((<-|--)))+import Pandora.Pattern.Kernel (constant)+import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-))) import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<), (====<<))) import Pandora.Pattern.Transformer.Lowerable (lower) import Pandora.Paradigm.Algebraic.Product ((:*:) ((:*:)), type (<:*:>))-import Pandora.Paradigm.Algebraic (extract)+import Pandora.Paradigm.Algebraic.Functor (extract, void, (.-*-))+import Pandora.Paradigm.Primary.Auxiliary (Horizontal (Left, Right)) import Pandora.Paradigm.Primary.Functor.Exactly (Exactly (Exactly))-import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))-import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct, (.-+))+import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct, constitute) import Pandora.Paradigm.Primary.Transformer.Reverse (Reverse (Reverse))+import Pandora.Paradigm.Controlflow.Effect.Adaptable (adapt)+import Pandora.Paradigm.Controlflow.Effect.Transformer ((:>)) import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), Morph (Rotate), premorph, rotate)+import Pandora.Paradigm.Structure.Ability.Substructure (sub, Segment (Root, Rest))+import Pandora.Paradigm.Structure.Ability.Slidable (Slidable (Sliding, slide)) import Pandora.Paradigm.Structure.Interface.Zipper (Zippable (Breadcrumbs))+import Pandora.Paradigm.Structure.Interface.Stack (Stack (Topping, push, pop, top)) import Pandora.Paradigm.Structure.Modification.Tape (Tape)+import Pandora.Paradigm.Inventory.Some.State (State, change, current)+import Pandora.Paradigm.Inventory.Some.Store (Store (Store))+import Pandora.Paradigm.Inventory.Some.Optics (transwrap)+import Pandora.Paradigm.Inventory (zoom, overlook)+import Pandora.Paradigm.Schemes.P_Q_T (P_Q_T (P_Q_T)) import Pandora.Paradigm.Schemes.T_U (T_U (T_U)) import Pandora.Paradigm.Algebraic (point)-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)  type Stream = Construction Exactly  instance Zippable (Construction Exactly) where 	type Breadcrumbs (Construction Exactly) = Reverse Stream <:*:> Stream +-- TODO: Try to generalize to Extendable (Tape structure)+instance {-# OVERLAPS #-} Extendable (->) (Tape Stream) where+	f <<= z = let move rtt = extract . deconstruct <---- constitute <-- point . rtt <-- z in+		f <-|- imply @(Tape Stream _) <-- z <-- move (rotate @Left) <-- move (rotate @Right)++instance Stack (Construction Exactly) where+	type Topping (Construction Exactly) = Exactly+	top = P_Q_T <-- \xs -> Store <--- Exactly (extract xs) :*: \(Exactly new) -> Construct new <--- deconstruct xs+	pop = (\(Construct x xs) -> constant <-- Exactly x <-|- change @(Stream _) . constant <<- xs) =<< current+	push x = point x .-*- (change <-- Construct x . Exactly)+ instance Morphable (Rotate Left) (Tape Stream) where 	type Morphing (Rotate Left) (Tape Stream) = Tape Stream-	morphing (run . lower . premorph -> Exactly x :*: T_U (Reverse ls :*: rs)) =+	morphing (run . premorph -> Exactly x :*: T_U (Reverse ls :*: rs)) = 		imply @(Tape Stream _) <--- extract ls <--- extract (deconstruct ls) <--- Construct x --> point rs  instance Morphable (Rotate Right) (Tape Stream) where 	type Morphing (Rotate Right) (Tape Stream) = Tape Stream-	morphing (run . lower . premorph -> Exactly x :*: T_U (Reverse ls :*: rs)) =+	morphing (run . premorph -> Exactly x :*: T_U (Reverse ls :*: rs)) = 		imply @(Tape Stream _) <--- extract rs <--- Construct x (point ls) <--- extract (deconstruct rs)--instance {-# OVERLAPS #-} Extendable (->) (Tape Stream) where-	f <<= z = let move rtt = extract . deconstruct <---- point . rtt .-+ z in-		f <-|-- imply @(Tape Stream _) <-- z <-- move (rotate @Left) <-- move (rotate @Right)  repeat :: a :=> Stream repeat x = Construct x . Exactly <-- repeat x

@@ -8,7 +8,7 @@ newtype Flip (v :: * -> * -> *) a e = Flip (v e a)  instance Semigroupoid m => Semigroupoid (Flip m) where-  Flip g . Flip f = Flip (f . g)+	Flip g . Flip f = Flip (f . g)  instance Category m => Category (Flip m) where 	identity = Flip identity

@@ -1,5 +1,5 @@ name:                pandora-version:             0.5.3+version:             0.5.4 synopsis:            A box of patterns and paradigms description:         Humble attempt to define a library for problem solving based on math abstractions. homepage:            https://github.com/iokasimov/pandora@@ -23,6 +23,7 @@     Pandora.Core     Pandora.Core.Functor     Pandora.Core.Impliable+    Pandora.Core.Interpreted      Pandora.Paradigm     -- Basic constructions@@ -34,6 +35,7 @@     Pandora.Paradigm.Algebraic.Zero     Pandora.Paradigm.Algebraic.One     Pandora.Paradigm.Primary+    Pandora.Paradigm.Primary.Auxiliary     Pandora.Paradigm.Primary.Object     Pandora.Paradigm.Primary.Object.Boolean     Pandora.Paradigm.Primary.Object.Ordering@@ -86,7 +88,6 @@     Pandora.Paradigm.Controlflow     -- Typeclassess about functor junctions     Pandora.Paradigm.Controlflow.Effect-    Pandora.Paradigm.Controlflow.Effect.Interpreted     Pandora.Paradigm.Controlflow.Effect.Transformer     Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic     Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic@@ -114,11 +115,12 @@     Pandora.Paradigm.Structure.Ability.Accessible     Pandora.Paradigm.Structure.Ability.Possible     Pandora.Paradigm.Structure.Ability.Substructure-    Pandora.Paradigm.Structure.Ability.Nonempty     Pandora.Paradigm.Structure.Ability.Monotonic+    Pandora.Paradigm.Structure.Ability.Slidable     Pandora.Paradigm.Structure.Modification     Pandora.Paradigm.Structure.Modification.Combinative     Pandora.Paradigm.Structure.Modification.Comprehension+    Pandora.Paradigm.Structure.Modification.Nonempty     Pandora.Paradigm.Structure.Modification.Prefixed     Pandora.Paradigm.Structure.Modification.Turnover     Pandora.Paradigm.Structure.Modification.Tape@@ -189,4 +191,4 @@     MultiParamTypeClasses, NoImplicitPrelude, PackageImports, PolyKinds, RankNTypes, ViewPatterns     ScopedTypeVariables, TypeApplications, TypeFamilies, TypeFamilyDependencies, TypeOperators   default-language: Haskell2010-  ghc-options: -Wall -fno-warn-tabs -fno-warn-unticked-promoted-constructors+  ghc-options: -Wall -fno-warn-tabs -fno-warn-unticked-promoted-constructors -fprint-potential-instances