pandora 0.3.5 → 0.3.6

raw patch · 33 files changed

+398/−404 lines, 33 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• CHANGELOG.md +18/−0
• Pandora/Core/Functor.hs +3/−3
• Pandora/Paradigm/Controlflow/Effect/Interpreted.hs +3/−0
• Pandora/Paradigm/Inventory.hs +18/−2
• Pandora/Paradigm/Inventory/Optics.hs +8/−18
• Pandora/Paradigm/Inventory/Store.hs +3/−3
• Pandora/Paradigm/Primary/Functor.hs +0/−1
• Pandora/Paradigm/Primary/Functor/Delta.hs +0/−51
• Pandora/Paradigm/Primary/Functor/Fix.hs +4/−4
• Pandora/Paradigm/Primary/Functor/Predicate.hs +2/−2
• Pandora/Paradigm/Primary/Functor/Tagged.hs +2/−2
• Pandora/Paradigm/Primary/Transformer/Construction.hs +2/−2
• Pandora/Paradigm/Schemes/T_U.hs +12/−25
• Pandora/Paradigm/Schemes/U_T.hs +3/−29
• Pandora/Paradigm/Structure.hs +78/−26
• Pandora/Paradigm/Structure/Ability.hs +3/−2
• Pandora/Paradigm/Structure/Ability/Accessible.hs +6/−0
• Pandora/Paradigm/Structure/Ability/Convertible.hs +0/−12
• Pandora/Paradigm/Structure/Ability/Deletable.hs +6/−0
• Pandora/Paradigm/Structure/Ability/Morphable.hs +19/−0
• Pandora/Paradigm/Structure/Ability/Rotatable.hs +0/−13
• Pandora/Paradigm/Structure/Ability/Substructure.hs +18/−6
• Pandora/Paradigm/Structure/Binary.hs +67/−59
• Pandora/Paradigm/Structure/Rose.hs +10/−9
• Pandora/Paradigm/Structure/Splay.hs +28/−41
• Pandora/Paradigm/Structure/Stack.hs +54/−61
• Pandora/Paradigm/Structure/Stream.hs +18/−17
• Pandora/Pattern/Functor/Bindable.hs +0/−3
• Pandora/Pattern/Functor/Covariant.hs +2/−2
• Pandora/Pattern/Functor/Extractable.hs +2/−2
• Pandora/Pattern/Functor/Pointable.hs +2/−2
• Pandora/Pattern/Functor/Representable.hs +2/−2
• pandora.cabal +5/−5

@@ -327,3 +327,21 @@ * Define `match` method to chain predicates  # 0.3.6+* Define `Walk` datatype to define different tree/graph traversals+* Make `a` paremeter in `:~.` to be existentially qualified+* Rename type operators: `|->` to `:=>` and `<-|` to `<:=`+* Define experimental `||=` method to apply a function inside transformer+* Define `subview`, `subplace` and `substitute` methods in `Substructure` typeclass+* Put `sub` method into `Substructure` typeclass+* Remove `^.`, `.~` and `%~` infix optics methods+* Generalize `T_U` and `U_T` schemes over some `p` (`Bifunctor`/`Profunctor`)+* Define experimental `Deletable` typeclass+* Define experimental `adjust`, `magnify`, `=<>`, `~<>`+* Define experimental `Accessible` type class+* Rename `access` method to `look` in `Optics` module+* Rename `Convertible` type class to `Morphable`+* Remove `Rotatable` type class in favor of `Morphable`+* Define `<:.:>`, `>:.:>`, `<:.:<`, `>:.:<` type synonyms+* Delete `Delta` datatype in favor of `(:*:) <:.:> t`++# 0.3.7

@@ -1,6 +1,6 @@ module Pandora.Core.Functor where -infixr 0 :=, <-|, |->, ~>+infixr 0 :=, <:=, :=>, ~> infixr 1 .:, :. infixr 2 ::|:., ::|.:, ::|:: @@ -14,10 +14,10 @@ type (.:) t u a = u (t a)  -- | Coalgebra's type operator-type (|->) a t = a -> t a+type (:=>) a t = a -> t a  -- | Algebra's type operator-type (<-|) a t = t a -> a+type (<:=) a t = t a -> a  -- | Numerator transformation type (~>) t u = forall a . t a -> u a

@@ -12,6 +12,9 @@ 	run :: t a -> Primary t a 	unite :: Primary t a -> t a +	(||=) :: (Primary t a -> Primary t b) -> t a -> t b+	(||=) f = unite . f . run+ (-=:) :: (Liftable t, Interpreted (t u), Interpreted (t v), Covariant u) 	=> (t u a -> t v b) -> u a -> Primary (t v) b (-=:) f = run . f . lift

@@ -1,6 +1,7 @@+{-# LANGUAGE AllowAmbiguousTypes #-} {-# OPTIONS_GHC -fno-warn-orphans #-} -module Pandora.Paradigm.Inventory (module Exports, zoom) where+module Pandora.Paradigm.Inventory (module Exports, zoom, magnify, (=<>), (~<>), adjust) where  import Pandora.Paradigm.Inventory.Optics as Exports import Pandora.Paradigm.Inventory.Store as Exports@@ -12,11 +13,14 @@  import Pandora.Core.Functor (type (~>)) import Pandora.Pattern.Category ((.), ($), identity)-import Pandora.Pattern.Functor (Adjoint ((-|), (|-)), extract, (<->))+import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))+import Pandora.Pattern.Functor.Extractable (extract)+import Pandora.Pattern.Functor.Bivariant ((<->)) import Pandora.Paradigm.Primary.Functor.Function ((!), (%)) import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:))) import Pandora.Paradigm.Controlflow.Effect.Interpreted (run) import Pandora.Paradigm.Controlflow.Effect.Adaptable (adapt)+import Pandora.Paradigm.Structure.Ability.Accessible (Accessible (access))  instance Adjoint (Store s) (State s) where 	(-|) :: a -> (Store s a -> b) -> State s b@@ -35,3 +39,15 @@ zoom :: Stateful bg t => Lens bg ls -> State ls ~> t zoom lens less = let restruct f v = f <-> identity $ run less v 	in adapt . State $ (|- restruct) . run . lens++(=<>) :: Stateful src t => src :-. tgt -> tgt -> t ()+lens =<> new = modify $ set lens new++(~<>) :: Stateful src t => src :-. tgt -> (tgt -> tgt) -> t ()+lens ~<> f = modify $ over lens f++magnify :: forall bg ls t . (Accessible ls bg, Stateful bg t) => t ls+magnify = zoom @bg (access @ls @bg) current++adjust :: forall bg ls t . (Accessible ls bg, Stateful bg t) => (ls -> ls) -> t ()+adjust = zoom @bg (access @ls @bg) . modify

@@ -2,7 +2,7 @@  module Pandora.Paradigm.Inventory.Optics where -import Pandora.Core.Functor (type (|->))+import Pandora.Core.Functor (type (:=>)) import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Covariant ((<$)) import Pandora.Pattern.Functor.Extractable (Extractable (extract))@@ -10,16 +10,18 @@ import Pandora.Pattern.Object.Setoid (Setoid ((==))) import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:))) import Pandora.Paradigm.Primary.Object.Boolean ((?))-import Pandora.Paradigm.Inventory.Store (Store (Store), access, position, retrofit)+import Pandora.Paradigm.Inventory.Store (Store (Store), position, look, retrofit)  infixr 0 :-.+infixr 0 :~.+ type (:-.) src tgt = Lens src tgt  -- Reference to taret within some source-type Lens src tgt = src |-> Store tgt+type Lens src tgt = src :=> Store tgt --- Lens as Numerator transformation-type (:~.) t u a = Lens (t a) (u a)+-- Lens as natural transformation+type (:~.) src tgt = forall a . Lens (src a) (tgt a)  -- | Lens composition infix operator (|>) :: Lens src old -> Lens old new -> Lens src new@@ -29,25 +31,13 @@ view :: Lens src tgt -> src -> tgt view lens = position . lens --- | Infix version of `view`-(^.) :: Lens src tgt -> src -> tgt-(^.) = view- -- | Replace the target of a lens set :: Lens src tgt -> tgt -> src -> src-set lens new = access new . lens---- | Infix version of `set`-(.~) :: Lens src tgt -> tgt -> src -> src-lens .~ new = set lens new+set lens new = look new . lens  -- | Modify the target of a lens over :: Lens src tgt -> (tgt -> tgt) -> src -> src over lens f = extract . retrofit f . lens---- | Infix version of `over`-(%~) :: Lens src tgt -> (tgt -> tgt) -> src -> src-lens %~ f = over lens f  -- | Representable based lens represent :: (Representable t, Setoid (Representation t)) => Representation t -> t a :-. a

@@ -2,7 +2,7 @@  module Pandora.Paradigm.Inventory.Store where -import Pandora.Core (type (:.), type (:=), type (<-|), type (~>))+import Pandora.Core (type (:.), type (:=), type (<:=), type (~>)) import Pandora.Pattern ((.|..)) import Pandora.Pattern.Category (identity, (.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))@@ -49,8 +49,8 @@ position = attached . run @(Store _) . adapt  -- | Given an index return value-access :: Storable s t => s -> a <-| t-access s = extract % s . run @(Store _) . adapt+look :: Storable s t => s -> a <:= t+look s = extract % s . run @(Store _) . adapt  -- | Change index with function retrofit :: (s -> s) -> Store s ~> Store s

@@ -16,7 +16,6 @@ import Pandora.Paradigm.Primary.Functor.Proxy as Exports import Pandora.Paradigm.Primary.Functor.Tagged as Exports import Pandora.Paradigm.Primary.Functor.Product as Exports-import Pandora.Paradigm.Primary.Functor.Delta as Exports import Pandora.Paradigm.Primary.Functor.Constant as Exports import Pandora.Paradigm.Primary.Functor.Identity as Exports import Pandora.Paradigm.Primary.Functor.Function as Exports

@@ -1,51 +0,0 @@-module Pandora.Paradigm.Primary.Functor.Delta where--import Pandora.Pattern.Category ((.))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))-import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))-import Pandora.Pattern.Functor.Representable (Representable (Representation, (<#>), tabulate))-import Pandora.Pattern.Object.Setoid (Setoid ((==)))-import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))-import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))-import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False))--infixr 1 :^:--data Delta a = a :^: a--instance Covariant Delta where-	f <$> (x :^: y) = f x :^: f y--instance Pointable Delta where-	point x = x :^: x--instance Applicative Delta where-	(f :^: g) <*> (x :^: y) = f x :^: g y--instance Distributive Delta where-	t >>- f = (True <#>) . f <$> t :^: (False <#>) . f <$> t--instance Traversable Delta where-	(x :^: y) ->> f = (:^:) <$> f x <*> f y--instance Extendable Delta where-	x =>> f = f x :^: f x--instance Representable Delta where-	type Representation Delta = Boolean-	True <#> (x :^: _) = x-	False <#> (_ :^: y) = y-	tabulate f = f True :^: f False--instance Setoid a => Setoid (Delta a) where-	(x :^: y) == (x' :^: y') = (x == x') * (y == y')--instance Semigroup a => Semigroup (Delta a) where-	(x :^: y) + (x' :^: y') = (x + x') :^: (y + y')--instance Ringoid a => Ringoid (Delta a) where-	(x :^: y) * (x' :^: y') = (x * x') :^: (y * y')

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

@@ -1,6 +1,6 @@ module Pandora.Paradigm.Primary.Functor.Predicate where -import Pandora.Core.Functor (type (~>), type (|->))+import Pandora.Core.Functor (type (~>), type (:=>)) import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<))) import Pandora.Pattern.Functor.Divisible (Divisible ((>*<)))@@ -24,7 +24,7 @@ instance Determinable Predicate where 	determine = Predicate (True !) -equate :: Setoid a => a |-> Predicate+equate :: Setoid a => a :=> Predicate equate x = Predicate (== x)  satisfy :: (Pointable t, Avoidable t) => Predicate a -> a -> t a

@@ -1,6 +1,6 @@ module Pandora.Paradigm.Primary.Functor.Tagged where -import Pandora.Core.Functor (type (|->), type (~>))+import Pandora.Core.Functor (type (:=>), type (~>)) import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>))) import Pandora.Pattern.Functor.Extractable (Extractable (extract))@@ -91,5 +91,5 @@ retag :: forall new old . Tagged old ~> Tagged new retag (Tag x) = Tag x -tagself :: a |-> Tagged a+tagself :: a :=> Tagged a tagself = Tag

@@ -1,6 +1,6 @@ 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.Category ((.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>))) import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))@@ -70,7 +70,7 @@ deconstruct ~(Construct _ xs) = xs  -- Generate a construction from seed using effectful computation-(.-+) :: Covariant t => a |-> t -> a |-> Construction t+(.-+) :: Covariant t => a :=> t -> a :=> Construction t f .-+ x = Construct x $ (f .-+) <$> f x  section :: Comonad t => t ~> Construction t

@@ -1,36 +1,23 @@ module Pandora.Paradigm.Schemes.T_U where -import Pandora.Core.Functor (type (~>)) import Pandora.Pattern.Category (($))-import Pandora.Pattern.Functor.Covariant (Covariant)+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>))) import Pandora.Pattern.Functor.Contravariant (Contravariant)-import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))-import Pandora.Pattern.Transformer.Liftable (Liftable (lift))-import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))-import Pandora.Pattern.Transformer.Hoistable (Hoistable (hoist))-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:))+import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->))) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite)) -newtype T_U ct cu t u a = T_U (t a :*: u a)+newtype T_U ct cu t p u a = T_U (p (t a) (u a)) -type (<:*:>) = T_U Covariant Covariant-type (>:*:>) = T_U Contravariant Covariant-type (<:*:<) = T_U Covariant Contravariant-type (>:*:<) = T_U Contravariant Contravariant+type (<:.:>) p t = T_U Covariant Covariant t p t+type (>:.:>) p t = T_U Contravariant Covariant t p t+type (<:.:<) p t = T_U Covariant Contravariant t p t+type (>:.:<) p t = T_U Contravariant Contravariant t p t -instance Interpreted (T_U ct cu t u) where-	type Primary (T_U ct cu t u) a = t a :*: u a+instance Interpreted (T_U ct cu t p u) where+	type Primary (T_U ct cu t p u) a = p (t a) (u a) 	run ~(T_U x) = x 	unite = T_U -instance Avoidable t => Liftable (T_U Covariant Covariant t) where-	lift :: Covariant u => u ~> t <:*:> u-	lift x = T_U $ empty :*: x--instance Lowerable (T_U Covariant Covariant t) where-	lower :: t <:*:> u ~> u-	lower ~(T_U (_ :*: y)) = y--instance Covariant t => Hoistable (T_U Covariant Covariant t) where-	hoist :: u ~> v -> (t <:*:> u ~> t <:*:> v)-	hoist f (T_U (x :*: y)) = T_U $ x :*: f y+instance (Bivariant p, Covariant t, Covariant u)+	=> Covariant (T_U Covariant Covariant t p u) where+		f <$> (T_U x) = T_U $ (f <$>) <-> (f <$>) $ x

@@ -1,36 +1,10 @@ module Pandora.Paradigm.Schemes.U_T where -import Pandora.Core.Functor (type (~>))-import Pandora.Pattern.Category (($))-import Pandora.Pattern.Functor.Covariant (Covariant)-import Pandora.Pattern.Functor.Contravariant (Contravariant)-import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))-import Pandora.Pattern.Transformer.Liftable (Liftable (lift))-import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))-import Pandora.Pattern.Transformer.Hoistable (Hoistable (hoist))-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:)) import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite)) -newtype U_T ct cu t u a = U_T (u a :*: t a)--type (<.:.>) = U_T Covariant Covariant-type (>.:.>) = U_T Contravariant Covariant-type (<.:.<) = U_T Covariant Contravariant-type (>.:.<) = U_T Contravariant Contravariant+newtype U_T ct cu t p u a = U_T (p (u a) (t a)) -instance Interpreted (U_T ct cu t u) where-	type Primary (U_T ct cu t u) a = u a :*: t a+instance Interpreted (U_T ct cu t p u) where+	type Primary (U_T ct cu t p u) a = p (u a) (t a) 	run ~(U_T x) = x 	unite = U_T--instance Avoidable t => Liftable (U_T Covariant Covariant t) where-	lift :: Covariant u => u ~> t <.:.> u-	lift x = U_T $ x :*: empty--instance Lowerable (U_T Covariant Covariant t) where-	lower :: t <.:.> u ~> u-	lower (U_T (x :*: _)) = x--instance Covariant t => Hoistable (U_T Covariant Covariant t) where-	hoist :: u ~> v -> (t <.:.> u ~> t <.:.> v)-	hoist f (U_T (x :*: y)) = U_T $ f x :*: y

@@ -10,16 +10,24 @@ import Pandora.Paradigm.Structure.Stack as Exports import Pandora.Paradigm.Structure.Stream as Exports -import Pandora.Pattern (($), (.), extract)+import Pandora.Pattern.Category (($), (.))+import Pandora.Pattern.Functor.Covariant (Covariant (comap))+import Pandora.Pattern.Functor.Extractable (extract)+import Pandora.Pattern.Functor.Pointable (point)+import Pandora.Pattern.Transformer.Liftable (lift)+import Pandora.Pattern.Object.Semigroup ((+)) import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, unite)+import Pandora.Paradigm.Inventory.Optics ((|>)) import Pandora.Paradigm.Inventory.Store (Store (Store)) import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False))-import Pandora.Paradigm.Primary.Functor.Delta (Delta ((:^:)))-import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just))+-- import Pandora.Paradigm.Primary.Functor.Delta (Delta ((:^:)))+import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))+import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))+import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag)) import Pandora.Paradigm.Primary.Functor.Predicate (Predicate (Predicate)) import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), attached)-import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag))-import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))+import Pandora.Paradigm.Primary.Functor.Wye (Wye (Both, Left, Right, End))+import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct)) import Pandora.Paradigm.Primary.Transformer.Tap (Tap (Tap)) import Pandora.Paradigm.Schemes.TU (type (<:.>)) @@ -29,30 +37,74 @@ instance Nullable Maybe where 	null = Predicate $ \case { Just _ -> True ; _ -> False } -instance Substructure Left (Product s) a where-	type Substructural Left (Product s) a = s-	substructure (extract -> s :*: x) = Store $ s :*: Tag . (:*: x)+instance Substructure Right (Product s) where+	type Substructural Right (Product s) = Identity+	substructure (extract . run -> s :*: x) =+		Store $ Identity x :*: lift . (s :*:) . extract -instance Substructure Right (Product s) a where-	type Substructural Right (Product s) a = a-	substructure (extract -> s :*: x) = Store $ x :*: Tag . (s :*:)+-- instance Substructure Left Delta where+-- 	type Substructural Left Delta = Identity+-- 	substructure (extract . run -> l :^: r) =+-- 		Store $ Identity l :*: lift . (:^: r) . extract+--+-- instance Substructure Right Delta where+-- 	type Substructural Right Delta = Identity+-- 	substructure (extract . run -> l :^: r) =+-- 		Store $ Identity r :*: lift . (l :^:) . extract+--+-- instance Covariant t => Substructure Left (Delta <:.> t) where+-- 	type Substructural Left (Delta <:.> t) = t+-- 	substructure (run . extract . run -> l :^: r) =+-- 		Store $ r :*: lift . unite . (l :^:)+--+-- instance Covariant t => Substructure Right (Delta <:.> t) where+-- 	type Substructural Right (Delta <:.> t) = t+-- 	substructure (run . extract . run -> l :^: r) =+-- 		Store $ l :*: lift . unite . (:^: r) -instance Substructure Left Delta a where-	type Substructural Left Delta a = a-	substructure (extract -> l :^: r) = Store $ l :*: Tag . (:^: r)+instance Covariant t => Substructure Tail (Tap t) where+	type Substructural Tail (Tap t) = t+	substructure (extract . run -> Tap x xs) =+		Store $ xs :*: lift . Tap x -instance Substructure Right Delta a where-	type Substructural Right Delta a = a-	substructure (extract -> l :^: r) = Store $ r :*: Tag . (l :^:)+instance Morphable Preorder (Construction Wye) where+	type Morphing Preorder (Construction Wye) = Construction Maybe+	morphing (extract . run -> Construct x End) = Construct x Nothing+	morphing (extract . run -> Construct x (Left lst)) = Construct x . Just $ morph @Preorder lst+	morphing (extract . run -> Construct x (Right rst)) = Construct x . Just $ morph @Preorder rst+	morphing (extract . run -> Construct x (Both lst rst)) = Construct x . Just $ morph @Preorder lst + morph @Preorder rst -instance Substructure Left (Delta <:.> t) a where-	type Substructural Left (Delta <:.> t) a = t a-	substructure (run . extract -> l :^: r) = Store $ r :*: Tag . unite . (l :^:)+instance Morphable Inorder (Construction Wye) where+	type Morphing Inorder (Construction Wye) = Construction Maybe+	morphing (extract . run -> Construct x End) = point x+	morphing (extract . run -> Construct x (Left lst)) = morph @Inorder lst + point x+	morphing (extract . run -> Construct x (Right rst)) = point x + morph @Inorder rst+	morphing (extract . run -> Construct x (Both lst rst)) = morph @Inorder lst + point x + morph @Inorder rst -instance Substructure Right (Delta <:.> t) a where-	type Substructural Right (Delta <:.> t) a = t a-	substructure (run . extract -> l :^: r) = Store $ l :*: Tag . unite . (:^: r)+instance Morphable Postorder (Construction Wye) where+	type Morphing Postorder (Construction Wye) = Construction Maybe+	morphing (extract . run -> Construct x End) = point x+	morphing (extract . run -> Construct x (Left lst)) = morph @Postorder lst + point x+	morphing (extract . run -> Construct x (Right rst)) = morph @Postorder rst + point x+	morphing (extract . run -> Construct x (Both lst rst)) = morph @Postorder lst + morph @Postorder rst + point x -instance Substructure Tail (Tap t) a where-	type Substructural Tail (Tap t) a = t a-	substructure (extract -> Tap x xs) = Store $ xs :*: Tag . Tap x+instance Morphable o (Construction Wye) => Morphable o Binary where+	type Morphing o Binary = Maybe <:.> Morphing o (Construction Wye)+	morphing = unite . comap (morph @o) . run . extract . run++instance Focusable Left (Product s) where+	type Focusing Left (Product s) a = s+	focusing (extract -> s :*: x) = Store $ s :*: Tag . (:*: x)++instance Focusable Right (Product s) where+	type Focusing Right (Product s) a = a+	focusing (extract -> s :*: x) = Store $ x :*: Tag . (s :*:)++instance Accessible s (s :*: a) where+	access ~(s :*: x) = Store $ s :*: (:*: x)++instance Accessible a (s :*: a) where+	access ~(s :*: x) = Store $ x :*: (s :*:)++instance {-# OVERLAPS #-} Accessible b a => Accessible b (s :*: a) where+	access = access @a |> access @b

@@ -3,11 +3,12 @@ import Pandora.Paradigm.Structure.Ability.Monotonic as Exports import Pandora.Paradigm.Structure.Ability.Zipper as Exports import Pandora.Paradigm.Structure.Ability.Substructure as Exports-import Pandora.Paradigm.Structure.Ability.Rotatable as Exports import Pandora.Paradigm.Structure.Ability.Insertable as Exports import Pandora.Paradigm.Structure.Ability.Measurable as Exports import Pandora.Paradigm.Structure.Ability.Focusable as Exports-import Pandora.Paradigm.Structure.Ability.Convertible as Exports+import Pandora.Paradigm.Structure.Ability.Deletable as Exports+import Pandora.Paradigm.Structure.Ability.Morphable as Exports+import Pandora.Paradigm.Structure.Ability.Accessible as Exports import Pandora.Paradigm.Structure.Ability.Nullable as Exports import Pandora.Paradigm.Structure.Ability.Nonempty as Exports import Pandora.Paradigm.Structure.Ability.Comprehension as Exports

@@ -0,0 +1,6 @@+module Pandora.Paradigm.Structure.Ability.Accessible where++import Pandora.Paradigm.Inventory.Optics (type (:-.))++class Accessible tgt src where+	access :: src :-. tgt

@@ -1,12 +0,0 @@-{-# LANGUAGE AllowAmbiguousTypes #-}--module Pandora.Paradigm.Structure.Ability.Convertible where--import Pandora.Pattern.Category ((.))-import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag))--class Convertible f t u a where-	conversion :: Tagged f (t a) -> u a--convert :: forall f t u a . Convertible f t u a => t a -> u a-convert = conversion . Tag @f

@@ -0,0 +1,6 @@+module Pandora.Paradigm.Structure.Ability.Deletable where++import Pandora.Pattern.Object.Setoid (Setoid)++class Deletable t where+	delete :: Setoid a => a -> t a -> t a

@@ -0,0 +1,19 @@+{-# LANGUAGE AllowAmbiguousTypes #-}++module Pandora.Paradigm.Structure.Ability.Morphable where++import Pandora.Core.Functor (type (~>))+import Pandora.Pattern.Category ((.))+import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag))+import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))++class Morphable f t where+	type Morphing (f :: k) (t :: * -> *) :: * -> *+	morphing :: Tagged f <:.> t ~> Morphing f t++morph :: forall f t . Morphable f t => t ~> Morphing f t+morph = morphing . TU . Tag @f++data Walk a = Preorder a | Inorder a | Postorder a | Levelorder a++data Morph a = Rotate a

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

@@ -2,18 +2,30 @@  module Pandora.Paradigm.Structure.Ability.Substructure where +import Pandora.Core.Functor (type (~>)) import Pandora.Pattern.Category ((.)) import Pandora.Pattern.Functor.Covariant (comap) import Pandora.Pattern.Functor.Extractable (extract)-import Pandora.Paradigm.Inventory.Optics (type (:-.))+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)+import Pandora.Paradigm.Inventory.Optics (type (:~.), view, over, set) import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag))+import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>)) -class Substructure f t a where-	type Substructural (f :: k) (t :: * -> *) a-	substructure :: Tagged f (t a) :-. Substructural f t a+class Substructure f t where+	type Substructural (f :: k) (t :: * -> *) :: * -> *+	substructure :: Tagged f <:.> t :~. Substructural f t -sub :: forall f t a . Substructure f t a => t a :-. Substructural f t a-sub = comap extract . substructure . Tag @f+	sub :: t :~. Substructural f t+	sub = comap (extract . run) . substructure . TU . Tag @f++	subview :: t ~> Substructural f t+	subview = view (sub @f)++	substitute :: (Substructural f t a -> Substructural f t a) -> t a -> t a+	substitute = over (sub @f)++	subplace :: (Substructural f t) a -> t a -> t a+	subplace = set (sub @f)  data Command a = Delete a 

@@ -19,23 +19,23 @@ import Pandora.Paradigm.Primary.Functor.Function ((!), (%), (&)) import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing)) import Pandora.Paradigm.Primary.Functor.Predicate (Predicate (Predicate))-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), attached)+import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), attached) import Pandora.Paradigm.Primary.Functor.Wye (Wye (End, Left, Right, Both)) import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag)) import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct)-import Pandora.Paradigm.Schemes (TU (TU), T_ (T_), T_U (T_U), type (<:.>), type (<:*:>))+import Pandora.Paradigm.Schemes (TU (TU), T_ (T_), T_U (T_U), type (<:.>)) import Pandora.Paradigm.Controlflow.Effect.Interpreted (run) import Pandora.Paradigm.Inventory.State (State, modify) import Pandora.Paradigm.Inventory.Store (Store (Store))-import Pandora.Paradigm.Inventory.Optics (type (:-.), (|>), (%~))+import Pandora.Paradigm.Inventory.Optics (over) import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty) import Pandora.Paradigm.Structure.Ability.Nullable (Nullable (null)) import Pandora.Paradigm.Structure.Ability.Focusable (Focusable (Focusing, focusing), Location (Root)) import Pandora.Paradigm.Structure.Ability.Measurable (Measurable (Measural, measurement), Scale (Heighth), measure) import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (resolve)) import Pandora.Paradigm.Structure.Ability.Insertable (Insertable (insert))-import Pandora.Paradigm.Structure.Ability.Rotatable (Rotatable (Rotational, rotation))-import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substructural, substructure), sub)+import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing))+import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substructural, substructure), sub, substitute) import Pandora.Paradigm.Structure.Ability.Zipper (Zipper)  type Binary = Maybe <:.> Construction Wye@@ -49,7 +49,7 @@ instance (forall a . Chain a) => Insertable Binary where 	insert x (run -> Nothing) = lift . Construct x $ End 	insert x tree@(run -> Just nonempty) = x <=> extract nonempty & order-		(sub @Left %~ insert x $ tree) tree (sub @Right %~ insert x $ tree)+		(tree & substitute @Left (insert x) ) tree (tree & substitute @Right (insert x))  instance (forall a . Chain a) => Focusable Root Binary where 	type Focusing Root Binary a = Maybe a@@ -64,18 +64,15 @@ instance Nullable Binary where 	null = Predicate $ \case { TU Nothing -> True ; _ -> False } -instance Substructure Left Binary a where-	type Substructural Left Binary a = Binary a-	substructure empty_tree@(run . extract -> Nothing) = Store $ extract empty_tree :*: (!) empty_tree-	substructure (run . extract -> Just tree) = Tag . lift <$> (sub @Left |> can_be_empty) tree--instance Substructure Right Binary a where-	type Substructural Right Binary a = Binary a-	substructure empty_tree@(run . extract -> Nothing) = Store $ extract empty_tree :*: (!) empty_tree-	substructure (run . extract -> Just tree) = Tag . lift <$> (sub @Right |> can_be_empty) tree+instance Substructure Left Binary where+	type Substructural Left Binary = Binary+	substructure empty_tree@(run . extract . run -> Nothing) = Store $ extract (run empty_tree) :*: (!) empty_tree+	substructure (run . extract . run -> Just tree) = lift . lift <$> sub @Left tree -can_be_empty :: Maybe (Construction Wye a) :-. Binary a-can_be_empty maybe_tree = Store $ TU maybe_tree :*: run+instance Substructure Right Binary where+	type Substructural Right Binary = Binary+	substructure empty_tree@(run . extract . run -> Nothing) = Store $ extract (run empty_tree) :*: (!) empty_tree+	substructure (run . extract . run -> Just tree) = lift . lift <$> sub @Right tree  binary :: forall t a . (Traversable t, Chain a) => t a -> Binary a binary struct = attached $ run @(State (Binary a)) % empty $ struct ->> modify @(Binary a) . insert' where@@ -83,7 +80,7 @@ 	insert' :: a -> Binary a -> Binary a 	insert' x (run -> Nothing) = lift . Construct x $ End 	insert' x tree@(run -> Just nonempty) = x <=> extract nonempty & order-		(sub @Left %~ insert' x $ tree) tree (sub @Right %~ insert' x $ tree)+		(tree & substitute @Left (insert' x)) tree (tree & substitute @Right (insert' x))  type instance Nonempty Binary = Construction Wye @@ -92,8 +89,8 @@ 	focusing (extract -> Construct x xs) = Store $ x :*: Tag . Construct % xs  instance (forall a . Chain a) => Insertable (Construction Wye) where-	insert x nonempty = let change = Just . resolve (insert x) (Construct x End) in-		x <=> extract nonempty & order (sub @Left %~ change $ nonempty) nonempty (sub @Right %~ change $ nonempty)+	insert x b = let change = lift . resolve (insert x) (Construct x End) . run in+		x <=> extract b & order (over (sub @Left) change $ b) b (over (sub @Right) change $ b)  instance Measurable Heighth (Construction Wye) where 	type Measural Heighth (Construction Wye) a = Denumerator@@ -104,51 +101,62 @@ 		let (lm :*: rm) = measure @Heighth lst :*: measure @Heighth rst 		in lm <=> rm & order rm lm lm -instance Substructure Left (Construction Wye) a where-	type Substructural Left (Construction Wye) a = Maybe :. Construction Wye := a-	substructure empty_tree@(extract -> Construct _ End) = Store $ Nothing :*: (empty_tree !)-	substructure (extract -> Construct x (Left lst)) = Store $ Just lst :*: Tag . Construct x . resolve Left End-	substructure (extract -> Construct x (Right rst)) = Store $ Nothing :*: Tag . Construct x . resolve (Both % rst) (Right rst)-	substructure (extract -> Construct x (Both lst rst)) = Store $ Just lst :*: Tag . Construct x . resolve (Both % rst) (Right rst)+instance Substructure Left (Construction Wye) where+	type Substructural Left (Construction Wye) = Binary+	substructure empty_tree@(extract . run -> Construct _ End) =+		Store $ TU Nothing :*: (empty_tree !)+	substructure (extract . run -> Construct x (Left lst)) =+		Store $ lift lst :*: lift . Construct x . resolve Left End . run+	substructure (extract . run -> Construct x (Right rst)) =+		Store $ empty :*: lift . Construct x . resolve (Both % rst) (Right rst) . run+	substructure (extract . run -> Construct x (Both lst rst)) =+		Store $ lift lst :*: lift . Construct x . resolve (Both % rst) (Right rst) . run -instance Substructure Right (Construction Wye) a where-	type Substructural Right (Construction Wye) a = Maybe :. Construction Wye := a-	substructure emtpy_tree@(extract -> Construct _ End) = Store $ Nothing :*: (emtpy_tree !)-	substructure (extract -> Construct x (Left lst)) = Store $ Nothing :*: Tag . Construct x . resolve (Both lst) (Left lst)-	substructure (extract -> Construct x (Right rst)) = Store $ Just rst :*: Tag . Construct x . resolve Right End-	substructure (extract -> Construct x (Both lst rst)) = Store $ Just rst :*: Tag . Construct x . resolve (Both lst) (Left lst)+instance Substructure Right (Construction Wye) where+	type Substructural Right (Construction Wye) = Binary+	substructure emtpy_tree@(extract . run -> Construct _ End) =+		Store $ empty :*: (emtpy_tree !)+	substructure (extract . run -> Construct x (Left lst)) =+		Store $ empty :*: lift . Construct x . resolve (Both lst) (Left lst) . run+	substructure (extract . run -> Construct x (Right rst)) =+		Store $ lift rst :*: lift . Construct x . resolve Right End . run+	substructure (extract . run -> Construct x (Both lst rst)) =+		 Store $ lift rst :*: lift . Construct x . resolve (Both lst) (Left lst) . run  data Biforked a = Top | Leftward a | Rightward a -type instance Zipper (Construction Wye) = Construction Wye <:*:> ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye))+type instance Zipper (Construction Wye) = T_U Covariant Covariant (Construction Wye) (:*:)+	((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye))  data Vertical a = Up a | Down a -instance Rotatable Up (Construction Wye <:*:> ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye))) where-	type Rotational Up (Construction Wye <:*:> ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye))) a-		= Maybe :. (Construction Wye <:*:> ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye))) := a-	rotation (run . extract -> focused :*: TU (TU (Leftward (Construct (T_ (parent :*: TU (Just rst))) next)))) =-		Just . T_U $ Construct parent (Both focused rst) :*: TU (TU next)-	rotation (run . extract -> focused :*: TU (TU (Leftward (Construct (T_ (parent :*: TU Nothing)) next)))) =-		Just . T_U $ Construct parent (Left focused) :*: TU (TU next)-	rotation (run . extract -> focused :*: TU (TU (Rightward (Construct (T_ (parent :*: TU (Just lst))) next)))) =-		Just . T_U $ Construct parent (Both lst focused) :*: TU (TU next)-	rotation (run . extract -> focused :*: TU (TU (Rightward (Construct (T_ (parent :*: TU Nothing)) next)))) =-		Just . T_U $ Construct parent (Right focused) :*: TU (TU next)-	rotation (extract -> T_U (_ :*: TU (TU Top))) = Nothing+instance Morphable Up (T_U Covariant Covariant (Construction Wye) (:*:) ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye))) where+	type Morphing Up (T_U Covariant Covariant (Construction Wye) (:*:) ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye)))+		= Maybe <:.> (T_U Covariant Covariant (Construction Wye) (:*:) ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye)))+	morphing (run . extract . run -> focused :*: TU (TU (Leftward (Construct (T_ (parent :*: TU (Just rst))) next)))) =+		TU . Just . T_U $ Construct parent (Both focused rst) :*: TU (TU next)+	morphing (run . extract . run -> focused :*: TU (TU (Leftward (Construct (T_ (parent :*: TU Nothing)) next)))) =+		TU . Just . T_U $ Construct parent (Left focused) :*: TU (TU next)+	morphing (run . extract . run -> focused :*: TU (TU (Rightward (Construct (T_ (parent :*: TU (Just lst))) next)))) =+		TU . Just . T_U $ Construct parent (Both lst focused) :*: TU (TU next)+	morphing (run . extract . run -> focused :*: TU (TU (Rightward (Construct (T_ (parent :*: TU Nothing)) next)))) =+		TU . Just . T_U $ Construct parent (Right focused) :*: TU (TU next)+	morphing (extract . run -> T_U (_ :*: TU (TU Top))) = TU Nothing -instance Rotatable (Down Left) (Construction Wye <:*:> ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye))) where-	type Rotational (Down Left) (Construction Wye <:*:> ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye))) a-		= Maybe :. (Construction Wye <:*:> ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye))) := a-	rotation (run . extract -> Construct x (Left lst) :*: TU (TU next)) = Just . T_U . (:*:) lst . TU . TU . Leftward . Construct (T_ $ x :*: TU Nothing) $ next-	rotation (run . extract -> Construct x (Both lst rst) :*: TU (TU next)) = Just . T_U . (:*:) lst . TU . TU . Leftward . Construct (T_ $ x :*: TU (Just rst)) $ next-	rotation (run . extract -> Construct _ (Right _) :*: _) = Nothing-	rotation (run . extract -> Construct _ End :*: _) = Nothing+instance Morphable (Down Left) (T_U Covariant Covariant (Construction Wye) (:*:) ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye))) where+	type Morphing (Down Left) (T_U Covariant Covariant (Construction Wye) (:*:) ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye)))+		= Maybe <:.> (T_U Covariant Covariant (Construction Wye) (:*:) ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye)))+	morphing (run . extract . run -> Construct x (Left lst) :*: TU (TU next)) =+		TU . Just . T_U . (:*:) lst . TU . TU . Leftward . Construct (T_ $ x :*: TU Nothing) $ next+	morphing (run . extract . run -> Construct x (Both lst rst) :*: TU (TU next)) =+		TU . Just . T_U . (:*:) lst . TU . TU . Leftward . Construct (T_ $ x :*: TU (Just rst)) $ next+	morphing (run . extract . run -> Construct _ (Right _) :*: _) = TU Nothing+	morphing (run . extract . run -> Construct _ End :*: _) = TU Nothing -instance Rotatable (Down Right) (Construction Wye <:*:> ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye))) where-	type Rotational (Down Right) (Construction Wye <:*:> ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye))) a-		= Maybe :. (Construction Wye <:*:> ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye))) := a-	rotation (run . extract -> Construct x (Right rst) :*: TU (TU next)) = Just . T_U . (:*:) rst . TU . TU . Rightward . Construct (T_ $ x :*: TU Nothing) $ next-	rotation (run . extract -> Construct x (Both lst rst) :*: TU (TU next)) = Just . T_U . (:*:) rst . TU . TU . Rightward . Construct (T_ $ x :*: TU (Just lst)) $ next-	rotation (run . extract -> Construct _ (Left _) :*: _) = Nothing-	rotation (run . extract -> Construct _ End :*: _) = Nothing+instance Morphable (Down Right) (T_U Covariant Covariant (Construction Wye) (:*:) ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye))) where+	type Morphing (Down Right) (T_U Covariant Covariant (Construction Wye) (:*:) ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye)))+		= Maybe <:.> (T_U Covariant Covariant (Construction Wye) (:*:) ((Biforked <:.> Construction Biforked) <:.> T_ Covariant (Maybe <:.> Construction Wye)))+	morphing (run . extract . run -> Construct x (Right rst) :*: TU (TU next)) = TU . Just . T_U . (:*:) rst . TU . TU . Rightward . Construct (T_ $ x :*: TU Nothing) $ next+	morphing (run . extract . run -> Construct x (Both lst rst) :*: TU (TU next)) = TU . Just . T_U . (:*:) rst . TU . TU . Rightward . Construct (T_ $ x :*: TU (Just lst)) $ next+	morphing (run . extract . run -> Construct _ (Left _) :*: _) = TU Nothing+	morphing (run . extract . run -> Construct _ End :*: _) = TU Nothing

@@ -2,7 +2,6 @@  module Pandora.Paradigm.Structure.Rose where -import Pandora.Core.Functor (type (:.), type (:=)) import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant (comap)) import Pandora.Pattern.Functor.Extractable (extract)@@ -31,15 +30,17 @@ 	type Focusing Root Rose a = Maybe a 	focusing (run . extract -> Nothing) = Store $ Nothing :*: Tag . TU . comap (Construct % empty) 	focusing (run . extract -> Just rose) = Store $ Just (extract rose)-		:*: Tag . resolve (lift . Construct % deconstruct rose) (TU Nothing)+		:*: Tag . resolve (lift . Construct % deconstruct rose) empty  instance Nullable Rose where 	null = Predicate $ \case { TU Nothing -> True ; _ -> False } -instance Substructure Just Rose a where-	type Substructural Just Rose a = Stack :. Construction Stack := a-	substructure (run . extract -> Nothing) = Store $ TU Nothing :*: (Tag (TU Nothing) !)-	substructure (run . extract -> Just (Construct x xs)) = Store $ xs :*: Tag . lift . Construct x+instance Substructure Just Rose where+	type Substructural Just Rose = Stack <:.> Construction Stack+	substructure (run . extract . run -> Nothing) =+		Store $ empty :*: (lift empty !)+	substructure (run . extract . run -> Just (Construct x xs)) =+		Store $ TU xs :*: lift . lift . Construct x . run  type instance Nonempty Rose = Construction Stack @@ -47,6 +48,6 @@ 	type Focusing Root (Construction Stack) a = a 	focusing (Tag rose) = Store $ extract rose :*: Tag . Construct % deconstruct rose -instance Substructure Just (Construction Stack) a where-	type Substructural Just (Construction Stack) a = Stack :. Construction Stack := a-	substructure (extract -> Construct x xs) = Store $ xs :*: Tag . Construct x+instance Substructure Just (Construction Stack) where+	type Substructural Just (Construction Stack) = Stack <:.> Construction Stack+	substructure (extract . run -> Construct x xs) = Store $ TU xs :*: lift . Construct x . run

@@ -1,8 +1,8 @@ {-# LANGUAGE UndecidableInstances #-}+{-# OPTIONS_GHC -fno-warn-orphans #-}  module Pandora.Paradigm.Structure.Splay where -import Pandora.Core.Functor (type (:.), type (:=)) import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>))) import Pandora.Pattern.Functor.Extractable (extract)@@ -11,54 +11,41 @@ import Pandora.Paradigm.Primary.Functor.Function ((%)) import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just)) import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))-import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag), type (:#)) import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct)-import Pandora.Paradigm.Inventory.Optics ((%~))-import Pandora.Paradigm.Structure.Ability.Rotatable (Rotatable (Rotational, rotation), rotate)-import Pandora.Paradigm.Structure.Ability.Substructure (sub)-import Pandora.Paradigm.Structure.Binary ()+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (||=))+import Pandora.Paradigm.Schemes (TU (TU))+import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), morph)+import Pandora.Paradigm.Structure.Ability.Substructure (substitute)+import Pandora.Paradigm.Structure.Binary (Binary)  data Splay a = Zig a | Zag a -instance Rotatable (Left Zig) (Construction Wye) where-	type Rotational (Left Zig) (Construction Wye) a = Maybe (Construction Wye a)-	rotation :: forall a . Left Zig :# Construction Wye a -> Maybe :. Construction Wye := a-	rotation (extract -> Construct parent st) = Construct % subtree <$> found where--		found :: Maybe a-		found = extract <$> left st--		subtree :: Wye :. Construction Wye := a-		subtree = branches (deconstruct <$> left st >>= left)-			. Just . Construct parent $ branches-				(deconstruct <$> left st >>= right) (right st)+instance Morphable (Left Zig) (Construction Wye) where+	type Morphing (Left Zig) (Construction Wye) = Binary+	morphing (extract . run -> Construct parent st) = TU $ Construct % subtree . extract <$> left st where -instance Rotatable (Right Zig) (Construction Wye) where-	type Rotational (Right Zig) (Construction Wye) a = Maybe (Construction Wye a)-	rotation :: forall a . Right Zig :# Construction Wye a -> Maybe :. Construction Wye := a-	rotation (extract -> Construct parent st) = Construct % subtree <$> found where+		subtree = branches (deconstruct <$> left st >>= left) . Just . Construct parent+			$ branches (deconstruct <$> left st >>= right) (right st) -		found :: Maybe a-		found = extract <$> right st+instance Morphable (Right Zig) (Construction Wye) where+	type Morphing (Right Zig) (Construction Wye) = Binary+	morphing (extract . run -> Construct parent st) = TU $ Construct % subtree . extract <$> right st where -		subtree :: Wye :. Construction Wye := a-		subtree = branches (left st)-			. Just . Construct parent $ branches-				(deconstruct <$> right st >>= left)-				(deconstruct <$> right st >>= right)+		subtree = branches (left st) . Just . Construct parent+			$ branches (deconstruct <$> right st >>= left) (deconstruct <$> right st >>= right) -instance Rotatable (Left (Zig Zig)) (Construction Wye) where-	type Rotational (Left (Zig Zig)) (Construction Wye) a = Maybe (Construction Wye a)-	rotation (Tag tree) = rotate @(Left Zig) tree >>= rotate @(Left Zig)+instance Morphable (Left (Zig Zig)) (Construction Wye) where+	type Morphing (Left (Zig Zig)) (Construction Wye) = Binary+	morphing (extract . run -> tree) = TU $ run (morph @(Left Zig) tree) >>= run . morph @(Left Zig) -instance Rotatable (Right (Zig Zig)) (Construction Wye) where-	type Rotational (Right (Zig Zig)) (Construction Wye) a = Maybe (Construction Wye a)-	rotation (Tag tree) = rotate @(Right Zig) tree >>= rotate @(Right Zig)+instance Morphable (Right (Zig Zig)) (Construction Wye) where+	type Morphing (Right (Zig Zig)) (Construction Wye) = Binary+	morphing (extract . run -> tree) = TU $ run (morph @(Right Zig) tree) >>= run . morph @(Right Zig) -instance Rotatable (Left (Zig Zag)) (Construction Wye) where-	type Rotational (Left (Zig Zag)) (Construction Wye) a = Maybe (Construction Wye a)-	rotation (Tag tree) = rotate @(Left Zig) $ sub @Left %~ (>>= rotate @(Right Zig)) $ tree+instance Morphable (Left (Zig Zag)) (Construction Wye) where+	type Morphing (Left (Zig Zag)) (Construction Wye) = Binary+	morphing = morph @(Left Zig) . substitute @Left ((>>= run . morph @(Right Zig)) ||=) . extract . run -instance Rotatable (Right (Zig Zag)) (Construction Wye) where-	type Rotational (Right (Zig Zag)) (Construction Wye) a = Maybe (Construction Wye a)-	rotation (Tag tree) = rotate @(Right Zig) $ sub @Right %~ (>>= rotate @(Left Zig)) $ tree+instance Morphable (Right (Zig Zag)) (Construction Wye) where+	type Morphing (Right (Zig Zag)) (Construction Wye) = Binary+	morphing = morph @(Right Zig) . substitute @Right ((>>= run . morph @(Left Zig)) ||=) . extract . run

@@ -2,16 +2,16 @@  module Pandora.Paradigm.Structure.Stack where -import Pandora.Core.Functor (type (:.), type (:=), type (|->))+import Pandora.Core.Functor (type (:.), type (:=)) import Pandora.Pattern ((.|..)) import Pandora.Pattern.Category ((.), ($), identity) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>))) import Pandora.Pattern.Functor.Alternative ((<+>)) import Pandora.Pattern.Functor.Pointable (point) import Pandora.Pattern.Functor.Extractable (extract)+import Pandora.Pattern.Functor.Avoidable (empty) import Pandora.Pattern.Functor.Traversable (Traversable) import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))-import Pandora.Pattern.Functor.Bindable (Bindable (join)) import Pandora.Pattern.Transformer.Liftable (lift) import Pandora.Pattern.Object.Setoid (Setoid ((==))) import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))@@ -19,29 +19,30 @@ import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False), (?)) import Pandora.Paradigm.Primary.Object.Numerator (Numerator (Numerator)) import Pandora.Paradigm.Primary.Object.Denumerator (Denumerator (One))-import Pandora.Paradigm.Primary.Functor.Delta (Delta ((:^:)))-import Pandora.Paradigm.Primary.Functor.Function ((!), (%), (&))+import Pandora.Paradigm.Primary.Functor.Function ((%), (&)) import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing)) import Pandora.Paradigm.Primary.Functor.Predicate (Predicate (Predicate))-import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)))+import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:)) 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.Tap (Tap (Tap)) import Pandora.Paradigm.Inventory.State (State, fold) import Pandora.Paradigm.Inventory.Store (Store (Store))-import Pandora.Paradigm.Inventory.Optics (view, (^.))-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, unite)+import Pandora.Paradigm.Inventory.Optics (view)+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run) import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))+import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>)) import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty) import Pandora.Paradigm.Structure.Ability.Nullable (Nullable (null)) import Pandora.Paradigm.Structure.Ability.Zipper (Zipper) import Pandora.Paradigm.Structure.Ability.Focusable (Focusable (Focusing, focusing), Location (Head), focus)+import Pandora.Paradigm.Structure.Ability.Deletable (Deletable (delete)) import Pandora.Paradigm.Structure.Ability.Insertable (Insertable (insert)) import Pandora.Paradigm.Structure.Ability.Measurable (Measurable (Measural, measurement), Scale (Length), measure) import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (reduce))-import Pandora.Paradigm.Structure.Ability.Rotatable (Rotatable (Rotational, rotation), rotate)-import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substructural, substructure), Command (Delete), Segment (All, First, Tail), sub)+import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), Morph (Rotate), morph)+import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substructural, substructure), Segment (Tail), sub, subview)  -- | Linear data structure that serves as a collection of elements type Stack = Maybe <:.> Construction Maybe@@ -55,16 +56,16 @@ 		$ TU @Covariant @Covariant xs + TU @Covariant @Covariant ys  instance Monoid (Stack a) where-	zero = TU Nothing+	zero = empty  instance Focusable Head Stack where 	type Focusing Head Stack a = Maybe a 	focusing (extract -> stack) = Store $ extract <$> run stack :*: \case-		Just x -> stack & view (sub @Tail) & insert x & Tag-		Nothing -> Tag $ sub @Tail ^. stack+		Just x -> stack & subview @Tail & insert x & Tag+		Nothing -> stack & subview @Tail & Tag  instance Insertable Stack where-	insert x (run -> stack) = unite $ (Construct x . Just <$> stack) <+> (point . point) x+	insert x (run -> stack) = TU $ (Construct x . Just <$> stack) <+> (point . point) x  instance Measurable Length Stack where 	type Measural Length Stack a = Numerator@@ -74,19 +75,15 @@ instance Nullable Stack where 	null = Predicate $ \case { TU Nothing -> True ; _ -> False } -instance Substructure Tail Stack a where-	type Substructural Tail Stack a = Stack a-	substructure (run . extract -> Just ns) = point . unite . Just <$> sub @Tail ns-	substructure (run . extract -> Nothing) = Store $ unite Nothing :*: point . identity--instance Setoid a => Substructure (Delete First) Stack a where-	type Substructural (Delete First) Stack a = a |-> Stack-	substructure (extract -> xs) = Store $ delete % xs :*: (point xs !) where+instance Substructure Tail Stack where+	type Substructural Tail Stack = Stack+	substructure (run . extract . run -> Just ns) = lift . lift <$> sub @Tail ns+	substructure (run . extract . run -> Nothing) = Store $ empty :*: lift . identity -		delete :: Setoid a => a -> Stack a -> Stack a-		delete _ (TU Nothing) = TU Nothing-		delete x (TU (Just (Construct y ys))) = x == y ? TU ys-			$ lift . Construct y . run . delete x $ TU ys+instance Deletable Stack where+	delete _ (TU Nothing) = TU Nothing+	delete x (TU (Just (Construct y ys))) = x == y ? TU ys+		$ lift . Construct y . run . delete @Stack x $ TU ys  filter :: forall a . Predicate a -> Stack a -> Stack a filter (Predicate p) = TU . extract@@ -99,6 +96,14 @@  type instance Nonempty Stack = Construction Maybe +instance {-# OVERLAPS #-} Semigroup (Construction Maybe a) where+	Construct x Nothing + ys = Construct x $ Just ys+	Construct x (Just xs) + ys = Construct x . Just $ xs + ys++instance Morphable Stack (Construction Maybe) where+	type Morphing Stack (Construction Maybe) = Stack+	morphing = lift . extract . run+ instance Focusable Head (Construction Maybe) where 	type Focusing Head (Construction Maybe) a = a 	focusing (extract -> stack) = Store $ extract stack :*: Tag . Construct % deconstruct stack@@ -114,50 +119,38 @@ instance Monotonic a (Construction Maybe a) where 	reduce f r ~(Construct x xs) = f x $ reduce f r xs -instance Substructure Tail (Construction Maybe) a where-	type Substructural Tail (Construction Maybe) a = Stack a-	substructure (extract -> Construct x xs) = Store $ unite xs :*: point . Construct x . run--instance Setoid a => Substructure (Delete First) (Construction Maybe) a where-	type Substructural (Delete First) (Construction Maybe) a = a |-> Stack-	substructure (extract -> xs) = Store $ delete % xs :*: (point xs !) where--		delete :: Setoid a => a -> Nonempty Stack a -> Stack a-		delete x (Construct y ys) = x == y ? unite ys-			$ unite $ Construct y . run . delete x <$> ys--instance Setoid a => Substructure (Delete All) (Construction Maybe) a where-	type Substructural (Delete All) (Construction Maybe) a = a |-> Stack-	substructure (extract -> xs) = Store $ delete % xs :*: (point xs !) where--		delete :: Setoid a => a -> Nonempty Stack a -> Stack a-		delete x (Construct y ys) = x == y-			? (unite . join $ run . delete x <$> ys)-			$ (unite $ Construct y . run . delete x <$> ys)+instance Substructure Tail (Construction Maybe) where+	type Substructural Tail (Construction Maybe) = Stack+	substructure (extract . run -> Construct x xs) =+		Store $ TU xs :*: lift . Construct x . run -type instance Zipper Stack = Tap (Delta <:.> Stack)+type instance Zipper Stack = Tap ((:*:) <:.:> Stack) -instance {-# OVERLAPS #-} Extendable (Tap (Delta <:.> Stack)) where+instance {-# OVERLAPS #-} Extendable (Tap ((:*:) <:.:> Stack)) where 	z =>> f = let move rtt = TU . deconstruct $ rtt .-+ z-		in f <$> Tap z (TU $ move (rotate @Left) :^: move (rotate @Right))+		in f <$> Tap z (T_U $ move (run . morph @(Rotate Left)) :*: move (run . morph @(Rotate Right))) -instance Rotatable Left (Tap (Delta <:.> Stack)) where-	type Rotational Left (Tap (Delta <:.> Stack)) a = Maybe :. Zipper Stack := a-	rotation (extract -> Tap x (TU (bs :^: fs))) = Tap % (TU $ sub @Tail ^. bs :^: insert x fs) <$> focus @Head ^. bs+instance Morphable (Rotate Left) (Tap ((:*:) <:.:> Stack)) where+	type Morphing (Rotate Left) (Tap ((:*:) <:.:> Stack)) = Maybe <:.> Zipper Stack+	morphing (extract . run -> Tap x (T_U (bs :*: fs))) = TU+		$ Tap % (T_U $ subview @Tail bs :*: insert x fs) <$> view (focus @Head) bs -instance Rotatable Right (Tap (Delta <:.> Stack)) where-	type Rotational Right (Tap (Delta <:.> Stack)) a = Maybe :. Zipper Stack := a-	rotation (extract -> Tap x (TU (bs :^: fs))) = Tap % (TU $ insert x bs :^: sub @Tail ^. fs) <$> focus @Head ^. fs+instance Morphable (Rotate Right) (Tap ((:*:) <:.:> Stack)) where+	type Morphing (Rotate Right) (Tap ((:*:) <:.:> Stack)) = Maybe <:.> Zipper Stack+	morphing (extract . run -> Tap x (T_U (bs :*: fs))) = TU+		$ Tap % (T_U $ insert x bs :*: subview @Tail fs) <$> view (focus @Head) fs -type instance Zipper (Construction Maybe) = Tap (Delta <:.> Construction Maybe)+type instance Zipper (Construction Maybe) = Tap ((:*:) <:.:> Construction Maybe) -instance Rotatable Left (Tap (Delta <:.> Construction Maybe)) where-	type Rotational Left (Tap (Delta <:.> Construction Maybe)) a = Maybe :. Zipper (Construction Maybe) := a-	rotation (extract -> Tap x (TU (bs :^: fs))) = Tap (extract bs) . TU . (:^: insert x fs) <$> deconstruct bs+instance Morphable (Rotate Left) (Tap ((:*:) <:.:> Construction Maybe)) where+	type Morphing (Rotate Left) (Tap ((:*:) <:.:> Construction Maybe)) = Maybe <:.> Zipper (Construction Maybe)+	morphing (extract . run -> Tap x (T_U (bs :*: fs))) = TU+		$ Tap (extract bs) . T_U . (:*: insert x fs) <$> deconstruct bs -instance Rotatable Right (Tap (Delta <:.> Construction Maybe)) where-	type Rotational Right (Tap (Delta <:.> Construction Maybe)) a = Maybe :. Zipper (Construction Maybe) := a-	rotation (extract -> Tap x (TU (bs :^: fs))) = Tap (extract fs) . TU . (insert x bs :^:) <$> deconstruct fs+instance Morphable (Rotate Right) (Tap ((:*:) <:.:> Construction Maybe)) where+	type Morphing (Rotate Right) (Tap ((:*:) <:.:> Construction Maybe)) = Maybe <:.> Zipper (Construction Maybe)+	morphing (extract . run -> Tap x (T_U (bs :*: fs))) = TU+		$ Tap (extract fs) . T_U . (insert x bs :*:) <$> deconstruct fs  instance Monotonic a (Maybe <:.> Construction Maybe := a) where 	reduce f r = reduce f r . run

@@ -2,38 +2,39 @@  module Pandora.Paradigm.Structure.Stream where -import Pandora.Core.Functor (type (|->))+import Pandora.Core.Functor (type (:=>)) import Pandora.Pattern.Category ((.), ($))-import Pandora.Pattern.Functor.Covariant ((<$>))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>))) import Pandora.Pattern.Functor.Pointable (point) import Pandora.Pattern.Functor.Extractable (extract) import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))-import Pandora.Paradigm.Primary.Functor.Delta (Delta ((:^:)))+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)+import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:)) import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity)) import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right)) import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct, (.-+)) import Pandora.Paradigm.Primary.Transformer.Tap (Tap (Tap))-import Pandora.Paradigm.Structure.Ability.Rotatable (Rotatable (Rotational, rotation), rotate)+import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), Morph (Rotate), morph) import Pandora.Paradigm.Structure.Ability.Zipper (Zipper)-import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))+import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))  type Stream = Construction Identity -type instance Zipper Stream = Tap (Delta <:.> Stream)+type instance Zipper Stream = Tap ((:*:) <:.:> Stream) -instance Rotatable Left (Tap (Delta <:.> Stream)) where-	type Rotational Left (Tap (Delta <:.> Stream)) a = Tap (Delta <:.> Stream) a-	rotation (extract -> Tap x (TU (bs :^: fs))) = Tap (extract bs) . TU-		$ extract (deconstruct bs) :^: Construct x (point fs)+instance Morphable (Rotate Left) (Tap ((:*:) <:.:> Stream)) where+	type Morphing (Rotate Left) (Tap ((:*:) <:.:> Stream)) = Tap ((:*:) <:.:> Stream)+	morphing (extract . run -> Tap x (T_U (bs :*: fs))) = Tap (extract bs) . T_U+		$ extract (deconstruct bs) :*: Construct x (point fs) -instance Rotatable Right (Tap (Delta <:.> Stream)) where-	type Rotational Right (Tap (Delta <:.> Stream)) a = Tap (Delta <:.> Stream) a-	rotation (extract -> Tap x (TU (bs :^: fs))) = Tap (extract fs) . TU-		$ Construct x (point bs) :^: extract (deconstruct fs)+instance Morphable (Rotate Right) (Tap ((:*:) <:.:> Stream)) where+	type Morphing (Rotate Right) (Tap ((:*:) <:.:> Stream)) = Tap ((:*:) <:.:> Stream)+	morphing (extract . run -> Tap x (T_U (bs :*: fs))) = Tap (extract fs) . T_U+		$ Construct x (point bs) :*: extract (deconstruct fs) -instance {-# OVERLAPS #-} Extendable (Tap (Delta <:.> Stream)) where+instance {-# OVERLAPS #-} Extendable (Tap ((:*:) <:.:> Stream)) where 	z =>> f = let move rtt = extract . deconstruct $ point . rtt .-+ z-		in f <$> Tap z (TU $ move (rotate @Left) :^: move (rotate @Right))+		in f <$> Tap z (T_U $ move (morph @(Rotate Left)) :*: move (morph @(Rotate Right))) -repeat :: a |-> Stream+repeat :: a :=> Stream repeat x = Construct x . Identity $ repeat x

@@ -35,6 +35,3 @@  	($>>=) :: Covariant u => u :. t := a -> (a -> t b) -> u :. t := b 	x $>>= f = (>>= f) <$> x--	-- (<>>=) :: (t b -> c) -> (a -> t b) -> t a -> c-	-- f <>>= g = f <$> (>>= g)

@@ -1,6 +1,6 @@ module Pandora.Pattern.Functor.Covariant where -import Pandora.Core.Functor (type (:.), type (:=), type (<-|))+import Pandora.Core.Functor (type (:.), type (:=), type (<:=)) import Pandora.Pattern.Category (Category ((.), ($)))  infixl 4 <$>, <$, $>@@ -37,7 +37,7 @@ 	void :: t a -> t () 	void x = () <$ x 	-- | Computing a value from a structure of values-	loeb :: t (a <-| t) -> t a+	loeb :: t (a <:= t) -> t a 	loeb tt = let fix f = let x = f x in x in fix (\f -> ($ f) <$> tt) 	-- | Flipped infix version of 'comap' 	(<&>) :: t a -> (a -> b) -> t b

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

@@ -1,8 +1,8 @@ module Pandora.Pattern.Functor.Pointable where -import Pandora.Core.Functor (type (|->))+import Pandora.Core.Functor (type (:=>)) import Pandora.Pattern.Functor.Covariant (Covariant)  class Covariant t => Pointable t where 	{-# MINIMAL point #-}-	point :: a |-> t+	point :: a :=> t

@@ -1,6 +1,6 @@ module Pandora.Pattern.Functor.Representable where -import Pandora.Core.Functor (type (<-|))+import Pandora.Core.Functor (type (<:=)) import Pandora.Pattern.Functor.Pointable (Pointable)  {- |@@ -15,7 +15,7 @@ 	{-# MINIMAL (<#>), tabulate #-} 	type Representation t :: * 	-- | Infix and flipped version of 'index'-	(<#>) :: Representation t -> a <-| t+	(<#>) :: Representation t -> a <:= t 	-- Build with a function which describes value 	tabulate :: (Representation t -> a) -> t a 	-- | Prefix and flipped version of '<#>'

@@ -1,5 +1,5 @@ name:                pandora-version:             0.3.5+version:             0.3.6 synopsis:            A box of patterns and paradigms description:         Humble attempt to define a library for problem solving based on math abstractions. homepage:            https://github.com/iokasimov/pandora@@ -35,7 +35,6 @@     Pandora.Paradigm.Primary.Functor.Function     Pandora.Paradigm.Primary.Functor.Conclusion     Pandora.Paradigm.Primary.Functor.Constant-    Pandora.Paradigm.Primary.Functor.Delta     Pandora.Paradigm.Primary.Functor.Edges     Pandora.Paradigm.Primary.Functor.Endo     Pandora.Paradigm.Primary.Functor.Fix@@ -102,11 +101,12 @@     Pandora.Paradigm.Structure.Rose     Pandora.Paradigm.Structure.Ability     Pandora.Paradigm.Structure.Ability.Comprehension-    Pandora.Paradigm.Structure.Ability.Convertible+    Pandora.Paradigm.Structure.Ability.Morphable+    Pandora.Paradigm.Structure.Ability.Deletable+    Pandora.Paradigm.Structure.Ability.Accessible     Pandora.Paradigm.Structure.Ability.Focusable     Pandora.Paradigm.Structure.Ability.Insertable     Pandora.Paradigm.Structure.Ability.Measurable-    Pandora.Paradigm.Structure.Ability.Rotatable     Pandora.Paradigm.Structure.Ability.Substructure     Pandora.Paradigm.Structure.Ability.Nonempty     Pandora.Paradigm.Structure.Ability.Nullable@@ -160,7 +160,7 @@     Pandora.Pattern.Transformer.Lowerable   default-extensions:     DataKinds, ConstraintKinds, ExistentialQuantification, GADTs, QuantifiedConstraints, InstanceSigs-    FlexibleContexts, FlexibleInstances, KindSignatures, LiberalTypeSynonyms, LambdaCase+    FlexibleContexts, FlexibleInstances, KindSignatures, LiberalTypeSynonyms, LambdaCase, FunctionalDependencies     MultiParamTypeClasses, NoImplicitPrelude, PackageImports, PolyKinds, RankNTypes, ViewPatterns     ScopedTypeVariables, TypeApplications, TypeFamilies, TypeFamilyDependencies, TypeOperators   default-language: Haskell2010