pandora 0.2.9 → 0.3.0

raw patch · 51 files changed

+346/−120 lines, 51 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• CHANGELOG.md +14/−0
• Pandora/Paradigm/Inventory/Optics.hs +7/−1
• Pandora/Paradigm/Inventory/State.hs +9/−2
• Pandora/Paradigm/Primary/Functor.hs +1/−0
• Pandora/Paradigm/Primary/Functor/Conclusion.hs +3/−3
• Pandora/Paradigm/Primary/Functor/Constant.hs +1/−1
• Pandora/Paradigm/Primary/Functor/Delta.hs +23/−6
• Pandora/Paradigm/Primary/Functor/Edges.hs +1/−1
• Pandora/Paradigm/Primary/Functor/Endo.hs +1/−1
• Pandora/Paradigm/Primary/Functor/Equivalence.hs +10/−0
• Pandora/Paradigm/Primary/Functor/Fix.hs +1/−1
• Pandora/Paradigm/Primary/Functor/Identity.hs +1/−1
• Pandora/Paradigm/Primary/Functor/Maybe.hs +1/−1
• Pandora/Paradigm/Primary/Functor/Predicate.hs +3/−3
• Pandora/Paradigm/Primary/Functor/Product.hs +5/−2
• Pandora/Paradigm/Primary/Functor/Tagged.hs +1/−1
• Pandora/Paradigm/Primary/Functor/These.hs +1/−1
• Pandora/Paradigm/Primary/Functor/Validation.hs +1/−1
• Pandora/Paradigm/Primary/Functor/Wedge.hs +1/−1
• Pandora/Paradigm/Primary/Functor/Wye.hs +8/−1
• Pandora/Paradigm/Primary/Object.hs +33/−0
• Pandora/Paradigm/Primary/Object/Boolean.hs +1/−1
• Pandora/Paradigm/Primary/Object/Ordering.hs +1/−1
• Pandora/Paradigm/Primary/Transformer.hs +1/−0
• Pandora/Paradigm/Primary/Transformer/Backwards.hs +1/−1
• Pandora/Paradigm/Primary/Transformer/Construction.hs +10/−9
• Pandora/Paradigm/Primary/Transformer/Continuation.hs +1/−1
• Pandora/Paradigm/Primary/Transformer/Day.hs +35/−0
• Pandora/Paradigm/Primary/Transformer/Instruction.hs +1/−1
• Pandora/Paradigm/Primary/Transformer/Jack.hs +1/−1
• Pandora/Paradigm/Primary/Transformer/Jet.hs +1/−1
• Pandora/Paradigm/Primary/Transformer/Kan.hs +1/−1
• Pandora/Paradigm/Primary/Transformer/Outline.hs +1/−1
• Pandora/Paradigm/Primary/Transformer/Reverse.hs +1/−1
• Pandora/Paradigm/Primary/Transformer/Tap.hs +1/−1
• Pandora/Paradigm/Primary/Transformer/Yoneda.hs +3/−2
• Pandora/Paradigm/Structure.hs +2/−2
• Pandora/Paradigm/Structure/Ability.hs +3/−0
• Pandora/Paradigm/Structure/Ability/Comprehension.hs +24/−0
• Pandora/Paradigm/Structure/Ability/Focusable.hs +1/−1
• Pandora/Paradigm/Structure/Ability/Insertable.hs +4/−0
• Pandora/Paradigm/Structure/Ability/Monotonic.hs +7/−0
• Pandora/Paradigm/Structure/Binary.hs +11/−49
• Pandora/Paradigm/Structure/Rose.hs +1/−1
• Pandora/Paradigm/Structure/Splay.hs +58/−0
• Pandora/Paradigm/Structure/Stack.hs +22/−10
• Pandora/Pattern.hs +1/−0
• Pandora/Pattern/Functor.hs +14/−1
• Pandora/Pattern/Functor/Bindable.hs +3/−2
• Pandora/Pattern/Functor/Representable.hs +1/−1
• pandora.cabal +8/−3

@@ -245,3 +245,17 @@ * Rename `sub` method of `Substructure` typeclass to `substructure` * Define `sub` method which doesn't involve `Tagged` * Change `Focusable` typeclass - now it's possible to point not only top/root++# 0.3.0+* Rename `Root` datatype to `Location` with `Head` (stack) and `Root` (tree) constructors+* Define `represent` as lens in `Representable` containers+* Define `Equivalence` datatype and define `Contravariant` instance for it+* Define `swop` for `Wye` (useful if you want to invert binary tree with `hoist swap`)+* Add experimental `Monotonic` typeclass+* Implement delete method for Stack+* Define `Comprehension` wrapper for data structures that can behave like list comprehensions+* Define experimental `Insertable` typeclass+* Define `Day convolution` datatype in `Transformer` module+* Define experimental methods: `<*+>`, `<**+>`, `<***+>`+* Rename Bindable method `>>=$` to `<>>=`+* Move `Comprehension` wrapper from `Construction` to `Structure.Ability` module

@@ -1,13 +1,16 @@ {-# OPTIONS_GHC -fno-warn-orphans #-} -module Pandora.Paradigm.Inventory.Optics (Lens, type (:-.), (|>), view, set, over, zoom, (^.), (.~), (%~)) where+module Pandora.Paradigm.Inventory.Optics where  import Pandora.Core.Functor (type (|->)) import Pandora.Pattern.Category (identity, (.), ($)) import Pandora.Pattern.Functor.Covariant ((<$)) import Pandora.Pattern.Functor.Extractable (Extractable (extract))+import Pandora.Pattern.Functor.Representable (Representable (Representation, (<#>), tabulate)) import Pandora.Pattern.Functor.Bivariant ((<->))+import Pandora.Pattern.Object.Setoid (Setoid ((==))) import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)))+import Pandora.Paradigm.Primary.Object.Boolean ((?)) import Pandora.Paradigm.Controlflow.Effect.Adaptable (adapt) import Pandora.Paradigm.Inventory.State (State (State), Stateful) import Pandora.Paradigm.Inventory.Store (Store (Store), access, position, retrofit)@@ -47,3 +50,6 @@  zoom :: Stateful bg t => Lens bg ls -> State ls a -> t a zoom lens (State f) = adapt . State $ (\(Store (p :*: g)) -> (g <-> identity) . f $ p) . lens++represent :: (Representable t, Setoid (Representation t)) => Representation t -> t a :-. a+represent r x = Store $ (r <#> x) :*: \new -> tabulate (\r' -> r' == r ? new $ r' <#> x)

@@ -5,6 +5,7 @@ import Pandora.Core.Functor (type (:.), type (:=)) import Pandora.Core.Morphism ((%)) import Pandora.Pattern.Category (identity, (.), ($))+import Pandora.Pattern.Functor ((<*+>)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>))) import Pandora.Pattern.Functor.Extractable (extract) import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))@@ -21,7 +22,7 @@ import Pandora.Paradigm.Controlflow.Effect.Schematic (Schematic) import Pandora.Paradigm.Schemes.TUT (TUT (TUT), type (<:<.>:>)) import Pandora.Paradigm.Primary.Object.Boolean (bool)-import Pandora.Paradigm.Primary.Functor.Predicate (Predicate (predicate))+import Pandora.Paradigm.Primary.Functor.Predicate (Predicate (Predicate)) import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)), type (:*:), delta)  newtype State s a = State ((->) s :. (:*:) s := a)@@ -47,7 +48,7 @@ 	$ struct ->> modify . op *> current  find :: (Pointable u, Avoidable u, Alternative u, Traversable t) => Predicate a -> t a -> u a-find p = fold empty (\x s -> (<+>) s . bool empty (point x) . predicate p $ x)+find (Predicate p) = fold empty (\x s -> (<+>) s . bool empty (point x) . p $ x)  instance Interpreted (State s) where 	type Primary (State s) a = (->) s :. (:*:) s := a@@ -74,6 +75,12 @@ 	TUT x >>= f = TUT $ \old -> x old >>= \(new :*: y) -> ($ new) . run . f $ y  instance Monad u => Monad ((->) s <:<.>:> (:*:) s := u) where++instance Alternative u => Alternative ((->) s <:<.>:> (:*:) s := u) where+	TUT x <+> TUT y = TUT (x <*+> y)++instance Avoidable u => Avoidable ((->) s <:<.>:> (:*:) s := u) where+	empty = TUT $ \_ -> empty  current :: Stateful s t => t s current = adapt $ State delta

@@ -1,6 +1,7 @@ module Pandora.Paradigm.Primary.Functor (module Exports, note, hush, left, right, this, that, here, there) where  import Pandora.Paradigm.Primary.Functor.Fix as Exports+import Pandora.Paradigm.Primary.Functor.Equivalence as Exports import Pandora.Paradigm.Primary.Functor.Predicate as Exports import Pandora.Paradigm.Primary.Functor.These as Exports import Pandora.Paradigm.Primary.Functor.Validation as Exports

@@ -1,11 +1,11 @@-module Pandora.Paradigm.Primary.Functor.Conclusion (Conclusion (..), Failable, conclusion, fail, failure) where+module Pandora.Paradigm.Primary.Functor.Conclusion where  import Pandora.Core.Functor (type (~>)) import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>))) import Pandora.Pattern.Functor.Pointable (Pointable (point)) import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), apply))+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>))) import Pandora.Pattern.Functor.Traversable (Traversable ((->>))) import Pandora.Pattern.Functor.Bindable (Bindable ((>>=))) import Pandora.Pattern.Functor.Monad (Monad)@@ -92,7 +92,7 @@ 	f <$> UT x = UT $ f <$$> x  instance Applicative u => Applicative (UT Covariant Covariant (Conclusion e) u) where-	UT f <*> UT x = UT $ apply <$> f <*> x+	UT f <*> UT x = UT $ (<*>) <$> f <*> x  instance Pointable u => Pointable (UT Covariant Covariant (Conclusion e) u) where 	point = UT . point . point

@@ -1,4 +1,4 @@-module Pandora.Paradigm.Primary.Functor.Constant (Constant (..)) where+module Pandora.Paradigm.Primary.Functor.Constant where  import Pandora.Pattern.Category (($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))

@@ -1,30 +1,47 @@-module Pandora.Paradigm.Primary.Functor.Delta (Delta (..), type (:^:)) where+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.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)) -data Delta a = a :^: a+infixr 1 :^: -type (:^:) = Delta+data Delta a = a :^: a  instance Covariant Delta where-	f <$> x :^: y = f x :^: f y+	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+	(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+	(x :^: y) ->> f = (:^:) <$> f x <*> f y  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,4 +1,4 @@-module Pandora.Paradigm.Primary.Functor.Edges (Edges (..), edges) where+module Pandora.Paradigm.Primary.Functor.Edges where  import Pandora.Pattern.Category (($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))

@@ -1,4 +1,4 @@-module Pandora.Paradigm.Primary.Functor.Endo (Endo (..)) where+module Pandora.Paradigm.Primary.Functor.Endo where  import Pandora.Pattern.Category (identity, (.)) import Pandora.Pattern.Functor.Invariant (Invariant (invmap))

@@ -0,0 +1,10 @@+module Pandora.Paradigm.Primary.Functor.Equivalence where++import Pandora.Pattern.Category (($))+import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))+import Pandora.Paradigm.Primary.Object.Boolean (Boolean)++data Equivalence a = Equivalence (a -> a -> Boolean)++instance Contravariant Equivalence where+	f >$< Equivalence g = Equivalence $ \x y -> g (f x) (f y)

@@ -1,4 +1,4 @@-module Pandora.Paradigm.Primary.Functor.Fix (Fix (..), cata, ana, hylo) where+module Pandora.Paradigm.Primary.Functor.Fix where  import Pandora.Core.Functor (type (<-|), type (|->)) import Pandora.Pattern.Category ((.))

@@ -1,4 +1,4 @@-module Pandora.Paradigm.Primary.Functor.Identity (Identity (..)) where+module Pandora.Paradigm.Primary.Functor.Identity where  import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), comap))

@@ -1,4 +1,4 @@-module Pandora.Paradigm.Primary.Functor.Maybe (Maybe (..), Optional, maybe, nothing) where+module Pandora.Paradigm.Primary.Functor.Maybe where  import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))

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

@@ -1,5 +1,4 @@-module Pandora.Paradigm.Primary.Functor.Product (Product (..), type (:*:)-	, delta, swap, attached, curry, uncurry) where+module Pandora.Paradigm.Primary.Functor.Product where  import Pandora.Pattern.Category (($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))@@ -17,6 +16,7 @@ import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/))) import Pandora.Pattern.Object.Lattice (Lattice) import Pandora.Pattern.Object.Group (Group (invert))+import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (iterate))  infixr 1 :*: @@ -70,6 +70,9 @@  instance (Group a, Group b) => Group (Product a b) where 	invert (x :*: y) = invert x :*: invert y++instance Monotonic e a => Monotonic (Product a e) a where+	iterate f r (x :*: e) = iterate f (f x r) e  delta :: a -> a :*: a delta x = x :*: x

@@ -1,4 +1,4 @@-module Pandora.Paradigm.Primary.Functor.Tagged (Tagged (..), retag, tagself, type (:#)) where+module Pandora.Paradigm.Primary.Functor.Tagged where  import Pandora.Core.Functor (type (|->), type (~>)) import Pandora.Pattern.Category ((.), ($))

@@ -1,4 +1,4 @@-module Pandora.Paradigm.Primary.Functor.These (These (..), these) where+module Pandora.Paradigm.Primary.Functor.These where  import Pandora.Pattern.Category (($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))

@@ -1,4 +1,4 @@-module Pandora.Paradigm.Primary.Functor.Validation (Validation (..)) where+module Pandora.Paradigm.Primary.Functor.Validation where  import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))

@@ -1,4 +1,4 @@-module Pandora.Paradigm.Primary.Functor.Wedge (Wedge (..), wedge) where+module Pandora.Paradigm.Primary.Functor.Wedge where  import Pandora.Pattern.Category (($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))

@@ -1,5 +1,6 @@-module Pandora.Paradigm.Primary.Functor.Wye (Wye (..), wye) where+module Pandora.Paradigm.Primary.Functor.Wye where +import Pandora.Core.Functor (type (~>)) import Pandora.Pattern.Category (($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>))) import Pandora.Pattern.Functor.Pointable (Pointable (point))@@ -25,3 +26,9 @@ 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

@@ -1,4 +1,37 @@+{-# OPTIONS_GHC -fno-warn-orphans #-}+ module Pandora.Paradigm.Primary.Object (module Exports) where  import Pandora.Paradigm.Primary.Object.Ordering as Exports import Pandora.Paradigm.Primary.Object.Boolean as Exports++import Pandora.Pattern.Object.Setoid (Setoid ((==)))+import Pandora.Pattern.Object.Chain (Chain ((<=>)))++instance Setoid Boolean where+	True == True = True+	False == False = True+	_ == _ = False++instance Chain Boolean where+	True <=> True = Equal+	True <=> False = Greater+	False <=> True = Less+	False <=> False = Equal++instance Setoid Ordering where+	Less == Less = True+	Equal == Equal = True+	Greater == Greater = True+	_ == _ = False++instance Chain Ordering where+	Less <=> Less = Equal+	Less <=> Equal = Less+	Less <=> Greater = Less+	Equal <=> Less = Greater+	Equal <=> Equal = Equal+	Equal <=> Greater = Equal+	Greater <=> Less = Greater+	Greater <=> Equal = Greater+	Greater <=> Greater = Equal

@@ -1,4 +1,4 @@-module Pandora.Paradigm.Primary.Object.Boolean (Boolean (..), bool, (?)) where+module Pandora.Paradigm.Primary.Object.Boolean where  import Pandora.Pattern.Object.Semigroup (Semigroup ((+))) import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))

@@ -1,4 +1,4 @@-module Pandora.Paradigm.Primary.Object.Ordering (Ordering (..), order) where+module Pandora.Paradigm.Primary.Object.Ordering where  data Ordering = Less | Equal | Greater 

@@ -4,6 +4,7 @@ import Pandora.Paradigm.Primary.Transformer.Tap as Exports import Pandora.Paradigm.Primary.Transformer.Continuation as Exports import Pandora.Paradigm.Primary.Transformer.Kan as Exports+import Pandora.Paradigm.Primary.Transformer.Day as Exports import Pandora.Paradigm.Primary.Transformer.Jet as Exports import Pandora.Paradigm.Primary.Transformer.Jack as Exports import Pandora.Paradigm.Primary.Transformer.Outline as Exports

@@ -1,4 +1,4 @@-module Pandora.Paradigm.Primary.Transformer.Backwards (Backwards (..)) where+module Pandora.Paradigm.Primary.Transformer.Backwards where  import Pandora.Core.Morphism ((&)) import Pandora.Pattern.Category ((.), ($))

@@ -1,4 +1,4 @@-module Pandora.Paradigm.Primary.Transformer.Construction (Construction (..), deconstruct, coiterate, section) where+module Pandora.Paradigm.Primary.Transformer.Construction where  import Pandora.Core.Functor (type (:.), type (:=), type (|->), type (~>)) import Pandora.Pattern.Category ((.), ($))@@ -19,7 +19,7 @@ import Pandora.Pattern.Object.Semigroup (Semigroup ((+))) import Pandora.Pattern.Object.Ringoid ((*)) import Pandora.Pattern.Object.Monoid (Monoid (zero))-import Pandora.Paradigm.Schemes.TU (TU (TU))+import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))  data Construction t a = Construct a (t :. Construction t := a) @@ -39,7 +39,8 @@ 	Construct x xs ->> f = Construct <$> f x <*> xs ->>> f  instance Alternative t => Bindable (Construction t) where-	Construct x xs >>= f = case f x of Construct y ys -> Construct y $ ys <+> (>>= f) <$> xs+	Construct x xs >>= f = case f x of+		Construct y ys -> Construct y $ ys <+> (>>= f) <$> xs  instance Covariant t => Extendable (Construction t) where 	x =>> f = Construct (f x) $ extend f <$> deconstruct x@@ -72,20 +73,20 @@ section :: Comonad t => t ~> Construction t section as = Construct (extract as) $ extend section as -instance (Covariant t, Covariant u) => Covariant (TU Covariant Covariant u (Construction t)) where+instance (Covariant t, Covariant u) => Covariant (u <:.> Construction t) where 	f <$> TU g = TU $ f <$$> g -instance (Avoidable t, Pointable u) => Pointable (TU Covariant Covariant u (Construction t)) where+instance (Avoidable t, Pointable u) => Pointable (u <:.> Construction t) where 	point x = TU . point . Construct x $ empty -instance (Applicative t, Applicative u) => Applicative (TU Covariant Covariant u (Construction t)) where+instance (Applicative t, Applicative u) => Applicative (u <:.> Construction t) where 	TU f <*> TU x = TU $ f <**> x -instance (Covariant t, Alternative u) => Alternative (TU Covariant Covariant u (Construction t)) where+instance (Covariant t, Alternative u) => Alternative (u <:.> Construction t) where 	TU x <+> TU y = TU $ x <+> y -instance (Covariant t, Avoidable u) => Avoidable (TU Covariant Covariant u (Construction t)) where+instance (Covariant t, Avoidable u) => Avoidable (u <:.> Construction t) where 	empty = TU empty -instance (Traversable t, Traversable u) => Traversable (TU Covariant Covariant u (Construction t)) where+instance (Traversable t, Traversable u) => Traversable (u <:.> Construction t) where 	TU g ->> f = TU <$> g ->>> f

@@ -1,4 +1,4 @@-module Pandora.Paradigm.Primary.Transformer.Continuation (Continuation (..), cwcc, reset, shift) where+module Pandora.Paradigm.Primary.Transformer.Continuation where  import Pandora.Core.Functor (type (:.), type (:=), type (::|:.)) import Pandora.Core.Morphism ((!), (%))

@@ -0,0 +1,35 @@+module Pandora.Paradigm.Primary.Transformer.Day where++import Pandora.Pattern.Category (($))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), (.|..))+import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Extractable (Extractable (extract))+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))+import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))+import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))+import Pandora.Pattern.Transformer.Hoistable (Hoistable (hoist))+import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:)))++data Day t u a = forall b c . Day (t b) (u c) (b -> c -> a)++instance Covariant (Day t u) where+	f <$> Day tb uc g = Day tb uc (f .|.. g)++instance (Pointable t, Pointable u) => Pointable (Day t u) where+	point x = Day (point ()) (point ()) $ \_ _ -> x++instance (Applicative t, Applicative u) => Applicative (Day t u) where+	Day tb uc bcad <*> Day vb wc bca = Day ((:*:) <$> tb <*> vb) ((:*:) <$> uc <*> wc)+		$ \(b :*: b') (c :*: c') -> bcad b c $ bca b' c'++instance (Extractable t, Extractable u) => Extractable (Day t u) where+	extract (Day tb uc bcad) = bcad (extract tb) (extract uc)++instance (Extendable t, Extendable u) => Extendable (Day t u) where+	day@(Day tb uc _) =>> f = Day tb uc (\_ _ -> f day)++instance Extractable t => Lowerable (Day t) where+	lower (Day tb uc bca) = bca (extract tb) <$> uc++instance Hoistable (Day t) where+	hoist g (Day tb uc bca) = Day tb (g uc) bca

@@ -1,4 +1,4 @@-module Pandora.Paradigm.Primary.Transformer.Instruction (Instruction (..)) where+module Pandora.Paradigm.Primary.Transformer.Instruction where  import Pandora.Core.Functor (type (:.), type (:=)) import Pandora.Pattern.Category (($))

@@ -1,4 +1,4 @@-module Pandora.Paradigm.Primary.Transformer.Jack (Jack (..), jack) where+module Pandora.Paradigm.Primary.Transformer.Jack where  import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), comap)

@@ -1,4 +1,4 @@-module Pandora.Paradigm.Primary.Transformer.Jet (Jet (..)) where+module Pandora.Paradigm.Primary.Transformer.Jet where  import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)), (<$$>)) import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))

@@ -1,4 +1,4 @@-module Pandora.Paradigm.Primary.Transformer.Kan (Kan (..)) where+module Pandora.Paradigm.Primary.Transformer.Kan where  import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))

@@ -1,4 +1,4 @@-module Pandora.Paradigm.Primary.Transformer.Outline (Outline (..)) where+module Pandora.Paradigm.Primary.Transformer.Outline where  import Pandora.Core.Morphism ((%)) import Pandora.Pattern.Category (identity, (.), ($))

@@ -1,4 +1,4 @@-module Pandora.Paradigm.Primary.Transformer.Reverse (Reverse (..)) where+module Pandora.Paradigm.Primary.Transformer.Reverse where  import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))

@@ -1,4 +1,4 @@-module Pandora.Paradigm.Primary.Transformer.Tap (Tap (..)) where+module Pandora.Paradigm.Primary.Transformer.Tap where  import Pandora.Core.Morphism ((%)) import Pandora.Pattern.Category ((.), ($))

@@ -1,7 +1,8 @@-module Pandora.Paradigm.Primary.Transformer.Yoneda (Yoneda (..)) where+module Pandora.Paradigm.Primary.Transformer.Yoneda where  import Pandora.Core.Morphism ((!)) import Pandora.Pattern.Category (identity, (.), ($))+import Pandora.Pattern.Functor ((<*+>)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>))) import Pandora.Pattern.Functor.Alternative (Alternative ((<+>))) import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))@@ -18,7 +19,7 @@ 	f <$> x = Yoneda (\k -> yoneda x (k . f))  instance Alternative t => Alternative (Yoneda t) where-	Yoneda f <+> Yoneda g = Yoneda (\k -> f k <+> g k)+	Yoneda f <+> Yoneda g = Yoneda (f <*+> g)  instance Applicative t => Applicative (Yoneda t) where 	Yoneda f <*> Yoneda x = Yoneda (\g -> f (g .) <*> x identity)

@@ -1,7 +1,7 @@ module Pandora.Paradigm.Structure (module Exports) where -import Pandora.Paradigm.Structure.Ability.Substructure as Exports-import Pandora.Paradigm.Structure.Ability.Nonempty as Exports+import Pandora.Paradigm.Structure.Ability as Exports import Pandora.Paradigm.Structure.Rose as Exports+import Pandora.Paradigm.Structure.Splay as Exports import Pandora.Paradigm.Structure.Binary as Exports import Pandora.Paradigm.Structure.Stack as Exports

@@ -1,7 +1,10 @@ module Pandora.Paradigm.Structure.Ability (module Exports) where +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.Focusable as Exports import Pandora.Paradigm.Structure.Ability.Nonempty as Exports+import Pandora.Paradigm.Structure.Ability.Comprehension as Exports

@@ -0,0 +1,24 @@+{-# LANGUAGE UndecidableInstances #-}++module Pandora.Paradigm.Structure.Ability.Comprehension where++import Pandora.Core.Functor (type (:=))+import Pandora.Pattern.Category ((.), ($))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))+import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))+import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))+import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct))+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run))++newtype Comprehension t a = Comprehension (t <:.> Construction t := a)++instance Interpreted (Comprehension t) where+	type Primary (Comprehension t) a = t <:.> Construction t := a+	run (Comprehension x) = x++instance Covariant (t <:.> Construction t) => Covariant (Comprehension t) where+	f <$> Comprehension x = Comprehension $ f <$> x++instance (forall a . Semigroup (t <:.> Construction t := a), Bindable t) => Bindable (Comprehension t) where+	Comprehension (TU t) >>= f = Comprehension . TU $ t >>= \(Construct x xs) -> run $ run (f x) + run (Comprehension (TU xs) >>= f)

@@ -15,4 +15,4 @@ focus :: forall f t a . Focusable f t => t a :-. Focusing f t a focus = comap extract . focusing . Tag @f -data Root a+data Location a = Root a | Head a

@@ -0,0 +1,4 @@+module Pandora.Paradigm.Structure.Ability.Insertable where++class Insertable t where+	insert :: a -> t a -> t a

@@ -0,0 +1,7 @@+module Pandora.Paradigm.Structure.Ability.Monotonic where++class Monotonic e a where+	iterate :: (a -> r -> r) -> r -> e -> r++instance Monotonic a a where+	iterate f r x = f x r

@@ -8,11 +8,9 @@ import Pandora.Pattern.Category ((.), ($)) import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), comap)) import Pandora.Pattern.Functor.Extractable (extract)-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=))) import Pandora.Pattern.Transformer.Liftable (lift) import Pandora.Pattern.Object.Chain (Chain ((<=>))) import Pandora.Paradigm.Primary.Object.Ordering (order)-import Pandora.Paradigm.Primary.Functor (left, right) import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing), maybe) import Pandora.Paradigm.Primary.Functor.Product (Product ((:*:))) import Pandora.Paradigm.Primary.Functor.Wye (Wye (End, Left, Right, Both))@@ -23,23 +21,23 @@ import Pandora.Paradigm.Inventory.Store (Store (Store)) import Pandora.Paradigm.Inventory.Optics (type (:-.), (|>), (%~)) import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty)-import Pandora.Paradigm.Structure.Ability.Focusable (Focusable (Focusing, focusing), Root)-import Pandora.Paradigm.Structure.Ability.Rotatable (Rotatable (rotation), rotate)+import Pandora.Paradigm.Structure.Ability.Focusable (Focusable (Focusing, focusing), Location (Root))+import Pandora.Paradigm.Structure.Ability.Insertable (Insertable (insert)) import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substructural, substructure), sub)  type Binary = Maybe <:.> Construction Wye -insert :: Chain a => 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)- rebalance :: Chain a => (Wye :. Construction Wye := a) -> Nonempty Binary a rebalance (Both x y) = extract x <=> extract y & order 	(Construct (extract y) $ Both x (rebalance $ deconstruct y)) 	(Construct (extract x) $ Both (rebalance $ deconstruct x) (rebalance $ deconstruct y)) 	(Construct (extract x) $ Both (rebalance $ deconstruct x) y) +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)+ instance (forall a . Chain a) => Focusable Root Binary where 	type Focusing Root Binary a = Maybe a 	focusing (run . extract -> Nothing) = Store $ Nothing :*: Tag . TU . comap (Construct % End)@@ -64,6 +62,10 @@ 	type Focusing Root (Construction Wye) a = a 	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 . maybe (Construct x End) (insert x) in+		x <=> extract nonempty & order (sub @Left %~ change $ nonempty) nonempty (sub @Right %~ change $ nonempty)+ instance Substructure Left (Construction Wye) where 	type Substructural Left (Construction Wye) a = Maybe :. Construction Wye := a 	substructure empty_tree@(extract -> Construct _ End) = Store $ Nothing :*: (!) empty_tree@@ -77,43 +79,3 @@ 	substructure (extract -> Construct x (Left lst)) = Store $ Nothing :*: Tag . Construct x . maybe (Left lst) (Both lst) 	substructure (extract -> Construct x (Right rst)) = Store $ Just rst :*: Tag . Construct x . maybe End Right 	substructure (extract -> Construct x (Both lst rst)) = Store $ Just rst :*: Tag . Construct x . maybe (Left lst) (Both lst)--data Splay a = Zig a | Zag a--instance Rotatable (Left Zig) (Construction Wye) where-	rotation (Tag (Construct parent st)) = Construct % subtree <$> found where--		subtree = maybe_subtree a . Just . Construct parent $ maybe_subtree b c-		found = extract <$> left st-		a = deconstruct <$> left st >>= left-		b = deconstruct <$> left st >>= right-		c = right st--instance Rotatable (Right Zig) (Construction Wye) where-	rotation (Tag (Construct parent st)) = Construct % subtree <$> found where--		found = extract <$> right st-		subtree = maybe_subtree a . Just . Construct parent $ maybe_subtree b c-		a = left st-		b = deconstruct <$> right st >>= left-		c = deconstruct <$> right st >>= right--instance Rotatable (Left (Zig Zig)) (Construction Wye) where-	rotation (Tag tree) = rotate @(Left Zig) tree >>= rotate @(Left Zig)--instance Rotatable (Right (Zig Zig)) (Construction Wye) where-	rotation (Tag tree) = rotate @(Right Zig) tree >>= rotate @(Right Zig)--instance Rotatable (Left (Zig Zag)) (Construction Wye) where-	rotation (Tag tree) = rotate @(Left Zig)-		$ sub @Left %~ (>>= rotate @(Right Zig)) $ tree--instance Rotatable (Right (Zig Zag)) (Construction Wye) where-	rotation (Tag tree) = rotate @(Right Zig)-		$ sub @Right %~ (>>= rotate @(Left Zig)) $ tree--maybe_subtree :: Maybe a -> Maybe a -> Wye a-maybe_subtree (Just x) (Just y) = Both x y-maybe_subtree Nothing (Just y) = Right y-maybe_subtree (Just x) Nothing = Left x-maybe_subtree Nothing Nothing = End

@@ -17,7 +17,7 @@ import Pandora.Paradigm.Controlflow.Effect.Interpreted (run) import Pandora.Paradigm.Inventory.Store (Store (Store)) import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty)-import Pandora.Paradigm.Structure.Ability.Focusable (Focusable (Focusing, focusing), Root)+import Pandora.Paradigm.Structure.Ability.Focusable (Focusable (Focusing, focusing), Location (Root)) import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Substructural, substructure)) import Pandora.Paradigm.Structure.Stack (Stack) 

@@ -0,0 +1,58 @@+{-# LANGUAGE UndecidableInstances #-}++module Pandora.Paradigm.Structure.Splay where++import Pandora.Core.Morphism ((%))+import Pandora.Pattern.Category ((.), ($))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))+import Pandora.Pattern.Functor.Extractable (extract)+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))+import Pandora.Paradigm.Primary.Functor (left, right)+import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))+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.Inventory.Optics ((%~))+import Pandora.Paradigm.Structure.Binary ()+import Pandora.Paradigm.Structure.Ability.Rotatable (Rotatable (rotation), rotate)+import Pandora.Paradigm.Structure.Ability.Substructure (sub)++data Splay a = Zig a | Zag a++instance Rotatable (Left Zig) (Construction Wye) where+	rotation (Tag (Construct parent st)) = Construct % subtree <$> found where++		subtree = maybe_subtree a . Just . Construct parent $ maybe_subtree b c+		found = extract <$> left st+		a = deconstruct <$> left st >>= left+		b = deconstruct <$> left st >>= right+		c = right st++instance Rotatable (Right Zig) (Construction Wye) where+	rotation (Tag (Construct parent st)) = Construct % subtree <$> found where++		found = extract <$> right st+		subtree = maybe_subtree a . Just . Construct parent $ maybe_subtree b c+		a = left st+		b = deconstruct <$> right st >>= left+		c = deconstruct <$> right st >>= right++instance Rotatable (Left (Zig Zig)) (Construction Wye) where+	rotation (Tag tree) = rotate @(Left Zig) tree >>= rotate @(Left Zig)++instance Rotatable (Right (Zig Zig)) (Construction Wye) where+	rotation (Tag tree) = rotate @(Right Zig) tree >>= rotate @(Right Zig)++instance Rotatable (Left (Zig Zag)) (Construction Wye) where+	rotation (Tag tree) = rotate @(Left Zig)+		$ sub @Left %~ (>>= rotate @(Right Zig)) $ tree++instance Rotatable (Right (Zig Zag)) (Construction Wye) where+	rotation (Tag tree) = rotate @(Right Zig)+		$ sub @Right %~ (>>= rotate @(Left Zig)) $ tree++maybe_subtree :: Maybe a -> Maybe a -> Wye a+maybe_subtree (Just x) (Just y) = Both x y+maybe_subtree Nothing (Just y) = Right y+maybe_subtree (Just x) Nothing = Left x+maybe_subtree Nothing Nothing = End

@@ -31,7 +31,8 @@ import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>)) import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty) import Pandora.Paradigm.Structure.Ability.Zipper (Zipper)-import Pandora.Paradigm.Structure.Ability.Focusable (Focusable (Focusing, focusing), Root, focus)+import Pandora.Paradigm.Structure.Ability.Focusable (Focusable (Focusing, focusing), Location (Head), focus)+import Pandora.Paradigm.Structure.Ability.Insertable (Insertable (insert))  -- | Linear data structure that serves as a collection of elements type Stack = Maybe <:.> Construction Maybe@@ -47,18 +48,23 @@ instance Monoid (Stack a) where 	zero = TU Nothing -instance Focusable Root Stack where-	type Focusing Root Stack a = Maybe a+instance Focusable Head Stack where+	type Focusing Head Stack a = Maybe a 	focusing (Tag stack) = Store $ extract <$> run stack :*: \case-		Just x -> stack & pop & push x & Tag+		Just x -> stack & pop & insert x & Tag 		Nothing -> Tag $ pop stack -push :: a -> Stack a -> Stack a-push x (TU stack) = TU $ (Construct x . Just <$> stack) <+> (point . point) x+instance Insertable Stack where+	insert x (TU stack) = TU $ (Construct x . Just <$> stack) <+> (point . point) x  pop :: Stack ~> Stack pop (TU stack) = TU $ stack >>= deconstruct +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+ filter :: Predicate a -> Stack a -> Stack a filter (Predicate p) = TU . fold empty 	(\now new -> p now ? Just (Construct now new) $ new)@@ -69,12 +75,18 @@  type instance Nonempty Stack = Construction Maybe -instance Focusable Root (Construction Maybe) where-	type Focusing Root (Construction Maybe) a = a+instance Focusable Head (Construction Maybe) where+	type Focusing Head (Construction Maybe) a = a 	focusing (Tag stack) = Store $ extract stack :*: Tag . Construct % deconstruct stack +instance Insertable (Construction Maybe) where+	insert x = Construct x . Just+ type instance Zipper Stack = Tap (Delta <:.> Stack) +instance Covariant (Delta <:.> Stack) where+	f <$> (TU (bs :^: fs)) = TU $ f <$> bs :^: f <$> fs+ forward, backward :: Zipper Stack a -> Maybe (Zipper Stack a)-forward (Tap x (TU (bs :^: fs))) = Tap % (TU $ push x bs :^: pop fs) <$> focus @Root ^. fs-backward (Tap x (TU (bs :^: fs))) = Tap % (TU $ pop bs :^: push x fs) <$> focus @Root ^. bs+forward (Tap x (TU (bs :^: fs))) = Tap % (TU $ insert x bs :^: pop fs) <$> focus @Head ^. fs+backward (Tap x (TU (bs :^: fs))) = Tap % (TU $ pop bs :^: insert x fs) <$> focus @Head ^. bs

@@ -1,5 +1,6 @@ module Pandora.Pattern (module Exports) where  import Pandora.Pattern.Object as Exports+import Pandora.Pattern.Transformer as Exports import Pandora.Pattern.Functor as Exports import Pandora.Pattern.Category as Exports

@@ -1,4 +1,4 @@-module Pandora.Pattern.Functor (module Exports) where+module Pandora.Pattern.Functor (module Exports, (<*+>), (<**+>), (<***+>)) where  import Pandora.Pattern.Functor.Bivariant as Exports import Pandora.Pattern.Functor.Divariant as Exports@@ -19,3 +19,16 @@ import Pandora.Pattern.Functor.Invariant as Exports import Pandora.Pattern.Functor.Contravariant as Exports import Pandora.Pattern.Functor.Covariant as Exports++import Pandora.Core.Functor (type (:.), type (:=))++(<*+>) :: (Applicative t, Alternative u) => t :. u := a -> t :. u := a -> t :. u := a+x <*+> y = (<+>) <$> x <*> y++(<**+>) :: (Applicative t, Applicative u, Alternative v)+	=> t :. u :. v := a -> t :. u :. v := a -> t :. u :. v := a+x <**+> y = (<+>) <$$> x <**> y++(<***+>) :: (Applicative t, Applicative u, Applicative v, Alternative w)+	=> t :. u :. v :. w := a -> t :. u :. v :. w := a -> t :. u :. v :. w := a+x <***+> y = (<+>) <$$$> x <***> y

@@ -37,8 +37,9 @@ 	-- | Experimental methods 	($>>=) :: Covariant u => (a -> t b) -> u :. t := a -> u :. t := b 	f $>>= x = (>>= f) <$> x-	(>>=$) :: (t b -> c) -> (a -> t b) -> t a -> c-	f >>=$ g = f <$> (>>= g)++	(<>>=) :: (t b -> c) -> (a -> t b) -> t a -> c+	f <>>= g = f <$> (>>= g)  instance Bindable ((->) e) where 	f >>= g = \x -> g (f x) x

@@ -22,7 +22,7 @@ 	tabulate :: (Representation t -> a) -> t a 	-- | Prefix and flipped version of '<#>' 	index :: t a -> Representation t -> a-	index x f = f <#> x+	index x r = r <#> x  instance Representable ((->) e) where 	type Representation ((->) e) = e

@@ -1,5 +1,5 @@ name:                pandora-version:             0.2.9+version:             0.3.0 synopsis:            A box of patterns and paradigms description:         Humble attempt to define a library for problem solving based on math abstractions. homepage:            https://github.com/iokasimov/pandora@@ -26,7 +26,6 @@      Pandora.Paradigm     -- Basic constructions-     Pandora.Paradigm.Primary     Pandora.Paradigm.Primary.Object     Pandora.Paradigm.Primary.Object.Boolean@@ -40,7 +39,6 @@     Pandora.Paradigm.Primary.Functor.Fix     Pandora.Paradigm.Primary.Functor.Identity     Pandora.Paradigm.Primary.Functor.Maybe-    Pandora.Paradigm.Primary.Functor.Predicate     Pandora.Paradigm.Primary.Functor.Product     Pandora.Paradigm.Primary.Functor.Proxy     Pandora.Paradigm.Primary.Functor.Tagged@@ -48,6 +46,8 @@     Pandora.Paradigm.Primary.Functor.Validation     Pandora.Paradigm.Primary.Functor.Wye     Pandora.Paradigm.Primary.Functor.Wedge+    Pandora.Paradigm.Primary.Functor.Predicate+    Pandora.Paradigm.Primary.Functor.Equivalence     Pandora.Paradigm.Primary.Transformer     Pandora.Paradigm.Primary.Transformer.Backwards     Pandora.Paradigm.Primary.Transformer.Reverse@@ -59,6 +59,7 @@     Pandora.Paradigm.Primary.Transformer.Jack     Pandora.Paradigm.Primary.Transformer.Jet     Pandora.Paradigm.Primary.Transformer.Kan+    Pandora.Paradigm.Primary.Transformer.Day     Pandora.Paradigm.Primary.Transformer.Yoneda     -- Schemes of functor compositions     Pandora.Paradigm.Schemes@@ -93,13 +94,17 @@     Pandora.Paradigm.Structure.Stream     Pandora.Paradigm.Structure.Stack     Pandora.Paradigm.Structure.Binary+    Pandora.Paradigm.Structure.Splay     Pandora.Paradigm.Structure.Rose     Pandora.Paradigm.Structure.Ability+    Pandora.Paradigm.Structure.Ability.Comprehension     Pandora.Paradigm.Structure.Ability.Focusable+    Pandora.Paradigm.Structure.Ability.Insertable     Pandora.Paradigm.Structure.Ability.Rotatable     Pandora.Paradigm.Structure.Ability.Substructure     Pandora.Paradigm.Structure.Ability.Nonempty     Pandora.Paradigm.Structure.Ability.Zipper+    Pandora.Paradigm.Structure.Ability.Monotonic      Pandora.Pattern     -- Category typeclass