diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -0,0 +1,9 @@
+# 0.1.1
+* Define `attached` destructor for `Product` datatype
+* Define `empty` destructor for `Stack` structure
+* Replace `flip` on `?` type operator
+* Remove type parameter from `Stack` type synonymous
+* Split `structure` and `value` in `Nonempty` type family
+* Define `Invariant` instance for `Constant` datatype
+* Remove all `Invariant` methods except `invmap`
+* Extract `Junction` module from `Basis`
diff --git a/Pandora/Core/Morphism.hs b/Pandora/Core/Morphism.hs
--- a/Pandora/Core/Morphism.hs
+++ b/Pandora/Core/Morphism.hs
@@ -1,18 +1,15 @@
-module Pandora.Core.Morphism (identity, flip, fix, (.), ($), (&), (!)) where
+module Pandora.Core.Morphism (identity, fix, (.), ($), (&), (!), (?)) where
 
-infixr 9 .
+infixr 8 .
 infixr 0 $
 infixl 1 &
 infixr 2 !
+infixr 9 ?
 
 {-# INLINE identity #-}
 identity :: a -> a
 identity x = x
 
-{-# INLINE flip #-}
-flip :: (a -> b -> c) -> b -> a -> c
-flip f x y = f y x
-
 fix :: (a -> a) -> a
 fix f = let x = f x in x
 
@@ -31,3 +28,7 @@
 {-# INLINE (!) #-}
 (!) :: a -> b -> a
 x ! y = x
+
+{-# INLINE (?) #-}
+(?) :: (a -> b -> c) -> b -> a -> c
+(?) f x y = f y x
diff --git a/Pandora/Paradigm/Basis.hs b/Pandora/Paradigm/Basis.hs
--- a/Pandora/Paradigm/Basis.hs
+++ b/Pandora/Paradigm/Basis.hs
@@ -14,9 +14,6 @@
 import Pandora.Paradigm.Basis.Product as Exports
 import Pandora.Paradigm.Basis.Constant as Exports
 import Pandora.Paradigm.Basis.Identity as Exports
-import Pandora.Paradigm.Basis.Junction.Kan as Exports
-import Pandora.Paradigm.Basis.Junction.Transformer as Exports
-import Pandora.Paradigm.Basis.Junction.Composition as Exports
 
 import Pandora.Core.Functor (type (~>))
 import Pandora.Core.Morphism ((.), (!))
diff --git a/Pandora/Paradigm/Basis/Conclusion.hs b/Pandora/Paradigm/Basis/Conclusion.hs
--- a/Pandora/Paradigm/Basis/Conclusion.hs
+++ b/Pandora/Paradigm/Basis/Conclusion.hs
@@ -1,7 +1,7 @@
 module Pandora.Paradigm.Basis.Conclusion (Conclusion (..), conclusion) where
 
 import Pandora.Core.Morphism ((.), ($), (!))
-import Pandora.Paradigm.Basis.Junction.Transformer (T (T, t), type (:!:))
+import Pandora.Paradigm.Junction.Transformer (T (T, t), type (:!:))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
diff --git a/Pandora/Paradigm/Basis/Constant.hs b/Pandora/Paradigm/Basis/Constant.hs
--- a/Pandora/Paradigm/Basis/Constant.hs
+++ b/Pandora/Paradigm/Basis/Constant.hs
@@ -3,6 +3,7 @@
 import Pandora.Core.Morphism (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
+import Pandora.Pattern.Functor.Invariant (Invariant (invmap))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
 
@@ -13,6 +14,9 @@
 
 instance Contravariant (Constant a) where
 	_ >$< Constant x = Constant x
+
+instance Invariant (Constant a) where
+	invmap _ _ (Constant x) = Constant x
 
 instance Traversable (Constant a) where
 	Constant x ->> _ = point (Constant x)
diff --git a/Pandora/Paradigm/Basis/Continuation.hs b/Pandora/Paradigm/Basis/Continuation.hs
--- a/Pandora/Paradigm/Basis/Continuation.hs
+++ b/Pandora/Paradigm/Basis/Continuation.hs
@@ -1,6 +1,6 @@
 module Pandora.Paradigm.Basis.Continuation (Continuation (..), oblige, cwcc) where
 
-import Pandora.Core.Morphism ((.), ($), (!), flip)
+import Pandora.Core.Morphism ((.), ($), (!), (?))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
@@ -29,4 +29,4 @@
 
 -- | Call with current continuation
 cwcc :: ((a -> Continuation r t b) -> Continuation r t a) -> Continuation r t a
-cwcc f = Continuation $ \g -> flip continue g . f $ Continuation . (!) . g
+cwcc f = Continuation $ \g -> continue ? g . f $ Continuation . (!) . g
diff --git a/Pandora/Paradigm/Basis/Junction/Composition.hs b/Pandora/Paradigm/Basis/Junction/Composition.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Basis/Junction/Composition.hs
+++ /dev/null
@@ -1,184 +0,0 @@
-module Pandora.Paradigm.Basis.Junction.Composition (U (..), UU (..), UUU (..)) where
-
-import Pandora.Core.Functor (Variant (Co, Contra), type (:.:))
-import Pandora.Core.Morphism ((.), ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), comap))
-import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<), contramap))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Exclusive (Exclusive (exclusive))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), apply))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>), traverse))
-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-), distribute))
-import Pandora.Pattern.Functor.Adjoint (Adjoint (phi, psi))
-
-type (:-|:) t u = (Extractable t, Pointable t, Extractable u, Pointable u, Adjoint t u)
-
-
-newtype U ct cu t u a = U { u :: (t :.: u) a }
-
-instance (Covariant t, Covariant u) => Covariant (U Co Co t u) where
-	f <$> U x = U $ (comap . comap) f x
-
-instance (Covariant t, Contravariant u) => Contravariant (U Co Contra t u) where
-	f >$< U x = U $ contramap f <$> x
-
-instance (Contravariant t, Covariant u) => Contravariant (U Contra Co t u) where
-	f >$< U x = U $ contramap (comap f) x
-
-instance (Contravariant t, Contravariant u) => Covariant (U Contra Contra t u) where
-	f <$> U x = U $ contramap (contramap f) x
-
-instance (Pointable t, Pointable u) => Pointable (U Co Co t u) where
-	point = U . point . point
-
-instance (Extractable t, Extractable u) => Extractable (U Co Co t u) where
-	extract = extract . extract . u
-
-instance (Exclusive t, Covariant u) => Exclusive (U Co Co t u) where
-	exclusive = U exclusive
-
-instance (Applicative t, Applicative u) => Applicative (U Co Co t u) where
-	U f <*> U x = U $ apply <$> f <*> x
-
-instance (Alternative t, Covariant u) => Alternative (U Co Co t u) where
-	U x <+> U y = U $ x <+> y
-
-instance (Traversable t, Traversable u) => Traversable (U Co Co t u) where
-	U x ->> f = U <$> (traverse . traverse) f x
-
-instance (Distributive t, Distributive u) => Distributive (U Co Co t u) where
-	x >>- f = U . comap distribute . distribute $ u . f <$> x
-
-instance (t :-|: u, v :-|: w) => Adjoint (U Co Co t v) (U Co Co u w) where
-	phi f = point . f . point
-	psi f = extract . extract . comap f
-
-
-newtype UU ct cu cv t u v a = UU { uu :: (t :.: u :.: v) a }
-
-instance (Covariant t, Covariant u, Covariant v) => Covariant (UU Co Co Co t u v) where
-	f <$> UU x = UU $ (comap . comap . comap) f x
-
-instance (Covariant t, Covariant u, Contravariant v) => Contravariant (UU Co Co Contra t u v) where
-	f >$< UU x = UU $ (comap . comap) (contramap f) x
-
-instance (Covariant t, Contravariant u, Covariant v) => Contravariant (UU Co Contra Co t u v) where
-	f >$< UU x = UU $ contramap (comap f) <$> x
-
-instance (Contravariant t, Covariant u, Covariant v) => Contravariant (UU Contra Co Co t u v) where
-	f >$< UU x = UU $ comap (comap f) >$< x
-
-instance (Contravariant t, Contravariant u, Covariant v) => Covariant (UU Contra Contra Co t u v) where
-	f <$> UU x = UU $ contramap (comap f) >$< x
-
-instance (Covariant t, Contravariant u, Contravariant v) => Covariant (UU Co Contra Contra t u v) where
-	f <$> UU x = UU $ contramap (contramap f) <$> x
-
-instance (Contravariant t, Covariant u, Contravariant v) => Covariant (UU Contra Co Contra t u v) where
-	f <$> UU x = UU $ comap (contramap f) >$< x
-
-instance (Contravariant t, Contravariant u, Contravariant v) => Contravariant (UU Contra Contra Contra t u v) where
-	f >$< UU x = UU $ (contramap . contramap . contramap) f x
-
-instance (Pointable t, Pointable u, Pointable v) => Pointable (UU Co Co Co t u v) where
-	point = UU . point . point . point
-
-instance (Extractable t, Extractable u, Extractable v) => Extractable (UU Co Co Co t u v) where
-	extract = extract . extract . extract . uu
-
-instance (Exclusive t, Covariant u, Covariant v) => Exclusive (UU Co Co Co t u v) where
-	exclusive = UU exclusive
-
-instance (Applicative t, Applicative u, Applicative v) => Applicative (UU Co Co Co t u v) where
-	UU f <*> UU x = UU $ (comap apply . (comap . comap) apply $ f) <*> x
-
-instance (Alternative t, Covariant u, Covariant v) => Alternative (UU Co Co Co t u v) where
-	UU x <+> UU y = UU $ x <+> y
-
-instance (Traversable t, Traversable u, Traversable v) => Traversable (UU Co Co Co t u v) where
-	UU x ->> f = UU <$> (traverse . traverse . traverse) f x
-
-instance (Distributive t, Distributive u, Distributive v) => Distributive (UU Co Co Co t u v) where
-	x >>- f = UU . (comap . comap) distribute . comap distribute . distribute $ uu . f <$> x
-
-instance (t :-|: w, v :-|: x, u :-|: y) => Adjoint (UU Co Co Co t v u) (UU Co Co Co w x y) where
-	phi f = point . f . point
-	psi f = extract . extract . comap f
-
-
-newtype UUU ct cu cv cw t u v w a = UUU { uuu :: (t :.: u :.: v :.: w) a }
-
-instance (Covariant t, Covariant u, Covariant v, Covariant w) => Covariant (UUU Co Co Co Co t u v w) where
-	f <$> UUU x = UUU $ (comap . comap . comap . comap) f x
-
-instance (Covariant t, Covariant u, Covariant v, Contravariant w) => Contravariant (UUU Co Co Co Contra t u v w) where
-	f >$< UUU x = UUU $ (comap . comap . comap) (contramap f) x
-
-instance (Covariant t, Covariant u, Contravariant v, Covariant w) => Contravariant (UUU Co Co Contra Co t u v w) where
-	f >$< UUU x = UUU $ (comap . comap) (contramap (comap f)) x
-
-instance (Covariant t, Contravariant u, Covariant v, Covariant w) => Contravariant (UUU Co Contra Co Co t u v w) where
-	f >$< UUU x = UUU $ (contramap (comap (comap f))) <$> x
-
-instance (Contravariant t, Covariant u, Covariant v, Covariant w) => Contravariant (UUU Contra Co Co Co t u v w) where
-	f >$< UUU x = UUU $ comap (comap (comap f)) >$< x
-
-instance (Contravariant t, Contravariant u, Covariant v, Covariant w) => Covariant (UUU Contra Contra Co Co t u v w) where
-	f <$> UUU x = UUU $ (contramap . contramap . comap . comap $ f) x
-
-instance (Covariant t, Contravariant u, Contravariant v, Covariant w) => Covariant (UUU Co Contra Contra Co t u v w) where
-	f <$> UUU x = UUU $ (comap . contramap . contramap . comap $ f) x
-
-instance (Covariant t, Covariant u, Contravariant v, Contravariant w) => Covariant (UUU Co Co Contra Contra t u v w) where
-	f <$> UUU x = UUU $ (comap . comap) (contramap . contramap $ f) x
-
-instance (Covariant t, Contravariant u, Covariant v, Contravariant w) => Covariant (UUU Co Contra Co Contra t u v w) where
-	f <$> UUU x = UUU $ (comap . contramap . comap . contramap $ f) x
-
-instance (Contravariant t, Covariant u, Contravariant v, Covariant w) => Covariant (UUU Contra Co Contra Co t u v w) where
-	f <$> UUU x = UUU $ (contramap . comap . contramap . comap $ f) x
-
-instance (Contravariant t, Covariant u, Covariant v, Contravariant w) => Covariant (UUU Contra Co Co Contra t u v w) where
-	f <$> UUU x = UUU $ (contramap . comap . comap . contramap $ f) x
-
-instance (Contravariant t, Contravariant u, Contravariant v, Covariant w) => Contravariant (UUU Contra Contra Contra Co t u v w) where
-	f >$< UUU x = UUU $ (contramap . contramap . contramap . comap) f x
-
-instance (Covariant t, Contravariant u, Contravariant v, Contravariant w) => Contravariant (UUU Co Contra Contra Contra t u v w) where
-	f >$< UUU x = UUU $ (comap . contramap . contramap . contramap) f x
-
-instance (Contravariant t, Covariant u, Contravariant v, Contravariant w) => Contravariant (UUU Contra Co Contra Contra t u v w) where
-	f >$< UUU x = UUU $ (contramap . comap . contramap . contramap) f x
-
-instance (Contravariant t, Contravariant u, Covariant v, Contravariant w) => Contravariant (UUU Contra Contra Co Contra t u v w) where
-	f >$< UUU x = UUU $ (contramap . contramap . comap . contramap) f x
-
-instance (Contravariant t, Contravariant u, Contravariant v, Contravariant w) => Covariant (UUU Contra Contra Contra Contra t u v w) where
-	f <$> UUU x = UUU $ (contramap . contramap . contramap . contramap) f x
-
-instance (Pointable t, Pointable u, Pointable v, Pointable w) => Pointable (UUU Co Co Co Co t u v w) where
-	point = UUU . point . point . point . point
-
-instance (Extractable t, Extractable u, Extractable v, Extractable w) => Extractable (UUU Co Co Co Co t u v w) where
-	extract = extract . extract . extract . extract . uuu
-
-instance (Exclusive t, Covariant u, Covariant v, Covariant w) => Exclusive (UUU Co Co Co Co t u v w) where
-	exclusive = UUU exclusive
-
-instance (Applicative t, Applicative u, Applicative v, Applicative w) => Applicative (UUU Co Co Co Co t u v w) where
-	UUU f <*> UUU x = UUU $ (comap apply . (comap . comap) apply . (comap . comap . comap) apply $ f) <*> x
-
-instance (Alternative t, Covariant u, Covariant v, Covariant w) => Alternative (UUU Co Co Co Co t u v w) where
-	UUU x <+> UUU y = UUU $ x <+> y
-
-instance (Traversable t, Traversable u, Traversable v, Traversable w) => Traversable (UUU Co Co Co Co t u v w) where
-	UUU x ->> f = UUU <$> (traverse . traverse . traverse . traverse) f x
-
-instance (Distributive t, Distributive u, Distributive v, Distributive w) => Distributive (UUU Co Co Co Co t u v w) where
-	x >>- f = UUU . (comap . comap . comap) distribute . (comap . comap) distribute . comap distribute . distribute $ uuu . f <$> x
-
-instance (t :-|: u, v :-|: w, q :-|: q, r :-|: s) => Adjoint (UUU Co Co Co Co t v q r) (UUU Co Co Co Co u w q s) where
-	phi f = point . f . point
-	psi f = extract . extract . comap f
diff --git a/Pandora/Paradigm/Basis/Junction/Kan.hs b/Pandora/Paradigm/Basis/Junction/Kan.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Basis/Junction/Kan.hs
+++ /dev/null
@@ -1,17 +0,0 @@
-module Pandora.Paradigm.Basis.Junction.Kan (Lan (..), Ran (..)) where
-
-import Pandora.Core.Morphism ((.), ($))
-import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
-
-newtype Lan (t :: * -> *) (u :: * -> *) (b :: *) (a :: *) =
-	Lan { lan :: (t b -> a) -> u b }
-
-instance Contravariant (Lan t u b) where
-	f >$< Lan x = Lan $ x . (f .)
-
-newtype Ran (t :: * -> *) (u :: * -> *) (b :: *) (a :: *) =
-	Ran { ran :: (a -> t b) -> u b }
-
-instance Covariant (Ran t u b) where
-	f <$> Ran x = Ran $ x . (. f)
diff --git a/Pandora/Paradigm/Basis/Junction/Transformer.hs b/Pandora/Paradigm/Basis/Junction/Transformer.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Basis/Junction/Transformer.hs
+++ /dev/null
@@ -1,88 +0,0 @@
-module Pandora.Paradigm.Basis.Junction.Transformer (T (..), type (:!:), up, Y (..), type (:>:)) where
-
-import Pandora.Core.Functor (type (:.:))
-import Pandora.Core.Morphism ((.), ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), comap))
-import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Extractable (Extractable (extract))
-import Pandora.Pattern.Functor.Exclusive (Exclusive (exclusive))
-import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), apply))
-import Pandora.Pattern.Functor.Traversable (Traversable ((->>), traverse))
-import Pandora.Pattern.Functor.Distributive (Distributive ((>>-), distribute))
-import Pandora.Pattern.Functor.Bindable (Bindable ((>>=), bind))
-import Pandora.Pattern.Functor.Liftable (Liftable (lift))
-import Pandora.Pattern.Functor.Lowerable (Lowerable (lower))
-
-infixr 0 :!:, :>:
-type (:!:) t u = T t u
-type (:>:) t u = Y t u
-
-
-newtype T t u a = T { t :: (u :.: t) a }
-
-instance (Covariant t, Covariant u) => Covariant (T t u) where
-	f <$> T x = T $ (comap . comap) f x
-
-instance (Pointable t, Pointable u) => Pointable (T t u) where
-	point = T . point . point
-
-instance (Extractable t, Extractable u) => Extractable (T t u) where
-	extract = extract . extract . t
-
-instance (Covariant t, Exclusive u) => Exclusive (T t u) where
-	exclusive = T exclusive
-
-instance (Covariant t, Alternative u) => Alternative (T t u) where
-	T x <+> T y = T $ x <+> y
-
-instance (Applicative t, Applicative u) => Applicative (T t u) where
-	T f <*> T x = T $ apply <$> f <*> x
-
-instance Pointable t => Liftable (T t) where
-	lift x = T $ point <$> x
-
-instance Extractable t => Lowerable (T t) where
-	lower (T x) = extract <$> x
-
-instance (Traversable t, Traversable u) => Traversable (T t u) where
-	T x ->> f = T <$> (traverse . traverse) f x
-
-instance (Distributive t, Distributive u) => Distributive (T t u) where
-	x >>- f = T . comap distribute . distribute $ t . f <$> x
-
-up :: Pointable u => t a -> T t u a
-up = T . point
-
-
-newtype Y t u a = Y { y :: (u :.: t u) a }
-
-instance (Covariant (t u), Covariant u) => Covariant (Y t u) where
-	f <$> Y x = Y $ (comap . comap) f x
-
-instance (Pointable (t u), Pointable u) => Pointable (Y t u) where
-	point = Y . point . point
-
-instance (Extractable (t u), Extractable u) => Extractable (Y t u) where
-	extract = extract . extract . y
-
-instance (Covariant (t u), Exclusive u) => Exclusive (Y t u) where
-	exclusive = Y exclusive
-
-instance (Covariant (t u), Alternative u) => Alternative (Y t u) where
-	Y x <+> Y y = Y $ x <+> y
-
-instance (Applicative (t u), Applicative u) => Applicative (Y t u) where
-	Y f <*> Y x = Y $ apply <$> f <*> x
-
-instance (Traversable (t u), Traversable u) => Traversable (Y t u) where
-	Y x ->> f = Y <$> (traverse . traverse) f x
-
-instance (Distributive (t u), Distributive u) => Distributive (Y t u) where
-	x >>- f = Y . comap distribute . distribute $ y . f <$> x
-
-instance (forall u . Pointable u, Liftable t) => Liftable (Y t) where
-	lift = Y . point . lift
-
-instance (forall u . Extractable u, Lowerable t) => Lowerable (Y t) where
-	lower = lower . extract . y
diff --git a/Pandora/Paradigm/Basis/Maybe.hs b/Pandora/Paradigm/Basis/Maybe.hs
--- a/Pandora/Paradigm/Basis/Maybe.hs
+++ b/Pandora/Paradigm/Basis/Maybe.hs
@@ -3,7 +3,7 @@
 import Pandora.Core.Functor (Variant (Co))
 import Pandora.Core.Morphism ((.), ($))
 import Pandora.Paradigm.Basis.Identity (Identity (Identity))
-import Pandora.Paradigm.Basis.Junction.Transformer (T (T, t), type (:!:))
+import Pandora.Paradigm.Junction.Transformer (T (T, t), type (:!:))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Exclusive (Exclusive (exclusive))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
diff --git a/Pandora/Paradigm/Basis/Product.hs b/Pandora/Paradigm/Basis/Product.hs
--- a/Pandora/Paradigm/Basis/Product.hs
+++ b/Pandora/Paradigm/Basis/Product.hs
@@ -1,4 +1,4 @@
-module Pandora.Paradigm.Basis.Product (Product (..), type (:*), delta, swap) where
+module Pandora.Paradigm.Basis.Product (Product (..), type (:*), delta, swap, attached) where
 
 import Pandora.Core.Morphism (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
@@ -33,3 +33,6 @@
 
 swap :: a :* b -> b :* a
 swap (x :* y) = y :* x
+
+attached :: a :* b -> a
+attached (x :* y) = x
diff --git a/Pandora/Paradigm/Controlflow/Observable.hs b/Pandora/Paradigm/Controlflow/Observable.hs
--- a/Pandora/Paradigm/Controlflow/Observable.hs
+++ b/Pandora/Paradigm/Controlflow/Observable.hs
@@ -11,11 +11,11 @@
 
 -- | Make continuation observable
 observe :: Continuation r t a -> Observable t a r
-observe f = Continuation $ \h -> Capture $ continue f (captured . h)
+observe action = Continuation $ \h -> Capture $ continue action (captured . h)
 
 -- | Listen only first event, call back just once
 notify :: Observable t a r -> (a -> t r) -> t r
-notify r f = captured $ continue r (Capture . f)
+notify r action = captured $ continue r (Capture . action)
 
 -- | Infix version of 'notify'
 (.:~.) :: Observable t a r -> (a -> t r) -> t r
@@ -23,7 +23,7 @@
 
 -- | Listen only first event, call back forever
 follow :: Applicative t => Observable t a r -> (a -> t r) -> t r
-follow r f = captured $ continue r (Capture . forever . f)
+follow r action = captured $ continue r (Capture . forever . action)
 
 -- | Infix version of 'follow'
 (.:~*) :: Applicative t => Observable t a r -> (a -> t r) -> t r
@@ -31,7 +31,7 @@
 
 -- | Listen all events from action, call back just once
 subscribe :: Applicative t => Observable t a r -> (a -> t r) -> t r
-subscribe r f = forever $ captured $ continue r (Capture . f)
+subscribe r action = forever $ captured $ continue r (Capture . action)
 
 -- | Infix version of 'subscribe'
 (*:~.) :: Applicative t => Observable t a r -> (a -> t r) -> t r
@@ -39,7 +39,7 @@
 
 -- | Listen all events from action, call back forever
 watch :: Applicative t => Observable t a r -> (a -> t r) -> t r
-watch r f = forever $ captured $ continue r (Capture . forever . f)
+watch r action = forever $ captured $ continue r (Capture . forever . action)
 
 -- | Infix version of 'watch'
 (*:~*) :: Applicative t => Observable t a r -> (a -> t r) -> t r
diff --git a/Pandora/Paradigm/Inventory/Environmental.hs b/Pandora/Paradigm/Inventory/Environmental.hs
--- a/Pandora/Paradigm/Inventory/Environmental.hs
+++ b/Pandora/Paradigm/Inventory/Environmental.hs
@@ -1,7 +1,7 @@
 module Pandora.Paradigm.Inventory.Environmental (Environmental (..), Environ, ask, local) where
 
 import Pandora.Core.Functor (type (:.:))
-import Pandora.Core.Morphism ((.), ($), (!), flip)
+import Pandora.Core.Morphism ((.), ($), (!), (?))
 import Pandora.Paradigm.Basis.Identity (Identity)
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), comap))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
@@ -28,7 +28,7 @@
 	x <+> y = Environmental $ \e -> environmentally x e <+> environmentally y e
 
 instance Bindable t => Bindable (Environmental e t) where
-	Environmental x >>= f = Environmental $ \e -> x e >>= flip environmentally e . f
+	Environmental x >>= f = Environmental $ \e -> x e >>= environmentally ? e . f
 
 instance Monad t => Monad (Environmental e t) where
 
diff --git a/Pandora/Paradigm/Inventory/Storage.hs b/Pandora/Paradigm/Inventory/Storage.hs
--- a/Pandora/Paradigm/Inventory/Storage.hs
+++ b/Pandora/Paradigm/Inventory/Storage.hs
@@ -1,7 +1,7 @@
 module Pandora.Paradigm.Inventory.Storage (Storage (..), Store, position, access, retrofit) where
 
 import Pandora.Core.Functor (type (:.:))
-import Pandora.Core.Morphism ((.), ($), flip)
+import Pandora.Core.Morphism ((.), ($), (?))
 import Pandora.Paradigm.Basis.Identity (Identity)
 import Pandora.Paradigm.Basis.Product (Product ((:*)), type (:*))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), comap))
@@ -34,7 +34,7 @@
 position (Storage (p :* _)) = p
 
 access :: Extractable t => p -> Storage p t a -> a
-access p = flip extract p . extract . stored
+access p = extract ? p . extract . stored
 
 retrofit :: Extractable t => (p -> p) -> Storage p t a -> Storage p t a
 retrofit f (Storage (p :* x)) = Storage $ (f p) :* x
diff --git a/Pandora/Paradigm/Junction.hs b/Pandora/Paradigm/Junction.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Junction.hs
@@ -0,0 +1,5 @@
+module Pandora.Paradigm.Junction (module Exports) where
+
+import Pandora.Paradigm.Junction.Kan as Exports
+import Pandora.Paradigm.Junction.Transformer as Exports
+import Pandora.Paradigm.Junction.Composition as Exports
diff --git a/Pandora/Paradigm/Junction/Composition.hs b/Pandora/Paradigm/Junction/Composition.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Junction/Composition.hs
@@ -0,0 +1,184 @@
+module Pandora.Paradigm.Junction.Composition (U (..), UU (..), UUU (..)) where
+
+import Pandora.Core.Functor (Variant (Co, Contra), type (:.:))
+import Pandora.Core.Morphism ((.), ($))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), comap))
+import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<), contramap))
+import Pandora.Pattern.Functor.Extractable (Extractable (extract))
+import Pandora.Pattern.Functor.Exclusive (Exclusive (exclusive))
+import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), apply))
+import Pandora.Pattern.Functor.Traversable (Traversable ((->>), traverse))
+import Pandora.Pattern.Functor.Distributive (Distributive ((>>-), distribute))
+import Pandora.Pattern.Functor.Adjoint (Adjoint (phi, psi))
+
+type (:-|:) t u = (Extractable t, Pointable t, Extractable u, Pointable u, Adjoint t u)
+
+
+newtype U ct cu t u a = U { u :: (t :.: u) a }
+
+instance (Covariant t, Covariant u) => Covariant (U Co Co t u) where
+	f <$> U x = U $ (comap . comap) f x
+
+instance (Covariant t, Contravariant u) => Contravariant (U Co Contra t u) where
+	f >$< U x = U $ contramap f <$> x
+
+instance (Contravariant t, Covariant u) => Contravariant (U Contra Co t u) where
+	f >$< U x = U $ contramap (comap f) x
+
+instance (Contravariant t, Contravariant u) => Covariant (U Contra Contra t u) where
+	f <$> U x = U $ contramap (contramap f) x
+
+instance (Pointable t, Pointable u) => Pointable (U Co Co t u) where
+	point = U . point . point
+
+instance (Extractable t, Extractable u) => Extractable (U Co Co t u) where
+	extract = extract . extract . u
+
+instance (Exclusive t, Covariant u) => Exclusive (U Co Co t u) where
+	exclusive = U exclusive
+
+instance (Applicative t, Applicative u) => Applicative (U Co Co t u) where
+	U f <*> U x = U $ apply <$> f <*> x
+
+instance (Alternative t, Covariant u) => Alternative (U Co Co t u) where
+	U x <+> U y = U $ x <+> y
+
+instance (Traversable t, Traversable u) => Traversable (U Co Co t u) where
+	U x ->> f = U <$> (traverse . traverse) f x
+
+instance (Distributive t, Distributive u) => Distributive (U Co Co t u) where
+	x >>- f = U . comap distribute . distribute $ u . f <$> x
+
+instance (t :-|: u, v :-|: w) => Adjoint (U Co Co t v) (U Co Co u w) where
+	phi f = point . f . point
+	psi f = extract . extract . comap f
+
+
+newtype UU ct cu cv t u v a = UU { uu :: (t :.: u :.: v) a }
+
+instance (Covariant t, Covariant u, Covariant v) => Covariant (UU Co Co Co t u v) where
+	f <$> UU x = UU $ (comap . comap . comap) f x
+
+instance (Covariant t, Covariant u, Contravariant v) => Contravariant (UU Co Co Contra t u v) where
+	f >$< UU x = UU $ (comap . comap) (contramap f) x
+
+instance (Covariant t, Contravariant u, Covariant v) => Contravariant (UU Co Contra Co t u v) where
+	f >$< UU x = UU $ contramap (comap f) <$> x
+
+instance (Contravariant t, Covariant u, Covariant v) => Contravariant (UU Contra Co Co t u v) where
+	f >$< UU x = UU $ comap (comap f) >$< x
+
+instance (Contravariant t, Contravariant u, Covariant v) => Covariant (UU Contra Contra Co t u v) where
+	f <$> UU x = UU $ contramap (comap f) >$< x
+
+instance (Covariant t, Contravariant u, Contravariant v) => Covariant (UU Co Contra Contra t u v) where
+	f <$> UU x = UU $ contramap (contramap f) <$> x
+
+instance (Contravariant t, Covariant u, Contravariant v) => Covariant (UU Contra Co Contra t u v) where
+	f <$> UU x = UU $ comap (contramap f) >$< x
+
+instance (Contravariant t, Contravariant u, Contravariant v) => Contravariant (UU Contra Contra Contra t u v) where
+	f >$< UU x = UU $ (contramap . contramap . contramap) f x
+
+instance (Pointable t, Pointable u, Pointable v) => Pointable (UU Co Co Co t u v) where
+	point = UU . point . point . point
+
+instance (Extractable t, Extractable u, Extractable v) => Extractable (UU Co Co Co t u v) where
+	extract = extract . extract . extract . uu
+
+instance (Exclusive t, Covariant u, Covariant v) => Exclusive (UU Co Co Co t u v) where
+	exclusive = UU exclusive
+
+instance (Applicative t, Applicative u, Applicative v) => Applicative (UU Co Co Co t u v) where
+	UU f <*> UU x = UU $ (comap apply . (comap . comap) apply $ f) <*> x
+
+instance (Alternative t, Covariant u, Covariant v) => Alternative (UU Co Co Co t u v) where
+	UU x <+> UU y = UU $ x <+> y
+
+instance (Traversable t, Traversable u, Traversable v) => Traversable (UU Co Co Co t u v) where
+	UU x ->> f = UU <$> (traverse . traverse . traverse) f x
+
+instance (Distributive t, Distributive u, Distributive v) => Distributive (UU Co Co Co t u v) where
+	x >>- f = UU . (comap . comap) distribute . comap distribute . distribute $ uu . f <$> x
+
+instance (t :-|: w, v :-|: x, u :-|: y) => Adjoint (UU Co Co Co t v u) (UU Co Co Co w x y) where
+	phi f = point . f . point
+	psi f = extract . extract . comap f
+
+
+newtype UUU ct cu cv cw t u v w a = UUU { uuu :: (t :.: u :.: v :.: w) a }
+
+instance (Covariant t, Covariant u, Covariant v, Covariant w) => Covariant (UUU Co Co Co Co t u v w) where
+	f <$> UUU x = UUU $ (comap . comap . comap . comap) f x
+
+instance (Covariant t, Covariant u, Covariant v, Contravariant w) => Contravariant (UUU Co Co Co Contra t u v w) where
+	f >$< UUU x = UUU $ (comap . comap . comap) (contramap f) x
+
+instance (Covariant t, Covariant u, Contravariant v, Covariant w) => Contravariant (UUU Co Co Contra Co t u v w) where
+	f >$< UUU x = UUU $ (comap . comap) (contramap (comap f)) x
+
+instance (Covariant t, Contravariant u, Covariant v, Covariant w) => Contravariant (UUU Co Contra Co Co t u v w) where
+	f >$< UUU x = UUU $ (contramap (comap (comap f))) <$> x
+
+instance (Contravariant t, Covariant u, Covariant v, Covariant w) => Contravariant (UUU Contra Co Co Co t u v w) where
+	f >$< UUU x = UUU $ comap (comap (comap f)) >$< x
+
+instance (Contravariant t, Contravariant u, Covariant v, Covariant w) => Covariant (UUU Contra Contra Co Co t u v w) where
+	f <$> UUU x = UUU $ (contramap . contramap . comap . comap $ f) x
+
+instance (Covariant t, Contravariant u, Contravariant v, Covariant w) => Covariant (UUU Co Contra Contra Co t u v w) where
+	f <$> UUU x = UUU $ (comap . contramap . contramap . comap $ f) x
+
+instance (Covariant t, Covariant u, Contravariant v, Contravariant w) => Covariant (UUU Co Co Contra Contra t u v w) where
+	f <$> UUU x = UUU $ (comap . comap) (contramap . contramap $ f) x
+
+instance (Covariant t, Contravariant u, Covariant v, Contravariant w) => Covariant (UUU Co Contra Co Contra t u v w) where
+	f <$> UUU x = UUU $ (comap . contramap . comap . contramap $ f) x
+
+instance (Contravariant t, Covariant u, Contravariant v, Covariant w) => Covariant (UUU Contra Co Contra Co t u v w) where
+	f <$> UUU x = UUU $ (contramap . comap . contramap . comap $ f) x
+
+instance (Contravariant t, Covariant u, Covariant v, Contravariant w) => Covariant (UUU Contra Co Co Contra t u v w) where
+	f <$> UUU x = UUU $ (contramap . comap . comap . contramap $ f) x
+
+instance (Contravariant t, Contravariant u, Contravariant v, Covariant w) => Contravariant (UUU Contra Contra Contra Co t u v w) where
+	f >$< UUU x = UUU $ (contramap . contramap . contramap . comap) f x
+
+instance (Covariant t, Contravariant u, Contravariant v, Contravariant w) => Contravariant (UUU Co Contra Contra Contra t u v w) where
+	f >$< UUU x = UUU $ (comap . contramap . contramap . contramap) f x
+
+instance (Contravariant t, Covariant u, Contravariant v, Contravariant w) => Contravariant (UUU Contra Co Contra Contra t u v w) where
+	f >$< UUU x = UUU $ (contramap . comap . contramap . contramap) f x
+
+instance (Contravariant t, Contravariant u, Covariant v, Contravariant w) => Contravariant (UUU Contra Contra Co Contra t u v w) where
+	f >$< UUU x = UUU $ (contramap . contramap . comap . contramap) f x
+
+instance (Contravariant t, Contravariant u, Contravariant v, Contravariant w) => Covariant (UUU Contra Contra Contra Contra t u v w) where
+	f <$> UUU x = UUU $ (contramap . contramap . contramap . contramap) f x
+
+instance (Pointable t, Pointable u, Pointable v, Pointable w) => Pointable (UUU Co Co Co Co t u v w) where
+	point = UUU . point . point . point . point
+
+instance (Extractable t, Extractable u, Extractable v, Extractable w) => Extractable (UUU Co Co Co Co t u v w) where
+	extract = extract . extract . extract . extract . uuu
+
+instance (Exclusive t, Covariant u, Covariant v, Covariant w) => Exclusive (UUU Co Co Co Co t u v w) where
+	exclusive = UUU exclusive
+
+instance (Applicative t, Applicative u, Applicative v, Applicative w) => Applicative (UUU Co Co Co Co t u v w) where
+	UUU f <*> UUU x = UUU $ (comap apply . (comap . comap) apply . (comap . comap . comap) apply $ f) <*> x
+
+instance (Alternative t, Covariant u, Covariant v, Covariant w) => Alternative (UUU Co Co Co Co t u v w) where
+	UUU x <+> UUU y = UUU $ x <+> y
+
+instance (Traversable t, Traversable u, Traversable v, Traversable w) => Traversable (UUU Co Co Co Co t u v w) where
+	UUU x ->> f = UUU <$> (traverse . traverse . traverse . traverse) f x
+
+instance (Distributive t, Distributive u, Distributive v, Distributive w) => Distributive (UUU Co Co Co Co t u v w) where
+	x >>- f = UUU . (comap . comap . comap) distribute . (comap . comap) distribute . comap distribute . distribute $ uuu . f <$> x
+
+instance (t :-|: u, v :-|: w, q :-|: q, r :-|: s) => Adjoint (UUU Co Co Co Co t v q r) (UUU Co Co Co Co u w q s) where
+	phi f = point . f . point
+	psi f = extract . extract . comap f
diff --git a/Pandora/Paradigm/Junction/Kan.hs b/Pandora/Paradigm/Junction/Kan.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Junction/Kan.hs
@@ -0,0 +1,17 @@
+module Pandora.Paradigm.Junction.Kan (Lan (..), Ran (..)) where
+
+import Pandora.Core.Morphism ((.), ($))
+import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+
+newtype Lan (t :: * -> *) (u :: * -> *) (b :: *) (a :: *) =
+	Lan { lan :: (t b -> a) -> u b }
+
+instance Contravariant (Lan t u b) where
+	f >$< Lan x = Lan $ x . (f .)
+
+newtype Ran (t :: * -> *) (u :: * -> *) (b :: *) (a :: *) =
+	Ran { ran :: (a -> t b) -> u b }
+
+instance Covariant (Ran t u b) where
+	f <$> Ran x = Ran $ x . (. f)
diff --git a/Pandora/Paradigm/Junction/Transformer.hs b/Pandora/Paradigm/Junction/Transformer.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Junction/Transformer.hs
@@ -0,0 +1,88 @@
+module Pandora.Paradigm.Junction.Transformer (T (..), type (:!:), up, Y (..), type (:>:)) where
+
+import Pandora.Core.Functor (type (:.:))
+import Pandora.Core.Morphism ((.), ($))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), comap))
+import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Extractable (Extractable (extract))
+import Pandora.Pattern.Functor.Exclusive (Exclusive (exclusive))
+import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), apply))
+import Pandora.Pattern.Functor.Traversable (Traversable ((->>), traverse))
+import Pandora.Pattern.Functor.Distributive (Distributive ((>>-), distribute))
+import Pandora.Pattern.Functor.Bindable (Bindable ((>>=), bind))
+import Pandora.Pattern.Functor.Liftable (Liftable (lift))
+import Pandora.Pattern.Functor.Lowerable (Lowerable (lower))
+
+infixr 0 :!:, :>:
+type (:!:) t u = T t u
+type (:>:) t u = Y t u
+
+
+newtype T t u a = T { t :: (u :.: t) a }
+
+instance (Covariant t, Covariant u) => Covariant (T t u) where
+	f <$> T x = T $ (comap . comap) f x
+
+instance (Pointable t, Pointable u) => Pointable (T t u) where
+	point = T . point . point
+
+instance (Extractable t, Extractable u) => Extractable (T t u) where
+	extract = extract . extract . t
+
+instance (Covariant t, Exclusive u) => Exclusive (T t u) where
+	exclusive = T exclusive
+
+instance (Covariant t, Alternative u) => Alternative (T t u) where
+	T x <+> T y = T $ x <+> y
+
+instance (Applicative t, Applicative u) => Applicative (T t u) where
+	T f <*> T x = T $ apply <$> f <*> x
+
+instance Pointable t => Liftable (T t) where
+	lift x = T $ point <$> x
+
+instance Extractable t => Lowerable (T t) where
+	lower (T x) = extract <$> x
+
+instance (Traversable t, Traversable u) => Traversable (T t u) where
+	T x ->> f = T <$> (traverse . traverse) f x
+
+instance (Distributive t, Distributive u) => Distributive (T t u) where
+	x >>- f = T . comap distribute . distribute $ t . f <$> x
+
+up :: Pointable u => t a -> T t u a
+up = T . point
+
+
+newtype Y t u a = Y { y :: (u :.: t u) a }
+
+instance (Covariant (t u), Covariant u) => Covariant (Y t u) where
+	f <$> Y x = Y $ (comap . comap) f x
+
+instance (Pointable (t u), Pointable u) => Pointable (Y t u) where
+	point = Y . point . point
+
+instance (Extractable (t u), Extractable u) => Extractable (Y t u) where
+	extract = extract . extract . y
+
+instance (Covariant (t u), Exclusive u) => Exclusive (Y t u) where
+	exclusive = Y exclusive
+
+instance (Covariant (t u), Alternative u) => Alternative (Y t u) where
+	Y x <+> Y y = Y $ x <+> y
+
+instance (Applicative (t u), Applicative u) => Applicative (Y t u) where
+	Y f <*> Y x = Y $ apply <$> f <*> x
+
+instance (Traversable (t u), Traversable u) => Traversable (Y t u) where
+	Y x ->> f = Y <$> (traverse . traverse) f x
+
+instance (Distributive (t u), Distributive u) => Distributive (Y t u) where
+	x >>- f = Y . comap distribute . distribute $ y . f <$> x
+
+instance (forall u . Pointable u, Liftable t) => Liftable (Y t) where
+	lift = Y . point . lift
+
+instance (forall u . Extractable u, Lowerable t) => Lowerable (Y t) where
+	lower = lower . extract . y
diff --git a/Pandora/Paradigm/Structure.hs b/Pandora/Paradigm/Structure.hs
--- a/Pandora/Paradigm/Structure.hs
+++ b/Pandora/Paradigm/Structure.hs
@@ -3,7 +3,7 @@
 import Pandora.Paradigm.Structure.Stack as Exports
 
 import Pandora.Paradigm.Basis.Cofree (Cofree)
-import Pandora.Paradigm.Basis.Junction.Transformer (type (:>:))
+import Pandora.Paradigm.Junction.Transformer (type (:>:))
 
-type family Nonempty structure :: * where
-	Nonempty ((Cofree :>: t) a) = Cofree t a
+type family Nonempty structure a :: * where
+	Nonempty (Cofree :>: t) a = Cofree t a
diff --git a/Pandora/Paradigm/Structure/Stack.hs b/Pandora/Paradigm/Structure/Stack.hs
--- a/Pandora/Paradigm/Structure/Stack.hs
+++ b/Pandora/Paradigm/Structure/Stack.hs
@@ -1,17 +1,17 @@
-module Pandora.Paradigm.Structure.Stack (Stack, push, top, pop) where
+module Pandora.Paradigm.Structure.Stack (Stack, push, top, pop, empty) where
 
 import Pandora.Core.Functor (type (:.:))
 import Pandora.Core.Morphism ((.), ($))
 import Pandora.Paradigm.Basis.Cofree (Cofree ((:<)), unwrap)
-import Pandora.Paradigm.Basis.Maybe (Maybe (Just))
-import Pandora.Paradigm.Basis.Junction.Transformer (Y (Y, y), type (:>:))
+import Pandora.Paradigm.Basis.Maybe (Maybe (Just, Nothing))
+import Pandora.Paradigm.Junction.Transformer (Y (Y, y), type (:>:))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
 
-type Stack a = (Cofree :>: Maybe) a
+type Stack = (Cofree :>: Maybe)
 
 push :: a -> Stack a -> Stack a
 push x (Y struct) = (Y $ (:<) x . Just <$> struct) <+> point x
@@ -21,3 +21,7 @@
 
 pop :: Stack a -> Stack a
 pop (Y struct) = Y $ struct >>= unwrap
+
+empty :: r -> (Cofree Maybe a -> r) -> Stack a -> r
+emtpy result _ (Y Nothing) = result
+empty _ f (Y (Just struct)) = f struct
diff --git a/Pandora/Pattern/Functor/Bindable.hs b/Pandora/Pattern/Functor/Bindable.hs
--- a/Pandora/Pattern/Functor/Bindable.hs
+++ b/Pandora/Pattern/Functor/Bindable.hs
@@ -1,7 +1,7 @@
 module Pandora.Pattern.Functor.Bindable (Bindable (..)) where
 
 import Pandora.Core.Functor (type (:.:))
-import Pandora.Core.Morphism (($), flip, identity)
+import Pandora.Core.Morphism (($), (?), identity)
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 
 infixl 1 >>=
@@ -19,7 +19,7 @@
 
 	-- | Flipped version of '>>=', the dual of '<<='
 	(=<<) :: (a -> t b) -> t a -> t b
-	(=<<) = flip (>>=)
+	(=<<) = (?) (>>=)
 	-- | Prefix and flipped version of '>>=', the dual of 'extend'
 	bind :: (a -> t b) -> t a -> t b
 	bind f t = t >>= f
@@ -31,4 +31,4 @@
 	f >=> g = \x -> f x >>= g
 	-- | Right-to-left Kleisli composition
 	(<=<) :: (b -> t c) -> (a -> t b) -> (a -> t c)
-	(<=<) = flip (>=>)
+	(<=<) = (?) (>=>)
diff --git a/Pandora/Pattern/Functor/Contravariant.hs b/Pandora/Pattern/Functor/Contravariant.hs
--- a/Pandora/Pattern/Functor/Contravariant.hs
+++ b/Pandora/Pattern/Functor/Contravariant.hs
@@ -1,6 +1,6 @@
 module Pandora.Pattern.Functor.Contravariant (Contravariant (..)) where
 
-import Pandora.Core.Morphism ((.), (!), flip)
+import Pandora.Core.Morphism ((.), (!), (?))
 
 infixl 4 >$<, $<, >$
 
@@ -23,7 +23,7 @@
 	(>$) = contramap . (!)
 	-- | Flipped version of '>$'
 	($<) :: t b -> b -> t a
-	($<) = flip (>$)
+	($<) = (?) (>$)
 	-- | Fill the input of evaluation
 	full :: t () -> t a
 	full x = () >$ x
diff --git a/Pandora/Pattern/Functor/Covariant.hs b/Pandora/Pattern/Functor/Covariant.hs
--- a/Pandora/Pattern/Functor/Covariant.hs
+++ b/Pandora/Pattern/Functor/Covariant.hs
@@ -1,6 +1,6 @@
 module Pandora.Pattern.Functor.Covariant (Covariant (..)) where
 
-import Pandora.Core.Morphism ((.), (!), flip)
+import Pandora.Core.Morphism ((.), (!), (?))
 
 infixl 4 <$>, <$, $>
 
@@ -23,7 +23,7 @@
 	(<$) = comap . (!)
 	-- | Flipped version of '<$'
 	($>) :: t a -> b -> t b
-	($>) = flip (<$)
+	($>) = (?) (<$)
 	-- | Discards the result of evaluation
 	void :: t a -> t ()
 	void x = () <$ x
diff --git a/Pandora/Pattern/Functor/Extendable.hs b/Pandora/Pattern/Functor/Extendable.hs
--- a/Pandora/Pattern/Functor/Extendable.hs
+++ b/Pandora/Pattern/Functor/Extendable.hs
@@ -1,7 +1,7 @@
 module Pandora.Pattern.Functor.Extendable (Extendable (..)) where
 
 import Pandora.Core.Functor (type (:.:))
-import Pandora.Core.Morphism ((.), flip, identity)
+import Pandora.Core.Morphism ((.), (?), identity)
 import Pandora.Pattern.Functor.Covariant (Covariant)
 
 infixl 1 =>>
@@ -20,7 +20,7 @@
 
 	-- | Flipped version of '>>=', the dual of '=<<'
 	(<<=) :: (t a -> b) -> t a -> t b
-	(<<=) = flip (=>>)
+	(<<=) = (?) (=>>)
 	-- | Prefix and flipped version of '=>>', the dual of 'bind'
 	extend :: (t a -> b) -> t a -> t b
 	extend f t = t =>> f
diff --git a/Pandora/Pattern/Functor/Invariant.hs b/Pandora/Pattern/Functor/Invariant.hs
--- a/Pandora/Pattern/Functor/Invariant.hs
+++ b/Pandora/Pattern/Functor/Invariant.hs
@@ -1,10 +1,5 @@
 module Pandora.Pattern.Functor.Invariant (Invariant (..)) where
 
-import Pandora.Core.Morphism (flip)
-
-infixl 4 >$>
-infixr 4 <$<
-
 {- |
 > When providing a new instance, you should ensure it satisfies the two laws:
 > Identity morphisms: invmap identity identity = identity
@@ -12,13 +7,5 @@
 -}
 
 class Invariant (t :: * -> *) where
-	{-# MINIMAL (<$<) #-}
-	-- | Infix version of 'invmap'
-	(<$<) :: (a -> b) -> (b -> a) -> t a -> t b
-
-	-- | Prefix version of '<$<'
+	{-# MINIMAL invmap #-}
 	invmap :: (a -> b) -> (b -> a) -> t a -> t b
-	invmap f x = f <$< x
-	-- | Flipped version of '<$<'
-	(>$>) :: (b -> a) -> (a -> b) -> t a -> t b
-	(>$>) = flip (<$<)
diff --git a/Pandora/Pattern/Object/Chain.hs b/Pandora/Pattern/Object/Chain.hs
--- a/Pandora/Pattern/Object/Chain.hs
+++ b/Pandora/Pattern/Object/Chain.hs
@@ -1,6 +1,6 @@
 module Pandora.Pattern.Object.Chain (Ordering (..), order, Chain (..)) where
 
-import Pandora.Core.Morphism (($), flip)
+import Pandora.Core.Morphism (($))
 import Pandora.Pattern.Object.Setoid (Boolean (True, False), Setoid)
 
 data Ordering = Less | Equal | Greater
diff --git a/pandora.cabal b/pandora.cabal
--- a/pandora.cabal
+++ b/pandora.cabal
@@ -1,5 +1,5 @@
 name:                pandora
-version:             0.1.0
+version:             0.1.1
 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
@@ -33,14 +33,16 @@
     Pandora.Paradigm.Basis.Free
     Pandora.Paradigm.Basis.Identity
     Pandora.Paradigm.Basis.Jack
-    Pandora.Paradigm.Basis.Junction.Composition
-    Pandora.Paradigm.Basis.Junction.Transformer
-    Pandora.Paradigm.Basis.Junction.Kan
     Pandora.Paradigm.Basis.Maybe
     Pandora.Paradigm.Basis.Predicate
     Pandora.Paradigm.Basis.Product
     Pandora.Paradigm.Basis.Wye
     Pandora.Paradigm.Basis.Yoneda
+    -- Universal functors constructions
+    Pandora.Paradigm.Junction
+    Pandora.Paradigm.Junction.Composition
+    Pandora.Paradigm.Junction.Transformer
+    Pandora.Paradigm.Junction.Kan
     -- Control flow primitives
     Pandora.Paradigm.Controlflow
     Pandora.Paradigm.Controlflow.Observable