pandora 0.2.5 → 0.2.6

raw patch · 24 files changed

+329/−182 lines, 24 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• CHANGELOG.md +15/−0
• Pandora/Paradigm/Basis.hs +24/−1
• Pandora/Paradigm/Basis/Backwards.hs +40/−0
• Pandora/Paradigm/Controlflow/Joint/Schemes/TUT.hs +3/−3
• Pandora/Paradigm/Controlflow/Joint/Transformer/Comonadic.hs +2/−0
• Pandora/Paradigm/Controlflow/Joint/Transformer/Monadic.hs +2/−0
• Pandora/Paradigm/Inventory/State.hs +6/−6
• Pandora/Paradigm/Inventory/Store.hs +4/−4
• Pandora/Paradigm/Structure.hs +5/−4
• Pandora/Paradigm/Structure/Binary.hs +86/−0
• Pandora/Paradigm/Structure/Cartesian.hs +0/−7
• Pandora/Paradigm/Structure/Graph.hs +29/−0
• Pandora/Paradigm/Structure/Nonempty.hs +0/−12
• Pandora/Paradigm/Structure/Specific.hs +0/−6
• Pandora/Paradigm/Structure/Specific/Binary.hs +0/−20
• Pandora/Paradigm/Structure/Specific/Graph.hs +0/−26
• Pandora/Paradigm/Structure/Specific/Stack.hs +0/−79
• Pandora/Paradigm/Structure/Specific/Stream.hs +0/−6
• Pandora/Paradigm/Structure/Stack.hs +82/−0
• Pandora/Paradigm/Structure/Stream.hs +6/−0
• Pandora/Paradigm/Structure/Variation/Nonempty.hs +4/−0
• Pandora/Paradigm/Structure/Variation/Substructure.hs +7/−0
• Pandora/Pattern/Transformer/Hoistable.hs +6/−0
• pandora.cabal +8/−8

@@ -185,3 +185,18 @@ * Remove `not` method of `Boolean`, (use `invert` instead) * Remove `Injective` and `Has` type families * Change superclasseses for `Liftable` and `Lowerable` classes to provide a law++# 0.2.6+* Change order of arguments for `TUT` joint schema+* `Binary` trees can be empty+* Define `left_sub_tree` and `right_sub_tree` lenses of `Binary` tree+* Fix `insert` function: `Binary` tree should not contain duplicate values+* Remove `Cartesian` type class+* Move `Nonempty` module to `Variation` submodule+* Remove `Specific` module+* Add functional dependency to `Nonempty` type family and distribute instances+* Define `left` and `right` natural transformations from `Wye` to `Maybe`+* Define experimental `Substructure` type class+* Remove `left_sub_tree` and `right_sub_tree` lenses of `Binary` tree+* Define `this` and `that` methods from `Variation` to `Maybe`+* Define `Backwards` type to run `Applicative` actions in reverse order

@@ -1,4 +1,4 @@-module Pandora.Paradigm.Basis (module Exports, note, hush) where+module Pandora.Paradigm.Basis (module Exports, note, hush, left, right, this, that) where  import Pandora.Paradigm.Basis.Twister as Exports import Pandora.Paradigm.Basis.Free as Exports@@ -20,6 +20,7 @@ import Pandora.Paradigm.Basis.Tagged as Exports import Pandora.Paradigm.Basis.Product as Exports import Pandora.Paradigm.Basis.Constant as Exports+import Pandora.Paradigm.Basis.Backwards as Exports import Pandora.Paradigm.Basis.Identity as Exports  import Pandora.Core.Morphism ((!))@@ -30,3 +31,25 @@  hush :: Conclusion e ~> Maybe hush = conclusion (Nothing !) Just++left :: Wye ~> Maybe+left (Both ls _) = Just ls+left (Left ls) = Just ls+left (Right _) = Nothing+left End = Nothing++right :: Wye ~> Maybe+right (Both _ rs) = Just rs+right (Left _) = Nothing+right (Right rs) = Just rs+right End = Nothing++this :: Variation e ~> Maybe+this (This x) = Just x+this (That _) = Nothing+this (These _ x) = Just x++that :: Variation e a -> Maybe e+that (This _) = Nothing+that (That x) = Just x+that (These y _) = Just y

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

@@ -3,8 +3,8 @@ import Pandora.Core.Functor (type (:.), type (:=)) import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run)) -newtype TUT ct cu cv t u t' a = TUT (t :. u :. t' := a)+newtype TUT ct ct' cu t t' u a = TUT (t :. u :. t' := a) -instance Interpreted (TUT ct cu cv t u t') where-	type Primary (TUT ct cu cv t u t') a = t :. u :. t' := a+instance Interpreted (TUT ct ct' cu t t' u) where+	type Primary (TUT ct ct' cu t t' u) a = t :. u :. t' := a 	run (TUT x) = x

@@ -53,6 +53,8 @@ instance Extendable (Schematic Comonad t u) => Extendable (t :< u) where 	TC x =>> f = TC $ x =>> f . TC +instance (Extractable (t :< u), Extendable (t :< u)) => Comonad (t :< u) where+ instance (Interpreted (Schematic Comonad t u)) => Interpreted (t :< u) where 	type Primary (t :< u) a = Primary (Schematic Comonad t u) a 	run (TC x) = run x

@@ -53,6 +53,8 @@ instance Extendable (Schematic Monad t u) => Extendable (t :> u) where 	TM x =>> f = TM $ x =>> f . TM +instance (Pointable (t :> u), Bindable (t :> u)) => Monad (t :> u) where+ instance (Interpreted (Schematic Monad t u)) => Interpreted (t :> u) where 	type Primary (t :> u) a = Primary (Schematic Monad t u) a 	run (TM x) = run x

@@ -55,7 +55,7 @@ 	run (State x) = x  type instance Schematic Monad (State s) u =-	TUT Covariant Covariant Covariant ((->) s) u ((:*:) s)+	TUT Covariant Covariant Covariant ((->) s) ((:*:) s) u  instance Monadic (State s) where 	lay x = TM . TUT $ \s -> (s :*:) <$> x@@ -63,19 +63,19 @@  type Stateful s = Adaptable (State s) -instance Covariant u => Covariant (TUT Covariant Covariant Covariant ((->) s) u ((:*:) s)) where+instance Covariant u => Covariant (TUT Covariant Covariant Covariant ((->) s) ((:*:) s) u) where 	f <$> TUT x = TUT $ \old -> f <$$> x old -instance Bindable u => Applicative (TUT Covariant Covariant Covariant ((->) s) u ((:*:) s)) where+instance Bindable u => Applicative (TUT Covariant Covariant Covariant ((->) s) ((:*:) s) u) where 	TUT f <*> TUT x = TUT $ \old -> f old >>= \(new :*: g) -> g <$$> x new -instance Pointable u => Pointable (TUT Covariant Covariant Covariant ((->) s) u ((:*:) s)) where+instance Pointable u => Pointable (TUT Covariant Covariant Covariant ((->) s) ((:*:) s) u) where 	point x = TUT $ \s -> point $ s :*: x -instance Bindable u => Bindable (TUT Covariant Covariant Covariant ((->) s) u ((:*:) s)) where+instance Bindable u => Bindable (TUT Covariant Covariant Covariant ((->) s) ((:*:) s) u) where 	TUT x >>= f = TUT $ \old -> x old >>= \(new :*: y) -> ($ new) . run . f $ y -instance Monad u => Monad (TUT Covariant Covariant Covariant ((->) s) u ((:*:) s)) where+instance Monad u => Monad (TUT Covariant Covariant Covariant ((->) s) ((:*:) s) u) where  current :: Stateful s t => t s current = adapt $ State delta

@@ -36,7 +36,7 @@ 	run (Store x) = x  type instance Schematic Comonad (Store p) u =-	TUT Covariant Covariant Covariant ((:*:) p) u ((->) p)+	TUT Covariant Covariant Covariant ((:*:) p) ((->) p) u  instance Comonadic (Store p) where 	flick (TC (TUT (p :*: f))) = ($ p) <$> f@@ -44,13 +44,13 @@  type Storable s x = Adaptable x (Store s) -instance Covariant u => Covariant (TUT Covariant Covariant Covariant ((:*:) p) u ((->) p)) where+instance Covariant u => Covariant (TUT Covariant Covariant Covariant ((:*:) p) ((->) p) u) where 	f <$> TUT (p :*: x) = TUT . (:*:) p $ f <$$> x -instance Extractable u => Extractable (TUT Covariant Covariant Covariant ((:*:) p) u ((->) p)) where+instance Extractable u => Extractable (TUT Covariant Covariant Covariant ((:*:) p) ((->) p) u) where 	extract (TUT (p :*: x)) = extract x p -instance Extendable u => Extendable (TUT Covariant Covariant Covariant ((:*:) p) u ((->) p)) where+instance Extendable u => Extendable (TUT Covariant Covariant Covariant ((:*:) p) ((->) p) u) where 	TUT (old :*: x) =>> f = TUT . (:*:) old $ x =>> (\x' new -> f . TUT . (:*:) new $ x')  position :: Storable s t => t a -> s

@@ -1,6 +1,7 @@ module Pandora.Paradigm.Structure (module Exports) where -import Pandora.Paradigm.Structure.Nonempty as Exports-import Pandora.Paradigm.Structure.Specific.Binary as Exports-import Pandora.Paradigm.Structure.Specific.Graph as Exports-import Pandora.Paradigm.Structure.Specific.Stack as Exports+import Pandora.Paradigm.Structure.Variation.Substructure as Exports+import Pandora.Paradigm.Structure.Variation.Nonempty as Exports+import Pandora.Paradigm.Structure.Binary as Exports+import Pandora.Paradigm.Structure.Graph as Exports+import Pandora.Paradigm.Structure.Stack as Exports

@@ -0,0 +1,86 @@+{-# OPTIONS_GHC -fno-warn-orphans #-}++module Pandora.Paradigm.Structure.Binary (Binary, insert) where++import Pandora.Core.Morphism ((&), (%), (!))+import Pandora.Pattern.Category ((.))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))+import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))+import Pandora.Pattern.Functor.Extractable (extract)+import Pandora.Pattern.Functor.Divariant (($))+import Pandora.Pattern.Object.Chain (Chain ((<=>)), order)+import Pandora.Paradigm.Basis.Maybe (Maybe (Just, Nothing), maybe)+import Pandora.Paradigm.Basis.Product (Product ((:*:)))+import Pandora.Paradigm.Basis.Wye (Wye (End, Left, Right, Both))+import Pandora.Paradigm.Basis.Twister (Twister (Twister))+import Pandora.Paradigm.Basis.Tagged (Tagged (Tag), type (:#))+import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))+import Pandora.Paradigm.Controlflow.Joint.Interpreted (run)+import Pandora.Paradigm.Inventory.Store (Store (Store))+import Pandora.Paradigm.Inventory.Optics ((%~))+import Pandora.Paradigm.Structure.Variation.Nonempty (Nonempty)+import Pandora.Paradigm.Structure.Variation.Substructure (Substructure (Output, sub))++type Binary = UT Covariant Covariant (Twister Wye) Maybe++instance Covariant Binary where+	f <$> UT g = UT $ f <$$> g++instance Pointable Binary where+	point x = UT . Just . Twister x $ End++instance Traversable Binary where+	UT g ->> f = UT <$> g ->>> f++insert :: Chain a => a -> Binary a -> Binary a+insert x (UT Nothing) = point x+insert x tree@(UT (Just (Twister y _))) = x <=> y & order+	(sub @'Left %~ (insert x <$>) $ tree) tree+	(sub @'Right %~ (insert x <$>) $ tree)++instance Substructure 'Left Binary where+	type Output 'Left Binary a = 'Left :# Binary a+	sub (UT Nothing) = Store $ (:*:) (Tag $ UT Nothing) $ (UT Nothing !)+	sub  t@(UT (Just (Twister x End))) = Store $ (:*:) (Tag $ UT Nothing) $+		maybe t (UT . Just . Twister x . Left) . run . extract+	sub (UT (Just (Twister x (Left lst)))) = Store $ (:*:) (Tag . UT . Just $ lst) $+		maybe (point x) (UT . Just . Twister x . Left) . run . extract+	sub t@(UT (Just (Twister x (Right rst)))) = Store $ (:*:) (Tag $ UT Nothing) $+		maybe t (UT . Just . Twister x . Both % rst) . run . extract+	sub  (UT (Just (Twister x (Both lst rst)))) = Store $ (:*:) (Tag . UT . Just $ lst) $+		maybe (UT (Just (Twister x (Right rst)))) (UT . Just . Twister x . Both % rst) . run . extract++instance Substructure 'Right Binary where+	type Output 'Right Binary a = 'Right :# Binary a+	sub (UT Nothing) = Store $ Tag (UT Nothing) :*: (!) (UT Nothing)+	sub t@(UT (Just (Twister x End))) = Store $ (:*:) (Tag $ UT Nothing) $+		maybe t (UT . Just . Twister x . Right) . run . extract+	sub t@(UT (Just (Twister x (Left lst)))) = Store $ (:*:) (Tag $ UT Nothing) $+		maybe t (UT . Just . Twister x . Both lst) . run . extract+	sub (UT (Just (Twister x (Right rst)))) = Store $ (:*:) (Tag . UT . Just $ rst) $+		maybe (point x) (UT . Just . Twister x . Right) . run . extract+	sub (UT (Just (Twister x (Both lst rst)))) = Store $ (:*:) (Tag . UT . Just $ rst) $+		maybe (UT (Just (Twister x (Left lst)))) (UT . Just . Twister x . Both lst) . run . extract++type instance Nonempty Binary = Twister Wye++instance Substructure 'Left (Twister Wye) where+	type Output 'Left (Twister Wye) a = Maybe ('Left :# Twister Wye a)+	sub (Twister x End) = Store $ (:*:) Nothing $ (Twister x End !)+	sub (Twister x (Left lst)) = Store $ (:*:) (Just . Tag $ lst) $+		maybe (Twister x End) (Twister x . Left . extract)+	sub tree@(Twister x (Right rst)) = Store $ (:*:) Nothing $+		maybe tree (Twister x . Both % rst . extract)+	sub (Twister x (Both lst rst)) = Store $ (:*:) (Just . Tag $ lst) $+		maybe (Twister x $ Right rst) (Twister x . Both % rst . extract)++instance Substructure 'Right (Twister Wye) where+	type Output 'Right (Twister Wye) a = Maybe ('Right :# Twister Wye a)+	sub (Twister x End) = Store $ (:*:) Nothing $ (Twister x End !)+	sub tree@(Twister x (Left lst)) = Store $ (:*:) Nothing $+		maybe tree (Twister x . Both lst . extract)+	sub (Twister x (Right rst)) = Store $ (:*:) (Just . Tag $ rst) $+		maybe (Twister x End) (Twister x . Right . extract)+	sub (Twister x (Both lst rst)) = Store $ (:*:) (Just . Tag $ rst) $+		maybe (Twister x $ Left lst) (Twister x . Both lst . extract)

@@ -1,7 +0,0 @@-module Pandora.Paradigm.Structure.Cartesian (Cartesian (..)) where--import Pandora.Paradigm.Basis.Product (type (:*:))--class Cartesian (t :: * -> *) where-	{-# MINIMAL (-:*:-) #-}-	(-:*:-) :: t a -> t b -> t (a :*: b)

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

@@ -1,12 +0,0 @@-module Pandora.Paradigm.Structure.Nonempty (Nonempty) where--import Pandora.Paradigm.Basis.Maybe (Maybe)-import Pandora.Paradigm.Basis.Edges (Edges)-import Pandora.Paradigm.Basis.Twister (Twister)-import Pandora.Paradigm.Structure.Specific.Stack (Stack)-import Pandora.Paradigm.Structure.Specific.Graph (Graph)---- | Type synonymous for at least one element data structure-type family Nonempty (structure :: * -> *) where-	Nonempty Stack = Twister Maybe-	Nonempty Graph = Twister Edges

@@ -1,6 +0,0 @@-module Pandora.Paradigm.Structure.Specific (module Exports) where--import Pandora.Paradigm.Structure.Specific.Stream as Exports-import Pandora.Paradigm.Structure.Specific.Stack as Exports-import Pandora.Paradigm.Structure.Specific.Graph as Exports-import Pandora.Paradigm.Structure.Specific.Binary as Exports

@@ -1,20 +0,0 @@-module Pandora.Paradigm.Structure.Specific.Binary (Binary, insert) where--import Pandora.Core.Morphism ((&))-import Pandora.Paradigm.Basis.Wye (Wye (End, Left, Right, Both))-import Pandora.Paradigm.Basis.Twister (Twister (Twister))-import Pandora.Pattern.Category ((.))-import Pandora.Pattern.Functor.Divariant (($))-import Pandora.Pattern.Object.Chain (Chain ((<=>)), order)--type Binary = Twister Wye--insert :: Chain a => a -> Binary a -> Binary a-insert x (Twister y End) = x <=> y & order (Twister y . Right $ Twister x End)-	(Twister y . Right $ Twister x End) (Twister y . Left $ Twister x End)-insert x (Twister y (Left ls)) = x <=> y & order (Twister y . Both ls $ Twister x End)-	(Twister y $ Both ls $ Twister x End) (Twister y . Left $ insert x ls)-insert x (Twister y (Right rs)) = x <=> y & order (Twister y . Right $ insert x rs)-	(Twister y $ Right (insert x rs)) (Twister y $ Both (Twister x End) rs)-insert x (Twister y (Both ls rs)) = x <=> y & order (Twister y . Both ls $ insert x rs)-	(Twister y . Both ls $ insert x rs) (Twister y $ Both (insert x ls) rs)

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

@@ -1,79 +0,0 @@-{-# OPTIONS_GHC -fno-warn-orphans #-}--module Pandora.Paradigm.Structure.Specific.Stack (Stack, push, top, pop, filter, linearize) where--import Pandora.Core.Functor (type (~>))-import Pandora.Core.Morphism ((&))-import Pandora.Pattern.Category ((.))-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))-import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (<**>)))-import Pandora.Pattern.Functor.Pointable (Pointable (point))-import Pandora.Pattern.Functor.Extractable (Extractable (extract))-import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))-import Pandora.Pattern.Functor.Divariant (($))-import Pandora.Pattern.Object.Setoid (Setoid ((==)), (?))-import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))-import Pandora.Pattern.Object.Monoid (Monoid (zero))-import Pandora.Paradigm.Basis.Maybe (Maybe (Just, Nothing))-import Pandora.Paradigm.Basis.Predicate (Predicate (Predicate))-import Pandora.Paradigm.Basis.Product (Product ((:*:)))-import Pandora.Paradigm.Basis.Twister (Twister (Twister), untwist)-import Pandora.Paradigm.Inventory.State (fold)-import Pandora.Paradigm.Inventory.Store (Store (Store))-import Pandora.Paradigm.Inventory.Optics (type (:-.))-import Pandora.Paradigm.Controlflow.Joint.Interpreted (run)-import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))---- | Linear data structure that serves as a collection of elements-type Stack = UT Covariant Covariant (Twister Maybe) Maybe--instance Covariant Stack where-	f <$> UT stack = UT $ f <$$> stack--instance Pointable Stack where-	point = UT . Just . point--instance Alternative Stack where-	UT x <+> UT y = UT $ x <+> y--instance Avoidable Stack where-	empty = UT Nothing--instance Applicative Stack where-	UT f <*> UT x = UT $ f <**> x--instance Traversable Stack where-	UT stack ->> f = UT <$> stack ->>> f--instance Setoid a => Setoid (Stack a) where-	UT ls == UT rs = ls == rs--instance Semigroup (Stack a) where-	UT Nothing + UT ys = UT ys-	UT (Just (Twister x xs)) + UT ys = UT . Just . Twister x . run-		$ UT @Covariant @Covariant xs + UT @Covariant @Covariant ys--instance Monoid (Stack a) where-	zero = UT Nothing--top :: Stack a :-. Maybe a-top stack = Store $ (:*:) (extract <$> run stack) $ \case-    Just x -> stack & pop & push x-    Nothing -> pop stack--push :: a -> Stack a -> Stack a-push x (UT stack) = UT $ (Twister x . Just <$> stack) <+> (point . point) x--pop :: Stack ~> Stack-pop (UT stack) = UT $ stack >>= untwist--filter :: Predicate a -> Stack a -> Stack a-filter (Predicate p) = UT . fold empty-	(\now new -> p now ? Just (Twister now new) $ new)---- | Transform any traversable structure into a stack-linearize :: Traversable t => t ~> Stack-linearize = UT . fold Nothing (\x -> Just . Twister x)

@@ -1,6 +0,0 @@-module Pandora.Paradigm.Structure.Specific.Stream (Stream) where--import Pandora.Paradigm.Basis.Identity (Identity)-import Pandora.Paradigm.Basis.Twister (Twister)--type Stream = Twister Identity

@@ -0,0 +1,82 @@+{-# OPTIONS_GHC -fno-warn-orphans #-}++module Pandora.Paradigm.Structure.Stack (Stack, push, top, pop, filter, linearize) where++import Pandora.Core.Functor (type (~>))+import Pandora.Core.Morphism ((&))+import Pandora.Pattern.Category ((.))+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))+import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))+import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (<**>)))+import Pandora.Pattern.Functor.Pointable (Pointable (point))+import Pandora.Pattern.Functor.Extractable (Extractable (extract))+import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))+import Pandora.Pattern.Functor.Divariant (($))+import Pandora.Pattern.Object.Setoid (Setoid ((==)), (?))+import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))+import Pandora.Pattern.Object.Monoid (Monoid (zero))+import Pandora.Paradigm.Basis.Maybe (Maybe (Just, Nothing))+import Pandora.Paradigm.Basis.Predicate (Predicate (Predicate))+import Pandora.Paradigm.Basis.Product (Product ((:*:)))+import Pandora.Paradigm.Basis.Twister (Twister (Twister), untwist)+import Pandora.Paradigm.Inventory.State (fold)+import Pandora.Paradigm.Inventory.Store (Store (Store))+import Pandora.Paradigm.Inventory.Optics (type (:-.))+import Pandora.Paradigm.Controlflow.Joint.Interpreted (run)+import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))+import Pandora.Paradigm.Structure.Variation.Nonempty (Nonempty)++-- | Linear data structure that serves as a collection of elements+type Stack = UT Covariant Covariant (Twister Maybe) Maybe++type instance Nonempty Stack = Twister Maybe++instance Covariant Stack where+	f <$> UT stack = UT $ f <$$> stack++instance Pointable Stack where+	point = UT . Just . point++instance Alternative Stack where+	UT x <+> UT y = UT $ x <+> y++instance Avoidable Stack where+	empty = UT Nothing++instance Applicative Stack where+	UT f <*> UT x = UT $ f <**> x++instance Traversable Stack where+	UT stack ->> f = UT <$> stack ->>> f++instance Setoid a => Setoid (Stack a) where+	UT ls == UT rs = ls == rs++instance Semigroup (Stack a) where+	UT Nothing + UT ys = UT ys+	UT (Just (Twister x xs)) + UT ys = UT . Just . Twister x . run+		$ UT @Covariant @Covariant xs + UT @Covariant @Covariant ys++instance Monoid (Stack a) where+	zero = UT Nothing++top :: Stack a :-. Maybe a+top stack = Store $ (:*:) (extract <$> run stack) $ \case+    Just x -> stack & pop & push x+    Nothing -> pop stack++push :: a -> Stack a -> Stack a+push x (UT stack) = UT $ (Twister x . Just <$> stack) <+> (point . point) x++pop :: Stack ~> Stack+pop (UT stack) = UT $ stack >>= untwist++filter :: Predicate a -> Stack a -> Stack a+filter (Predicate p) = UT . fold empty+	(\now new -> p now ? Just (Twister now new) $ new)++-- | Transform any traversable structure into a stack+linearize :: Traversable t => t ~> Stack+linearize = UT . fold Nothing (\x -> Just . Twister x)

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

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

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

@@ -2,5 +2,11 @@  import Pandora.Core.Functor (type (~>)) +{- |+> When providing a new instance, you should ensure it satisfies one law:+> * Identity morphism: hoist identity ≡ identity+> * Interpreted of morphisms: hoist (f . g) ≡ hoist f . hoist g+-}+ class Hoistable t where 	hoist :: u ~> v -> t u ~> t v

@@ -1,5 +1,5 @@ name:                pandora-version:             0.2.5+version:             0.2.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@@ -27,6 +27,7 @@     Pandora.Paradigm     -- Basic constructions     Pandora.Paradigm.Basis+    Pandora.Paradigm.Basis.Backwards     Pandora.Paradigm.Basis.Conclusion     Pandora.Paradigm.Basis.Constant     Pandora.Paradigm.Basis.Continuation@@ -77,13 +78,12 @@     Pandora.Paradigm.Inventory.Store     -- Tree-based datastructures     Pandora.Paradigm.Structure-    Pandora.Paradigm.Structure.Cartesian-    Pandora.Paradigm.Structure.Nonempty-    Pandora.Paradigm.Structure.Specific-    Pandora.Paradigm.Structure.Specific.Stream-    Pandora.Paradigm.Structure.Specific.Stack-    Pandora.Paradigm.Structure.Specific.Graph-    Pandora.Paradigm.Structure.Specific.Binary+    Pandora.Paradigm.Structure.Stream+    Pandora.Paradigm.Structure.Stack+    Pandora.Paradigm.Structure.Graph+    Pandora.Paradigm.Structure.Binary+    Pandora.Paradigm.Structure.Variation.Nonempty+    Pandora.Paradigm.Structure.Variation.Substructure      Pandora.Pattern     -- Category typeclass