diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -629,3 +629,22 @@
 * Remove `<$$$$>`, `<$$$$||=` and `=||$$$$>` operators
 * Define `Effectful` typeclass to delegate instance resolution for `Adaptable`
 * Change order of type parameters in `Adaptable` typeclass
+
+# 0.4.9
+* Define `<-*-*-` method of `Applicative` typeclass
+* Define `-*-*-` method of `Applicative` typeclass
+* Define `TT` scheme where two effects are known
+* Use `TT` instead of `TU` in `List` and `Binary`
+* Define `Lensic` typeclass to combine different lenses
+* Use `TT` instead of `TU` in `Tape` instances
+* Rename Environment module and type to `Provision`
+* Rename `Configured` to `Provided`
+* Rename `env` to `provided`
+* Rename `-<<-<<-` operator of `Traversable` to `<<-<<-`
+* Rename `-*-` and `-*-*-` to `.-*-` and `.-*-*-`
+* Define experimental `Kernel` typeclass
+* Remove `!.`, `!..`, `!..` operators in `Exponential` module
+* Move `<-|-|-` and `<-|-|-|-` under `Covariant` typeclass
+* Change priority of `:*:` operator
+* Change priority of `!` operator
+* Remove `$` operator in favor of `!`
diff --git a/Pandora/Paradigm/Controlflow/Effect/Interpreted.hs b/Pandora/Paradigm/Controlflow/Effect/Interpreted.hs
--- a/Pandora/Paradigm/Controlflow/Effect/Interpreted.hs
+++ b/Pandora/Paradigm/Controlflow/Effect/Interpreted.hs
@@ -4,11 +4,12 @@
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)), (<$$>), (<$$$>))
+import Pandora.Pattern.Category (identity)
+import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ()
 
-infixl 1 !
+infixl 0 !
 infixr 2 ||=, =||
 
 type family Schematic (c :: (* -> * -> *) -> (* -> *) -> k) (t :: * -> *) = (r :: (* -> *) -> * -> *) | r -> t
@@ -65,3 +66,8 @@
 	type Primary (Straight v e) a = v e a
 	run ~(Straight x) = x
 	unite = Straight
+
+instance Interpreted (->) ((->) e) where
+	type Primary ((->) e) a = e -> a
+	run = identity
+	unite = identity
diff --git a/Pandora/Paradigm/Controlflow/Effect/Transformer/Comonadic.hs b/Pandora/Paradigm/Controlflow/Effect/Transformer/Comonadic.hs
--- a/Pandora/Paradigm/Controlflow/Effect/Transformer/Comonadic.hs
+++ b/Pandora/Paradigm/Controlflow/Effect/Transformer/Comonadic.hs
@@ -3,7 +3,6 @@
 module Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic (Comonadic (..), (:<) (..)) where
 
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
@@ -29,25 +28,25 @@
 newtype (:<) t u a = TC { tc :: Schematic Comonad t u a }
 
 instance Covariant (->) (->) (Schematic Comonad t u) => Covariant (->) (->) (t :< u) where
-	f <-|- TC x = TC $ f <-|- x
+	f <-|- TC x = TC ! f <-|- x
 
 instance Semimonoidal (-->) (:*:) (:*:) (Schematic Comonad t u) => Semimonoidal (-->) (:*:) (:*:) (t :< u) where
-	mult = Straight $ \(TC f :*: TC x) -> TC $ mult @(-->) @(:*:) @(:*:) ! (f :*: x)
+	mult = Straight ! \(TC f :*: TC x) -> TC (mult @(-->) @(:*:) @(:*:) ! f :*: x)
 
 instance Monoidal (-->) (-->) (:*:) (:*:) (Schematic Comonad t u) => Monoidal (-->) (-->) (:*:) (:*:) (t :< u) where
-	unit _ = Straight $ TC . point . ($ One) . run
+	unit _ = Straight ! TC . point . (! One) . run
 
 instance Traversable (->) (->) (Schematic Comonad t u) => Traversable (->) (->) (t :< u) where
 	f <<- TC x = TC <-|- f <<- x
 
 instance Distributive (->) (->) (Schematic Comonad t u) => Distributive (->) (->) (t :< u) where
-	f -<< x = TC $ tc . f -<< x
+	f -<< x = TC ! tc . f -<< x
 
 instance Bindable (->) (Schematic Comonad t u) => Bindable (->) (t :< u) where
-	f =<< TC x = TC $ tc . f =<< x
+	f =<< TC x = TC ! tc . f =<< x
 
 instance Extendable (->) (Schematic Comonad t u) => Extendable (->) (t :< u) where
-	f <<= TC x = TC $ f . TC <<= x
+	f <<= TC x = TC ! f . TC <<= x
 
 instance (Extractable (t :< u), Extendable (->) (t :< u)) => Comonad (->) (t :< u) where
 
@@ -55,7 +54,7 @@
 	lower (TC x) = lower x
 
 instance Hoistable (->) (Schematic Comonad t) => Hoistable (->) ((:<) t) where
-	f /|\ TC x = TC $ f /|\ x
+	f /|\ TC x = TC ! f /|\ x
 
 instance (Interpreted (->) (Schematic Comonad t u)) => Interpreted (->) (t :< u) where
 	type Primary (t :< u) a = Primary (Schematic Comonad t u) a
diff --git a/Pandora/Paradigm/Controlflow/Effect/Transformer/Monadic.hs b/Pandora/Paradigm/Controlflow/Effect/Transformer/Monadic.hs
--- a/Pandora/Paradigm/Controlflow/Effect/Transformer/Monadic.hs
+++ b/Pandora/Paradigm/Controlflow/Effect/Transformer/Monadic.hs
@@ -4,7 +4,6 @@
 
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
@@ -30,28 +29,28 @@
 newtype (:>) t u a = TM { tm :: Schematic Monad t u a }
 
 instance Covariant (->) (->) (Schematic Monad t u) => Covariant (->) (->) (t :> u) where
-	f <-|- TM x = TM $ f <-|- x
+	f <-|- TM x = TM ! f <-|- x
 
 instance Semimonoidal (-->) (:*:) (:*:) (Schematic Monad t u) => Semimonoidal (-->) (:*:) (:*:) (t :> u) where
-	mult = Straight $ \(TM f :*: TM x) -> TM $ mult @(-->) @(:*:) @(:*:) ! (f :*: x)
+	mult = Straight ! \(TM f :*: TM x) -> TM (mult @(-->) @(:*:) @(:*:) ! f :*: x)
 
 instance Monoidal (-->) (-->) (:*:) (:*:) (Schematic Monad t u) => Monoidal (-->) (-->) (:*:) (:*:) (t :> u) where
-	unit _ = Straight $ TM . point . ($ One) . run
+	unit _ = Straight ! TM . point . (! One) . run
 
 instance Semimonoidal (-->) (:*:) (:+:) (Schematic Monad t u) => Semimonoidal (-->) (:*:) (:+:) (t :> u) where
-	mult = Straight $ \(TM f :*: TM x) -> TM $ mult @(-->) @(:*:) @(:+:) ! (f :*: x)
+	mult = Straight ! \(TM f :*: TM x) -> TM (mult @(-->) @(:*:) @(:+:) ! f :*: x)
 
 instance Traversable (->) (->) (Schematic Monad t u) => Traversable (->) (->) (t :> u) where
 	f <<- TM x = TM <-|- f <<- x
 
 instance Distributive (->) (->) (Schematic Monad t u) => Distributive (->) (->) (t :> u) where
-	f -<< x = TM $ tm . f -<< x
+	f -<< x = TM ! tm . f -<< x
 
 instance Bindable (->) (Schematic Monad t u) => Bindable (->) (t :> u) where
-	f =<< TM x = TM $ tm . f =<< x
+	f =<< TM x = TM ! tm . f =<< x
 
 instance Extendable (->) (Schematic Monad t u) => Extendable (->) (t :> u) where
-	f <<= TM x = TM $ f . TM <<= x
+	f <<= TM x = TM ! f . TM <<= x
 
 instance (Covariant (->) (->) (Schematic Monad t u), Monoidal (-->) (-->) (:*:) (:*:) (Schematic Monad t u), Bindable (->) (t :> u)) => Monad (->) (t :> u) where
 
@@ -59,7 +58,7 @@
 	lift = TM . lift
 
 instance Hoistable (->) (Schematic Monad t) => Hoistable (->) ((:>) t) where
-	f /|\ TM x = TM $ f /|\ x
+	f /|\ TM x = TM ! f /|\ x
 
 instance (Interpreted (->) (Schematic Monad t u)) => Interpreted (->) (t :> u) where
 	type Primary (t :> u) a = Primary (Schematic Monad t u) a
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
@@ -2,10 +2,10 @@
 	notify, follow, subscribe, watch, (.:~.), (.:~*), (*:~.), (*:~*)) where
 
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (($), (#))
+import Pandora.Pattern.Category ((#))
 import Pandora.Paradigm.Primary.Algebraic (Applicative, forever_)
 import Pandora.Paradigm.Primary.Transformer.Continuation (Continuation (Continuation))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (!))
 
 newtype Capture r t a = Capture { captured :: t r }
 
@@ -13,11 +13,11 @@
 
 -- | Make continuation observable
 observe :: Continuation r t a -> Observable t a r
-observe action = Continuation $ \h -> Capture $ run action # captured . h
+observe action = Continuation ! \h -> Capture ! run action # captured . h
 
 -- | Listen only first event, call back just once
 notify :: Observable t a r -> (a -> t r) -> t r
-notify r action = captured $ run r # Capture . action
+notify r action = captured ! run r # Capture . action
 
 -- | Infix version of 'notify'
 (.:~.) :: Observable t a r -> (a -> t r) -> t r
@@ -25,7 +25,7 @@
 
 -- | Listen only first event, call back forever_
 follow :: Applicative t => Observable t a r -> (a -> t r) -> t r
-follow r action = captured $ run r # Capture . forever_ . action
+follow r action = captured ! run r # Capture . forever_ . action
 
 -- | Infix version of 'follow'
 (.:~*) :: Applicative t => Observable t a r -> (a -> t r) -> t r
@@ -33,7 +33,7 @@
 
 -- | Listen all events from action, call back just once
 subscribe :: Applicative t => Observable t a r -> (a -> t r) -> t r
-subscribe r action = forever_ $ captured $ run r # Capture . action
+subscribe r action = forever_ ! captured ! run r # Capture . action
 
 -- | Infix version of 'subscribe'
 (*:~.) :: Applicative t => Observable t a r -> (a -> t r) -> t r
@@ -41,7 +41,7 @@
 
 -- | Listen all events from action, call back forever_
 watch :: Applicative t => Observable t a r -> (a -> t r) -> t r
-watch r action = forever_ $ captured $ run r # Capture . forever_ . action
+watch r action = forever_ ! captured ! run r # Capture . forever_ . action
 
 -- | Infix version of 'watch'
 (*:~*) :: Applicative t => Observable t a r -> (a -> t r) -> t r
diff --git a/Pandora/Paradigm/Controlflow/Pipeline.hs b/Pandora/Paradigm/Controlflow/Pipeline.hs
--- a/Pandora/Paradigm/Controlflow/Pipeline.hs
+++ b/Pandora/Paradigm/Controlflow/Pipeline.hs
@@ -1,13 +1,14 @@
 module Pandora.Paradigm.Controlflow.Pipeline (Pipeline, await, yield, finish, impact, (=*=), pipeline) where
 
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (($), (#))
+import Pandora.Pattern.Category ((#))
+import Pandora.Pattern.Kernel (constant)
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Monoidal (Monoidal)
-import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.), (!..), type (-->))
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (-->))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))
 import Pandora.Paradigm.Primary.Algebraic (point)
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (!)))
 import Pandora.Paradigm.Primary.Transformer.Continuation (Continuation (Continuation))
 
 newtype Producer i t r = Producer { produce :: Consumer i t r -> t r }
@@ -29,40 +30,40 @@
 type Pipeline i o t a r = Continuation r (Pipe i o r t) a
 
 pause :: (() -> Pipe i o r t a) -> Producer i t r -> Producer o t r
-pause next ik = Producer $ \ok -> (pipe $ next ()) ik ok
+pause next ik = Producer ! \ok -> (pipe ! next ()) ik ok
 
 suspend :: (i -> Pipe i o r t a) -> Consumer o t r -> Consumer i t r
-suspend next ok = Consumer $ \v ik -> pipe # next v # ik # ok
+suspend next ok = Consumer ! \v ik -> pipe # next v # ik # ok
 
 -- | Take incoming value from pipeline
 await :: Pipeline i o t i r
-await = Continuation $ \next -> Pipe $ \(Producer i) o -> i # suspend next o
+await = Continuation ! \next -> Pipe ! \(Producer i) o -> i # suspend next o
 
 -- | Give a value to the future consuming
 yield :: o -> Pipeline i o t () r
-yield v = Continuation $ \next -> Pipe $ \i (Consumer o) -> o v # pause next i
+yield v = Continuation ! \next -> Pipe ! \i (Consumer o) -> o v # pause next i
 
 -- | Pipeline that does nothing
 finish :: Monoidal (-->) (-->) (:*:) (:*:) t => Pipeline i o t () ()
-finish = Continuation (Pipe (point () !..) !.)
+finish = Continuation (constant # Pipe (constant . constant # point ()))
 
 -- | Do some effectful computation within pipeline
 impact :: Bindable (->) t => t a -> Pipeline i o t a a
-impact action = Continuation $ \next -> Pipe $ \i o -> (\x -> pipe (next x) i o) =<< action
+impact action = Continuation ! \next -> Pipe ! \i o -> (\x -> pipe (next x) i o) =<< action
 
 -- | Compose two pipelines into one
 (=*=) :: forall i e o t . Monoidal (-->) (-->) (:*:) (:*:) t => Pipeline i e t () () -> Pipeline e o t () () -> Pipeline i o t () ()
-p =*= q = Continuation $ \_ -> Pipe $ \i -> pipe # run q end # pause (run p end !.) i where
+p =*= q = Continuation ! \_ -> Pipe ! \i -> pipe # run q end # pause (constant # run p end) i where
 
 	end :: b -> Pipe c d () t ()
-	end _ = Pipe (point () !..)
+	end _ = Pipe (constant . constant # point ())
 
 -- | Run pipeline and get result
 pipeline :: Monoidal (-->) (-->) (:*:) (:*:) t => Pipeline i o t () () -> t ()
-pipeline p = pipe # run p (Pipe . (!..) . point) # i # o where
+pipeline p = pipe # run p (Pipe . constant . constant . point) # i # o where
 
 	i :: Producer i t ()
-	i = Producer $ \o' -> produce i o'
+	i = Producer ! \o' -> produce i o'
 
 	o :: Consumer o t ()
-	o = Consumer $ \v i' -> consume o v i'
+	o = Consumer ! \v i' -> consume o v i'
diff --git a/Pandora/Paradigm/Inventory.hs b/Pandora/Paradigm/Inventory.hs
--- a/Pandora/Paradigm/Inventory.hs
+++ b/Pandora/Paradigm/Inventory.hs
@@ -8,46 +8,47 @@
 import Pandora.Paradigm.Inventory.State as Exports
 import Pandora.Paradigm.Inventory.Imprint as Exports
 import Pandora.Paradigm.Inventory.Equipment as Exports
-import Pandora.Paradigm.Inventory.Environment as Exports
+import Pandora.Paradigm.Inventory.Provision as Exports
 import Pandora.Paradigm.Inventory.Accumulator as Exports
 
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (($))
+import Pandora.Pattern.Category ((#))
+import Pandora.Pattern.Kernel (constant)
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.), (%), type (<--))
+import Pandora.Paradigm.Primary.Algebraic.Exponential ((%), type (<--))
 import Pandora.Paradigm.Primary.Algebraic (extract)
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (!))
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
 
 instance Adjoint (->) (->) (Store s) (State s) where
 	(-|) :: (Store s a -> b) -> a -> State s b
-	f -| x = State $ \s -> (:*:) s . f . Store $ s :*: (x !.)
+	f -| x = State ! \s -> (:*:) s . f . Store ! s :*: constant x
 	(|-) :: (a -> State s b) -> Store s a -> b
-	g |- Store (s :*: f) = extract . (run % s) . g $ f s
+	g |- Store (s :*: f) = extract . (run % s) . g ! f s
 
 instance Adjoint (->) (->) (Accumulator e) (Imprint e) where
-	f -| x = Imprint $ f . Accumulator -| x
+	f -| x = Imprint ! f . Accumulator -| x
 	g |- x = run . g |- run x
 
-instance Adjoint (->) (->) (Equipment e) (Environment e) where
-	f -| x = Environment $ f . Equipment -| x
+instance Adjoint (->) (->) (Equipment e) (Provision e) where
+	f -| x = Provision ! f . Equipment -| x
 	g |- x = run . g |- run x
 
 zoom :: forall bg ls t u result . Stateful bg t => Lens u bg ls -> State (u ls) result -> t result
-zoom lens less = adapt . State $ \source -> restruct |- run (lens ! source) where
+zoom lens less = adapt . State ! \source -> restruct |- run (lens ! source) where
 
 	restruct :: (u ls -> bg) -> u ls -> bg :*: result
-	restruct to target = run $ to <-|- Flip (less ! target)
+	restruct to target = run # to <-|- Flip (less ! target)
 
 overlook :: (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t) => State s result -> State (t s) (t result)
-overlook (State state) = State $ \ts -> mult @(<--) @(:*:) @(:*:) ! (state <-|- ts)
+overlook (State state) = State ! \ts -> mult @(<--) @(:*:) @(:*:) ! (state <-|- ts)
 
 (=<>) :: Stateful src t => Lens available src tgt -> available tgt -> t src
-lens =<> new = modify $ set lens new
+lens =<> new = modify ! set lens new
 
 (~<>) :: Stateful src t => Lens available src tgt -> (available tgt -> available tgt) -> t src
-lens ~<> f = modify $ over lens f
+lens ~<> f = modify ! over lens f
diff --git a/Pandora/Paradigm/Inventory/Accumulator.hs b/Pandora/Paradigm/Inventory/Accumulator.hs
--- a/Pandora/Paradigm/Inventory/Accumulator.hs
+++ b/Pandora/Paradigm/Inventory/Accumulator.hs
@@ -1,10 +1,9 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
-
 module Pandora.Paradigm.Inventory.Accumulator (Accumulator (..), Accumulated, gather) where
 
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (($), (#))
+import Pandora.Pattern.Category ((#))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
@@ -14,7 +13,7 @@
 import Pandora.Paradigm.Primary.Algebraic.Exponential (type (-->))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Primary.Algebraic (point)
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite, (!)))
 import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM))
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
 import Pandora.Paradigm.Schemes.UT (UT (UT), type (<.:>))
@@ -22,15 +21,15 @@
 newtype Accumulator e a = Accumulator (e :*: a)
 
 instance Covariant (->) (->) (Accumulator e) where
-	f <-|- Accumulator x = Accumulator $ f <-|- x
+	f <-|- Accumulator x = Accumulator ! f <-|- x
 
 instance Semigroup e => Semimonoidal (-->) (:*:) (:*:) (Accumulator e) where
-	mult = Straight $ \(x :*: y) -> Accumulator $ k # run x # run y where
+	mult = Straight ! \(x :*: y) -> Accumulator ! k # run x # run y where
 		k ~(ex :*: x') ~(ey :*: y') = ex + ey :*: x' :*: y'
 
 instance Semigroup e => Bindable (->) (Accumulator e) where
-	f =<< Accumulator (e :*: x) = let e' :*: b = run $ f x in
-		Accumulator $ e + e':*: b
+	f =<< Accumulator (e :*: x) = let e' :*: b = run @(->) ! f x in
+		Accumulator ! e + e':*: b
 
 type instance Schematic Monad (Accumulator e) = (<.:>) ((:*:) e)
 
@@ -45,4 +44,4 @@
 type Accumulated e t = Adaptable t (->) (Accumulator e)
 
 gather :: Accumulated e t => e -> t ()
-gather x = adapt . Accumulator $ x :*: ()
+gather x = adapt . Accumulator ! x :*: ()
diff --git a/Pandora/Paradigm/Inventory/Environment.hs b/Pandora/Paradigm/Inventory/Environment.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Inventory/Environment.hs
+++ /dev/null
@@ -1,66 +0,0 @@
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-
-module Pandora.Paradigm.Inventory.Environment (Environment (..), Configured, env) where
-
-import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (identity, ($))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
-import Pandora.Pattern.Functor.Contravariant (Contravariant ((>-|-)))
-import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
-import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
-import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
-import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
-import Pandora.Pattern.Functor.Monad (Monad)
-import Pandora.Pattern.Functor.Divariant (Divariant ((>->)))
-import Pandora.Pattern.Functor.Bivariant ((<->))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (-->), (%))
-import Pandora.Paradigm.Primary.Algebraic ()
-import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))
-import Pandora.Paradigm.Primary.Algebraic.One (One (One))
-import Pandora.Paradigm.Primary.Algebraic (point)
-import Pandora.Pattern.Morphism.Flip (Flip (Flip))
-import Pandora.Pattern.Morphism.Straight (Straight (Straight))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite, (!)))
-import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM))
-import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
-import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))
-
-newtype Environment e a = Environment (e -> a)
-
-instance Covariant (->) (->) (Environment e) where
-	f <-|- Environment x = Environment $ f . x
-
-instance Contravariant (->) (->) (Flip Environment a) where
-	f >-|- Flip (Environment g) = Flip . Environment $ g . f
-
-instance Semimonoidal (-->) (:*:) (:*:) (Environment e) where
-	mult = Straight $ Environment . (mult @(-->) !) . (run @(->) <-> run @(->))
-
-instance Monoidal (-->) (-->) (:*:) (:*:) (Environment e) where
-	unit _ = Straight $ \f -> Environment $ \_ -> run f One
-
-instance Distributive (->) (->) (Environment e) where
-	f -<< g = Environment $ (run @(->) <-|- f) -<< g
-
-instance Bindable (->) (Environment e) where
-	f =<< Environment x = Environment $ \e -> (run % e) . f . x $ e
-
-instance Monad (->) (Environment e) where
-
-instance Divariant (->) (->) (->) Environment where
-	(>->) ab cd bc = Environment $ ab >-> cd $ run bc
-
-instance Interpreted (->) (Environment e) where
-	type Primary (Environment e) a = (->) e a
-	run ~(Environment x) = x
-	unite = Environment
-
-type instance Schematic Monad (Environment e) = (<:.>) ((->) e)
-
-instance Monadic (->) (Environment e) where
-	wrap x = TM . TU $ point <-|- run x
-
-type Configured e t = Adaptable t (->) (Environment e)
-
-env :: Configured e t => t e
-env = adapt $ Environment identity
diff --git a/Pandora/Paradigm/Inventory/Equipment.hs b/Pandora/Paradigm/Inventory/Equipment.hs
--- a/Pandora/Paradigm/Inventory/Equipment.hs
+++ b/Pandora/Paradigm/Inventory/Equipment.hs
@@ -3,7 +3,6 @@
 module Pandora.Paradigm.Inventory.Equipment (Equipment (..), retrieve) where
 
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
@@ -11,19 +10,19 @@
 import Pandora.Paradigm.Primary.Algebraic ()
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), attached)
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite, (!)))
 import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))
 
 newtype Equipment e a = Equipment (e :*: a)
 
 instance Covariant (->) (->) (Equipment e) where
-	f <-|- Equipment x = Equipment $ f <-|- x
+	f <-|- Equipment x = Equipment ! f <-|- x
 
 instance Traversable (->) (->) (Equipment e) where
 	f <<- Equipment x = Equipment <-|- f <<- x
 
 instance Extendable (->) (Equipment e) where
-	f <<= Equipment (e :*: x) = Equipment . (:*:) e . f . Equipment $ e :*: x
+	f <<= Equipment (e :*: x) = Equipment . (:*:) e . f . Equipment ! e :*: x
 
 instance Interpreted (->) (Equipment e) where
 	type Primary (Equipment e) a = e :*: a
@@ -35,7 +34,7 @@
 type Equipped e t = Adaptable (Equipment e) (->) t
 
 instance {-# OVERLAPS #-} Extendable (->) u => Extendable (->) ((:*:) e <:.> u) where
-	f <<= TU (e :*: x) = TU . (:*:) e $ f . TU . (:*:) e <<= x
+	f <<= TU (e :*: x) = TU . (:*:) e ! f . TU . (:*:) e <<= x
 
 retrieve :: Equipped e t => t a -> e
 retrieve = attached . run @(->) @(Equipment _) . adapt
diff --git a/Pandora/Paradigm/Inventory/Imprint.hs b/Pandora/Paradigm/Inventory/Imprint.hs
--- a/Pandora/Paradigm/Inventory/Imprint.hs
+++ b/Pandora/Paradigm/Inventory/Imprint.hs
@@ -3,7 +3,6 @@
 module Pandora.Paradigm.Inventory.Imprint (Imprint (..), Traceable) where
 
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>-|-)))
 import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
@@ -13,26 +12,26 @@
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ()
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite, (||=)))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite, (||=), (!)))
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable)
 import Pandora.Paradigm.Schemes.UT (UT (UT), type (<.:>))
 
 newtype Imprint e a = Imprint (e -> a)
 
 instance Covariant (->) (->) (Imprint e) where
-	f <-|- Imprint g = Imprint $ f . g
+	f <-|- Imprint g = Imprint ! f . g
 
 instance Contravariant (->) (->) (Flip Imprint a) where
-	f >-|- Flip (Imprint g) = Flip . Imprint $ g . f
+	f >-|- Flip (Imprint g) = Flip . Imprint ! g . f
 
 instance Distributive (->) (->) (Imprint e) where
-	f -<< g = Imprint $ (run @(->) <-|- f) -<< g
+	f -<< g = Imprint ! (run @(->) <-|- f) -<< g
 
 instance Divariant (->) (->) (->) Imprint where
 	(>->) ab cd bc = ab >-> cd ||= bc
 
 instance Semigroup e => Extendable (->) (Imprint e) where
-	f <<= Imprint x = Imprint $ \e -> f $ Imprint $ x . (e +)
+	f <<= Imprint x = Imprint ! \e -> f . Imprint ! x . (e +)
 
 instance Interpreted (->) (Imprint e) where
 	type Primary (Imprint e) a = (->) e a
@@ -42,6 +41,6 @@
 type instance Schematic Comonad (Imprint e) = (<.:>) ((->) e)
 
 instance {-# OVERLAPS #-} (Semigroup e, Extendable (->) u) => Extendable (->) ((->) e <.:> u) where
-	f <<= UT x = UT $ (\x' e -> f . UT . (<-|-) (. (e +)) $ x') <<= x
+	f <<= UT x = UT ! (\x' e -> f . UT . (<-|-) (. (e +)) ! x') <<= x
 
 type Traceable e t = Adaptable t (->) (Imprint e)
diff --git a/Pandora/Paradigm/Inventory/Optics.hs b/Pandora/Paradigm/Inventory/Optics.hs
--- a/Pandora/Paradigm/Inventory/Optics.hs
+++ b/Pandora/Paradigm/Inventory/Optics.hs
@@ -1,20 +1,21 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
+{-# LANGUAGE UndecidableInstances #-}
 
 module Pandora.Paradigm.Inventory.Optics where
 
 import Pandora.Core.Impliable (Impliable (Arguments, imply))
 import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
-import Pandora.Pattern.Category (Category (identity, ($), (#)))
+import Pandora.Pattern.Category (Category (identity, (#)))
+import Pandora.Pattern.Kernel (Kernel (constant))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
-import Pandora.Pattern.Functor.Invariant (Invariant ((<$<)))
+import Pandora.Pattern.Functor.Invariant (Invariant ((<!<)))
 import Pandora.Pattern.Functor.Divariant ((>->))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Representable (Representable (Representation, (<#>), tabulate))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
-import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (run))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (run, (!)))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (-->), (!.), (%))
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (-->), (%))
 import Pandora.Paradigm.Primary.Algebraic (extract)
 import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))
@@ -30,31 +31,33 @@
 type Lens = P_Q_T (->) Store
 
 instance Invariant (Flip (Lens available) tgt) where
-	f <$< g = \(Flip (P_Q_T lens)) -> Flip . P_Q_T $ g >-> (f <-|-) $ lens
+	f <!< g = \(Flip (P_Q_T lens)) -> Flip . P_Q_T ! g >-> (f <-|-) # lens
 
 type family Convex lens where
 	Convex Lens = Lens Identity
 
 instance Semigroupoid (Lens Identity) where
 	(.) :: Convex Lens between target -> Convex Lens source between -> Convex Lens source target
-	P_Q_T to . P_Q_T from = P_Q_T $ \source ->
+	P_Q_T to . P_Q_T from = P_Q_T ! \source ->
 		let (Identity between :*: bs) = run # from source in
 		let (Identity target :*: tb) = run # to between in
-		Store $ Identity target :*: bs . Identity . tb
+		Store ! Identity target :*: bs . Identity . tb
 
 instance Category (Lens Identity) where
 	identity :: Convex Lens source source
-	identity = imply @(Convex Lens _ _) identity ((%) (!.))
+	identity = imply @(Convex Lens _ _) identity ((%) constant)
 
-instance Semigroup source => Semimonoidal (-->) (:*:) (:*:) (Lens Identity source) where
-	mult = Straight $ \(P_Q_T x :*: P_Q_T y) -> P_Q_T $ \source ->
-		let Store (Identity xt :*: ixts) :*: Store (Identity yt :*: iyts) = x source :*: y source in
-		Store $ Identity (xt :*: yt) :*: \(Identity (xt_ :*: yt_)) -> ixts (Identity xt_) + iyts (Identity yt_)
+instance Semimonoidal (-->) (:*:) (:*:) (Lens Identity source) where
+	mult = Straight ! \(P_Q_T x :*: P_Q_T y) -> P_Q_T ! \source ->
+		let Store (Identity xt :*: ixts) :*: Store (Identity yt :*: _) = x source :*: y source in
+		Store ! Identity (xt :*: yt) :*: \(Identity (xt_ :*: yt_)) ->
+			let modified = ixts (Identity xt_) in
+			extract # run (y modified) # Identity yt_
 
 instance Impliable (P_Q_T (->) Store Identity source target) where
 	type Arguments (P_Q_T (->) Store Identity source target) =
 		(source -> target) -> (source -> target -> source) -> Lens Identity source target
-	imply getter setter = P_Q_T $ \source -> Store $ Identity # getter source :*: setter source . extract
+	imply getter setter = P_Q_T ! \source -> Store ! Identity # getter source :*: setter source . extract
 
 type family Obscure lens where
 	Obscure Lens = Lens Maybe
@@ -62,15 +65,15 @@
 instance Impliable (P_Q_T (->) Store Maybe source target) where
 	type Arguments (P_Q_T (->) Store Maybe source target) =
 		(source -> Maybe target) -> (source -> Maybe target -> source) -> Lens Maybe source target
-	imply getter setter = P_Q_T $ \source -> Store $ getter source :*: setter source
+	imply getter setter = P_Q_T ! \source -> Store ! getter source :*: setter source
 
 instance Semigroupoid (Lens Maybe) where
 	(.) :: Obscure Lens between target -> Obscure Lens source between -> Obscure Lens source target
-	P_Q_T to . P_Q_T from = P_Q_T $ \source -> case run # from source of
-		(Nothing :*: _) -> Store $ Nothing :*: \_ -> source
+	P_Q_T to . P_Q_T from = P_Q_T ! \source -> case run # from source of
+		(Nothing :*: _) -> Store ! Nothing :*: \_ -> source
 		(Just between :*: mbs) -> case run # to between of
-			(Nothing :*: _) -> Store $ Nothing :*: \_ -> source
-			(Just target :*: mtb) -> Store $ Just target :*: mbs . Just . mtb
+			(Nothing :*: _) -> Store ! Nothing :*: \_ -> source
+			(Just target :*: mtb) -> Store ! Just target :*: mbs . Just . mtb
 
 instance Category (Lens Maybe) where
 	identity :: Obscure Lens source source
@@ -93,4 +96,26 @@
 
 -- | Representable based lens
 represent :: forall t a . (Representable t, Setoid (Representation t)) => Representation t -> Convex Lens (t a) a
-represent r = imply @(Convex Lens (t a) a) (r <#>) (\source target -> tabulate $ \r' -> r' == r ? target $ r' <#> source)
+represent r = imply @(Convex Lens (t a) a) (r <#>) (\source target -> tabulate ! \r' -> r' == r ? target ! r' <#> source)
+
+class Lensic previous next where
+	type Lensally previous next :: * -> *
+	(>>>) :: Lens previous source between -> Lens next between target -> Lens (Lensally previous next) source target
+
+instance Semigroupoid (Lens t) => Lensic t t where
+	type Lensally t t = t
+	x >>> y = y . x
+
+instance Lensic Maybe Identity where
+	type Lensally Maybe Identity = Maybe
+	P_Q_T from >>> P_Q_T to = P_Q_T ! \source -> case run # from source of
+		(Nothing :*: _) -> Store ! Nothing :*: \_ -> source
+		(Just between :*: mbs) -> case run # to between of
+			(Identity target :*: itb) -> Store ! Just target :*: \mt -> mbs ! itb . Identity <-|- mt
+
+instance Lensic Identity Maybe where
+	type Lensally Identity Maybe = Maybe
+	P_Q_T from >>> P_Q_T to = P_Q_T ! \source -> case run # from source of
+		(Identity between :*: ibs) -> case run # to between of
+			(Just target :*: mtb) -> Store ! Just target :*: ibs . Identity . mtb
+			(Nothing :*: _) -> Store ! Nothing :*: \_ -> source
diff --git a/Pandora/Paradigm/Inventory/Provision.hs b/Pandora/Paradigm/Inventory/Provision.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Inventory/Provision.hs
@@ -0,0 +1,62 @@
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+module Pandora.Paradigm.Inventory.Provision where
+
+import Pandora.Pattern.Semigroupoid ((.))
+import Pandora.Pattern.Category (identity, (#))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
+import Pandora.Pattern.Functor.Contravariant (Contravariant ((>-|-)))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
+import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
+import Pandora.Pattern.Functor.Monad (Monad)
+import Pandora.Pattern.Functor.Divariant (Divariant ((>->)))
+import Pandora.Pattern.Functor.Bivariant ((<->))
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (-->), (%))
+import Pandora.Paradigm.Primary.Algebraic ()
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))
+import Pandora.Paradigm.Primary.Algebraic.One (One (One))
+import Pandora.Paradigm.Primary.Algebraic (point)
+import Pandora.Pattern.Morphism.Flip (Flip (Flip))
+import Pandora.Pattern.Morphism.Straight (Straight (Straight))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite, (!)))
+import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM))
+import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
+import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))
+
+newtype Provision e a = Provision (e -> a)
+
+instance Covariant (->) (->) (Provision e) where
+	f <-|- Provision x = Provision ! f . x
+
+instance Contravariant (->) (->) (Flip Provision a) where
+	f >-|- Flip (Provision g) = Flip . Provision ! g . f
+
+instance Semimonoidal (-->) (:*:) (:*:) (Provision e) where
+	mult = Straight ! Provision . (mult @(-->) !) . (run @(->) <-> run @(->))
+
+instance Monoidal (-->) (-->) (:*:) (:*:) (Provision e) where
+	unit _ = Straight ! \f -> Provision ! \_ -> run f One
+
+instance Distributive (->) (->) (Provision e) where
+	f -<< g = Provision ! (run @(->) <-|- f) -<< g
+
+instance Bindable (->) (Provision e) where
+	f =<< Provision x = Provision ! \e -> (run % e) . f . x ! e
+
+instance Monad (->) (Provision e) where
+
+instance Interpreted (->) (Provision e) where
+	type Primary (Provision e) a = (->) e a
+	run ~(Provision x) = x
+	unite = Provision
+
+type instance Schematic Monad (Provision e) = (<:.>) ((->) e)
+
+instance Monadic (->) (Provision e) where
+	wrap x = TM . TU ! point <-|- run x
+
+type Provided e t = Adaptable t (->) (Provision e)
+
+provided :: Provided e t => t e
+provided = adapt # Provision identity
diff --git a/Pandora/Paradigm/Inventory/State.hs b/Pandora/Paradigm/Inventory/State.hs
--- a/Pandora/Paradigm/Inventory/State.hs
+++ b/Pandora/Paradigm/Inventory/State.hs
@@ -6,9 +6,9 @@
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (identity, ($))
+import Pandora.Pattern.Category (identity, (#))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
-import Pandora.Pattern.Functor.Invariant (Invariant ((<$<)))
+import Pandora.Pattern.Functor.Invariant (Invariant ((<!<)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
@@ -18,11 +18,11 @@
 import Pandora.Pattern.Functor.Bivariant ((<->))
 import Pandora.Pattern.Functor.Divariant ((>->))
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (||=)), Schematic)
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (||=), (!)), Schematic)
 import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM))
 import Pandora.Paradigm.Schemes.TUT (TUT (TUT), type (<:<.>:>))
 import Pandora.Paradigm.Primary.Algebraic.Exponential (type (-->))
-import Pandora.Paradigm.Primary.Algebraic ((:*:) ((:*:)), (-*-), delta)
+import Pandora.Paradigm.Primary.Algebraic ((:*:) ((:*:)), (.-*-), delta)
 import Pandora.Paradigm.Primary.Algebraic.One (One (One))
 import Pandora.Paradigm.Primary.Algebraic (Pointable, point)
 
@@ -30,24 +30,24 @@
 newtype State s a = State ((->) s :. (:*:) s := a)
 
 instance Covariant (->) (->) (State s) where
-	f <-|- x = State $ (<-|-) f . run x
+	f <-|- x = State ! (<-|-) f . run x
 
 instance Semimonoidal (-->) (:*:) (:*:) (State s) where
-	mult = Straight $ \(State g :*: State h) -> State $ \s ->
+	mult = Straight ! \(State g :*: State h) -> State ! \s ->
 		let old :*: x = g s in
 		let new :*: y = h old in
 		new :*: x :*: y
 
 instance Monoidal (-->) (-->) (:*:) (:*:) (State s) where
-	unit _ = Straight $ State . (identity @(->) -|) . ($ One) . run
+	unit _ = Straight ! State . (identity @(->) -|) . (! One) . run
 
 instance Bindable (->) (State s) where
-	f =<< x = State $ (run . f |-) <-|- run x
+	f =<< x = State ! (run . f |-) <-|- run x
 
 instance Monad (->) (State s) where
 
 instance Invariant (Flip State r) where
-	f <$< g = ((g >-> ((<->) @_ @(->) @(->) f identity) ||=) ||=)
+	f <!< g = ((g >-> ((<->) @_ @(->) @(->) f identity) ||=) ||=)
 
 instance Interpreted (->) (State s) where
 	type Primary (State s) a = (->) s :. (:*:) s := a
@@ -57,21 +57,21 @@
 type instance Schematic Monad (State s) = (->) s <:<.>:> (:*:) s
 
 instance Monadic (->) (State s) where
-	wrap x = TM . TUT $ point <-|- run x
+	wrap x = TM . TUT ! point <-|- run x
 
 type Stateful s t = Adaptable t (->) (State s)
 
 -- | Get current value
 current :: Stateful s t => t s
-current = adapt $ State delta
+current = adapt # State delta
 
 -- | Modify stored value with a function
 modify :: Stateful s t => (s -> s) -> t s
-modify f = adapt . State $ \s -> let r = f s in r :*: r
+modify f = adapt . State ! \s -> let r = f s in r :*: r
 
 -- | Replace current value with another one
 replace :: Stateful s t => s -> t s
-replace s = adapt . State $ \_ -> s :*: s
+replace s = adapt . State ! \_ -> s :*: s
 
 reconcile :: (Bindable (->) t, Stateful s t, Adaptable t (->) u) => (s -> u s) -> t s
 reconcile f = replace =<< adapt . f =<< current
@@ -79,4 +79,4 @@
 type Memorable s t = (Covariant (->) (->) t, Pointable t, Stateful s t)
 
 fold :: (Traversable (->) (->) t, Memorable s u) => (a -> s -> s) -> t a -> u s
-fold op struct = current -*- modify . op <<- struct
+fold op struct = current .-*- modify . op <<- struct
diff --git a/Pandora/Paradigm/Inventory/Store.hs b/Pandora/Paradigm/Inventory/Store.hs
--- a/Pandora/Paradigm/Inventory/Store.hs
+++ b/Pandora/Paradigm/Inventory/Store.hs
@@ -4,23 +4,24 @@
 
 import Pandora.Core (type (:.), type (:=), type (<:=), type (~>))
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (identity, ($))
+import Pandora.Pattern.Category (identity)
+import Pandora.Pattern.Kernel (constant)
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)), (<-|-|-))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
-import Pandora.Pattern.Functor.Invariant (Invariant ((<$<)))
+import Pandora.Pattern.Functor.Invariant (Invariant ((<!<)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Pattern.Functor.Bivariant ((<->))
 import Pandora.Pattern.Functor.Divariant ((>->))
 import Pandora.Pattern.Functor.Adjoint ((-|))
-import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), type (-->), (%), (!.), (-.#..-))
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), type (-->), (%), (-.#..-))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), attached)
 import Pandora.Paradigm.Primary.Algebraic (extract)
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (||=)), Schematic)
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (||=), (!)), Schematic)
 import Pandora.Paradigm.Controlflow.Effect.Transformer.Comonadic (Comonadic (bring), (:<) (TC))
 import Pandora.Paradigm.Schemes.TUT (TUT (TUT), type (<:<.>:>))
 
@@ -32,21 +33,21 @@
 	(<-|-) f = (||=) (f <-|-|-)
 
 instance Semimonoidal (<--) (:*:) (:*:) (Store s) where
-	mult = Flip $ \(Store (s :*: f)) ->
+	mult = Flip ! \(Store (s :*: f)) ->
 		let (x :*: y) = f s in
-		Store (s :*: (x !.)) :*: Store (s :*: (y !.))
+		Store (s :*: constant x) :*: Store (s :*: constant y)
 
 instance Monoidal (<--) (-->) (:*:) (:*:) (Store s) where
-	unit _ = Flip $ \(Store (s :*: f)) -> Straight (\_ -> f s)
+	unit _ = Flip ! \(Store (s :*: f)) -> Straight (\_ -> f s)
 
 -- TODO: Try to generalize (->) here
 instance Extendable (->) (Store s) where
-	f <<= Store x = Store $ f <-|-|- (Store -.#..- (identity @(->) -|) <-|- x)
+	f <<= Store x = Store ! f <-|-|- (Store -.#..- (identity @(->) -|) <-|- x)
 
 instance Comonad (->) (Store s) where
 
 instance Invariant (Flip Store r) where
-	f <$< g = \(Flip x) -> Flip $ (<->) @_ @(->) f (g >-> identity @(->)) ||= x
+	f <!< g = \(Flip x) -> Flip ! (<->) @_ @(->) f (g >-> identity @(->)) ||= x
 
 instance Interpreted (->) (Store s) where
 	type Primary (Store s) a = (:*:) s :. (->) s := a
@@ -56,7 +57,7 @@
 type instance Schematic Comonad (Store s) = (:*:) s <:<.>:> (->) s
 
 instance Comonadic (->) (Store s) where
-	bring (TC (TUT (s :*: f))) = Store $ s :*: extract f
+	bring (TC (TUT (s :*: f))) = Store ! s :*: extract f
 
 type Storable s t = Adaptable (Store s) (->) t
 
@@ -70,4 +71,4 @@
 
 -- | Change index with function
 retrofit :: (s -> s) -> Store s ~> Store s
-retrofit g (Store (s :*: f)) = Store $ g s :*: f
+retrofit g (Store (s :*: f)) = Store ! g s :*: f
diff --git a/Pandora/Paradigm/Primary.hs b/Pandora/Paradigm/Primary.hs
--- a/Pandora/Paradigm/Primary.hs
+++ b/Pandora/Paradigm/Primary.hs
@@ -11,12 +11,13 @@
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Core.Functor (type (:=))
 import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
-import Pandora.Pattern.Category (Category (($), (#)))
+import Pandora.Pattern.Category ((#))
+import Pandora.Pattern.Kernel (Kernel (constant))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((|-), (-|)))
 import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Pattern.Transformer.Lowerable (lower)
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (!))
 import Pandora.Paradigm.Inventory.Store (Store (Store))
 import Pandora.Paradigm.Schemes (TU (TU), P_Q_T (P_Q_T), type (<:.>), type (<:.:>))
 import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (resolve))
@@ -24,22 +25,22 @@
 import Pandora.Paradigm.Structure.Ability.Substructure (Substructure (Available, Substance, substructure))
 
 instance Adjoint (->) (->) (Flip (:*:) s) ((->) s) where
-	f -| x = \s -> f $ Flip $ x :*: s
+	f -| x = \s -> f . Flip ! x :*: s
 	f |- Flip (x :*: s) = f x s
 
 instance Morphable (Into Maybe) (Conclusion e) where
 	type Morphing (Into Maybe) (Conclusion e) = Maybe
-	morphing = conclusion (Nothing !.) Just . premorph
+	morphing = conclusion (constant Nothing) Just . premorph
 
 instance Morphable (Into (Conclusion e)) Maybe where
 	type Morphing (Into (Conclusion e)) Maybe = (->) e <:.> Conclusion e
-	morphing (premorph -> Just x) = TU $ \_ -> Success x
-	morphing (premorph -> Nothing) = TU $ \e -> Failure e
+	morphing (premorph -> Just x) = TU ! \_ -> Success x
+	morphing (premorph -> Nothing) = TU ! \e -> Failure e
 
 instance Morphable (Into (Flip Conclusion e)) Maybe where
 	type Morphing (Into (Flip Conclusion e)) Maybe = (->) e <:.> Flip Conclusion e
-	morphing (run . premorph -> Just x) = TU $ \_ -> Flip $ Failure x
-	morphing (run . premorph -> Nothing) = TU $ Flip . Success
+	morphing (run . premorph -> Just x) = TU ! \_ -> Flip ! Failure x
+	morphing (run . premorph -> Nothing) = TU ! Flip . Success
 
 instance Morphable (Into (Left Maybe)) Wye where
 	type Morphing (Into (Left Maybe)) Wye = Maybe
@@ -89,17 +90,17 @@
 instance Substructure Left Wye where
 	type Available Left Wye = Maybe
 	type Substance Left Wye = Identity
-	substructure = P_Q_T $ \new -> case lower new of
-		End -> Store $ Nothing :*: lift . resolve Left End . (extract <-|-)
-		Left x -> Store $ Just (Identity x) :*: lift . resolve Left End . (extract <-|-)
-		Right y -> Store $ Nothing :*: (lift # Right y !.) . (extract <-|-)
-		Both x y -> Store $ Just (Identity x) :*: lift . resolve (Both % y) (Right y) . (extract <-|-)
+	substructure = P_Q_T ! \new -> case lower new of
+		End -> Store ! Nothing :*: lift . resolve Left End . (extract <-|-)
+		Left x -> Store ! Just (Identity x) :*: lift . resolve Left End . (extract <-|-)
+		Right y -> Store ! Nothing :*: lift . constant (Right y) . (extract <-|-)
+		Both x y -> Store ! Just (Identity x) :*: lift . resolve (Both % y) (Right y) . (extract <-|-)
 
 instance Substructure Right Wye where
 	type Available Right Wye = Maybe
 	type Substance Right Wye = Identity
-	substructure = P_Q_T $ \new -> case lower new of
-		End -> Store $ Nothing :*: lift . resolve Right End . (extract <-|-)
-		Left x -> Store $ Nothing :*: (lift # Left x !.) . (extract <-|-)
-		Right y -> Store $ Just (Identity y) :*: lift . resolve Right End . (extract <-|-)
-		Both x y -> Store $ Just (Identity y) :*: lift . resolve (Both x) (Left x) . (extract <-|-)
+	substructure = P_Q_T ! \new -> case lower new of
+		End -> Store ! Nothing :*: lift . resolve Right End . (extract <-|-)
+		Left x -> Store ! Nothing :*: lift . constant (Left x) . (extract <-|-)
+		Right y -> Store ! Just (Identity y) :*: lift . resolve Right End . (extract <-|-)
+		Both x y -> Store ! Just (Identity y) :*: lift . resolve (Both x) (Left x) . (extract <-|-)
diff --git a/Pandora/Paradigm/Primary/Algebraic.hs b/Pandora/Paradigm/Primary/Algebraic.hs
--- a/Pandora/Paradigm/Primary/Algebraic.hs
+++ b/Pandora/Paradigm/Primary/Algebraic.hs
@@ -1,6 +1,6 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 
-module Pandora.Paradigm.Primary.Algebraic (module Exports, Applicative, Alternative, Divisible, Decidable, Extractable, Pointable, ($>-), ($$>-), ($$$>-), (<-*-), (-*-), forever_, (<-+-), (-+-), void, empty, point, pass, extract) where
+module Pandora.Paradigm.Primary.Algebraic (module Exports, Applicative, Alternative, Divisible, Decidable, Extractable, Pointable, (!>-), (!!>-), (!!!>-), (<-*-), (.-*-), (<-*-*-), (.-*-*-), forever_, (<-+-), (-+-), void, empty, point, pass, extract) where
 
 import Pandora.Paradigm.Primary.Algebraic.Exponential as Exports
 import Pandora.Paradigm.Primary.Algebraic.Product as Exports
@@ -10,8 +10,8 @@
 
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
-import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Semigroupoid ((.))
+import Pandora.Pattern.Kernel (constant)
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)), (<-|-|-), (<-|-|-|-))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit), Unit)
@@ -24,73 +24,74 @@
 type instance Unit (:*:) = One
 type instance Unit (:+:) = Zero
 
+infixl 4 <-*-, .-*-
+infixl 3 <-*-*-, .-*-*-
 infixl 3 <-+-, -+-
-infixl 4 <-*-, -*-
 
-($>-) :: Covariant (->) (->) t => t a -> b -> t b
-x $>- r = (r !.) <-|- x
+(!>-) :: Covariant (->) (->) t => t a -> b -> t b
+x !>- r = constant r <-|- x
 
-($$>-) :: (Covariant (->) (->) t, Covariant (->) (->) u) => t (u a) -> b -> t (u b)
-x $$>- r = (r !.) <-|-|- x
+(!!>-) :: (Covariant (->) (->) t, Covariant (->) (->) u) => t (u a) -> b -> t (u b)
+x !!>- r = constant r <-|-|- x
 
-($$$>-) :: (Covariant (->) (->) t, Covariant (->) (->) u, Covariant (->) (->) v) => t (u (v a)) -> b -> t (u (v b))
-x $$$>- r = (r !.) <-|-|-|- x
+(!!!>-) :: (Covariant (->) (->) t, Covariant (->) (->) u, Covariant (->) (->) v) => t (u (v a)) -> b -> t (u (v b))
+x !!!>- r = constant r <-|-|-|- x
 
 void :: Covariant (->) (->) t => t a -> t ()
-void x = x $>- ()
+void x = x !>- ()
 
 instance Traversable (->) (->) ((:*:) s) where
 	f <<- x = (attached x :*:) <-|- f (extract x)
 
 instance Adjoint (->) (->) ((:*:) s) ((->) s) where
 	(-|) :: ((s :*: a) -> b) -> a -> (s -> b)
-	f -| x = \s -> f $ s :*: x
+	f -| x = \s -> f ! s :*: x
 	(|-) :: (a -> s -> b) -> (s :*: a) -> b
 	f |- ~(s :*: x) = f x s
 
 instance Semimonoidal (-->) (:*:) (:*:) ((->) e) where
 	mult :: ((e -> a) :*: (e -> b)) --> (e -> (a :*: b))
-	mult = Straight $ \(g :*: h) -> \x -> g x :*: h x
+	mult = Straight ! \(g :*: h) -> \x -> g x :*: h x
 
 instance Monoidal (-->) (-->) (:*:) (:*:) ((->) e) where
-	unit _ = Straight $ (!.) . (! One)
+	unit _ = Straight ! constant . (! One)
 
 instance Semimonoidal (<--) (:*:) (:*:) ((->) e) where
 	mult :: ((e -> a) :*: (e -> b)) <-- (e -> a :*: b)
-	mult = Flip $ \f -> attached . f :*: extract . f
+	mult = Flip ! \f -> attached . f :*: extract . f
 
 instance Semimonoidal (-->) (:*:) (:+:) ((:+:) e) where
 	mult :: ((e :+: a) :*: (e :+: b)) --> (e :+: a :+: b)
-	mult = Straight $ \case
+	mult = Straight ! \case
 		Option _ :*: Option e' -> Option e'
-		Option _ :*: Adoption y -> Adoption $ Adoption y
-		Adoption x :*: _ -> Adoption $ Option x
+		Option _ :*: Adoption y -> Adoption ! Adoption y
+		Adoption x :*: _ -> Adoption ! Option x
 
 instance Semimonoidal (-->) (:*:) (:*:) ((:+:) e) where
-	mult = Straight $ \case
-		Adoption x :*: Adoption y -> Adoption $ x :*: y
+	mult = Straight ! \case
+		Adoption x :*: Adoption y -> Adoption ! x :*: y
 		Option e :*: _ -> Option e
 		_ :*: Option e -> Option e
 
 instance Monoidal (-->) (-->) (:*:) (:*:) ((:+:) e) where
-	unit _ = Straight $ Adoption . (! One)
+	unit _ = Straight ! Adoption . (! One)
 
 instance Semimonoidal (<--) (:*:) (:*:) ((:*:) s) where
-	mult = Flip $ \(s :*: x :*: y) -> (s :*: x) :*: (s :*: y)
+	mult = Flip ! \(s :*: x :*: y) -> (s :*: x) :*: (s :*: y)
 
 instance Monoidal (<--) (-->) (:*:) (:*:) ((:*:) s) where
-	unit _ = Flip $ \(_ :*: x) -> Straight (\_ -> x)
+	unit _ = Flip ! \(_ :*: x) -> Straight (\_ -> x)
 
 instance Comonad (->) ((:*:) s) where
 
 instance Semimonoidal (<--) (:*:) (:*:) (Flip (:*:) a) where
-	mult = Flip $ \(Flip ((sx :*: sy) :*: r)) -> Flip (sx :*: r) :*: Flip (sy :*: r)
+	mult = Flip ! \(Flip ((sx :*: sy) :*: r)) -> Flip (sx :*: r) :*: Flip (sy :*: r)
 
 instance Monoidal (<--) (-->) (:*:) (:*:) (Flip (:*:) a) where
-	unit _ = Flip $ \(Flip (s :*: _)) -> Straight (\_ -> s)
+	unit _ = Flip ! \(Flip (s :*: _)) -> Straight (\_ -> s)
 
 --instance Semimonoidal (-->) (:*:) (:*:) (Flip (:*:) a) where
---mult = Straight $ \(Flip ((sx :*: sy) :*: r)) -> Flip (sx :*: r) :*: Flip (sy :*: r)
+--mult = Straight ! \(Flip ((sx :*: sy) :*: r)) -> Flip (sx :*: r) :*: Flip (sy :*: r)
 
 type Applicative t = (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t, Monoidal (-->) (-->) (:*:) (:*:) t)
 type Alternative t = (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:+:) t, Monoidal (-->) (-->) (:*:) (:+:) t)
@@ -100,11 +101,17 @@
 (<-*-) :: (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t) => t (a -> b) -> t a -> t b
 f <-*- x = (|-) @(->) @(->) (&) <-|- (mult @(-->) @_ @(:*:) ! (f :*: x))
 
-(-*-) :: (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t) => t b -> t a -> t b
-y -*- x = (\x' y' -> y') <-|- x <-*- y
+(<-*-*-) :: (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (-->) (:*:) (:*:) t, Semimonoidal (-->) (:*:) (:*:) u) => t (u (a -> b)) -> t (u a) -> t (u b)
+f <-*-*- x = (<-*-) <-|- f <-*- x
 
+(.-*-) :: (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t) => t b -> t a -> t b
+y .-*- x = (\x' y' -> y') <-|- x <-*- y
+
+(.-*-*-) :: (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (-->) (:*:) (:*:) t, Semimonoidal (-->) (:*:) (:*:) u) => t (u b) -> t (u a) -> t (u b)
+y .-*-*- x = (\x' y' -> y') <-|-|- x <-*-*- y
+
 forever_ :: (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t) => t a -> t b
-forever_ x = let r = r -*- x in r
+forever_ x = let r = r .-*- x in r
 
 (<-+-) :: (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:+:) t) => t b -> t a -> (a :+: b -> r) -> t r
 y <-+- x = \f -> f <-|- (mult @(-->) ! (x :*: y))
@@ -120,7 +127,7 @@
 extract j = unit @(<--) @(-->) Proxy ! j ! One
 
 point :: Pointable t => a -> t a
-point x = unit @(-->) Proxy ! (Straight $ \One -> x)
+point x = unit @(-->) Proxy ! (Straight ! \One -> x)
 
 pass :: Pointable t => t ()
 pass = point ()
diff --git a/Pandora/Paradigm/Primary/Algebraic/Exponential.hs b/Pandora/Paradigm/Primary/Algebraic/Exponential.hs
--- a/Pandora/Paradigm/Primary/Algebraic/Exponential.hs
+++ b/Pandora/Paradigm/Primary/Algebraic/Exponential.hs
@@ -4,7 +4,8 @@
 
 import Pandora.Pattern.Betwixt (Betwixt)
 import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
-import Pandora.Pattern.Category (Category (($), (#), identity))
+import Pandora.Pattern.Category (Category ((#), identity))
+import Pandora.Pattern.Kernel (Kernel (constant))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>-|-)))
 import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
@@ -15,7 +16,6 @@
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 
-infixr 2 !.
 infixr 7 -.#..-
 infixr 9 %
 infixl 1 &
@@ -28,6 +28,9 @@
 instance Category (->) where
 	identity x = x
 
+instance Kernel (->) where
+	constant x _ = x
+
 instance Covariant (->) (->) ((->) a) where
 	(<-|-) = (.)
 
@@ -49,27 +52,15 @@
 type (<--) = Flip (->)
 
 instance Contravariant (->) (->) ((<--) a) where
-	f >-|- Flip g = Flip $ g . f
+	f >-|- Flip g = Flip (g . f)
 
 type (-->) = Straight (->)
 
 instance Covariant (->) (->) ((-->) b) where
-	f <-|- Straight g = Straight $ f . g
+	f <-|- Straight g = Straight (f . g)
 
 (-.#..-) :: (Covariant (->) target (v a), Semigroupoid v) => v c d -> target (v a (v b c)) (v a (v b d))
 (-.#..-) f = (<-|-) (f .)
-
-{-# INLINE (!.) #-}
-(!.) :: a -> b -> a
-x !. _ = x
-
-{-# INLINE (!..) #-}
-(!..) :: a -> b -> c -> a
-(!..) x _ _ = x
-
-{-# INLINE (!...) #-}
-(!...) :: a -> b -> c -> d -> a
-(!...) x _ _ _ = x
 
 {-# INLINE (%) #-}
 (%) :: (a -> b -> c) -> b -> a -> c
diff --git a/Pandora/Paradigm/Primary/Algebraic/Product.hs b/Pandora/Paradigm/Primary/Algebraic/Product.hs
--- a/Pandora/Paradigm/Primary/Algebraic/Product.hs
+++ b/Pandora/Paradigm/Primary/Algebraic/Product.hs
@@ -1,7 +1,7 @@
 module Pandora.Paradigm.Primary.Algebraic.Product where
 
 import Pandora.Core.Functor (type (:=))
-import Pandora.Pattern.Category (($), (#))
+import Pandora.Pattern.Category ((#))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
@@ -20,7 +20,7 @@
 import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted ((!))
 
-infixr 0 :*:
+infixr 1 :*:
 
 data (:*:) s a = s :*: a
 
@@ -28,7 +28,7 @@
 	f <-|- ~(s :*: x) = s :*: f x
 
 instance Covariant (->) (->) (Flip (:*:) a) where
-	f <-|- (Flip (x :*: y)) = Flip $ f x :*: y
+	f <-|- (Flip (x :*: y)) = Flip ! f x :*: y
 
 instance Extendable (->) ((:*:) s) where
 	f <<= ~(s :*: x) = s :*: f (s :*: x)
@@ -63,11 +63,11 @@
 	invert ~(s :*: x) = invert # s :*: invert # x
 
 instance (Semimonoidal (-->) (:*:) (:*:) t, Semimonoidal (-->) (:*:) (:*:) u) => Semimonoidal (-->) (:*:) (:*:) (t <:.:> u := (:*:)) where
-	mult = Straight $ \(T_U (xls :*: xrs) :*: T_U (yls :*: yrs)) -> T_U $ (mult @(-->) !) (xls :*: yls) :*: (mult @(-->) !) (xrs :*: yrs)
+	mult = Straight ! \(T_U (xls :*: xrs) :*: T_U (yls :*: yrs)) -> T_U ! (mult @(-->) !) (xls :*: yls) :*: (mult @(-->) !) (xrs :*: yrs)
 
 -- TODO: Generalize (:*:) as Bivariant p
 instance (Semimonoidal (<--) (:*:) (:*:) t, Semimonoidal (<--) (:*:) (:*:) u) => Semimonoidal (<--) (:*:) (:*:) (t <:.:> u := (:*:)) where
-	mult = Flip $ \(T_U lrxys) ->
+	mult = Flip ! \(T_U lrxys) ->
 		-- TODO: I need matrix transposing here
 		let ((lxs :*: lys) :*: (rxs :*: rys)) = ((mult @(<--) !) <-> (mult @(<--) !)) lrxys in
 		T_U (lxs :*: rxs) :*: T_U (lys :*: rys)
@@ -82,4 +82,4 @@
 attached ~(x :*: _) = x
 
 twosome :: t a -> u a -> (<:.:>) t u (:*:) a
-twosome x y = T_U $ x :*: y
+twosome x y = T_U ! x :*: y
diff --git a/Pandora/Paradigm/Primary/Algebraic/Sum.hs b/Pandora/Paradigm/Primary/Algebraic/Sum.hs
--- a/Pandora/Paradigm/Primary/Algebraic/Sum.hs
+++ b/Pandora/Paradigm/Primary/Algebraic/Sum.hs
@@ -1,29 +1,34 @@
 module Pandora.Paradigm.Primary.Algebraic.Sum where
 
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ()
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted ((!))
 
 infixr 0 :+:
 
-data (:+:) s a = Option s | Adoption a
+data (:+:) o a = Option o | Adoption a
 
-instance Covariant (->) (->) ((:+:) s) where
+instance Covariant (->) (->) ((:+:) o) where
 	_ <-|- Option s = Option s
-	f <-|- Adoption x = Adoption $ f x
+	f <-|- Adoption x = Adoption ! f x
 
 instance Bivariant (->) (->) (->) (:+:) where
 	f <-> g = \case
-		Option s -> Option $ f s
-		Adoption x -> Adoption $ g x
+		Option s -> Option ! f s
+		Adoption x -> Adoption ! g x
 
 instance Covariant (->) (->) (Flip (:+:) a) where
-	_ <-|- Flip (Adoption x) = Flip $ Adoption x
-	f <-|- Flip (Option y) = Flip . Option $ f y
+	_ <-|- Flip (Adoption x) = Flip ! Adoption x
+	f <-|- Flip (Option y) = Flip . Option ! f y
 
 sum :: (e -> r) -> (a -> r) -> e :+: a -> r
 sum f _ (Option x) = f x
 sum _ s (Adoption x) = s x
+
+-- TODO: keep it until we realize how to implement n-ary functors
+bitraverse_sum :: Covariant (->) (->) t => (e -> t e') -> (a -> t a') -> (e :+: a) -> t (e' :+: a')
+bitraverse_sum f _ (Option x) = Option <-|- f x
+bitraverse_sum _ g (Adoption x) = Adoption <-|- g x
diff --git a/Pandora/Paradigm/Primary/Functor.hs b/Pandora/Paradigm/Primary/Functor.hs
--- a/Pandora/Paradigm/Primary/Functor.hs
+++ b/Pandora/Paradigm/Primary/Functor.hs
@@ -16,13 +16,13 @@
 import Pandora.Paradigm.Primary.Functor.Constant as Exports
 import Pandora.Paradigm.Primary.Functor.Identity as Exports
 
-import Pandora.Pattern.Category (($))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean, (?))
 import Pandora.Paradigm.Primary.Object.Ordering (Ordering)
+import Pandora.Paradigm.Controlflow.Effect.Interpreted ((!))
 
 type Equivalence = Convergence Boolean
 type Comparison = Convergence Ordering
 
 match :: Predicate a -> (a -> r) -> a -> r -> r :*: a
-match (Predicate p) f x r = p x ? (f x :*: x) $ r :*: x
+match (Predicate p) f x r = p x ? (f x :*: x) ! r :*: x
diff --git a/Pandora/Paradigm/Primary/Functor/Conclusion.hs b/Pandora/Paradigm/Primary/Functor/Conclusion.hs
--- a/Pandora/Paradigm/Primary/Functor/Conclusion.hs
+++ b/Pandora/Paradigm/Primary/Functor/Conclusion.hs
@@ -3,7 +3,7 @@
 import Pandora.Core.Functor (type (~>))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
-import Pandora.Pattern.Category (identity, ($), (#))
+import Pandora.Pattern.Category (identity, (#))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
@@ -19,7 +19,7 @@
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Primary.Algebraic.Sum ((:+:) (Option, Adoption))
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite, (!)))
 import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM))
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
 import Pandora.Paradigm.Schemes.UT (UT (UT), type (<.:>))
@@ -30,31 +30,31 @@
 data Conclusion e a = Failure e | Success a
 
 instance Covariant (->) (->) (Conclusion e) where
-	f <-|- Success x = Success $ f x
+	f <-|- Success x = Success ! f x
 	_ <-|- Failure y = Failure y
 
 instance Covariant (->) (->) (Flip Conclusion e) where
-	_ <-|- Flip (Success x) = Flip $ Success x
-	f <-|- Flip (Failure y) = Flip . Failure $ f y
+	_ <-|- Flip (Success x) = Flip ! Success x
+	f <-|- Flip (Failure y) = Flip . Failure ! f y
 
 instance Semimonoidal (-->) (:*:) (:*:) (Conclusion e) where
-	mult = Straight $ \case
-		Success x :*: Success y -> Success $ x :*: y
+	mult = Straight ! \case
+		Success x :*: Success y -> Success ! x :*: y
 		Failure x :*: _ -> Failure x
 		_ :*: Failure x -> Failure x
 
 instance Monoidal (-->) (-->) (:*:) (:*:) (Conclusion e) where
-	unit _ = Straight $ Success . ($ One) . run
+	unit _ = Straight ! Success . (! One) . run
 
 instance Semigroup e => Semimonoidal (-->) (:*:) (:+:) (Conclusion e) where
-	mult = Straight $ \case
+	mult = Straight ! \case
 		Failure _ :*: x -> Adoption <-|- x
 		Success x :*: _ -> Option <-|- Success x
 
 instance Traversable (->) (->) (Conclusion e) where
 	(<<-) :: (Covariant (->) (->) u, Monoidal (-->) (-->) (:*:) (:*:) u, Semimonoidal (-->) (:*:) (:*:) u)
 		 => (a -> u b) -> Conclusion e a -> u (Conclusion e b)
-	_ <<- Failure y = point $ Failure y
+	_ <<- Failure y = point ! Failure y
 	f <<- Success x = Success <-|- f x
 
 instance Bindable (->) (Conclusion e) where
@@ -78,8 +78,8 @@
 	Success _ <=> Failure _ = Greater
 
 instance (Semigroup e, Semigroup a) => Semigroup (Conclusion e a) where
-	Success x + Success y = Success $ x + y
-	Failure x + Failure y = Failure $ x + y
+	Success x + Success y = Success ! x + y
+	Failure x + Failure y = Failure ! x + y
 	Failure _ + Success y = Success y
 	Success x + Failure _ = Success x
 
@@ -88,7 +88,7 @@
 conclusion _ s (Success x) = s x
 
 fail :: (e -> r) -> Conclusion e ~> Conclusion r
-fail f (Failure x) = Failure $ f x
+fail f (Failure x) = Failure ! f x
 fail _ (Success y) = Success y
 
 instance Interpreted (->) (Conclusion e) where
@@ -115,4 +115,4 @@
 
 instance (Monoidal (-->) (-->) (:*:) (:*:) u, Bindable (->) u) => Catchable e (Conclusion e <.:> u) where
 	catch (UT x) handle = let conclude = conclusion # run . handle # point . Success
-		in UT $ conclude =<< x
+		in UT ! conclude =<< x
diff --git a/Pandora/Paradigm/Primary/Functor/Constant.hs b/Pandora/Paradigm/Primary/Functor/Constant.hs
--- a/Pandora/Paradigm/Primary/Functor/Constant.hs
+++ b/Pandora/Paradigm/Primary/Functor/Constant.hs
@@ -1,10 +1,9 @@
 module Pandora.Paradigm.Primary.Functor.Constant where
 
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>-|-)))
-import Pandora.Pattern.Functor.Invariant (Invariant ((<$<)))
+import Pandora.Pattern.Functor.Invariant (Invariant ((<!<)))
 import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
@@ -17,6 +16,7 @@
 import Pandora.Pattern.Object.Group (Group (invert))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ()
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted ((!))
 
 newtype Constant a b = Constant a
 
@@ -24,16 +24,16 @@
 	_ <-|- Constant x = Constant x
 
 instance Covariant (->) (->) (Flip Constant b) where
-	f <-|- Flip (Constant x) = Flip . Constant $ f x
+	f <-|- Flip (Constant x) = Flip . Constant ! f x
 
 instance Contravariant (->) (->) (Constant a) where
 	_ >-|- Constant x = Constant x
 
 instance Invariant (Constant a) where
-	_ <$< _ = \(Constant x) -> Constant x
+	_ <!< _ = \(Constant x) -> Constant x
 
 instance Bivariant (->) (->) (->) Constant where
-	f <-> _ = \(Constant x) -> Constant $ f x
+	f <-> _ = \(Constant x) -> Constant ! f x
 
 instance Setoid a => Setoid (Constant a b) where
 	Constant x == Constant y = x == y
@@ -42,24 +42,24 @@
 	Constant x <=> Constant y = x <=> y
 
 instance Semigroup a => Semigroup (Constant a b) where
-	Constant x + Constant y = Constant $ x + y
+	Constant x + Constant y = Constant ! x + y
 
 instance Monoid a => Monoid (Constant a b) where
 	 zero = Constant zero
 
 instance Ringoid a => Ringoid (Constant a b) where
-	Constant x * Constant y = Constant $ x * y
+	Constant x * Constant y = Constant ! x * y
 
 instance Quasiring a => Quasiring (Constant a b) where
 	 one = Constant one
 
 instance Infimum a => Infimum (Constant a b) where
-	Constant x /\ Constant y = Constant $ x /\ y
+	Constant x /\ Constant y = Constant ! x /\ y
 
 instance Supremum a => Supremum (Constant a b) where
-	Constant x \/ Constant y = Constant $ x \/ y
+	Constant x \/ Constant y = Constant ! x \/ y
 
 instance Lattice a => Lattice (Constant a b) where
 
 instance Group a => Group (Constant a b) where
-	invert (Constant x) = Constant $ invert x
+	invert (Constant x) = Constant ! invert x
diff --git a/Pandora/Paradigm/Primary/Functor/Convergence.hs b/Pandora/Paradigm/Primary/Functor/Convergence.hs
--- a/Pandora/Paradigm/Primary/Functor/Convergence.hs
+++ b/Pandora/Paradigm/Primary/Functor/Convergence.hs
@@ -1,6 +1,6 @@
 module Pandora.Paradigm.Primary.Functor.Convergence where
 
-import Pandora.Pattern.Category (($), (#))
+import Pandora.Pattern.Category ((#))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>-|-)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
@@ -10,14 +10,15 @@
 import Pandora.Paradigm.Primary.Algebraic.Exponential (type (-->), type (<--))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:)((:*:)))
 import Pandora.Paradigm.Primary.Algebraic ()
+import Pandora.Paradigm.Controlflow.Effect.Interpreted ((!))
 
 data Convergence r a = Convergence (a -> a -> r)
 
 instance Contravariant (->) (->) (Convergence r) where
-	f >-|- Convergence g = Convergence $ \x y -> g # f x # f y
+	f >-|- Convergence g = Convergence ! \x y -> g # f x # f y
 
 instance Semigroup r => Semimonoidal (-->) (:*:) (:*:) (Convergence r) where
-	mult = Straight $ \(Convergence f :*: Convergence g) -> Convergence $ \(a :*: b) (a' :*: b') -> f a a' + g b b'
+	mult = Straight ! \(Convergence f :*: Convergence g) -> Convergence ! \(a :*: b) (a' :*: b') -> f a a' + g b b'
 
 instance Monoid r => Monoidal (-->) (<--) (:*:) (:*:) (Convergence r) where
-	unit _ = Straight $ \_ -> Convergence $ \_ _ -> zero
+	unit _ = Straight ! \_ -> Convergence ! \_ _ -> zero
diff --git a/Pandora/Paradigm/Primary/Functor/Edges.hs b/Pandora/Paradigm/Primary/Functor/Edges.hs
--- a/Pandora/Paradigm/Primary/Functor/Edges.hs
+++ b/Pandora/Paradigm/Primary/Functor/Edges.hs
@@ -1,18 +1,18 @@
 module Pandora.Paradigm.Primary.Functor.Edges where
 
-import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ()
 import Pandora.Paradigm.Primary.Algebraic (point)
+import Pandora.Paradigm.Controlflow.Effect.Interpreted ((!))
 
 data Edges a = Empty | Leap a | Connect a | Overlay a
 
 instance Covariant (->) (->) Edges where
 	_ <-|- Empty = Empty
-	f <-|- Connect x = Connect $ f x
-	f <-|- Overlay x = Overlay $ f x
-	f <-|- Leap x = Leap $ f x
+	f <-|- Connect x = Connect ! f x
+	f <-|- Overlay x = Overlay ! f x
+	f <-|- Leap x = Leap ! f x
 
 instance Traversable (->) (->) Edges where
 	_ <<- Empty = point Empty
diff --git a/Pandora/Paradigm/Primary/Functor/Endo.hs b/Pandora/Paradigm/Primary/Functor/Endo.hs
--- a/Pandora/Paradigm/Primary/Functor/Endo.hs
+++ b/Pandora/Paradigm/Primary/Functor/Endo.hs
@@ -2,7 +2,7 @@
 
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category (identity, (#))
-import Pandora.Pattern.Functor.Invariant (Invariant ((<$<)))
+import Pandora.Pattern.Functor.Invariant (Invariant ((<!<)))
 import Pandora.Pattern.Functor.Divariant ((>->))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
@@ -17,7 +17,7 @@
 	unite = Endo
 
 instance Invariant Endo where
-	f <$< g = (g >-> f ||=)
+	f <!< g = (g >-> f ||=)
 
 instance Semigroup (Endo a) where
 	Endo f + Endo g = Endo # g . f
diff --git a/Pandora/Paradigm/Primary/Functor/Identity.hs b/Pandora/Paradigm/Primary/Functor/Identity.hs
--- a/Pandora/Paradigm/Primary/Functor/Identity.hs
+++ b/Pandora/Paradigm/Primary/Functor/Identity.hs
@@ -1,7 +1,6 @@
 module Pandora.Paradigm.Primary.Functor.Identity where
 
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
@@ -28,24 +27,24 @@
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Primary.Algebraic.One (One (One))
 import Pandora.Paradigm.Primary.Algebraic (extract)
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (!))
 
 newtype Identity a = Identity a
 
 instance Covariant (->) (->) Identity where
-	f <-|- Identity x = Identity $ f x
+	f <-|- Identity x = Identity ! f x
 
 instance Semimonoidal (-->) (:*:) (:*:) Identity where
-	mult = Straight $ Identity . (extract <-> extract)
+	mult = Straight ! Identity . (extract <-> extract)
 
 instance Monoidal (-->) (-->) (:*:) (:*:) Identity where
-	unit _ = Straight $ Identity . ($ One) . run
+	unit _ = Straight ! Identity . (! One) . run
 
 instance Semimonoidal (<--) (:*:) (:*:) Identity where
-	mult = Flip $ \(Identity (x :*: y)) -> Identity x :*: Identity y
+	mult = Flip ! \(Identity (x :*: y)) -> Identity x :*: Identity y
 
 instance Monoidal (<--) (-->) (:*:) (:*:) Identity where
-	unit _ = Flip $ \(Identity x) -> Straight (\_ -> x)
+	unit _ = Flip ! \(Identity x) -> Straight (\_ -> x)
 
 instance Traversable (->) (->) Identity where
 	f <<- Identity x = Identity <-|- f x
@@ -56,18 +55,18 @@
 instance Monad (->) Identity
 
 instance Extendable (->) Identity where
-	f <<= x = Identity . f $ x
+	f <<= x = Identity . f ! x
 
 instance Comonad (->) Identity
 
 --instance Representable Identity where
 	--type Representation Identity = ()
 	--() <#> Identity x = x
-	--tabulate f = Identity $ f ()
+	--tabulate f = Identity ! f ()
 
 instance Adjoint (->) (->) Identity Identity where
-	f -| x = Identity . f . Identity $ x
-	g |- x = extract . extract . (g <-|-) $ x
+	f -| x = Identity . f . Identity ! x
+	g |- x = extract . extract . (g <-|-) ! x
 
 instance Setoid a => Setoid (Identity a) where
 	Identity x == Identity y = x == y
@@ -76,24 +75,24 @@
 	Identity x <=> Identity y = x <=> y
 
 instance Semigroup a => Semigroup (Identity a) where
-	Identity x + Identity y = Identity $ x + y
+	Identity x + Identity y = Identity ! x + y
 
 instance Monoid a => Monoid (Identity a) where
 	 zero = Identity zero
 
 instance Ringoid a => Ringoid (Identity a) where
-	Identity x * Identity y = Identity $ x * y
+	Identity x * Identity y = Identity ! x * y
 
 instance Quasiring a => Quasiring (Identity a) where
 	 one = Identity one
 
 instance Infimum a => Infimum (Identity a) where
-	Identity x /\ Identity y = Identity $ x /\ y
+	Identity x /\ Identity y = Identity ! x /\ y
 
 instance Supremum a => Supremum (Identity a) where
-	Identity x \/ Identity y = Identity $ x \/ y
+	Identity x \/ Identity y = Identity ! x \/ y
 
 instance Lattice a => Lattice (Identity a) where
 
 instance Group a => Group (Identity a) where
-	invert (Identity x) = Identity $ invert x
+	invert (Identity x) = Identity ! invert x
diff --git a/Pandora/Paradigm/Primary/Functor/Maybe.hs b/Pandora/Paradigm/Primary/Functor/Maybe.hs
--- a/Pandora/Paradigm/Primary/Functor/Maybe.hs
+++ b/Pandora/Paradigm/Primary/Functor/Maybe.hs
@@ -2,7 +2,7 @@
 
 import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (identity, ($))
+import Pandora.Pattern.Category (identity)
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
@@ -19,7 +19,7 @@
 import Pandora.Pattern.Object.Lattice (Lattice)
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False))
 import Pandora.Paradigm.Primary.Object.Ordering (Ordering (Less, Equal, Greater))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Schematic, Interpreted (Primary, run, unite, (!)))
 import Pandora.Paradigm.Controlflow.Effect.Transformer.Monadic (Monadic (wrap), (:>) (TM))
 import Pandora.Paradigm.Controlflow.Effect.Adaptable (Adaptable (adapt))
 import Pandora.Paradigm.Schemes.UT (UT (UT), type (<.:>))
@@ -33,30 +33,30 @@
 data Maybe a = Nothing | Just a
 
 instance Covariant (->) (->) Maybe where
-	f <-|- Just x = Just $ f x
+	f <-|- Just x = Just ! f x
 	_ <-|- Nothing = Nothing
 
 instance Semimonoidal (-->) (:*:) (:*:) Maybe where
-	mult = Straight $ \case
-		Just x :*: Just y -> Just $ x :*: y
+	mult = Straight ! \case
+		Just x :*: Just y -> Just ! x :*: y
 		Nothing :*: _ -> Nothing
 		_ :*: Nothing -> Nothing
 
 instance Semimonoidal (-->) (:*:) (:+:) Maybe where
-	mult = Straight $ \case
-		Just x :*: _ -> Just $ Option x
-		Nothing :*: Just y -> Just $ Adoption y
+	mult = Straight ! \case
+		Just x :*: _ -> Just ! Option x
+		Nothing :*: Just y -> Just ! Adoption y
 		Nothing :*: Nothing -> Nothing
 
 instance Monoidal (-->) (-->) (:*:) (:*:) Maybe where
-	unit _ = Straight $ Just . ($ One) . run
+	unit _ = Straight ! Just . (! One) . run
 
 instance Monoidal (-->) (-->) (:*:) (:+:) Maybe where
-	unit _ = Straight $ \_ -> Nothing
+	unit _ = Straight ! \_ -> Nothing
 
 -- TODO: Check laws
 instance Semimonoidal (<--) (:*:) (:*:) Maybe where
-	mult = Flip $ \case
+	mult = Flip ! \case
 		Just (x :*: y) -> Just x :*: Just y
 		Nothing -> Nothing :*: Nothing
 
@@ -82,7 +82,7 @@
 	Just _ <=> Nothing = Greater
 
 instance Semigroup a => Semigroup (Maybe a) where
-	Just x + Just y = Just $ x + y
+	Just x + Just y = Just ! x + y
 	Nothing + x = x
 	x + Nothing = x
 
@@ -90,12 +90,12 @@
 	zero = Nothing
 
 instance Infimum a => Infimum (Maybe a) where
-	Just x /\ Just y = Just $ x /\ y
+	Just x /\ Just y = Just ! x /\ y
 	_ /\ Nothing = Nothing
 	Nothing /\ _ = Nothing
 
 instance Supremum a => Supremum (Maybe a) where
-	Just x \/ Just y = Just $ x \/ y
+	Just x \/ Just y = Just ! x \/ y
 	x \/ Nothing = x
 	Nothing \/ x = x
 
diff --git a/Pandora/Paradigm/Primary/Functor/Predicate.hs b/Pandora/Paradigm/Primary/Functor/Predicate.hs
--- a/Pandora/Paradigm/Primary/Functor/Predicate.hs
+++ b/Pandora/Paradigm/Primary/Functor/Predicate.hs
@@ -2,7 +2,6 @@
 
 import Pandora.Core.Functor (type (~>), type (:=>))
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>-|-)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
@@ -13,7 +12,7 @@
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:)((:*:)))
 import Pandora.Paradigm.Primary.Algebraic.Sum ((:+:)(Option, Adoption))
 import Pandora.Paradigm.Primary.Algebraic.Exponential (type (-->), type (<--))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (!)))
 
 newtype Predicate a = Predicate (a -> Boolean)
 
@@ -23,16 +22,16 @@
 	unite = Predicate
 
 instance Contravariant (->) (->) Predicate where
-	f >-|- Predicate g = Predicate $ g . f
+	f >-|- Predicate g = Predicate ! g . f
 
 instance Semimonoidal (-->) (:*:) (:*:) Predicate where
-	mult = Straight $ \(Predicate f :*: Predicate g) -> Predicate $ \(x :*: y) -> f x * g y
+	mult = Straight ! \(Predicate f :*: Predicate g) -> Predicate ! \(x :*: y) -> f x * g y
 
 instance Monoidal (-->) (<--) (:*:) (:*:) Predicate where
-	unit _ = Straight $ \_ -> Predicate $ \_ -> True
+	unit _ = Straight ! \_ -> Predicate ! \_ -> True
 
 instance Semimonoidal (-->) (:*:) (:+:) Predicate where
-	mult = Straight $ \(Predicate f :*: Predicate g) -> Predicate $ \case
+	mult = Straight ! \(Predicate f :*: Predicate g) -> Predicate ! \case
 		Option x -> f x
 		Adoption y -> g y
 
@@ -40,4 +39,4 @@
 equate x = Predicate (== x)
 
 not :: Predicate ~> Predicate
-not (Predicate p) = Predicate $ bool True False . p
+not (Predicate p) = Predicate ! bool True False . p
diff --git a/Pandora/Paradigm/Primary/Functor/Tagged.hs b/Pandora/Paradigm/Primary/Functor/Tagged.hs
--- a/Pandora/Paradigm/Primary/Functor/Tagged.hs
+++ b/Pandora/Paradigm/Primary/Functor/Tagged.hs
@@ -4,7 +4,6 @@
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
-import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
@@ -28,7 +27,7 @@
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Primary.Algebraic.One (One (One))
 import Pandora.Paradigm.Primary.Algebraic (extract)
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (!))
 
 newtype Tagged tag a = Tag a
 
@@ -36,28 +35,28 @@
 type (:#) tag = Tagged tag
 
 instance Covariant (->) (->) (Tagged tag) where
-	f <-|- Tag x = Tag $ f x
+	f <-|- Tag x = Tag ! f x
 
 instance Covariant (->) (->) (Flip Tagged a) where
-	_ <-|- Flip (Tag x) = Flip $ Tag x
+	_ <-|- Flip (Tag x) = Flip ! Tag x
 
 instance Semimonoidal (-->) (:*:) (:*:) (Tagged tag) where
-	mult = Straight $ Tag . (extract <-> extract)
+	mult = Straight ! Tag . (extract <-> extract)
 
 instance Monoidal (-->) (-->) (:*:) (:*:) (Tagged tag) where
-	unit _ = Straight $ Tag . ($ One) . run
+	unit _ = Straight ! Tag . (! One) . run
 
 instance Semimonoidal (<--) (:*:) (:*:) (Tagged tag) where
-	mult = Flip $ \(Tag (x :*: y)) -> Tag x :*: Tag y
+	mult = Flip ! \(Tag (x :*: y)) -> Tag x :*: Tag y
 
 instance Monoidal (<--) (-->) (:*:) (:*:) (Tagged tag) where
-	unit _ = Flip $ \(Tag x) -> Straight (\_ -> x)
+	unit _ = Flip ! \(Tag x) -> Straight (\_ -> x)
 
 instance Traversable (->) (->) (Tagged tag) where
 	f <<- Tag x = Tag <-|- f x
 
 instance Distributive (->) (->) (Tagged tag) where
-	f -<< x = Tag $ extract . f <-|- x
+	f -<< x = Tag ! extract . f <-|- x
 
 instance Bindable (->) (Tagged tag) where
 	f =<< Tag x = f x
@@ -65,12 +64,12 @@
 instance Monad (->) (Tagged tag)
 
 instance Extendable (->) (Tagged tag) where
-	f <<= x = Tag . f $ x
+	f <<= x = Tag . f ! x
 
 instance Comonad (->) (Tagged tag)
 
 instance Bivariant (->) (->) (->) Tagged where
-	_ <-> g = \(Tag x) -> Tag $ g x
+	_ <-> g = \(Tag x) -> Tag ! g x
 
 instance Setoid a => Setoid (Tagged tag a) where
 	Tag x == Tag y = x == y
@@ -79,27 +78,27 @@
 	Tag x <=> Tag y = x <=> y
 
 instance Semigroup a => Semigroup (Tagged tag a) where
-	Tag x + Tag y = Tag $ x + y
+	Tag x + Tag y = Tag ! x + y
 
 instance Monoid a => Monoid (Tagged tag a) where
 	 zero = Tag zero
 
 instance Ringoid a => Ringoid (Tagged tag a) where
-	Tag x * Tag y = Tag $ x * y
+	Tag x * Tag y = Tag ! x * y
 
 instance Quasiring a => Quasiring (Tagged tag a) where
 	one = Tag one
 
 instance Infimum a => Infimum (Tagged tag a) where
-	Tag x /\ Tag y = Tag $ x /\ y
+	Tag x /\ Tag y = Tag ! x /\ y
 
 instance Supremum a => Supremum (Tagged tag a) where
-	Tag x \/ Tag y = Tag $ x \/ y
+	Tag x \/ Tag y = Tag ! x \/ y
 
 instance Lattice a => Lattice (Tagged tag a) where
 
 instance Group a => Group (Tagged tag a) where
-	invert (Tag x) = Tag $ invert x
+	invert (Tag x) = Tag ! invert x
 
 retag :: forall new old . Tagged old ~> Tagged new
 retag (Tag x) = Tag x
diff --git a/Pandora/Paradigm/Primary/Functor/These.hs b/Pandora/Paradigm/Primary/Functor/These.hs
--- a/Pandora/Paradigm/Primary/Functor/These.hs
+++ b/Pandora/Paradigm/Primary/Functor/These.hs
@@ -1,22 +1,23 @@
 module Pandora.Paradigm.Primary.Functor.These where
 
-import Pandora.Pattern.Category (($), (#))
+import Pandora.Pattern.Category ((#))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ()
 import Pandora.Paradigm.Primary.Algebraic (point)
+import Pandora.Paradigm.Controlflow.Effect.Interpreted ((!))
 
 data These e a = This a | That e | These e a
 
 instance Covariant (->) (->) (These e) where
-	f <-|- This x = This $ f x
+	f <-|- This x = This ! f x
 	_ <-|- That y = That y
-	f <-|- These y x = These y $ f x
+	f <-|- These y x = These y ! f x
 
 instance Traversable (->) (->) (These e) where
 	f <<- This x = This <-|- f x
-	_ <<- That y = point $ That y
+	_ <<- That y = point ! That y
 	f <<- These y x = These y <-|- f x
 
 instance (Semigroup e, Semigroup a) => Semigroup (These e a) where
diff --git a/Pandora/Paradigm/Primary/Functor/Validation.hs b/Pandora/Paradigm/Primary/Functor/Validation.hs
--- a/Pandora/Paradigm/Primary/Functor/Validation.hs
+++ b/Pandora/Paradigm/Primary/Functor/Validation.hs
@@ -1,7 +1,7 @@
 module Pandora.Paradigm.Primary.Functor.Validation where
 
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (($), (#))
+import Pandora.Pattern.Category ((#))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
@@ -19,44 +19,44 @@
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (False))
 import Pandora.Paradigm.Primary.Object.Ordering (Ordering (Less, Greater))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (!))
 
 data Validation e a = Flaws e | Validated a
 
 instance Covariant (->) (->) (Validation e) where
 	_ <-|- Flaws e = Flaws e
-	f <-|- Validated x = Validated $ f x
+	f <-|- Validated x = Validated ! f x
 	_ <-|- Flaws e = Flaws e
-	f <-|- Validated x = Validated $ f x
+	f <-|- Validated x = Validated ! f x
 	_ <-|- Flaws e = Flaws e
-	f <-|- Validated x = Validated $ f x
+	f <-|- Validated x = Validated ! f x
 
 instance Covariant (->) (->) (Flip Validation a) where
-	f <-|- Flip (Flaws e) = Flip . Flaws $ f e
-	_ <-|- Flip (Validated x) = Flip $ Validated x
-	f <-|- Flip (Flaws e) = Flip . Flaws $ f e
-	_ <-|- Flip (Validated x) = Flip $ Validated x
-	f <-|- Flip (Flaws e) = Flip . Flaws $ f e
-	_ <-|- Flip (Validated x) = Flip $ Validated x
+	f <-|- Flip (Flaws e) = Flip . Flaws ! f e
+	_ <-|- Flip (Validated x) = Flip ! Validated x
+	f <-|- Flip (Flaws e) = Flip . Flaws ! f e
+	_ <-|- Flip (Validated x) = Flip ! Validated x
+	f <-|- Flip (Flaws e) = Flip . Flaws ! f e
+	_ <-|- Flip (Validated x) = Flip ! Validated x
 
 instance Semigroup e => Semimonoidal (-->) (:*:) (:*:) (Validation e) where
-	mult = Straight $ \case
-		Validated x :*: Validated y -> Validated $ x :*: y
-		Flaws x :*: Flaws y -> Flaws $ x + y
+	mult = Straight ! \case
+		Validated x :*: Validated y -> Validated ! x :*: y
+		Flaws x :*: Flaws y -> Flaws ! x + y
 		Validated _ :*: Flaws y -> Flaws y
 		Flaws x :*: Validated _ -> Flaws x
 
 instance Semigroup e => Monoidal (-->) (-->) (:*:) (:*:) (Validation e) where
-	unit _ = Straight $ Validated . ($ One) . run
+	unit _ = Straight ! Validated . (! One) . run
 
 instance Semigroup e => Semimonoidal (-->) (:*:) (:+:) (Validation e) where
-	mult = Straight $ \case
+	mult = Straight ! \case
 		Flaws _ :*: y -> Adoption <-|- y
 		Validated x :*: _ -> Option <-|- Validated x
 
 instance Traversable (->) (->) (Validation e) where
 	f <<- Validated x = Validated <-|- f x
-	_ <<- Flaws e = point $ Flaws e
+	_ <<- Flaws e = point ! Flaws e
 
 instance Bivariant (->) (->) (->) Validation where
 	f <-> g = validation # Flaws . f # Validated . g
@@ -73,8 +73,8 @@
 	Validated _ <=> Flaws _ = Greater
 
 instance (Semigroup e, Semigroup a) => Semigroup (Validation e a) where
-	Validated x + Validated y = Validated $ x + y
-	Flaws x + Flaws y = Flaws $ x + y
+	Validated x + Validated y = Validated ! x + y
+	Flaws x + Flaws y = Flaws ! x + y
 	Flaws _ + Validated y = Validated y
 	Validated x + Flaws _ = Validated x
 
diff --git a/Pandora/Paradigm/Primary/Functor/Wedge.hs b/Pandora/Paradigm/Primary/Functor/Wedge.hs
--- a/Pandora/Paradigm/Primary/Functor/Wedge.hs
+++ b/Pandora/Paradigm/Primary/Functor/Wedge.hs
@@ -1,21 +1,21 @@
 module Pandora.Paradigm.Primary.Functor.Wedge where
 
-import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Paradigm.Primary.Algebraic.Exponential ()
 import Pandora.Paradigm.Primary.Algebraic (point)
+import Pandora.Paradigm.Controlflow.Effect.Interpreted ((!))
 
 data Wedge e a = Nowhere | Here e | There a
 
 instance Covariant (->) (->) (Wedge e) where
 	_ <-|- Nowhere = Nowhere
 	_ <-|- Here x = Here x
-	f <-|- There x = There $ f x
+	f <-|- There x = There ! f x
 
 instance Traversable (->) (->) (Wedge e) where
 	_ <<- Nowhere = point Nowhere
-	_ <<- Here x = point $ Here x
+	_ <<- Here x = point ! Here x
 	f <<- There x = There <-|- f x
 
 wedge :: (e -> r) -> (a -> r) -> r -> Wedge e a -> r
diff --git a/Pandora/Paradigm/Primary/Functor/Wye.hs b/Pandora/Paradigm/Primary/Functor/Wye.hs
--- a/Pandora/Paradigm/Primary/Functor/Wye.hs
+++ b/Pandora/Paradigm/Primary/Functor/Wye.hs
@@ -1,7 +1,7 @@
 module Pandora.Paradigm.Primary.Functor.Wye where
 
 import Pandora.Core.Functor (type (~>))
-import Pandora.Pattern.Category ((#), ($))
+import Pandora.Pattern.Category ((#))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
@@ -10,6 +10,7 @@
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (reduce))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted ((!))
 
 data Wye a = End | Left a | Right a | Both a a
 
@@ -20,7 +21,7 @@
 	f <-|- Both x y = Both # f x # f y
 
 instance Semimonoidal (<--) (:*:) (:*:) Wye where
-	mult = Flip $ \case
+	mult = Flip ! \case
 		End -> End :*: End
 		Left (x :*: y) -> Left x :*: Left y
 		Right (x :*: y) -> Right x :*: Right y
diff --git a/Pandora/Paradigm/Primary/Linear/Matrix.hs b/Pandora/Paradigm/Primary/Linear/Matrix.hs
--- a/Pandora/Paradigm/Primary/Linear/Matrix.hs
+++ b/Pandora/Paradigm/Primary/Linear/Matrix.hs
@@ -2,16 +2,16 @@
 
 module Pandora.Paradigm.Primary.Linear.Matrix where
 
-import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Paradigm.Primary.Linear.Vector (Vector)
+import Pandora.Paradigm.Controlflow.Effect.Interpreted ((!))
 
 newtype Matrix i j a = Matrix (Vector i (Vector j a))
 
 instance (Semigroup a, Semigroup (Vector i a), Semigroup (Vector i (Vector j a))) => Semigroup (Matrix i j a) where
-	~(Matrix x) + ~(Matrix y) = Matrix $ x + y
+	~(Matrix x) + ~(Matrix y) = Matrix ! x + y
 
 instance (Monoid a, Monoid (Vector i a), Monoid (Vector i (Vector j a))) => Monoid (Matrix i j a) where
 	zero = Matrix zero
diff --git a/Pandora/Paradigm/Primary/Linear/Vector.hs b/Pandora/Paradigm/Primary/Linear/Vector.hs
--- a/Pandora/Paradigm/Primary/Linear/Vector.hs
+++ b/Pandora/Paradigm/Primary/Linear/Vector.hs
@@ -1,9 +1,8 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
-
 module Pandora.Paradigm.Primary.Linear.Vector where
 
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (($), (#))
+import Pandora.Pattern.Category ((#))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
@@ -13,24 +12,25 @@
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Just, Nothing))
 import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct))
-import Pandora.Paradigm.Schemes.TU (TU (TU))
+import Pandora.Paradigm.Schemes.TT (TT (TT))
 import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty)
 import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (reduce))
 import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), Morph (Into, Push), premorph, into, item)
 import Pandora.Paradigm.Structure.Some.List (List)
+import Pandora.Paradigm.Controlflow.Effect.Interpreted ((!))
 
 data Vector r a where
 	Scalar :: a -> Vector a a
 	Vector :: a -> Vector r a -> Vector (a :*: r) a
 
 instance Semigroup a => Semigroup (Vector a a) where
-	~(Scalar x) + ~(Scalar y) = Scalar $ x + y
+	~(Scalar x) + ~(Scalar y) = Scalar ! x + y
 
 instance (Semigroup a, Semigroup r, Semigroup (a :*: r), Semigroup (Vector r a)) => Semigroup (Vector (a :*: r) a) where
 	Vector x xs + Vector y ys = Vector # x + y # xs + ys
 
 instance Ringoid a => Ringoid (Vector a a) where
-	~(Scalar x) * ~(Scalar y) = Scalar $ x * y
+	~(Scalar x) * ~(Scalar y) = Scalar ! x * y
 
 instance (Ringoid a, Ringoid r, Ringoid (a :*: r), Ringoid (Vector r a)) => Ringoid (Vector (a :*: r) a) where
 	Vector x xs * Vector y ys = Vector # x * y # xs * ys
@@ -48,7 +48,7 @@
 	one = Vector one one
 
 instance Group a => Group (Vector a a) where
-	invert ~(Scalar x) = Scalar $ invert x
+	invert ~(Scalar x) = Scalar ! invert x
 
 instance (Group a, Group r, Group (a :*: r), Group (Vector r a)) => Group (Vector (a :*: r) a) where
 	invert (Vector x xs) = Vector # invert x # invert xs
@@ -65,15 +65,16 @@
 instance Monotonic a (Vector r a) => Monotonic a (Vector (a :*: r) a) where
 	reduce f r (Vector x xs) = reduce f # f x r # xs
 
+-- TODO: move these instances to somewhere else since they involve structures
 instance Morphable (Into List) (Vector r) where
 	type Morphing (Into List) (Vector r) = List
-	morphing (premorph -> Scalar x) = TU . Just $ Construct x Nothing
-	morphing (premorph -> Vector x xs) = item @Push x $ into @List xs
+	morphing (premorph -> Scalar x) = TT . Just ! Construct x Nothing
+	morphing (premorph -> Vector x xs) = item @Push x ! into @List xs
 
 instance Morphable (Into (Construction Maybe)) (Vector r) where
 	type Morphing (Into (Construction Maybe)) (Vector r) = Construction Maybe
 	morphing (premorph -> Scalar x) = Construct x Nothing
-	morphing (premorph -> Vector x xs) = item @Push x $ into @(Nonempty List) xs
+	morphing (premorph -> Vector x xs) = item @Push x ! into @(Nonempty List) xs
 
 class Vectorize a r where
 	vectorize :: r -> Vector r a
@@ -82,4 +83,4 @@
 	vectorize x = Scalar x
 
 instance Vectorize a r => Vectorize a (a :*: r) where
-	vectorize (x :*: r) = Vector x $ vectorize r
+	vectorize (x :*: r) = Vector x ! vectorize r
diff --git a/Pandora/Paradigm/Primary/Transformer/Backwards.hs b/Pandora/Paradigm/Primary/Transformer/Backwards.hs
--- a/Pandora/Paradigm/Primary/Transformer/Backwards.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Backwards.hs
@@ -1,7 +1,7 @@
 module Pandora.Paradigm.Primary.Transformer.Backwards where
 
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (($), (#))
+import Pandora.Pattern.Category ((#))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>-|-)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
@@ -19,34 +19,34 @@
 import Pandora.Paradigm.Primary.Algebraic (point, extract)
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (!)))
 
 newtype Backwards t a = Backwards (t a)
 
 instance Covariant (->) (->) t => Covariant (->) (->) (Backwards t) where
-	f <-|- Backwards x = Backwards $ f <-|- x
+	f <-|- Backwards x = Backwards ! f <-|- x
 
 -- TODO: check that effects evaluation goes in opposite order
 instance (Semimonoidal (-->) (:*:) (:*:) t, Covariant (->) (->) t) => Semimonoidal (-->) (:*:) (:*:) (Backwards t) where
-	mult = Straight $ \(Backwards x :*: Backwards y) -> Backwards # ((:*:) %) <-|- y <-*- x
+	mult = Straight ! \(Backwards x :*: Backwards y) -> Backwards # ((:*:) %) <-|- y <-*- x
 
 instance (Covariant (->) (->) t, Monoidal (-->) (-->) (:*:) (:*:) t) => Monoidal (-->) (-->) (:*:) (:*:) (Backwards t) where
-	unit _ = Straight $ Backwards . point . ($ One) . run
+	unit _ = Straight ! Backwards . point . (! One) . run
 
 instance (Semimonoidal (<--) (:*:) (:*:) t, Covariant (->) (->) t) => Semimonoidal (<--) (:*:) (:*:) (Backwards t) where
-	mult = Flip $ (Backwards <-> Backwards) . run (mult @(<--)) . run
+	mult = Flip ! (Backwards <-> Backwards) . run (mult @(<--)) . run
 
 instance (Covariant (->) (->) t, Monoidal (<--) (-->) (:*:) (:*:) t) => Monoidal (<--) (-->) (:*:) (:*:) (Backwards t) where
-	unit _ = Flip $ \(Backwards x) -> Straight (\_ -> extract x)
+	unit _ = Flip ! \(Backwards x) -> Straight (\_ -> extract x)
 
 instance Traversable (->) (->) t => Traversable (->) (->) (Backwards t) where
 	f <<- Backwards x = Backwards <-|- f <<- x
 
 instance Distributive (->) (->) t => Distributive (->) (->) (Backwards t) where
-	f -<< x = Backwards $ run . f -<< x
+	f -<< x = Backwards ! run . f -<< x
 
 instance Contravariant (->) (->) t => Contravariant (->) (->) (Backwards t) where
-	f >-|- Backwards x = Backwards $ f >-|- x
+	f >-|- Backwards x = Backwards ! f >-|- x
 
 instance Interpreted (->) (Backwards t) where
 	type Primary (Backwards t) a = t a
@@ -60,4 +60,4 @@
 	lower = run
 
 instance Hoistable (->) Backwards where
-	f /|\ Backwards x = Backwards $ f x
+	f /|\ Backwards x = Backwards ! f x
diff --git a/Pandora/Paradigm/Primary/Transformer/Construction.hs b/Pandora/Paradigm/Primary/Transformer/Construction.hs
--- a/Pandora/Paradigm/Primary/Transformer/Construction.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Construction.hs
@@ -4,11 +4,11 @@
 
 import Pandora.Core.Functor (type (:.), type (:=), type (:=>), type (~>))
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (($), (#))
+import Pandora.Pattern.Category ((#))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)), (<-|-|-), (<-|-))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
-import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (-<<-<<-))
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (<<-<<-))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Pattern.Functor.Bivariant ((<->))
@@ -28,7 +28,7 @@
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (!))
 import Pandora.Paradigm.Structure.Ability.Monotonic (Monotonic (reduce))
-import Pandora.Paradigm.Schemes (type (<:.>))
+import Pandora.Paradigm.Schemes (type (<::>))
 
 infixr 7 .-+
 
@@ -38,23 +38,23 @@
 	f <-|- ~(Construct x xs) = Construct # f x # f <-|-|- xs
 
 instance (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t) => Semimonoidal (-->) (:*:) (:*:) (Construction t) where
-	mult = Straight $ \(Construct x xs :*: Construct y ys) -> Construct # (x :*: y) # (mult @(-->) !) <-|- (mult @(-->) ! (xs :*: ys))
+	mult = Straight ! \(Construct x xs :*: Construct y ys) -> Construct # (x :*: y) # (mult @(-->) !) <-|- (mult @(-->) ! (xs :*: ys))
 
 instance (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t) => Semimonoidal (<--) (:*:) (:*:) (Construction t) where
-	mult = Flip $ \(Construct (x :*: y) xys) -> (Construct x <-> Construct y)
-		$ (mult @(<--) !) $ (mult @(<--) !) <-|- xys
+	mult = Flip ! \(Construct (x :*: y) xys) -> (Construct x <-> Construct y)
+		. (mult @(<--) !) ! (mult @(<--) !) <-|- xys
 
 instance (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t) => Monoidal (<--) (-->) (:*:) (:*:) (Construction t) where
-	unit _ = Flip $ \(Construct x _) -> Straight (\_ -> x)
+	unit _ = Flip ! \(Construct x _) -> Straight (\_ -> x)
 
 --instance (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:+:) t) => Semimonoidal (-->) (:*:) (:+:) (Construction t) where
-	--mult = Straight $ \(Construct x xs :*: Construct y ys) ->
+	--mult = Straight ! \(Construct x xs :*: Construct y ys) ->
 
 instance (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t, Monoidal (-->) (-->) (:*:) (:+:) t) => Monoidal (-->) (-->) (:*:) (:*:) (Construction t) where
-	unit _ = Straight $ \f -> Construct # run f One # empty
+	unit _ = Straight ! \f -> Construct # run f One # empty
 
 instance Traversable (->) (->) t => Traversable (->) (->) (Construction t) where
-	f <<- ~(Construct x xs) = Construct <-|- f x <-*- f -<<-<<- xs
+	f <<- ~(Construct x xs) = Construct <-|- f x <-*- f <<-<<- xs
 
 instance Covariant (->) (->) t => Extendable (->) (Construction t) where
 	f <<= x = Construct # f x # (f <<=) <-|- deconstruct x
@@ -65,7 +65,7 @@
 	lower x = extract <-|- deconstruct x
 
 instance (forall u . Semimonoidal (<--) (:*:) (:*:) u, forall u . Covariant (->) (->) u) => Hoistable (->) Construction where
-	f /|\ x = Construct # extract x $ (/|\) @(->) f <-|- f (deconstruct x)
+	f /|\ x = Construct # extract x ! (/|\) @(->) f <-|- f (deconstruct x)
 
 instance (Setoid a, forall b . Setoid b => Setoid (t b), Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t) => Setoid (Construction t a) where
 	x == y = (extract x == extract y) * (deconstruct x == deconstruct y)
@@ -77,9 +77,9 @@
 	zero = Construct zero zero
 
 instance Monotonic a (t :. Construction t := a) => Monotonic a (Construction t a) where
-	reduce f r ~(Construct x xs) = f x $ reduce f r xs
+	reduce f r ~(Construct x xs) = f x ! reduce f r xs
 
-instance Monotonic a (t :. Construction t := a) => Monotonic a (t <:.> Construction t := a) where
+instance Monotonic a (t :. Construction t := a) => Monotonic a (t <::> Construction t := a) where
 	reduce f r = reduce f r . run
 
 deconstruct :: Construction t a -> t :. Construction t := a
@@ -87,7 +87,7 @@
 
 -- Generate a construction from seed using effectful computation
 (.-+) :: Covariant (->) (->) t => a :=> t -> a :=> Construction t
-f .-+ x = Construct x $ (f .-+) <-|- f x
+f .-+ x = Construct x ! (f .-+) <-|- f x
 
 section :: (Comonad (->) t, Monoidal (<--) (-->) (:*:) (:*:) t) => t ~> Construction t
-section xs = Construct # extract xs $ section <<= xs
+section xs = Construct # extract xs ! section <<= xs
diff --git a/Pandora/Paradigm/Primary/Transformer/Continuation.hs b/Pandora/Paradigm/Primary/Transformer/Continuation.hs
--- a/Pandora/Paradigm/Primary/Transformer/Continuation.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Continuation.hs
@@ -4,14 +4,15 @@
 
 import Pandora.Core.Functor (type (:.), type (:=), type (::|:.))
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (($), (#))
+import Pandora.Pattern.Category ((#))
+import Pandora.Pattern.Kernel (constant)
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Monoidal (Monoidal)
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
-import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.), (%), type (-->))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (!)))
+import Pandora.Paradigm.Primary.Algebraic.Exponential ((%), type (-->))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))
 import Pandora.Paradigm.Primary.Algebraic (point)
 
@@ -23,10 +24,10 @@
 	unite = Continuation
 
 instance Covariant (->) (->) t => Covariant (->) (->) (Continuation r t) where
-	f <-|- Continuation continuation = Continuation $ continuation . (. f)
+	f <-|- Continuation continuation = Continuation ! continuation . (. f)
 
 instance Covariant (->) (->) t => Bindable (->) (Continuation r t) where
-	f =<< x = Continuation $ \g -> run x $ \y -> run # f y # g
+	f =<< x = Continuation ! \g -> run x ! \y -> run # f y # g
 
 --instance Monad t => Monad (Continuation r t) where
 
@@ -35,7 +36,7 @@
 
 -- | Call with current continuation
 cwcc :: ((a -> Continuation r t b) -> Continuation r t a) -> Continuation r t a
-cwcc f = Continuation $ \g -> (run % g) . f $ Continuation . (!.) . g
+cwcc f = Continuation ! \g -> (run % g) . f ! Continuation . constant . g
 
 -- | Delimit the continuation of any 'shift'
 reset :: (forall u . Bindable (->) u, Monad (->) t) => Continuation r t r -> Continuation s t r
@@ -43,7 +44,7 @@
 
 -- | Capture the continuation up to the nearest enclosing 'reset' and pass it
 shift :: Monoidal (-->) (-->) (:*:) (:*:) t => ((a -> t r) -> Continuation r t r) -> Continuation r t a
-shift f = Continuation $ (run % point) . f
+shift f = Continuation ! (run % point) . f
 
 interruptable :: Monoidal (-->) (-->) (:*:) (:*:) t => ((a -> Continuation a t a) -> Continuation a t a) -> t a
 interruptable = (run % point) . cwcc
diff --git a/Pandora/Paradigm/Primary/Transformer/Day.hs b/Pandora/Paradigm/Primary/Transformer/Day.hs
--- a/Pandora/Paradigm/Primary/Transformer/Day.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Day.hs
@@ -2,11 +2,13 @@
 
 module Pandora.Paradigm.Primary.Transformer.Day where
 
+import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Category ((#))
+import Pandora.Pattern.Kernel (constant)
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
-import Pandora.Paradigm.Primary.Algebraic.Exponential ((!..), (-.#..-))
+import Pandora.Paradigm.Primary.Algebraic.Exponential ((-.#..-))
 
 data Day t u a = forall b c . Day (t b) (u c) (b -> c -> a)
 
@@ -14,7 +16,7 @@
 	f <-|- Day tb uc g = Day tb uc # f -.#..- g
 
 instance (Extendable (->) t, Extendable (->) u) => Extendable (->) (Day t u) where
-	f <<= day@(Day tb uc _) = Day tb uc (f day !..)
+	f <<= day@(Day tb uc _) = Day tb uc (constant . constant # f day)
 
 instance Hoistable (->) (Day t) where
 	g /|\ Day tb uc bca = Day tb # g uc # bca
diff --git a/Pandora/Paradigm/Primary/Transformer/Instruction.hs b/Pandora/Paradigm/Primary/Transformer/Instruction.hs
--- a/Pandora/Paradigm/Primary/Transformer/Instruction.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Instruction.hs
@@ -4,12 +4,11 @@
 
 import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)), (<-|-|-))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
-import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (-<<-<<-))
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (<<-<<-))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
@@ -24,31 +23,31 @@
 data Instruction t a = Enter a | Instruct (t :. Instruction t := a)
 
 instance Covariant (->) (->) t => Covariant (->) (->) (Instruction t) where
-	f <-|- Enter x = Enter $ f x
-	f <-|- Instruct xs = Instruct $ f <-|-|- xs
+	f <-|- Enter x = Enter ! f x
+	f <-|- Instruct xs = Instruct ! f <-|-|- xs
 
 instance (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t) => Semimonoidal (-->) (:*:) (:*:) (Instruction t) where
-	mult = Straight $ \case
-		Enter x :*: Enter y -> Enter $ x :*: y
+	mult = Straight ! \case
+		Enter x :*: Enter y -> Enter ! x :*: y
 		Enter x :*: Instruct y -> (x :*:) <-|- Instruct y
 		Instruct x :*: Enter y -> (:*: y) <-|- Instruct x
-		Instruct x :*: Instruct y -> Instruct $ (mult @(-->) !) <-|- (mult @(-->) ! (x :*: y))
+		Instruct x :*: Instruct y -> Instruct ! (mult @(-->) !) <-|- (mult @(-->) ! (x :*: y))
 
 instance (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t) => Monoidal (-->) (-->) (:*:) (:*:) (Instruction t) where
-	unit _ = Straight $ Enter . ($ One) . run
+	unit _ = Straight ! Enter . (! One) . run
 
 instance Covariant (->) (->) t => Bindable (->) (Instruction t) where
 	f =<< Enter x = f x
-	f =<< Instruct xs = Instruct $ (f =<<) <-|- xs
+	f =<< Instruct xs = Instruct ! (f =<<) <-|- xs
 
 instance Monad (->) t => Monad (->) (Instruction t) where
 
 instance Traversable (->) (->) t => Traversable (->) (->) (Instruction t) where
 	f <<- Enter x = Enter <-|- f x
-	f <<- Instruct xs = Instruct <-|- f -<<-<<- xs
+	f <<- Instruct xs = Instruct <-|- f <<-<<- xs
 
 instance Liftable (->) Instruction where
-	lift x = Instruct $ Enter <-|- x
+	lift x = Instruct ! Enter <-|- x
 
 instance (forall t . Bindable (->) t, forall t . Monoidal (-->) (-->) (:*:) (:*:) t) => Lowerable (->) Instruction where
 	lower (Enter x) = point x
@@ -56,4 +55,4 @@
 
 instance (forall v . Covariant (->) (->) v) => Hoistable (->) Instruction where
 	_ /|\ Enter x = Enter x
-	f /|\ Instruct xs = Instruct $ (f /|\) <-|- f xs
+	f /|\ Instruct xs = Instruct ! (f /|\) <-|- f xs
diff --git a/Pandora/Paradigm/Primary/Transformer/Jack.hs b/Pandora/Paradigm/Primary/Transformer/Jack.hs
--- a/Pandora/Paradigm/Primary/Transformer/Jack.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Jack.hs
@@ -3,7 +3,7 @@
 module Pandora.Paradigm.Primary.Transformer.Jack where
 
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (identity, ($))
+import Pandora.Pattern.Category (identity)
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)), (<-|-))
 import Pandora.Pattern.Functor.Monoidal (Monoidal)
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
@@ -18,12 +18,13 @@
 import Pandora.Paradigm.Primary.Algebraic (point)
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (False))
 import Pandora.Paradigm.Primary.Object.Ordering (Ordering (Less, Greater))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted ((!))
 
 data Jack t a = It a | Other (t a)
 
 instance Covariant (->) (->) t => Covariant (->) (->) (Jack t) where
-	f <-|- It x = It $ f x
-	f <-|- Other y = Other $ f <-|- y
+	f <-|- It x = It ! f x
+	f <-|- Other y = Other ! f <-|- y
 
 instance Traversable (->) (->) t => Traversable (->) (->) (Jack t) where
 	f <<- It x = It <-|- f x
@@ -31,18 +32,18 @@
 
 instance (Monoidal (-->) (-->) (:*:) (:*:) t, Bindable (->) t) => Bindable (->) (Jack t) where
 	f =<< It x = f x
-	f =<< Other x = Other $ jack point identity . f =<< x
+	f =<< Other x = Other ! jack point identity . f =<< x
 
 instance Extendable (->) t => Extendable (->) (Jack t) where
-	f <<= It x = It . f $ It x
-	f <<= Other x = Other $ f . Other <<= x
+	f <<= It x = It . f ! It x
+	f <<= Other x = Other ! f . Other <<= x
 
 instance Liftable (->) Jack where
 	lift = Other
 
 instance Hoistable (->) Jack where
 	_ /|\ It x = It x
-	f /|\ Other x = Other $ f x
+	f /|\ Other x = Other ! f x
 
 instance (Setoid a, Setoid (t a)) => Setoid (Jack t a) where
 	It x == It y = x == y
diff --git a/Pandora/Paradigm/Primary/Transformer/Jet.hs b/Pandora/Paradigm/Primary/Transformer/Jet.hs
--- a/Pandora/Paradigm/Primary/Transformer/Jet.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Jet.hs
@@ -3,7 +3,7 @@
 module Pandora.Paradigm.Primary.Transformer.Jet where
 
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)), (<-|-|-), (<-|-))
-import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (-<<-<<-))
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (<<-<<-))
 import Pandora.Paradigm.Primary.Algebraic ((<-*-))
 
 data Jet t a = Jet a (Jet t (t a))
@@ -12,4 +12,4 @@
 	f <-|- Jet x xs = Jet (f x) (f <-|-|- xs)
 
 instance Traversable (->) (->) t => Traversable (->) (->) (Jet t) where
-	f <<- Jet x xs = Jet <-|- f x <-*- f -<<-<<- xs
+	f <<- Jet x xs = Jet <-|- f x <-*- f <<-<<- xs
diff --git a/Pandora/Paradigm/Primary/Transformer/Kan.hs b/Pandora/Paradigm/Primary/Transformer/Kan.hs
--- a/Pandora/Paradigm/Primary/Transformer/Kan.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Kan.hs
@@ -1,10 +1,9 @@
 module Pandora.Paradigm.Primary.Transformer.Kan where
 
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>-|-)))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (!)))
 import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))
 
 data family Kan (v :: * -> k) (t :: * -> *) (u :: * -> *) b a
@@ -12,7 +11,7 @@
 data instance Kan Left t u b a = Lan ((t b -> a) -> u b)
 
 instance Contravariant (->) (->) (Kan Left t u b) where
-	f >-|- Lan x = Lan $ x . (f .)
+	f >-|- Lan x = Lan ! x . (f .)
 
 instance Interpreted (->) (Kan Left t u b) where
 	type Primary (Kan Left t u b) a = (t b -> a) -> u b
@@ -22,7 +21,7 @@
 data instance Kan Right t u b a = Ran ((a -> t b) -> u b)
 
 instance Covariant (->) (->) (Kan Right t u b) where
-	f <-|- Ran x = Ran $ x . (. f)
+	f <-|- Ran x = Ran ! x . (. f)
 
 instance Interpreted (->) (Kan Right t u b) where
 	type Primary (Kan Right t u b) a = (a -> t b) -> u b
diff --git a/Pandora/Paradigm/Primary/Transformer/Outline.hs b/Pandora/Paradigm/Primary/Transformer/Outline.hs
--- a/Pandora/Paradigm/Primary/Transformer/Outline.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Outline.hs
@@ -3,7 +3,7 @@
 module Pandora.Paradigm.Primary.Transformer.Outline where
 
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (identity, ($), (#))
+import Pandora.Pattern.Category (identity, (#))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
@@ -14,7 +14,7 @@
 	Outlined :: t a -> Outline t (a -> b) -> Outline t b
 
 instance Covariant (->) (->) (Outline t) where
-	f <-|- Line a = Line $ f a
+	f <-|- Line a = Line (f a)
 	f <-|- Outlined x y = Outlined x # (.) f <-|- y
 
 instance Liftable (->) Outline where
diff --git a/Pandora/Paradigm/Primary/Transformer/Reverse.hs b/Pandora/Paradigm/Primary/Transformer/Reverse.hs
--- a/Pandora/Paradigm/Primary/Transformer/Reverse.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Reverse.hs
@@ -3,7 +3,7 @@
 module Pandora.Paradigm.Primary.Transformer.Reverse where
 
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (($), (#))
+import Pandora.Pattern.Category ((#))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>-|-)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
@@ -29,22 +29,22 @@
 	f <-|- Reverse x = Reverse # f <-|- x
 
 instance (Semimonoidal (-->) (:*:) (:*:) t, Covariant (->) (->) t) => Semimonoidal (-->) (:*:) (:*:) (Reverse t) where
-	mult = Straight $ \(Reverse x :*: Reverse y) -> Reverse $ mult @(-->) ! (x :*: y)
+	mult = Straight ! \(Reverse x :*: Reverse y) -> Reverse (mult @(-->) ! x :*: y)
 
 instance (Covariant (->) (->) t, Monoidal (-->) (-->) (:*:) (:*:) t) => Monoidal (-->) (-->) (:*:) (:*:) (Reverse t) where
-	unit _ = Straight $ Reverse . point . ($ One) . run
+	unit _ = Straight ! Reverse . point . (! One) . run
 
 instance (Semimonoidal (<--) (:*:) (:*:) t, Covariant (->) (->) t) => Semimonoidal (<--) (:*:) (:*:) (Reverse t) where
-	mult = Flip $ (Reverse <-> Reverse) . run (mult @(<--)) . run
+	mult = Flip ! (Reverse <-> Reverse) . run (mult @(<--)) . run
 
 instance (Covariant (->) (->) t, Monoidal (<--) (-->) (:*:) (:*:) t) => Monoidal (<--) (-->) (:*:) (:*:) (Reverse t) where
-	unit _ = Flip $ \(Reverse x) -> Straight (\_ -> extract x)
+	unit _ = Flip ! \(Reverse x) -> Straight (\_ -> extract x)
 
 instance Traversable (->) (->) t => Traversable (->) (->) (Reverse t) where
 	f <<- Reverse x = Reverse <-|- run (Backwards . f <<- x)
 
 instance Distributive (->) (->) t => Distributive (->) (->) (Reverse t) where
-	f -<< x = Reverse $ run . f -<< x
+	f -<< x = Reverse ! run . f -<< x
 
 instance Contravariant (->) (->) t => Contravariant (->) (->) (Reverse t) where
 	f >-|- Reverse x = Reverse # f >-|- x
diff --git a/Pandora/Paradigm/Primary/Transformer/Tap.hs b/Pandora/Paradigm/Primary/Transformer/Tap.hs
--- a/Pandora/Paradigm/Primary/Transformer/Tap.hs
+++ b/Pandora/Paradigm/Primary/Transformer/Tap.hs
@@ -4,7 +4,7 @@
 
 import Pandora.Core.Functor (type (:=))
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (($), (#))
+import Pandora.Pattern.Category ((#))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
@@ -35,20 +35,19 @@
 	f <-|- Tap x xs = Tap # f x # f <-|- xs
 
 instance Semimonoidal (-->) (:*:) (:*:) t => Semimonoidal (-->) (:*:) (:*:) (Tap t) where
-	mult = Straight $ \(Tap x xs :*: Tap y ys) -> Tap # (x :*: y) # (mult @(-->) ! (xs :*: ys))
+	mult = Straight ! \(Tap x xs :*: Tap y ys) -> Tap # (x :*: y) # (mult @(-->) ! (xs :*: ys))
 
 instance Semimonoidal (<--) (:*:) (:*:) t => Semimonoidal (<--) (:*:) (:*:) (Tap t) where
-	mult = Flip $ \(Tap (x :*: y) xys) ->
-		(Tap x <-> Tap y) $ mult @(<--) ! xys
+	mult = Flip ! \(Tap (x :*: y) xys) -> (Tap x <-> Tap y) (mult @(<--) ! xys)
 
 instance Semimonoidal (<--) (:*:) (:*:) t => Monoidal (<--) (-->) (:*:) (:*:) (Tap t) where
-	unit _ = Flip $ \(Tap x _) -> Straight (\_ -> x)
+	unit _ = Flip ! \(Tap x _) -> Straight (\_ -> x)
 
 instance Traversable (->) (->) t => Traversable (->) (->) (Tap t) where
 	f <<- Tap x xs = Tap <-|- f x <-*- f <<- xs
 
 instance (Semimonoidal (<--) (:*:) (:*:) t, Extendable (->) t, Covariant (->) (->) t) => Extendable (->) (Tap t) where
-	f <<= x = Tap # f x $ f . Tap (extract x) <<= lower x
+	f <<= x = Tap # f x ! f . Tap (extract x) <<= lower x
 
 instance Lowerable (->) Tap where
 	lower (Tap _ xs) = xs
@@ -57,27 +56,27 @@
 	f /|\ Tap x xs = Tap x # f xs
 
 instance {-# OVERLAPS #-} Semimonoidal (-->) (:*:) (:*:) t => Semimonoidal (-->) (:*:) (:*:) (Tap (t <:.:> t := (:*:))) where
-	mult = Straight $ \(Tap x (T_U (xls :*: xrs)) :*: Tap y (T_U (yls :*: yrs))) -> Tap (x :*: y)
-		$ T_U $ (mult @(-->) ! (xls :*: yls)) :*: (mult @(-->) ! (xrs :*: yrs))
+	mult = Straight ! \(Tap x (T_U (xls :*: xrs)) :*: Tap y (T_U (yls :*: yrs))) ->
+		Tap (x :*: y) . T_U ! (mult @(-->) ! xls :*: yls) :*: (mult @(-->) ! xrs :*: yrs)
 
 instance {-# OVERLAPS #-} Traversable (->) (->) t => Traversable (->) (->) (Tap (t <:.:> t := (:*:))) where
-	f <<- Tap x (T_U (future :*: past)) = (\past' x' future' -> Tap x' $ twosome # future' # run past')
+	f <<- Tap x (T_U (future :*: past)) = (\past' x' future' -> Tap x' ! twosome # future' # run past')
 		<-|- f <<- Reverse past <-*- f x <-*- f <<- future
 
 instance (Covariant (->) (->) t) => Substructure Root (Tap (t <:.:> t := (:*:))) where
 	type Available Root (Tap (t <:.:> t := (:*:))) = Identity
 	type Substance Root (Tap (t <:.:> t := (:*:))) = Identity
-	substructure = P_Q_T $ \zipper -> case lower zipper of
-		Tap x xs -> Store $ Identity (Identity x) :*: lift . (Tap % xs) . extract . extract
+	substructure = P_Q_T ! \zipper -> case lower zipper of
+		Tap x xs -> Store ! Identity (Identity x) :*: lift . (Tap % xs) . extract . extract
 
 instance (Covariant (->) (->) t) => Substructure Left (Tap (t <:.:> t := (:*:))) where
 	type Available Left (Tap (t <:.:> t := (:*:))) = Identity
 	type Substance Left (Tap (t <:.:> t := (:*:))) = t
-	substructure = P_Q_T $ \zipper -> case lower zipper of
-		Tap x (T_U (future :*: past)) -> Store $ Identity future :*: lift . Tap x . T_U . (:*: past) . extract
+	substructure = P_Q_T ! \zipper -> case lower zipper of
+		Tap x (T_U (future :*: past)) -> Store ! Identity future :*: lift . Tap x . T_U . (:*: past) . extract
 
 instance (Covariant (->) (->) t) => Substructure Right (Tap (t <:.:> t := (:*:))) where
 	type Available Right (Tap (t <:.:> t := (:*:))) = Identity
 	type Substance Right (Tap (t <:.:> t := (:*:))) = t
-	substructure = P_Q_T $ \zipper -> case lower zipper of
-		Tap x (T_U (future :*: past)) -> Store $ Identity past :*: lift . Tap x . T_U . (future :*:) . extract
+	substructure = P_Q_T ! \zipper -> case lower zipper of
+		Tap x (T_U (future :*: past)) -> Store ! Identity past :*: lift . Tap x . T_U . (future :*:) . extract
diff --git a/Pandora/Paradigm/Schemes.hs b/Pandora/Paradigm/Schemes.hs
--- a/Pandora/Paradigm/Schemes.hs
+++ b/Pandora/Paradigm/Schemes.hs
@@ -13,35 +13,35 @@
 import Pandora.Paradigm.Schemes.TUVW as Exports
 import Pandora.Paradigm.Schemes.TUT as Exports
 import Pandora.Paradigm.Schemes.TU as Exports
+import Pandora.Paradigm.Schemes.TT as Exports
 
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Functor.Covariant (Covariant)
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (!))
 
 instance (Covariant (->) (->) (v <:.> t), Covariant (->) (->) (u <:.> w), Adjoint (->) (->) t u, Adjoint (->) (->) v w)
 
 	=> Adjoint (->) (->) (v <:.> t) (u <:.> w) where
 		g |- TU y = (run . g |-) |- y
-		f -| x = TU $ (f . TU -|) -| x
+		f -| x = TU ! (f . TU -|) -| x
 
 instance (Covariant (->) (->) (v <:.> t), Covariant (->) (->) (w <.:> u), Adjoint (->) (->) t u, Adjoint (->) (->) v w)
 	=> Adjoint (->) (->) (v <:.> t) (w <.:> u) where
 		g |- TU t = (run . g |-) |- t
-		f -| x = UT $ (f . TU -|) -| x
+		f -| x = UT ! (f . TU -|) -| x
 
 instance (Covariant (->) (->) (t <.:> v), Covariant (->) (->) (w <.:> u), Adjoint (->) (->) t u, Adjoint (->) (->) v w)
 	=> Adjoint (->) (->) (t <.:> v) (w <.:> u) where
 		g |- UT t =  (run . g |-) |- t
-		f -| x = UT $ (f . UT -|) -| x
+		f -| x = UT ! (f . UT -|) -| x
 
 instance (Covariant (->) (->) (t <.:> v), Covariant (->) (->) (w <:.> u), Adjoint (->) (->) v u, Adjoint (->) (->) t w)
 	=> Adjoint (->) (->) (t <.:> v) (w <:.> u) where
 		g |- UT x = (run . g |-) |- x
-		f -| x = TU $ (f . UT -|) -| x
+		f -| x = TU ! (f . UT -|) -| x
 
 instance (Covariant (->) (->) ((t <:<.>:> u) t'),  Covariant (->) (->) ((v <:<.>:> w) v'), Adjoint (->) (->) t w, Adjoint (->) (->) t' v', Adjoint (->) (->) t v, Adjoint (->) (->) u v, Adjoint (->) (->) v' t')
 	=> Adjoint (->) (->) ((t <:<.>:> u) t') ((v <:<.>:> w) v') where
 		g |- TUT x = ((run . g |-) |-) |- x
-		f -| x = TUT $  ((f . TUT -|) -|) -| x
+		f -| x = TUT !  ((f . TUT -|) -|) -| x
diff --git a/Pandora/Paradigm/Schemes/TT.hs b/Pandora/Paradigm/Schemes/TT.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Schemes/TT.hs
@@ -0,0 +1,79 @@
+{-# LANGUAGE UndecidableInstances #-}
+module Pandora.Paradigm.Schemes.TT where
+
+import Pandora.Core.Functor (type (:.), type (:=), type (~>))
+import Pandora.Pattern.Betwixt (Betwixt)
+import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
+import Pandora.Pattern.Category (identity)
+import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)), (<-|-|-))
+import Pandora.Pattern.Functor.Contravariant (Contravariant)
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
+import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (<<-<<-))
+import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
+import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
+import Pandora.Pattern.Functor.Bivariant ((<->))
+import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
+import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
+import Pandora.Pattern.Transformer.Hoistable (Hoistable ((/|\)))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (!), (||=)))
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (<--), type (-->))
+import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)))
+import Pandora.Paradigm.Primary.Algebraic.Sum ((:+:), bitraverse_sum)
+import Pandora.Paradigm.Primary.Algebraic.One (One (One))
+import Pandora.Paradigm.Primary.Algebraic (empty, point, extract)
+import Pandora.Pattern.Morphism.Flip (Flip (Flip))
+import Pandora.Pattern.Morphism.Straight (Straight (Straight))
+
+newtype TT ct ct' t t' a = TT (t :. t' := a)
+
+infixr 3 <::>, >::>, <::<, >::<
+
+type (<::>) = TT Covariant Covariant
+type (>::>) = TT Contravariant Covariant
+type (<::<) = TT Covariant Contravariant
+type (>::<) = TT Contravariant Contravariant
+
+instance Interpreted (->) (TT ct ct' t t') where
+	type Primary (TT ct ct' t t') a = t :. t' := a
+	run ~(TT x) = x
+	unite = TT
+
+instance (Semigroupoid m, Covariant m m t, Covariant (Betwixt m m) m t, Covariant m (Betwixt m m) t', Interpreted m (t <::> t')) => Covariant m m (t <::> t') where
+	(<-|-) f = (||=) ((<-|-|-) f)
+
+instance (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t, Semimonoidal (-->) (:*:) (:*:) t') => Semimonoidal (-->) (:*:) (:*:) (t <::> t') where
+	mult = Straight ! TT . (<-|-) (mult @(-->) !) . (mult @(-->) !) . (run @(->) <-> run @(->))
+
+instance (Covariant (->) (->) t, Covariant (->) (->) t', Semimonoidal (-->) (:*:) (:*:) t', Monoidal (-->) (-->) (:*:) (:*:) t, Monoidal (-->) (-->) (:*:) (:*:) t') => Monoidal (-->) (-->) (:*:) (:*:) (t <::> t') where
+	unit _ = Straight ! TT . point . point . (! One) . run
+
+instance (Covariant (->) (->) t, Covariant (->) (->) t', Semimonoidal (-->) (:*:) (:+:) t) => Semimonoidal (-->) (:*:) (:+:) (t <::> t') where
+	mult = Straight ! \(TT x :*: TT y) -> TT ! bitraverse_sum identity identity <-|- (mult @(-->) @(:*:) @(:+:) ! (x :*: y))
+
+instance (Covariant (->) (->) t, Covariant (->) (->) t', Semimonoidal (-->) (:*:) (:+:) t, Monoidal (-->) (-->) (:*:) (:+:) t) => Monoidal (-->) (-->) (:*:) (:+:) (t <::> t') where
+	unit _ = Straight ! \_ -> TT empty
+
+instance (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t, Semimonoidal (<--) (:*:) (:*:) t') => Semimonoidal (<--) (:*:) (:*:) (t <::> t') where
+	mult = Flip ! \(TT xys) -> (TT <-> TT) . (mult @(<--) !) ! (mult @(<--) !) <-|- xys
+
+instance (Covariant (->) (->) t, Monoidal (<--) (-->) (:*:) (:*:) t, Monoidal (<--) (-->) (:*:) (:*:) t') => Monoidal (<--) (-->) (:*:) (:*:) (t <::> t') where
+	unit _ = Flip ! \(TT x) -> Straight (\_ -> extract ! extract x)
+
+instance (Traversable (->) (->) t, Traversable (->) (->) t') => Traversable (->) (->) (t <::> t') where
+	f <<- x = TT <-|- f <<-<<- run x
+
+instance (Bindable (->) t, Distributive (->) (->) t, Covariant (->) (->) t', Bindable (->) t') => Bindable (->) (t <::> t') where
+	f =<< TT x = TT ! (\i -> (identity =<<) <-|- run . f -<< i) =<< x
+
+instance Monoidal (-->) (-->) (:*:) (:*:) t => Liftable (->) (TT Covariant Covariant t) where
+	lift :: Covariant (->) (->) t' => t' ~> t <::> t'
+	lift = TT . point
+
+instance Monoidal (<--) (-->) (:*:) (:*:) t => Lowerable (->) (TT Covariant Covariant t) where
+	lower :: t <::> t' ~> t'
+	lower (TT x) = extract x
+
+instance Covariant (->) (->) t => Hoistable (->) (TT Covariant Covariant t) where
+	(/|\) :: t' ~> v -> (t <::> t' ~> t <::> v)
+	f /|\ TT x = TT ! f <-|- x
diff --git a/Pandora/Paradigm/Schemes/TU.hs b/Pandora/Paradigm/Schemes/TU.hs
--- a/Pandora/Paradigm/Schemes/TU.hs
+++ b/Pandora/Paradigm/Schemes/TU.hs
@@ -5,12 +5,12 @@
 import Pandora.Core.Functor (type (:.), type (:=), type (~>))
 import Pandora.Pattern.Betwixt (Betwixt)
 import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
-import Pandora.Pattern.Category (($), identity)
+import Pandora.Pattern.Category (identity)
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)), (<-|-|-))
 import Pandora.Pattern.Functor.Contravariant (Contravariant)
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
-import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (-<<-<<-))
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (<<-<<-))
 import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Bivariant ((<->))
@@ -40,32 +40,32 @@
 	run ~(TU x) = x
 	unite = TU
 
-instance (Semigroupoid m, Covariant (Betwixt m m) m t, Covariant m (Betwixt m m) u, Interpreted m (t <:.> u)) => Covariant m m (t <:.> u) where
+instance (Semigroupoid m, Covariant m m t, Covariant (Betwixt m m) m t, Covariant m (Betwixt m m) u, Interpreted m (t <:.> u)) => Covariant m m (t <:.> u) where
 	(<-|-) f = (||=) ((<-|-|-) f)
 
 instance (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t, Semimonoidal (-->) (:*:) (:*:) u) => Semimonoidal (-->) (:*:) (:*:) (t <:.> u) where
-	mult = Straight $ TU . (<-|-) (mult @(-->) !) . (mult @(-->) !) . (run @(->) <-> run @(->))
+	mult = Straight ! TU . (<-|-) (mult @(-->) !) . (mult @(-->) !) . (run @(->) <-> run @(->))
 
 instance (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (-->) (:*:) (:*:) u, Monoidal (-->) (-->) (:*:) (:*:) t, Monoidal (-->) (-->) (:*:) (:*:) u) => Monoidal (-->) (-->) (:*:) (:*:) (t <:.> u) where
-	unit _ = Straight $ TU . point . point . ($ One) . run
+	unit _ = Straight ! TU . point . point . (! One) . run
 
 instance (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (-->) (:*:) (:*:) t, Semimonoidal (-->) (:*:) (:+:) u) => Semimonoidal (-->) (:*:) (:+:) (t <:.> u) where
-	mult = Straight $ \(TU x :*: TU y) -> TU $ (mult @(-->) @(:*:) @(:+:)) <-|- (mult @(-->) @(:*:) @(:*:) ! (x :*: y))
+	mult = Straight ! \(TU x :*: TU y) -> TU ! (mult @(-->) @(:*:) @(:+:)) <-|- (mult @(-->) @(:*:) @(:*:) ! (x :*: y))
 
 instance (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (-->) (:*:) (:*:) t, Semimonoidal (-->) (:*:) (:+:) u, Monoidal (-->) (-->) (:*:) (:+:) t) => Monoidal (-->) (-->) (:*:) (:+:) (t <:.> u) where
-	unit _ = Straight $ \_ -> TU empty
+	unit _ = Straight ! \_ -> TU empty
 
 instance (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t, Semimonoidal (<--) (:*:) (:*:) u) => Semimonoidal (<--) (:*:) (:*:) (t <:.> u) where
-	mult = Flip $ \(TU xys) -> (TU <-> TU) . (mult @(<--) !) $ (mult @(<--) !) <-|- xys
+	mult = Flip ! \(TU xys) -> (TU <-> TU) . (mult @(<--) !) ! (mult @(<--) !) <-|- xys
 
 instance (Covariant (->) (->) t, Monoidal (<--) (-->) (:*:) (:*:) t, Monoidal (<--) (-->) (:*:) (:*:) u) => Monoidal (<--) (-->) (:*:) (:*:) (t <:.> u) where
-	unit _ = Flip $ \(TU x) -> Straight (\_ -> extract $ extract x)
+	unit _ = Flip ! \(TU x) -> Straight (\_ -> extract ! extract x)
 
 instance (Traversable (->) (->) t, Traversable (->) (->) u) => Traversable (->) (->) (t <:.> u) where
-	f <<- x = TU <-|- f -<<-<<- run x
+	f <<- x = TU <-|- f <<-<<- run x
 
 instance (Bindable (->) t, Distributive (->) (->) t, Covariant (->) (->) u, Bindable (->) u) => Bindable (->) (t <:.> u) where
-	f =<< TU x = TU $ (\i -> (identity =<<) <-|- run . f -<< i) =<< x
+	f =<< TU x = TU ! (\i -> (identity =<<) <-|- run . f -<< i) =<< x
 
 instance Monoidal (-->) (-->) (:*:) (:*:) t => Liftable (->) (TU Covariant Covariant t) where
 	lift :: Covariant (->) (->) u => u ~> t <:.> u
@@ -77,4 +77,4 @@
 
 instance Covariant (->) (->) t => Hoistable (->) (TU Covariant Covariant t) where
 	(/|\) :: u ~> v -> (t <:.> u ~> t <:.> v)
-	f /|\ TU x = TU $ f <-|- x
+	f /|\ TU x = TU ! f <-|- x
diff --git a/Pandora/Paradigm/Schemes/TUT.hs b/Pandora/Paradigm/Schemes/TUT.hs
--- a/Pandora/Paradigm/Schemes/TUT.hs
+++ b/Pandora/Paradigm/Schemes/TUT.hs
@@ -1,17 +1,15 @@
 {-# LANGUAGE UndecidableInstances #-}
-
 module Pandora.Paradigm.Schemes.TUT where
 
 import Pandora.Core.Functor (type (:.), type (:=), type (~>))
 import Pandora.Pattern.Betwixt (Betwixt)
 import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
-import Pandora.Pattern.Category (identity, ($))
+import Pandora.Pattern.Category (identity)
 import Pandora.Pattern.Functor.Covariant (Covariant, Covariant ((<-|-)), (<-|-|-), (<-|-|-|-))
 import Pandora.Pattern.Functor.Contravariant (Contravariant)
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
-import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Distributive (Distributive ((-<<)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Functor.Bivariant ((<->))
@@ -45,38 +43,38 @@
 	run ~(TUT x) = x
 	unite = TUT
 
-instance (Semigroupoid m, Covariant (Betwixt (Betwixt m m) m) m t, Covariant (Betwixt m (Betwixt m m)) (Betwixt (Betwixt m m) m) u, Covariant m (Betwixt m (Betwixt m m)) t', Interpreted m (t <:<.>:> t' := u)) => Covariant m m (t <:<.>:> t' := u) where
+instance (Semigroupoid m, Covariant m m t, Covariant (Betwixt (Betwixt m m) m) m t, Covariant (Betwixt m (Betwixt m m)) (Betwixt (Betwixt m m) m) u, Covariant m (Betwixt m (Betwixt m m)) t', Interpreted m (t <:<.>:> t' := u)) => Covariant m m (t <:<.>:> t' := u) where
 	(<-|-) f = (||=) ((<-|-|-|-) f)
 
 instance (Adjoint (->) (->) t' t, Bindable (->) u) => Semimonoidal (-->) (:*:) (:*:) (t <:<.>:> t' := u) where
-	mult = Straight $ \(TUT x :*: TUT y) -> TUT ((((\r -> (<-|-|-|-) (r :*:) y) |-) =<<) <-|- x)
+	mult = Straight ! \(TUT x :*: TUT y) -> TUT ((((\r -> (<-|-|-|-) (r :*:) y) |-) =<<) <-|- x)
 
 instance (Covariant (->) (->) t, Semimonoidal (<--) (:*:) (:*:) t, Covariant (->) (->) u, Semimonoidal (<--) (:*:) (:*:) u, Covariant (->) (->) t', Semimonoidal (<--) (:*:) (:*:) t') => Semimonoidal (<--) (:*:) (:*:) (t <:<.>:> t' := u) where
-	mult = Flip $ (TUT <-> TUT) . (mult @(<--) !) . (<-|-) (mult @(<--) !) . (<-|-|-) @_ @(->) (mult @(<--) !) . run
+	mult = Flip ! (TUT <-> TUT) . (mult @(<--) !) . (<-|-) (mult @(<--) !) . (<-|-|-) @_ @(->) (mult @(<--) !) . run
 
 instance (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (<--) (:*:) (:*:) t, Semimonoidal (<--) (:*:) (:*:) t', Monoidal (<--) (-->) (:*:) (:*:) u, Adjoint (->) (->) t t') => Monoidal (<--) (-->) (:*:) (:*:) (t <:<.>:> t' := u) where
-	unit _ = Flip $ \(TUT xys) -> Straight (\_ -> (extract |-) xys)
+	unit _ = Flip ! \(TUT xys) -> Straight (\_ -> (extract |-) xys)
 
 -- TODO: generalize on (->) and (:*:)
 instance {-# OVERLAPS #-} (Covariant (->) (->) u, Semimonoidal (-->) (:*:) (:+:) u) => Semimonoidal (-->) (:*:) (:+:) ((->) s <:<.>:> (:*:) s := u) where
- mult = Straight $ \(TUT x :*: TUT y) -> TUT $ product_over_sum <-|-|- mult @(-->) @(:*:) @(:+:) <-|- (mult @(-->) @(:*:) @(:*:) ! (x :*: y))
+ mult = Straight ! \(TUT x :*: TUT y) -> TUT ! product_over_sum <-|-|- mult @(-->) @(:*:) @(:+:) <-|- (mult @(-->) @(:*:) @(:*:) ! (x :*: y))
 
 product_over_sum :: (s :*: a) :+: (s :*: b) -> s :*: (a :+: b)
 product_over_sum (Option (s :*: x)) = s :*: Option x
 product_over_sum (Adoption (s :*: y)) = s :*: Adoption y
 
 instance (Covariant (->) (->) t, Covariant (->) (->) t', Adjoint (->) (->) t' t, Bindable (->) u) => Bindable (->) (t <:<.>:> t' := u) where
-	f =<< x = TUT $ ((run . f |-) =<<) <-|- run x
+	f =<< x = TUT ! ((run . f |-) =<<) <-|- run x
 
 instance (Bindable (->) u, Monoidal (-->) (-->) (:*:) (:*:) u, Adjoint (->) (->) t' t) => Monoidal (-->) (-->) (:*:) (:*:) (t <:<.>:> t' := u) where
-	unit _ = Straight $ unite . (point -|) . ($ One) . run
+	unit _ = Straight ! unite . (point -|) . (! One) . run
 
 instance (Adjoint (->) (->) t' t, Extendable (->) u) => Extendable (->) (t' <:<.>:> t := u) where
-	f <<= x = TUT $ ((f . unite -|) <<=) <-|- run x
+	f <<= x = TUT ! ((f . unite -|) <<=) <-|- run x
 
 instance (Adjoint (->) (->) t' t, Distributive (->) (->) t) => Liftable (->) (t <:<.>:> t') where
 	lift :: Covariant (->) (->) u => u ~> t <:<.>:> t' := u
-	lift x = TUT $ (identity @(->) -|) -<< x
+	lift x = TUT ! (identity @(->) -|) -<< x
 
 instance (Adjoint (->) (->) t t', Distributive (->) (->) t') => Lowerable (->) (t <:<.>:> t') where
 	lower :: Covariant (->) (->) u => (t <:<.>:> t' := u) ~> u
diff --git a/Pandora/Paradigm/Schemes/UT.hs b/Pandora/Paradigm/Schemes/UT.hs
--- a/Pandora/Paradigm/Schemes/UT.hs
+++ b/Pandora/Paradigm/Schemes/UT.hs
@@ -5,7 +5,7 @@
 import Pandora.Core.Functor (type (:.), type (:=), type (~>))
 import Pandora.Pattern.Betwixt (Betwixt)
 import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
-import Pandora.Pattern.Category (($), identity)
+import Pandora.Pattern.Category (identity)
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)), (<-|-|-))
 import Pandora.Pattern.Functor.Contravariant (Contravariant)
@@ -38,30 +38,30 @@
 	run ~(UT x) = x
 	unite = UT
 
-instance (Semigroupoid m, Covariant m (Betwixt m m) t, Covariant (Betwixt m m) m u, Interpreted m (t <.:> u)) => Covariant m m (t <.:> u) where
+instance (Semigroupoid m, Covariant m m u, Covariant m m t, Covariant m (Betwixt m m) t, Covariant (Betwixt m m) m u, Interpreted m (t <.:> u)) => Covariant m m (t <.:> u) where
 	(<-|-) f = (||=) ((<-|-|-) f)
 
 instance (Covariant (->) (->) u, Semimonoidal (-->) (:*:) (:*:) t, Semimonoidal (-->) (:*:) (:*:) u) => Semimonoidal (-->) (:*:) (:*:) (t <.:> u) where
-	mult = Straight $ UT . (<-|-) (mult @(-->) !) . (mult @(-->) !) . (run @(->) <-> run @(->))
+	mult = Straight ! UT . (<-|-) (mult @(-->) !) . (mult @(-->) !) . (run @(->) <-> run @(->))
 
 instance (Covariant (->) (->) u, Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) u, Semimonoidal (-->) (:*:) (:+:) t) => Semimonoidal (-->) (:*:) (:+:) (t <.:> u) where
-	mult = Straight $ \(UT x :*: UT y) -> UT $ (mult @(-->) @(:*:) @(:+:)) <-|- (mult @(-->) @(:*:) @(:*:) ! (x :*: y))
+	mult = Straight ! \(UT x :*: UT y) -> UT ! (mult @(-->) @(:*:) @(:+:)) <-|- (mult @(-->) @(:*:) @(:*:) ! (x :*: y))
 
 instance (Covariant (->) (->) t, Covariant (->) (->) u, Semimonoidal (-->) (:*:) (:*:) u, Monoidal (-->) (-->) (:*:) (:*:) t, Monoidal (-->) (-->) (:*:) (:*:) u) => Monoidal (-->) (-->) (:*:) (:*:) (t <.:> u) where
-	unit _ = Straight $ UT . point . point . ($ One) . run
+	unit _ = Straight ! UT . point . point . (! One) . run
 
 instance (Traversable (->) (->) t, Bindable (->) t, Semimonoidal (-->) (:*:) (:*:) u, Monoidal (-->) (-->) (:*:) (:*:) u, Bindable (->) u) => Bindable (->) (t <.:> u) where
-	f =<< UT x = UT $ ((identity =<<) <-|-) . (run . f <<-) =<< x
+	f =<< UT x = UT ! ((identity =<<) <-|-) . (run . f <<-) =<< x
 
 instance (Covariant (->) (->) u, Semimonoidal (<--) (:*:) (:*:) t, Semimonoidal (<--) (:*:) (:*:) u) => Semimonoidal (<--) (:*:) (:*:) (t <.:> u) where
-	mult = Flip $ \(UT xys) -> (UT <-> UT) . (mult @(<--) !) $ (mult @(<--) !) <-|- xys
+	mult = Flip ! \(UT xys) -> (UT <-> UT) . (mult @(<--) !) ! (mult @(<--) !) <-|- xys
 
 instance (Covariant (->) (->) u, Monoidal (<--) (-->) (:*:) (:*:) t, Monoidal (<--) (-->) (:*:) (:*:) u) => Monoidal (<--) (-->) (:*:) (:*:) (t <.:> u) where
-	unit _ = Flip $ \(UT x) -> Straight (\_ -> extract $ extract x)
+	unit _ = Flip ! \(UT x) -> Straight (\_ -> extract ! extract x)
 
 instance Monoidal (-->) (-->) (:*:) (:*:) t => Liftable (->) (UT Covariant Covariant t) where
 	lift :: Covariant (->) (->) u => u ~> t <.:> u
-	lift x = UT $ point <-|- x
+	lift x = UT ! point <-|- x
 
 instance Monoidal (<--) (-->) (:*:) (:*:) t => Lowerable (->) (UT Covariant Covariant t) where
 	lower :: Covariant (->) (->) u => t <.:> u ~> u
diff --git a/Pandora/Paradigm/Structure.hs b/Pandora/Paradigm/Structure.hs
--- a/Pandora/Paradigm/Structure.hs
+++ b/Pandora/Paradigm/Structure.hs
@@ -10,8 +10,10 @@
 
 import Pandora.Core.Functor (type (:=))
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (($), (#), identity)
+import Pandora.Pattern.Category ((#), identity)
+import Pandora.Pattern.Kernel (constant)
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
+import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Transformer.Liftable (lift)
 import Pandora.Pattern.Transformer.Lowerable (lower)
 import Pandora.Pattern.Object.Semigroup ((+))
@@ -19,7 +21,8 @@
 import Pandora.Paradigm.Inventory.Optics ()
 import Pandora.Paradigm.Inventory.Store (Store (Store))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), attached, twosome)
-import Pandora.Paradigm.Primary.Algebraic.Exponential ((%))
+import Pandora.Paradigm.Primary.Algebraic.Sum ((:+:) (Option, Adoption))
+import Pandora.Paradigm.Primary.Algebraic.Exponential (type (-->), (%))
 import Pandora.Paradigm.Primary.Algebraic (extract)
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False))
 import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))
@@ -37,21 +40,21 @@
 	reduce f r x = reduce f # f (attached x) r # extract x
 
 instance Nullable Maybe where
-	null = Predicate $ \case { Just _ -> True ; _ -> False }
+	null = Predicate ! \case { Just _ -> True ; _ -> False }
 
 instance (Covariant (->) (->) t) => Substructure Tail (Tap t) where
 	type Available Tail (Tap t) = Identity
 	type Substance Tail (Tap t) = t
-	substructure = P_Q_T $ \tap -> case extract # run tap of
-		Tap x xs -> Store $ Identity xs :*: lift . Tap x . extract
+	substructure = P_Q_T ! \tap -> case extract # run tap of
+		Tap x xs -> Store ! Identity xs :*: lift . Tap x . extract
 
 instance Morphable (Into (Preorder (Construction Maybe))) (Construction Wye) where
 	type Morphing (Into (Preorder (Construction Maybe))) (Construction Wye) = Construction Maybe
 	morphing nonempty_binary = case premorph nonempty_binary of
 		Construct x End -> Construct x Nothing
-		Construct x (Left lst) -> Construct x . Just $ into @(Preorder (Nonempty List)) lst
-		Construct x (Right rst) -> Construct x . Just $ into @(Preorder (Nonempty List)) rst
-		Construct x (Both lst rst) -> Construct x . Just $ into @(Preorder (Nonempty List)) lst + into @(Preorder (Nonempty List)) rst
+		Construct x (Left lst) -> Construct x . Just ! into @(Preorder (Nonempty List)) lst
+		Construct x (Right rst) -> Construct x . Just ! into @(Preorder (Nonempty List)) rst
+		Construct x (Both lst rst) -> Construct x . Just ! into @(Preorder (Nonempty List)) lst + into @(Preorder (Nonempty List)) rst
 
 instance Morphable (Into (Inorder (Construction Maybe))) (Construction Wye) where
 	type Morphing (Into (Inorder (Construction Maybe))) (Construction Wye) = Construction Maybe
@@ -76,49 +79,58 @@
 instance Substructure Left (Flip (:*:) a) where
 	type Available Left (Flip (:*:) a) = Identity
 	type Substance Left (Flip (:*:) a) = Identity
-	substructure = P_Q_T $ \product -> case run # lower product of
-		s :*: x -> Store $ Identity (Identity s) :*: lift . Flip . (:*: x) . extract . extract
+	substructure = P_Q_T ! \product -> case run # lower product of
+		s :*: x -> Store ! Identity (Identity s) :*: lift . Flip . (:*: x) . extract . extract
 
 instance Substructure Right ((:*:) s) where
 	type Available Right ((:*:) s) = Identity
 	type Substance Right ((:*:) s) = Identity
-	substructure = P_Q_T $ \product -> case lower product of
-		s :*: x -> Store $ Identity (Identity x) :*: lift . (s :*:) . extract . extract
+	substructure = P_Q_T ! \product -> case lower product of
+		s :*: x -> Store ! Identity (Identity x) :*: lift . (s :*:) . extract . extract
 
 instance Accessible s (s :*: a) where
-	access = P_Q_T $ \(s :*: x) -> Store $ Identity s :*: (:*: x) . extract
+	access = P_Q_T ! \(s :*: x) -> Store ! Identity s :*: (:*: x) . extract
 
 instance Accessible a (s :*: a) where
-	access = P_Q_T $ \(s :*: x) -> Store $ Identity x :*: (s :*:) . extract
+	access = P_Q_T ! \(s :*: x) -> Store ! Identity x :*: (s :*:) . extract
 
 instance {-# OVERLAPS #-} Accessible b a => Accessible b (s :*: a) where
 	access = access @b . access @a
 
+-- TODO: Causes overlapping instances error when target is (a :*: b), it's better to use some wrapper instead
+-- instance {-# OVERLAPS #-} (Accessible a s, Accessible b s) => Accessible (a :*: b) s where
+	-- access = mult @(-->) @(:*:) @(:*:) ! (access @a :*: access @b)
+
 instance Accessible a (Identity a) where
-	access = P_Q_T $ \(Identity x) -> Store $ Identity x :*: identity
+	access = P_Q_T ! \(Identity x) -> Store ! Identity x :*: identity
 
 instance Possible a (Maybe a) where
-	perhaps = P_Q_T $ \x -> Store $ x :*: identity
+	perhaps = P_Q_T ! \x -> Store ! x :*: identity
 
+instance Possible a (o :+: a) where
+	perhaps = P_Q_T ! \case
+		Option s -> Store ! Nothing :*: resolve @a @(Maybe a) Adoption (Option s)
+		Adoption x -> Store ! Just x :*: resolve @a @(Maybe a) Adoption (Adoption x)
+
 instance Accessible target source => Possible target (Maybe source) where
-	perhaps = let lst = access @target @source in P_Q_T $ \case
-		Just source -> let (Identity target :*: its) = run $ lst ! source in
-			Store $ Just target :*: (its . Identity <-|-)
-		Nothing -> Store $ Nothing :*: \_ -> Nothing
+	perhaps = let lst = access @target @source in P_Q_T ! \case
+		Just source -> let (Identity target :*: its) = run (lst ! source) in
+			Store ! Just target :*: (its . Identity <-|-)
+		Nothing -> Store ! Nothing :*: \_ -> Nothing
 
 instance Accessible (Maybe target) source => Possible target source where
-	perhaps = let lst = access @(Maybe target) @source in P_Q_T $ \source ->
-		let target :*: imts = run $ lst ! source in
-			Store $ extract target :*: imts . Identity
+	perhaps = let lst = access @(Maybe target) @source in P_Q_T ! \source ->
+		let target :*: imts = run (lst ! source) in
+			Store ! extract target :*: imts . Identity
 
 instance (Covariant (->) (->) t) => Substructure Left (t <:.:> t := (:*:)) where
 	type Available Left (t <:.:> t := (:*:)) = Identity
 	type Substance Left (t <:.:> t := (:*:)) = t
-	substructure = P_Q_T $ \x -> case run # lower x of
-		ls :*: rs -> Store $ Identity ls :*: lift . (twosome % rs) . extract
+	substructure = P_Q_T ! \x -> case run # lower x of
+		ls :*: rs -> Store ! Identity ls :*: lift . (twosome % rs) . extract
 
 instance (Covariant (->) (->) t) => Substructure Right (t <:.:> t := (:*:)) where
 	type Available Right (t <:.:> t := (:*:)) = Identity
 	type Substance Right (t <:.:> t := (:*:)) = t
-	substructure = P_Q_T $ \x -> case run # lower x of
-		ls :*: rs -> Store $ Identity rs :*: lift . (twosome ls) . extract
+	substructure = P_Q_T ! \x -> case run # lower x of
+		ls :*: rs -> Store ! Identity rs :*: lift . (twosome ls) . extract
diff --git a/Pandora/Paradigm/Structure/Ability/Monotonic.hs b/Pandora/Paradigm/Structure/Ability/Monotonic.hs
--- a/Pandora/Paradigm/Structure/Ability/Monotonic.hs
+++ b/Pandora/Paradigm/Structure/Ability/Monotonic.hs
@@ -1,7 +1,8 @@
 module Pandora.Paradigm.Structure.Ability.Monotonic where
 
 import Pandora.Pattern.Category ((#))
-import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.), (-.#..-))
+import Pandora.Pattern.Kernel (constant)
+import Pandora.Paradigm.Primary.Algebraic.Exponential ((-.#..-))
 
 class Monotonic a e where
 	{-# MINIMAL reduce #-}
@@ -9,7 +10,7 @@
 
 	-- | Version of `reduce` which ignores accumulator
 	resolve :: (a -> r) -> r -> e -> r
-	resolve g = reduce # g -.#..- (!.)
+	resolve g = reduce # g -.#..- constant
 
 instance Monotonic a a where
 	reduce f r x = f x r
diff --git a/Pandora/Paradigm/Structure/Ability/Morphable.hs b/Pandora/Paradigm/Structure/Ability/Morphable.hs
--- a/Pandora/Paradigm/Structure/Ability/Morphable.hs
+++ b/Pandora/Paradigm/Structure/Ability/Morphable.hs
@@ -16,19 +16,19 @@
 import Pandora.Paradigm.Primary.Functor.Predicate (Predicate, equate)
 import Pandora.Paradigm.Primary.Functor.Tagged (Tagged (Tag))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
-import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))
+import Pandora.Paradigm.Schemes.TT (TT (TT), type (<::>))
 import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))
 
 class Morphable mod struct | mod struct -> struct where
 	type Morphing (mod :: k) (struct :: * -> *) :: * -> *
-	morphing :: Tagged mod <:.> struct ~> Morphing mod struct
+	morphing :: Tagged mod <::> struct ~> Morphing mod struct
 
 type Morphed mod struct result = (Morphable mod struct, Morphing mod struct ~ result)
 
 morph :: forall mod struct . Morphable mod struct => struct ~> Morphing mod struct
-morph = morphing . TU . Tag @mod
+morph = morphing . TT . Tag @mod
 
-premorph :: Morphable mod struct => Tagged mod <:.> struct ~> struct
+premorph :: Morphable mod struct => Tagged mod <::> struct ~> struct
 premorph = extract . run
 
 data Walk a = Preorder a | Inorder a | Postorder a | Levelorder a
@@ -40,10 +40,10 @@
 data Vertical a = Up a | Down a
 
 rotate :: forall mod struct . Morphable (Rotate mod) struct => struct ~> Morphing (Rotate mod) struct
-rotate = morphing . TU . Tag @(Rotate mod)
+rotate = morphing . TT . Tag @(Rotate mod)
 
 into :: forall mod struct . Morphable (Into mod) struct => struct ~> Morphing (Into mod) struct
-into = morphing . TU . Tag @(Into mod)
+into = morphing . TT . Tag @(Into mod)
 
 insert :: forall mod struct a . Morphed (Insert mod) struct (Identity <:.:> struct := (->)) => a :=:=> struct
 insert new xs = run # morph @(Insert mod) xs # Identity new
@@ -63,8 +63,8 @@
 find :: forall mod struct result a . (Morphed (Find mod) struct (Predicate <:.:> result := (->))) => Predicate a -> struct a -> result a
 find p xs = run # morph @(Find mod) xs # p
 
-lookup :: forall mod key struct a . (Morphed (Lookup mod) struct ((->) key <:.> Maybe)) => key -> struct a -> Maybe a
+lookup :: forall mod key struct a . (Morphed (Lookup mod) struct ((->) key <::> Maybe)) => key -> struct a -> Maybe a
 lookup key struct = run # morph @(Lookup mod) struct # key
 
-vary :: forall mod key value struct . (Morphed (Vary mod) struct (((:*:) key <:.> Identity) <:.:> struct := (->))) => key -> value -> struct value -> struct value
-vary key value xs = run # morph @(Vary mod) @struct xs # TU (key :*: Identity value)
+vary :: forall mod key value struct . (Morphed (Vary mod) struct (((:*:) key <::> Identity) <:.:> struct := (->))) => key -> value -> struct value -> struct value
+vary key value xs = run # morph @(Vary mod) @struct xs # TT (key :*: Identity value)
diff --git a/Pandora/Paradigm/Structure/Ability/Substructure.hs b/Pandora/Paradigm/Structure/Ability/Substructure.hs
--- a/Pandora/Paradigm/Structure/Ability/Substructure.hs
+++ b/Pandora/Paradigm/Structure/Ability/Substructure.hs
@@ -5,7 +5,7 @@
 
 import Pandora.Core.Functor (type (:=))
 import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
-import Pandora.Pattern.Category (($), identity)
+import Pandora.Pattern.Category (identity)
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Divariant ((>->))
 import Pandora.Pattern.Transformer.Liftable (lift)
@@ -18,6 +18,7 @@
 import Pandora.Paradigm.Primary.Functor.Tagged (Tagged)
 import Pandora.Paradigm.Schemes.TU (type (<:.>))
 import Pandora.Paradigm.Schemes.P_Q_T (P_Q_T (P_Q_T))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted ((!))
 
 data Segment a = Root a | Tail a
 
@@ -40,4 +41,4 @@
 only = inner . ((sub @segment) :: Convex Lens (structure element) (Identity element)) where
 
 	inner :: Convex Lens (Identity element) element
-	inner = P_Q_T $ \x -> Store $ x :*: identity
+	inner = P_Q_T ! \x -> Store ! x :*: identity
diff --git a/Pandora/Paradigm/Structure/Ability/Zipper.hs b/Pandora/Paradigm/Structure/Ability/Zipper.hs
--- a/Pandora/Paradigm/Structure/Ability/Zipper.hs
+++ b/Pandora/Paradigm/Structure/Ability/Zipper.hs
@@ -8,7 +8,7 @@
 import Pandora.Pattern.Morphism.Flip (Flip (Flip))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (($), (#))
+import Pandora.Pattern.Category ((#))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Semimonoidal (Semimonoidal (mult))
 import Pandora.Pattern.Functor.Monoidal (Monoidal (unit))
@@ -20,7 +20,7 @@
 import Pandora.Paradigm.Primary.Algebraic ((<-*-))
 import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))
 import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))
-import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))
+import Pandora.Paradigm.Schemes.TT (TT (TT), type (<::>))
 import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))
 import Pandora.Paradigm.Schemes.P_Q_T (P_Q_T (P_Q_T))
 import Pandora.Paradigm.Structure.Ability.Morphable (Morphable, Morph (Rotate), Vertical (Up, Down))
@@ -37,12 +37,12 @@
 type Breadcrumbed structure t = (Zippable structure, Breadcrumbs structure ~ t)
 
 instance {-# OVERLAPS #-} Semimonoidal (<--) (:*:) (:*:) t => Semimonoidal (<--) (:*:) (:*:) (Identity <:.:> t := (:*:)) where
-	mult = Flip $ \(T_U (Identity (x :*: y) :*: xys)) ->
+	mult = Flip ! \(T_U (Identity (x :*: y) :*: xys)) ->
 		let xs :*: ys = mult @(<--) ! xys in
 			T_U (Identity x :*: xs) :*: T_U (Identity y :*: ys)
 
 instance {-# OVERLAPS #-} Semimonoidal (<--) (:*:) (:*:) t => Monoidal (<--) (-->) (:*:) (:*:) (Identity <:.:> t := (:*:)) where
-	unit _ = Flip $ \(T_U (Identity x :*: _)) -> Straight (\_ -> x)
+	unit _ = Flip ! \(T_U (Identity x :*: _)) -> Straight (\_ -> x)
 
 type family Fastenable structure rs where
 	Fastenable structure (r ::: rs) = (Morphable (Rotate r) structure, Fastenable structure rs)
@@ -55,47 +55,47 @@
 instance Covariant (->) (->) t => Substructure Root (Tape t) where
 	type Available Root (Tape t) = Identity
 	type Substance Root (Tape t) = Identity
-	substructure = P_Q_T $ \zipper -> case run # lower zipper of
-		 Identity x :*: xs -> Store $ Identity (Identity x) :*: lift . T_U . (:*: xs) . extract
+	substructure = P_Q_T ! \zipper -> case run # lower zipper of
+		 Identity x :*: xs -> Store ! Identity (Identity x) :*: lift . T_U . (:*: xs) . extract
 
 instance Covariant (->) (->) t => Substructure Left (Tape t) where
 	type Available Left (Tape t) = Identity
 	type Substance Left (Tape t) = t
-	substructure = P_Q_T $ \zipper -> case run # lower zipper of
-		Identity x :*: T_U (ls :*: rs) -> Store $ Identity ls :*: lift . T_U . (Identity x :*:) . T_U . (:*: rs) . extract
+	substructure = P_Q_T ! \zipper -> case run # lower zipper of
+		Identity x :*: T_U (ls :*: rs) -> Store ! Identity ls :*: lift . T_U . (Identity x :*:) . T_U . (:*: rs) . extract
 
 instance Covariant (->) (->) t => Substructure Right (Tape t) where
 	type Available Right (Tape t) = Identity
 	type Substance Right (Tape t) = t
-	substructure = P_Q_T $ \zipper -> case run # lower zipper of
-		Identity x :*: T_U (ls :*: rs) -> Store $ Identity rs :*: lift . T_U . (Identity x :*:) . T_U . (ls :*:) . extract
+	substructure = P_Q_T ! \zipper -> case run # lower zipper of
+		Identity x :*: T_U (ls :*: rs) -> Store ! Identity rs :*: lift . T_U . (Identity x :*:) . T_U . (ls :*:) . extract
 
-instance Covariant (->) (->) t => Substructure Up (Tape t <:.> Tape t) where
-	type Available Up (Tape t <:.> Tape t) = Identity
-	type Substance Up (Tape t <:.> Tape t) = t <:.> Tape t
-	substructure = P_Q_T $ \x -> case run . run . extract . run # x of
+instance Covariant (->) (->) t => Substructure Up (Tape t <::> Tape t) where
+	type Available Up (Tape t <::> Tape t) = Identity
+	type Substance Up (Tape t <::> Tape t) = t <::> Tape t
+	substructure = P_Q_T ! \x -> case run . run . extract . run # x of
 		Identity focused :*: T_U (d :*: u) -> 
-			Store $ Identity (TU u) :*: lift . TU . twosome (Identity focused) . twosome d . run . extract
+			Store ! Identity (TT u) :*: lift . TT . twosome (Identity focused) . twosome d . run . extract
 
-instance Covariant (->) (->) t => Substructure Down (Tape t <:.> Tape t) where
-	type Available Down (Tape t <:.> Tape t) = Identity
-	type Substance Down (Tape t <:.> Tape t) = t <:.> Tape t
-	substructure = P_Q_T $ \ii -> case run . run . extract . run # ii of
+instance Covariant (->) (->) t => Substructure Down (Tape t <::> Tape t) where
+	type Available Down (Tape t <::> Tape t) = Identity
+	type Substance Down (Tape t <::> Tape t) = t <::> Tape t
+	substructure = P_Q_T ! \ii -> case run . run . extract . run # ii of
 		Identity focused :*: T_U (d :*: u) -> 
-			Store $ Identity (TU d) :*: lift . TU . twosome (Identity focused) . (twosome % u) . run . extract
+			Store ! Identity (TT d) :*: lift . TT . twosome (Identity focused) . (twosome % u) . run . extract
 
-instance (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t) => Substructure Left (Tape t <:.> Tape t) where
-	type Available Left (Tape t <:.> Tape t) = Identity
-	type Substance Left (Tape t <:.> Tape t) = Tape t <:.> t
-	substructure = P_Q_T $ \ii ->
+instance (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t) => Substructure Left (Tape t <::> Tape t) where
+	type Available Left (Tape t <::> Tape t) = Identity
+	type Substance Left (Tape t <::> Tape t) = Tape t <::> t
+	substructure = P_Q_T ! \ii ->
 		let target = (extract . view (sub @Left) <-|-) ||= (lower ii) in
 		let updated new = set (sub @Left) . Identity <-|- new <-*- run (lower ii) in
-		Store $ Identity target :*: lift . (updated ||=) . extract
+		Store ! Identity target :*: lift . (updated ||=) . extract
 
-instance (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t) => Substructure Right (Tape t <:.> Tape t) where
-	type Available Right (Tape t <:.> Tape t) = Identity
-	type Substance Right (Tape t <:.> Tape t) = Tape t <:.> t
-	substructure = P_Q_T $ \ii ->
+instance (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t) => Substructure Right (Tape t <::> Tape t) where
+	type Available Right (Tape t <::> Tape t) = Identity
+	type Substance Right (Tape t <::> Tape t) = Tape t <::> t
+	substructure = P_Q_T ! \ii ->
 		let target = (extract . view (sub @Right) <-|-) ||= lower ii in
 		let updated new = set (sub @Right) . Identity <-|- new <-*- run (lower ii) in
-		Store $ Identity target :*: lift . (updated ||=) . extract
+		Store ! Identity target :*: lift . (updated ||=) . extract
diff --git a/Pandora/Paradigm/Structure/Interface/Set.hs b/Pandora/Paradigm/Structure/Interface/Set.hs
--- a/Pandora/Paradigm/Structure/Interface/Set.hs
+++ b/Pandora/Paradigm/Structure/Interface/Set.hs
@@ -4,14 +4,14 @@
 
 import Pandora.Core.Functor (type (:=))
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (($))
+import Pandora.Pattern.Kernel (constant)
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Object.Setoid (Setoid ((!=)))
 import Pandora.Pattern.Object.Semigroup ((+))
 import Pandora.Pattern.Object.Quasiring (one)
 import Pandora.Paradigm.Primary.Algebraic ()
 import Pandora.Paradigm.Primary.Algebraic.Product (attached)
-import Pandora.Paradigm.Primary.Algebraic.Exponential ((!.), (%))
+import Pandora.Paradigm.Primary.Algebraic.Exponential ((%))
 import Pandora.Paradigm.Primary.Functor.Convergence (Convergence (Convergence))
 import Pandora.Paradigm.Primary.Functor.Maybe (Maybe (Nothing))
 import Pandora.Paradigm.Primary.Functor.Predicate (Predicate, equate)
@@ -20,12 +20,12 @@
 import Pandora.Paradigm.Schemes.T_U (type (<:.:>))
 import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing), Morph (Find), find)
 import Pandora.Paradigm.Inventory.State (State, modify)
-import Pandora.Paradigm.Controlflow.Effect (run)
+import Pandora.Paradigm.Controlflow.Effect (run, (!))
 
 type Set t f a = (Traversable (->) (->) t, Setoid a, Setoid (t a), Morphable (Find f) t)
 
 subset :: forall t f a . (Set t f a, Morphing (Find f) t ~ (Predicate <:.:> Maybe := (->))) => Convergence Boolean := t a
-subset = Convergence $ \s ss -> Nothing != (find @f @t @Maybe % s) . equate <<- ss
+subset = Convergence ! \s ss -> Nothing != (find @f @t @Maybe % s) . equate <<- ss
 
 cardinality :: Traversable (->) (->) t => t a -> Numerator
-cardinality s = attached . run @(->) @(State _) % Zero $ (modify @Numerator (+ one) !.) <<- s
+cardinality s = attached . run @(->) @(State _) % Zero ! constant (modify @Numerator (+ one)) <<- s
diff --git a/Pandora/Paradigm/Structure/Modification/Comprehension.hs b/Pandora/Paradigm/Structure/Modification/Comprehension.hs
--- a/Pandora/Paradigm/Structure/Modification/Comprehension.hs
+++ b/Pandora/Paradigm/Structure/Modification/Comprehension.hs
@@ -5,7 +5,6 @@
 
 import Pandora.Core.Functor (type (:=))
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (($))
 import Pandora.Pattern.Morphism.Straight (Straight (Straight))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Contravariant ((>-|-))
@@ -21,7 +20,7 @@
 import Pandora.Paradigm.Primary.Functor.Identity (Identity (Identity))
 import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (!)))
-import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))
+import Pandora.Paradigm.Schemes.TT (TT (TT), type (<::>))
 import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))
 import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), Morph (Push), premorph)
 import Pandora.Paradigm.Structure.Ability.Nullable (Nullable (null))
@@ -30,40 +29,40 @@
 import Pandora.Paradigm.Primary.Algebraic.Sum ((:+:))
 import Pandora.Paradigm.Primary.Algebraic (empty)
 
-newtype Comprehension t a = Comprehension (t <:.> Construction t := a)
+newtype Comprehension t a = Comprehension (t <::> Construction t := a)
 
 instance Interpreted (->) (Comprehension t) where
-	type Primary (Comprehension t) a = t <:.> Construction t := a
+	type Primary (Comprehension t) a = t <::> Construction t := a
 	run ~(Comprehension x) = x
 	unite = Comprehension
 
-instance Covariant (->) (->) (t <:.> Construction t) => Covariant (->) (->) (Comprehension t) where
-	f <-|- Comprehension x = Comprehension $ f <-|- x
+instance Covariant (->) (->) (t <::> Construction t) => Covariant (->) (->) (Comprehension t) where
+	f <-|- Comprehension x = Comprehension ! f <-|- x
 
-instance Traversable (->) (->) (t <:.> Construction t) => Traversable (->) (->) (Comprehension t) where
+instance Traversable (->) (->) (t <::> Construction t) => Traversable (->) (->) (Comprehension t) where
 	f <<- Comprehension x = Comprehension <-|- f <<- x
 
-instance (Covariant (->) (->) t, Semimonoidal (-->) (:*:) right t, Semimonoidal (-->) (:*:) right (t <:.> Construction t)) => Semimonoidal (-->) (:*:) right (Comprehension t) where
-	mult = Straight $ Comprehension . (mult @(-->) @(:*:) @right !) . (run @(->) <-> run @(->))
+instance (Covariant (->) (->) t, Semimonoidal (-->) (:*:) right t, Semimonoidal (-->) (:*:) right (t <::> Construction t)) => Semimonoidal (-->) (:*:) right (Comprehension t) where
+	mult = Straight ! Comprehension . (mult @(-->) @(:*:) @right !) . (run @(->) <-> run @(->))
 
 instance (Covariant (->) (->) t, Semimonoidal (-->) (:*:) (:*:) t, Semimonoidal (-->) (:*:) (:*:) (Construction t), Semimonoidal (-->) (:*:) (:+:) t, Semimonoidal (-->) (:*:) (:+:) (Construction t), Monoidal (-->) (-->) (:*:) (:+:) t) => Monoidal (-->) (-->) (:*:) (:+:) (Comprehension t) where
-	unit _ = Straight $ \_ -> Comprehension empty
+	unit _ = Straight ! \_ -> Comprehension empty
 
-instance (forall a . Semigroup (t <:.> Construction t := a), Bindable (->) t) => Bindable (->) (Comprehension t) where
-	f =<< Comprehension (TU t) = Comprehension . TU $ (\(Construct x xs) -> run . run $ f x + (f =<< Comprehension (TU xs))) =<< t
+instance (forall a . Semigroup (t <::> Construction t := a), Bindable (->) t) => Bindable (->) (Comprehension t) where
+	f =<< Comprehension (TT t) = Comprehension . TT ! (\(Construct x xs) -> run . run @(->) ! f x + (f =<< Comprehension (TT xs))) =<< t
 
-instance Setoid (t <:.> Construction t := a) => Setoid (Comprehension t a) where
+instance Setoid (t <::> Construction t := a) => Setoid (Comprehension t a) where
 	Comprehension ls == Comprehension rs = ls == rs
 
-instance Semigroup (t <:.> Construction t := a) => Semigroup (Comprehension t a) where
-	Comprehension x + Comprehension y = Comprehension $ x + y
+instance Semigroup (t <::> Construction t := a) => Semigroup (Comprehension t a) where
+	Comprehension x + Comprehension y = Comprehension ! x + y
 
-instance Monoid (t <:.> Construction t := a) => Monoid (Comprehension t a) where
+instance Monoid (t <::> Construction t := a) => Monoid (Comprehension t a) where
 	zero = Comprehension zero
 
 instance (Covariant (->) (->) t, Monoidal (-->) (-->) (:*:) (:*:) t) => Morphable Push (Comprehension t) where
 	type Morphing Push (Comprehension t) = Identity <:.:> Comprehension t := (->)
-	morphing (run . premorph -> xs) = T_U $ \(Identity x) -> Comprehension . lift . Construct x . run $ xs
+	morphing (run . premorph -> xs) = T_U ! \(Identity x) -> Comprehension . lift . Construct x . run ! xs
 
-instance Nullable (t <:.> Construction t) => Nullable (Comprehension t) where
+instance Nullable (t <::> Construction t) => Nullable (Comprehension t) where
 	null = run @(->) >-|- null
diff --git a/Pandora/Paradigm/Structure/Modification/Prefixed.hs b/Pandora/Paradigm/Structure/Modification/Prefixed.hs
--- a/Pandora/Paradigm/Structure/Modification/Prefixed.hs
+++ b/Pandora/Paradigm/Structure/Modification/Prefixed.hs
@@ -6,7 +6,7 @@
 import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Pattern.Semigroupoid ((.))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)), (<-|-|-))
-import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (-<<-<<-))
+import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)), (<<-<<-))
 import Pandora.Paradigm.Primary.Algebraic (extract)
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:))
 import Pandora.Paradigm.Controlflow.Effect.Interpreted (Interpreted (Primary, run, unite, (||=)))
@@ -25,7 +25,7 @@
 	(<-|-) f = (||=) (f <-|-|-)
 
 instance Traversable (->) (->) t => Traversable (->) (->) (Prefixed t k) where
-	f <<- Prefixed x = Prefixed <-|- f -<<-<<- x
+	f <<- Prefixed x = Prefixed <-|- f <<-<<- x
 
 instance Covariant (->) (->) t => Morphable (Into t) (Prefixed t k) where
 	type Morphing (Into t) (Prefixed t k) = t
diff --git a/Pandora/Paradigm/Structure/Some/Binary.hs b/Pandora/Paradigm/Structure/Some/Binary.hs
--- a/Pandora/Paradigm/Structure/Some/Binary.hs
+++ b/Pandora/Paradigm/Structure/Some/Binary.hs
@@ -1,10 +1,9 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
-
 module Pandora.Paradigm.Structure.Some.Binary where
 
 import Pandora.Core.Functor (type (~>), type (:=), type (:=>))
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (($), (#))
+import Pandora.Pattern.Category ((#))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Bindable ((=<<))
@@ -14,7 +13,7 @@
 import Pandora.Paradigm.Primary ()
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), type (:*:), attached, twosome)
 import Pandora.Paradigm.Primary.Algebraic.Exponential ((%), (&))
-import Pandora.Paradigm.Primary.Algebraic (($$$>-), (<-*-), extract, point)
+import Pandora.Paradigm.Primary.Algebraic ((!!!>-), (<-*-), extract, point)
 import Pandora.Paradigm.Primary.Object.Boolean (Boolean (True, False))
 import Pandora.Paradigm.Primary.Object.Ordering (order)
 import Pandora.Paradigm.Primary.Functor (Comparison)
@@ -24,8 +23,8 @@
 import Pandora.Paradigm.Primary.Functor.Predicate (Predicate (Predicate))
 import Pandora.Paradigm.Primary.Functor.Wye (Wye (End, Left, Right, Both))
 import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct))
-import Pandora.Paradigm.Schemes (TU (TU), T_U (T_U), P_Q_T (P_Q_T), type (<:.>), type (<:.:>))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (=||))
+import Pandora.Paradigm.Schemes (TT (TT), T_U (T_U), P_Q_T (P_Q_T), type (<::>), type (<:.:>))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (!), (=||))
 import Pandora.Paradigm.Inventory.Store (Store (Store))
 import Pandora.Paradigm.Inventory.Optics (over, view)
 import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty)
@@ -37,7 +36,7 @@
 import Pandora.Paradigm.Structure.Ability.Zipper (Zippable (Breadcrumbs))
 import Pandora.Paradigm.Structure.Modification.Prefixed (Prefixed (Prefixed))
 
-type Binary = Maybe <:.> Construction Wye
+type Binary = Maybe <::> Construction Wye
 
 instance {-# OVERLAPS #-} Traversable (->) (->) (Construction Wye) where
 	f <<- (Construct x (Left l)) = Construct <-|- f x <-*- (Left <-|- f <<- l)
@@ -54,29 +53,29 @@
 instance Morphable Insert Binary where
 	type Morphing Insert Binary = (Identity <:.:> Comparison := (:*:)) <:.:> Binary := (->)
 	morphing binary = case run # premorph binary of
-		Nothing -> T_U $ \(T_U (Identity x :*: _)) -> lift $ leaf x
-		Just non_empty_binary -> T_U $ \(T_U (Identity x :*: Convergence f)) ->
-			let continue xs = run # morph @Insert @(Nonempty Binary) xs $ twosome # Identity x # Convergence f in
+		Nothing -> T_U ! \(T_U (Identity x :*: _)) -> lift # leaf x
+		Just non_empty_binary -> T_U ! \(T_U (Identity x :*: Convergence f)) -> lift @(->) !
+			let continue xs = run # morph @Insert @(Nonempty Binary) xs ! twosome # Identity x # Convergence f in
 			let change = Just . resolve continue (leaf x) in
-			lift $ f x # extract non_empty_binary & order # non_empty_binary
+			f x # extract non_empty_binary & order # non_empty_binary
 				# over (sub @Left) change non_empty_binary
 				# over (sub @Right) change non_empty_binary
 
 instance Nullable Binary where
-	null = Predicate $ \case { TU Nothing -> True ; _ -> False }
+	null = Predicate ! \case { TT Nothing -> True ; _ -> False }
 
 instance Substructure Left Binary where
 	type Available Left Binary = Maybe
 	type Substance Left Binary = Construction Wye
-	substructure = P_Q_T $ \bintree -> case run . lower # bintree of
-		Nothing -> Store $ Nothing :*: lift . TU
+	substructure = P_Q_T ! \bintree -> case run . lower # bintree of
+		Nothing -> Store ! Nothing :*: lift . TT
 		Just tree -> lift . lift @(->) <-|- run (sub @Left) tree
 
 instance Substructure Right Binary where
 	type Available Right Binary = Maybe
 	type Substance Right Binary = Construction Wye
-	substructure = P_Q_T $ \bintree -> case run . extract . run # bintree of
-		Nothing -> Store $ Nothing :*: lift . TU
+	substructure = P_Q_T ! \bintree -> case run . extract . run # bintree of
+		Nothing -> Store ! Nothing :*: lift . TT
 		Just tree -> lift . lift @(->) <-|- run (sub @Right) tree
 
 -------------------------------------- Non-empty binary tree ---------------------------------------
@@ -89,8 +88,8 @@
 
 instance Morphable Insert (Construction Wye) where
 	type Morphing Insert (Construction Wye) = (Identity <:.:> Comparison := (:*:)) <:.:> Construction Wye := (->)
-	morphing (premorph -> nonempty_list) = T_U $ \(T_U (Identity x :*: Convergence f)) ->
-		let continue xs = run # morph @Insert @(Nonempty Binary) xs $ twosome # Identity x # Convergence f in
+	morphing (premorph -> nonempty_list) = T_U ! \(T_U (Identity x :*: Convergence f)) ->
+		let continue xs = run # morph @Insert @(Nonempty Binary) xs ! twosome # Identity x # Convergence f in
 		let change = Just . resolve continue (leaf x) in
 		order # nonempty_list
 			# over (sub @Left) change nonempty_list
@@ -100,54 +99,54 @@
 instance Substructure Root (Construction Wye) where
 	type Available Root (Construction Wye) = Identity
 	type Substance Root (Construction Wye) = Identity
-	substructure = P_Q_T $ \bintree -> case lower bintree of
-		Construct x xs -> Store $ Identity (Identity x) :*: lift . (Construct % xs) . extract . extract
+	substructure = P_Q_T ! \bintree -> case lower bintree of
+		Construct x xs -> Store ! Identity (Identity x) :*: lift . (Construct % xs) . extract . extract
 
 instance Substructure Left (Construction Wye) where
 	type Available Left (Construction Wye) = Maybe
 	type Substance Left (Construction Wye) = Construction Wye
-	substructure = P_Q_T $ \bintree -> case extract # run bintree of
-		Construct x End -> Store $ Nothing :*: lift . resolve (Construct x . Left) (leaf x)
-		Construct x (Left lst) -> Store $ Just lst :*: lift . Construct x . resolve Left End
-		Construct x (Right rst) -> Store $ Nothing :*: lift . Construct x . resolve (Both % rst) (Right rst)
-		Construct x (Both lst rst) -> Store $ Just lst :*: lift . Construct x . resolve (Both % rst) (Right rst)
+	substructure = P_Q_T ! \bintree -> case extract # run bintree of
+		Construct x End -> Store ! Nothing :*: lift . resolve (Construct x . Left) (leaf x)
+		Construct x (Left lst) -> Store ! Just lst :*: lift . Construct x . resolve Left End
+		Construct x (Right rst) -> Store ! Nothing :*: lift . Construct x . resolve (Both % rst) (Right rst)
+		Construct x (Both lst rst) -> Store ! Just lst :*: lift . Construct x . resolve (Both % rst) (Right rst)
 
 instance Substructure Right (Construction Wye) where
 	type Available Right (Construction Wye) = Maybe
 	type Substance Right (Construction Wye) = Construction Wye
-	substructure = P_Q_T $ \bintree -> case extract # run bintree of
-		Construct x End -> Store $ Nothing :*: lift . resolve (Construct x . Right) (leaf x)
-		Construct x (Left lst) -> Store $ Nothing :*: lift . Construct x . resolve (Both lst) (Left lst)
-		Construct x (Right rst) -> Store $ Just rst :*: lift . Construct x . resolve Right End
-		Construct x (Both lst rst) -> Store $ Just rst :*: lift . Construct x . resolve (Both lst) (Left lst)
+	substructure = P_Q_T ! \bintree -> case extract # run bintree of
+		Construct x End -> Store ! Nothing :*: lift . resolve (Construct x . Right) (leaf x)
+		Construct x (Left lst) -> Store ! Nothing :*: lift . Construct x . resolve (Both lst) (Left lst)
+		Construct x (Right rst) -> Store ! Just rst :*: lift . Construct x . resolve Right End
+		Construct x (Both lst rst) -> Store ! Just rst :*: lift . Construct x . resolve (Both lst) (Left lst)
 
 -------------------------------------- Prefixed binary tree ----------------------------------------
 
 instance Chain k => Morphable (Lookup Key) (Prefixed Binary k) where
-	type Morphing (Lookup Key) (Prefixed Binary k) = (->) k <:.> Maybe
-	morphing prefixed_tree = case run . run . premorph $ prefixed_tree of
-		Nothing -> TU $ \_ -> Nothing
-		Just tree -> TU $ \key ->
+	type Morphing (Lookup Key) (Prefixed Binary k) = (->) k <::> Maybe
+	morphing prefixed_tree = case run . run . premorph ! prefixed_tree of
+		Nothing -> TT ! \_ -> Nothing
+		Just tree -> TT ! \key ->
 			let root = extract tree in key <=> attached root & order (Just # extract root)
 				(lookup @Key key . Prefixed =<< view # sub @Left # tree)
 				(lookup @Key key . Prefixed =<< view # sub @Right # tree)
 
 instance Chain k => Morphable (Vary Element) (Prefixed Binary k) where
-	type Morphing (Vary Element) (Prefixed Binary k) = ((:*:) k <:.> Identity) <:.:> Prefixed Binary k := (->)
-	morphing prefixed_tree = case run . run . premorph $ prefixed_tree of
-		Nothing -> T_U $ \(TU (key :*: Identity value)) -> Prefixed . lift . leaf $ key :*: value
-		Just tree -> T_U $ \(TU (key :*: Identity value)) ->
+	type Morphing (Vary Element) (Prefixed Binary k) = ((:*:) k <::> Identity) <:.:> Prefixed Binary k := (->)
+	morphing prefixed_tree = case run . run . premorph ! prefixed_tree of
+		Nothing -> T_U ! \(TT (key :*: Identity value)) -> Prefixed . lift . leaf ! key :*: value
+		Just tree -> T_U ! \(TT (key :*: Identity value)) ->
 			let continue = ((vary @Element @k @_ @(Prefixed Binary _) key value =||) =||)
-			in let root = extract tree in Prefixed . lift $ key <=> attached root & order
-				# over (sub @Root) ($$$>- value) tree
+			in let root = extract tree in Prefixed . lift ! key <=> attached root & order
+				# over (sub @Root) (!!!>- value) tree
 				# over (sub @Left) continue tree
 				# over (sub @Right) continue tree
 
 ---------------------------------- Prefixed non-empty binary tree ----------------------------------
 
 instance Chain key => Morphable (Lookup Key) (Prefixed (Construction Wye) key) where
-	type Morphing (Lookup Key) (Prefixed (Construction Wye) key) = (->) key <:.> Maybe
-	morphing (run . premorph -> Construct x xs) = TU $ \key ->
+	type Morphing (Lookup Key) (Prefixed (Construction Wye) key) = (->) key <::> Maybe
+	morphing (run . premorph -> Construct x xs) = TT ! \key ->
 		key <=> attached x & order (Just # extract x)
 			(lookup @Key key . Prefixed . extract =<< view # sub @Left # xs)
 			(lookup @Key key . Prefixed . extract =<< view # sub @Left # xs)
@@ -158,66 +157,66 @@
 
 instance Covariant (->) (->) Biforked where
 	_ <-|- Top = Top
-	f <-|- Leftward l = Leftward $ f l
-	f <-|- Rightward r = Rightward $ f r
+	f <-|- Leftward l = Leftward ! f l
+	f <-|- Rightward r = Rightward ! f r
 
 instance Traversable (->) (->) Biforked where
 	_ <<- Top = point Top
 	f <<- Leftward l = Leftward <-|- f l
 	f <<- Rightward r = Rightward <-|- f r
 
-type Bifurcation = Biforked <:.> Construction Biforked
+type Bifurcation = Biforked <::> Construction Biforked
 
 type Bicursor = Identity <:.:> Binary := (:*:)
 
 instance Zippable (Construction Wye) where
-	type Breadcrumbs (Construction Wye) = (Wye <:.> Construction Wye) <:.:> (Bifurcation <:.> Bicursor) := (:*:)
+	type Breadcrumbs (Construction Wye) = (Wye <::> Construction Wye) <:.:> (Bifurcation <::> Bicursor) := (:*:)
 
-_focused_part_to_nonempty_binary_tree :: (Identity <:.:> Wye <:.> Construction Wye := (:*:)) ~> Construction Wye
+_focused_part_to_nonempty_binary_tree :: (Identity <:.:> Wye <::> Construction Wye := (:*:)) ~> Construction Wye
 _focused_part_to_nonempty_binary_tree (T_U (Identity x :*: xs)) = Construct x # run xs
 
-instance Morphable (Rotate Up) ((Identity <:.:> Wye <:.> Construction Wye := (:*:)) <:.:> (Bifurcation <:.> Bicursor) := (:*:)) where
-	type Morphing (Rotate Up) ((Identity <:.:> Wye <:.> Construction Wye := (:*:)) <:.:> (Bifurcation <:.> Bicursor) := (:*:))
-		= Maybe <:.> ((Identity <:.:> Wye <:.> Construction Wye := (:*:)) <:.:> Bifurcation <:.> Bicursor := (:*:))
+instance Morphable (Rotate Up) ((Identity <:.:> Wye <::> Construction Wye := (:*:)) <:.:> (Bifurcation <::> Bicursor) := (:*:)) where
+	type Morphing (Rotate Up) ((Identity <:.:> Wye <::> Construction Wye := (:*:)) <:.:> (Bifurcation <::> Bicursor) := (:*:))
+		= Maybe <::> ((Identity <:.:> Wye <::> Construction Wye := (:*:)) <:.:> Bifurcation <::> Bicursor := (:*:))
 	morphing zipper = case run # premorph zipper of
-		focused :*: TU (TU (Rightward (Construct (T_U (Identity parent :*: rest)) next))) ->
-			lift . twosome % TU (TU next) $ twosome # Identity parent $ TU $ resolve
+		focused :*: TT (TT (Rightward (Construct (T_U (Identity parent :*: rest)) next))) ->
+			lift @(->) . (twosome % TT (TT next)) . twosome (Identity parent) . TT ! resolve
 				# Both (_focused_part_to_nonempty_binary_tree focused)
 				# Left (_focused_part_to_nonempty_binary_tree focused)
 				# run rest
-		focused :*: TU (TU (Leftward (Construct (T_U (Identity parent :*: rest)) next))) ->
-			lift . twosome % TU (TU next) $ twosome # Identity parent $ TU $ resolve
+		focused :*: TT (TT (Leftward (Construct (T_U (Identity parent :*: rest)) next))) ->
+			lift @(->) . (twosome % TT (TT next)) . twosome (Identity parent) . TT ! resolve
 				# Both % _focused_part_to_nonempty_binary_tree focused
 				# Right (_focused_part_to_nonempty_binary_tree focused)
 				# run rest
-		_ -> TU Nothing
+		_ -> TT Nothing
 
-_nonempty_binary_tree_to_focused_part :: Construction Wye ~> Identity <:.:> Wye <:.> Construction Wye := (:*:)
-_nonempty_binary_tree_to_focused_part (Construct x xs) = twosome # Identity x # TU xs
+_nonempty_binary_tree_to_focused_part :: Construction Wye ~> Identity <:.:> Wye <::> Construction Wye := (:*:)
+_nonempty_binary_tree_to_focused_part (Construct x xs) = twosome # Identity x # TT xs
 
-instance Morphable (Rotate (Down Left)) ((Identity <:.:> Wye <:.> Construction Wye := (:*:)) <:.:> (Bifurcation <:.> Bicursor) := (:*:)) where
-	type Morphing (Rotate (Down Left)) ((Identity <:.:> Wye <:.> Construction Wye := (:*:)) <:.:> (Bifurcation <:.> Bicursor) := (:*:))
-		= Maybe <:.> ((Identity <:.:> Wye <:.> Construction Wye := (:*:)) <:.:> Bifurcation <:.> Bicursor := (:*:))
+instance Morphable (Rotate (Down Left)) ((Identity <:.:> Wye <::> Construction Wye := (:*:)) <:.:> (Bifurcation <::> Bicursor) := (:*:)) where
+	type Morphing (Rotate (Down Left)) ((Identity <:.:> Wye <::> Construction Wye := (:*:)) <:.:> (Bifurcation <::> Bicursor) := (:*:))
+		= Maybe <::> ((Identity <:.:> Wye <::> Construction Wye := (:*:)) <:.:> Bifurcation <::> Bicursor := (:*:))
 	morphing zipper = case run # premorph zipper of
-		T_U (Identity x :*: TU (Left lst)) :*: TU (TU next) ->
+		T_U (Identity x :*: TT (Left lst)) :*: TT (TT next) ->
 			lift . twosome (_nonempty_binary_tree_to_focused_part lst)
-				. TU . TU . Leftward $ Construct # twosome (Identity x) (TU Nothing) # next
-		T_U (Identity x :*: TU (Both lst rst)) :*: TU (TU next) ->
+				. TT . TT . Leftward ! Construct # twosome (Identity x) (TT Nothing) # next
+		T_U (Identity x :*: TT (Both lst rst)) :*: TT (TT next) ->
 			lift . twosome (_nonempty_binary_tree_to_focused_part lst)
-				. TU . TU . Leftward $ Construct # twosome (Identity x) (lift rst) # next
-		_ -> TU Nothing
+				. TT . TT . Leftward ! Construct # twosome (Identity x) (lift rst) # next
+		_ -> TT Nothing
 
-instance Morphable (Rotate (Down Right)) ((Identity <:.:> Wye <:.> Construction Wye := (:*:)) <:.:> (Bifurcation <:.> Bicursor) := (:*:)) where
-	type Morphing (Rotate (Down Right)) ((Identity <:.:> Wye <:.> Construction Wye := (:*:)) <:.:> (Bifurcation <:.> Bicursor) := (:*:))
-		= Maybe <:.> ((Identity <:.:> Wye <:.> Construction Wye := (:*:)) <:.:> Bifurcation <:.> Bicursor := (:*:))
+instance Morphable (Rotate (Down Right)) ((Identity <:.:> Wye <::> Construction Wye := (:*:)) <:.:> (Bifurcation <::> Bicursor) := (:*:)) where
+	type Morphing (Rotate (Down Right)) ((Identity <:.:> Wye <::> Construction Wye := (:*:)) <:.:> (Bifurcation <::> Bicursor) := (:*:))
+		= Maybe <::> ((Identity <:.:> Wye <::> Construction Wye := (:*:)) <:.:> Bifurcation <::> Bicursor := (:*:))
 	morphing zipper = case run # premorph zipper of
-		T_U (Identity x :*: TU (Right rst)) :*: TU (TU next) ->
+		T_U (Identity x :*: TT (Right rst)) :*: TT (TT next) ->
 			lift . twosome (_nonempty_binary_tree_to_focused_part rst)
-				. TU . TU . Rightward $ Construct # twosome (Identity x) (TU Nothing) # next
-		T_U (Identity x :*: TU (Both lst rst)) :*: TU (TU next) ->
+				. TT . TT . Rightward ! Construct # twosome (Identity x) (TT Nothing) # next
+		T_U (Identity x :*: TT (Both lst rst)) :*: TT (TT next) ->
 			lift . twosome (_nonempty_binary_tree_to_focused_part rst)
-				. TU . TU . Rightward $ Construct # twosome (Identity x) (lift lst) # next
-		_ -> TU Nothing
+				. TT . TT . Rightward ! Construct # twosome (Identity x) (lift lst) # next
+		_ -> TT Nothing
 
 leaf :: a :=> Nonempty Binary
 leaf x = Construct x End
diff --git a/Pandora/Paradigm/Structure/Some/List.hs b/Pandora/Paradigm/Structure/Some/List.hs
--- a/Pandora/Paradigm/Structure/Some/List.hs
+++ b/Pandora/Paradigm/Structure/Some/List.hs
@@ -5,7 +5,7 @@
 import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Core.Impliable (imply)
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (($), (#), identity)
+import Pandora.Pattern.Category ((#), identity)
 import Pandora.Pattern.Functor.Covariant (Covariant, Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((<<-)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
@@ -30,8 +30,8 @@
 import Pandora.Paradigm.Inventory.State (State, fold, modify)
 import Pandora.Paradigm.Inventory.Store (Store (Store))
 import Pandora.Paradigm.Inventory.Optics (Convex, Lens, view)
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (||=))
-import Pandora.Paradigm.Schemes.TU (TU (TU), type (<:.>))
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (!), (||=))
+import Pandora.Paradigm.Schemes.TT (TT (TT), type (<::>))
 import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))
 import Pandora.Paradigm.Schemes.P_Q_T (P_Q_T (P_Q_T))
 import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty)
@@ -48,22 +48,22 @@
 import Pandora.Paradigm.Structure.Modification.Prefixed (Prefixed (Prefixed))
 
 -- | Linear data structure that serves as a collection of elements
-type List = Maybe <:.> Construction Maybe
+type List = Maybe <::> Construction Maybe
 
 instance Setoid a => Setoid (List a) where
-	TU ls == TU rs = ls == rs
+	TT ls == TT rs = ls == rs
 
 instance Semigroup (List a) where
-	TU Nothing + TU ys = TU ys
-	TU (Just (Construct x xs)) + TU ys = lift . Construct x . run
-		$ TU @Covariant @Covariant xs + TU @Covariant @Covariant ys
+	TT Nothing + TT ys = TT ys
+	TT (Just (Construct x xs)) + TT ys = lift . Construct x . run
+		! TT @Covariant @Covariant xs + TT @Covariant @Covariant ys
 
 instance Monoid (List a) where
-	zero = TU Nothing
+	zero = TT Nothing
 
 instance Morphable Push List where
 	type Morphing Push List = Identity <:.:> List := (->)
-	morphing (premorph -> xs) = T_U $ lift . (Construct % run xs) . extract
+	morphing (premorph -> xs) = T_U ! lift . (Construct % run xs) . extract
 
 instance Morphable Pop List where
 	type Morphing Pop List = List
@@ -72,86 +72,87 @@
 instance Morphable (Find Element) List where
 	type Morphing (Find Element) List = Predicate <:.:> Maybe := (->)
 	morphing list = case run # premorph list of
-		Nothing -> T_U $ \_ -> Nothing
-		Just (Construct x xs) -> T_U $ \p -> run p x ? Just x
-			$ find @Element @List @Maybe # p # TU xs
+		Nothing -> T_U ! \_ -> Nothing
+		Just (Construct x xs) -> T_U ! \p -> run p x ? Just x
+			! find @Element @List @Maybe # p # TT xs
 
 instance Morphable (Delete First) List where
 	type Morphing (Delete First) List = Predicate <:.:> List := (->)
 	morphing list = case run # premorph list of
-		Nothing -> T_U $ \_ -> TU Nothing
-		Just (Construct x xs) -> T_U $ \p -> run p x ? TU xs
-			$ lift . Construct x . run . filter @First @List p $ TU xs
+		Nothing -> T_U ! \_ -> TT Nothing
+		Just (Construct x xs) -> T_U ! \p -> 
+			run p x ? TT xs ! lift . Construct x . run . filter @First @List p # TT xs
 
 instance Morphable (Delete All) List where
 	type Morphing (Delete All) List = Predicate <:.:> List := (->)
 	morphing list = case run # premorph list of
-		Nothing -> T_U $ \_ -> TU Nothing
-		Just (Construct x xs) -> T_U $ \p -> run p x ? filter @All @List p (TU xs)
-			$ lift . Construct x . run . filter @All @List p $ TU xs
+		Nothing -> T_U ! \_ -> TT Nothing
+		Just (Construct x xs) -> T_U ! \p ->
+			run p x ? filter @All @List p (TT xs)
+				! lift . Construct x . run . filter @All @List p # TT xs
 
 instance Stack List where
 
 instance Nullable List where
-	null = Predicate $ \case { TU Nothing -> True ; _ -> False }
+	null = Predicate ! \case { TT Nothing -> True ; _ -> False }
 
 instance Substructure Root List where
 	type Available Root List = Maybe
 	type Substance Root List = Identity
-	substructure = P_Q_T $ \zipper -> case run # lower zipper of
-		Just (Construct x xs) -> Store $ Just (Identity x) :*: lift . resolve (lift . (Construct % xs) . extract @Identity) zero
-		Nothing -> Store $ Nothing :*: lift . resolve (lift . (Construct % Nothing) . extract @Identity) zero
+	substructure = P_Q_T ! \zipper -> case run # lower zipper of
+		Just (Construct x xs) -> Store ! Just (Identity x) :*: lift . resolve (lift . (Construct % xs) . extract @Identity) zero
+		Nothing -> Store ! Nothing :*: lift . resolve (lift . (Construct % Nothing) . extract @Identity) zero
 
 instance Substructure Tail List where
 	type Available Tail List = Identity
 	type Substance Tail List = List
-	substructure = P_Q_T $ \x -> case run . extract . run $ x of
+	substructure = P_Q_T ! \x -> case run . extract . run ! x of
 		Just ns -> lift . lift @(->) <-|- run (sub @Tail) ns
-		Nothing -> Store $ Identity zero :*: lift . identity . extract
+		Nothing -> Store ! Identity zero :*: lift . identity . extract
 
 -- | Transform any traversable structure into a stack
 linearize :: forall t a . Traversable (->) (->) t => t a -> List a
-linearize = TU . extract . (run @(->) @(State (Maybe :. Nonempty List := a)) % Nothing) . fold (Just -.#..- Construct)
+linearize = TT . extract . (run @(->) @(State (Maybe :. Nonempty List := a)) % Nothing) . fold (Just -.#..- Construct)
 
 ----------------------------------------- Non-empty list -------------------------------------------
 
 type instance Nonempty List = Construction Maybe
 
 instance {-# OVERLAPS #-} Semigroup (Construction Maybe a) where
-	Construct x Nothing + ys = Construct x $ Just ys
-	Construct x (Just xs) + ys = Construct x . Just $ xs + ys
+	Construct x Nothing + ys = Construct x ! Just ys
+	Construct x (Just xs) + ys = Construct x . Just ! xs + ys
 
 instance Morphable (Find Element) (Construction Maybe) where
 	type Morphing (Find Element) (Construction Maybe) = Predicate <:.:> Maybe := (->)
-	morphing (premorph -> Construct x xs) = T_U $ \p ->
-		run p x ? Just x $ find @Element @(Nonempty List) @Maybe # p =<< xs
+	morphing (premorph -> Construct x xs) = T_U ! \p ->
+		run p x ? Just x ! find @Element @(Nonempty List) @Maybe # p =<< xs
 
 instance Morphable (Into List) (Construction Maybe) where
 	type Morphing (Into List) (Construction Maybe) = List
 	morphing = lift . premorph
 
-instance Morphable (Into List) (Construction Maybe <:.> Maybe) where
-	type Morphing (Into List) (Construction Maybe <:.> Maybe) = List
+instance Morphable (Into List) (Construction Maybe <::> Maybe) where
+	type Morphing (Into List) (Construction Maybe <::> Maybe) = List
 	morphing nonempty_list_with_maybe_elements = case run . premorph # nonempty_list_with_maybe_elements of
-		Construct (Just x) (Just xs) -> item @Push x # into @List (TU @Covariant @Covariant xs)
+		Construct (Just x) (Just xs) -> item @Push x # into @List (TT @Covariant @Covariant xs)
 		Construct (Just x) Nothing -> point x
-		Construct Nothing Nothing -> TU Nothing -- empty
+		Construct Nothing Nothing -> TT Nothing -- empty
 
 instance Morphable Push (Construction Maybe) where
 	type Morphing Push (Construction Maybe) = Identity <:.:> Construction Maybe := (->)
-	morphing (premorph -> xs) = T_U $ \(Identity x) -> Construct x $ Just xs
+	morphing (premorph -> xs) = T_U ! \(Identity x) -> Construct x ! Just xs
 
 instance Substructure Root (Construction Maybe) where
 	type Available Root (Construction Maybe) = Identity
 	type Substance Root (Construction Maybe) = Identity
 	substructure = imply @(Convex Lens _ _) (Identity . extract . lower)
-		(\source target -> lift $ Construct # extract target # deconstruct (lower source))
+		(\source target -> lift (Construct # extract target # deconstruct (lower source)))
 
 instance Substructure Tail (Construction Maybe) where
 	type Available Tail (Construction Maybe) = Identity
 	type Substance Tail (Construction Maybe) = List
-	substructure = imply @(Convex Lens _ _) (TU . deconstruct . lower)
-		(\source target -> lift $ Construct # extract (lower source) # run target)
+	substructure = imply @(Convex Lens _ _) (TT . deconstruct . lower)
+		(\source target -> lift (Construct # extract (lower source) # run target))
 
 ---------------------------------------- Combinative list ------------------------------------------
 
@@ -163,38 +164,38 @@
 	type Breadcrumbs List = (List <:.:> List := (:*:))
 
 instance {-# OVERLAPS #-} Traversable (->) (->) (Identity <:.:> (List <:.:> List := (:*:)) := (:*:)) where
-	f <<- T_U (Identity x :*: T_U (future :*: past)) = (\past' x' future' -> twosome (Identity x') $ twosome # future' # run past')
+	f <<- T_U (Identity x :*: T_U (future :*: past)) = (\past' x' future' -> twosome (Identity x') ! twosome # future' # run past')
 		<-|- f <<- Reverse past <-*- f x <-*- f <<- future
 
 instance {-# OVERLAPS #-} Extendable (->) (Identity <:.:> (List <:.:> List := (:*:)) := (:*:)) where
-	f <<= z = let move rtt = TU . deconstruct $ run . rtt .-+ z in
-		twosome (Identity # f z) $ twosome # f <-|- move (rotate @Left) # f <-|- move (rotate @Right)
+	f <<= z = let move rtt = TT . deconstruct ! run . rtt .-+ z in
+		twosome (Identity # f z) ! twosome # f <-|- move (rotate @Left) # f <-|- move (rotate @Right)
 
 instance Morphable (Rotate Left) (Identity <:.:> (List <:.:> List := (:*:)) := (:*:)) where
-	type Morphing (Rotate Left) (Identity <:.:> (List <:.:> List := (:*:)) := (:*:)) = Maybe <:.> (Identity <:.:> (List <:.:> List := (:*:)) := (:*:))
+	type Morphing (Rotate Left) (Identity <:.:> (List <:.:> List := (:*:)) := (:*:)) = Maybe <::> (Identity <:.:> (List <:.:> List := (:*:)) := (:*:))
 	morphing (premorph -> T_U (Identity x :*: T_U (future :*: past))) =
 		let subtree = twosome # extract (view (sub @Tail) future) # item @Push x past in
-		TU $ (twosome . Identity . extract) % subtree <-|- view (sub @Root) future
+		TT ! (twosome . Identity . extract) % subtree <-|- view (sub @Root) future
 
 instance Morphable (Rotate Right) (Identity <:.:> (List <:.:> List := (:*:)) := (:*:)) where
-	type Morphing (Rotate Right) (Identity <:.:> (List <:.:> List := (:*:)) := (:*:)) = Maybe <:.> (Identity <:.:> (List <:.:> List := (:*:)) := (:*:))
+	type Morphing (Rotate Right) (Identity <:.:> (List <:.:> List := (:*:)) := (:*:)) = Maybe <::> (Identity <:.:> (List <:.:> List := (:*:)) := (:*:))
 	morphing (premorph -> T_U (Identity x :*: T_U (future :*: past))) =
 		let subtree = twosome # item @Push x future # extract (view (sub @Tail) past) in
-		TU $ (twosome . Identity . extract) % subtree <-|- view (sub @Root) past
+		TT ! (twosome . Identity . extract) % subtree <-|- view (sub @Root) past
 
 instance Morphable (Into (Identity <:.:> (List <:.:> List := (:*:)) := (:*:))) List where
-	type Morphing (Into (Identity <:.:> (List <:.:> List := (:*:)) := (:*:))) List = Maybe <:.> (Identity <:.:> (List <:.:> List := (:*:)) := (:*:))
+	type Morphing (Into (Identity <:.:> (List <:.:> List := (:*:)) := (:*:))) List = Maybe <::> (Identity <:.:> (List <:.:> List := (:*:)) := (:*:))
 	morphing (premorph -> list) = (into @(Zipper List) <-|-) ||= list
 
 instance Morphable (Into List) (Identity <:.:> (List <:.:> List := (:*:)) := (:*:)) where
 	type Morphing (Into List) (Identity <:.:> (List <:.:> List := (:*:)) := (:*:)) = List
-	morphing (premorph -> T_U (Identity x :*: T_U (future :*: past))) = attached $ run @(->) @(State _)
+	morphing (premorph -> T_U (Identity x :*: T_U (future :*: past))) = attached ! run @(->) @(State _)
 		# modify . item @Push @List <<- past
 		# item @Push x future
 
 instance Morphable (Into (Comprehension Maybe)) (Identity <:.:> (List <:.:> List := (:*:)) := (:*:)) where
 	type Morphing (Into (Comprehension Maybe)) (Identity <:.:> (List <:.:> List := (:*:)) := (:*:)) = Comprehension Maybe
-	morphing (premorph -> T_U (Identity x :*: T_U (future :*: past))) = attached $ run @(->) @(State _)
+	morphing (premorph -> T_U (Identity x :*: T_U (future :*: past))) = attached ! run @(->) @(State _)
 		# modify . item @Push @(Comprehension Maybe) <<- past
 		# item @Push x (Comprehension future)
 
@@ -205,17 +206,17 @@
 
 instance Morphable (Rotate Left) (Identity <:.:> (Construction Maybe <:.:> Construction Maybe := (:*:)) := (:*:)) where
 	type Morphing (Rotate Left) (Identity <:.:> (Construction Maybe <:.:> Construction Maybe := (:*:)) := (:*:)) =
-		Maybe <:.> (Identity <:.:> (Construction Maybe <:.:> Construction Maybe := (:*:)) := (:*:))
-	morphing (premorph -> T_U (Identity x :*: T_U (future :*: past))) = TU $ T_U . (Identity (extract future) :*:) . twosome % item @Push x past <-|- deconstruct future
+		Maybe <::> (Identity <:.:> (Construction Maybe <:.:> Construction Maybe := (:*:)) := (:*:))
+	morphing (premorph -> T_U (Identity x :*: T_U (future :*: past))) = TT ! T_U . (Identity (extract future) :*:) . twosome % item @Push x past <-|- deconstruct future
 
 instance Morphable (Rotate Right) (Identity <:.:> (Construction Maybe <:.:> Construction Maybe := (:*:)) := (:*:)) where
 	type Morphing (Rotate Right) (Identity <:.:> (Construction Maybe <:.:> Construction Maybe := (:*:)) := (:*:)) =
-		Maybe <:.> (Identity <:.:> (Construction Maybe <:.:> Construction Maybe := (:*:)) := (:*:))
-	morphing (premorph -> T_U (Identity x :*: T_U (future :*: past))) = TU $ T_U . (Identity (extract past) :*:) . twosome (item @Push x future) <-|- deconstruct past
+		Maybe <::> (Identity <:.:> (Construction Maybe <:.:> Construction Maybe := (:*:)) := (:*:))
+	morphing (premorph -> T_U (Identity x :*: T_U (future :*: past))) = TT ! T_U . (Identity (extract past) :*:) . twosome (item @Push x future) <-|- deconstruct past
 
 instance Morphable (Into (Identity <:.:> (List <:.:> List := (:*:)) := (:*:))) (Construction Maybe) where
 	type Morphing (Into (Identity <:.:> (List <:.:> List := (:*:)) := (:*:))) (Construction Maybe) = Identity <:.:> (List <:.:> List := (:*:)) := (:*:)
-	morphing (premorph -> ne) = twosome # Identity (extract ne) $ twosome # extract (view # sub @Tail # ne) # zero
+	morphing (premorph -> ne) = twosome # Identity (extract ne) ! twosome # extract (view # sub @Tail # ne) # zero
 
 instance Morphable (Into (Identity <:.:> (List <:.:> List := (:*:)) := (:*:))) (Identity <:.:> (Construction Maybe <:.:> Construction Maybe := (:*:)) := (:*:)) where
 	type Morphing (Into (Identity <:.:> (List <:.:> List := (:*:)) := (:*:))) (Identity <:.:> (Construction Maybe <:.:> Construction Maybe := (:*:)) := (:*:)) =
@@ -224,19 +225,19 @@
 
 instance Morphable (Into (Identity <:.:> (Construction Maybe <:.:> Construction Maybe := (:*:)) := (:*:))) (Identity <:.:> (List <:.:> List := (:*:)) := (:*:)) where
 	type Morphing (Into (Identity <:.:> (Construction Maybe <:.:> Construction Maybe := (:*:)) := (:*:))) (Identity <:.:> (List <:.:> List := (:*:)) := (:*:)) =
-		Maybe <:.> (Identity <:.:> (Construction Maybe <:.:> Construction Maybe := (:*:)) := (:*:))
+		Maybe <::> (Identity <:.:> (Construction Maybe <:.:> Construction Maybe := (:*:)) := (:*:))
 	morphing (premorph -> zipper) = let spread x y = (:*:) <-|- x <-*- y in
-		TU $ T_U . (Identity (extract zipper) :*:) . T_U <-|- ((spread |-) . (run @(->) <-> run @(->)) . run . extract $ run zipper)
+		TT ! T_U . (Identity (extract zipper) :*:) . T_U <-|- ((spread |-) . (run @(->) <-> run @(->)) . run . extract ! run zipper)
 
 instance Morphable (Into (Construction Maybe)) (Identity <:.:> (Construction Maybe <:.:> Construction Maybe := (:*:)) := (:*:)) where
 	type Morphing (Into (Construction Maybe)) (Identity <:.:> (Construction Maybe <:.:> Construction Maybe := (:*:)) := (:*:)) = Construction Maybe
-	morphing (premorph -> T_U (Identity x :*: T_U (future :*: past))) = attached $ run @(->) @(State _)
+	morphing (premorph -> T_U (Identity x :*: T_U (future :*: past))) = attached ! run @(->) @(State _)
 		# modify . item @Push @(Nonempty List) <<- past
 		# item @Push x future
 
 instance Morphable (Into List) (Identity <:.:> (Construction Maybe <:.:> Construction Maybe := (:*:)) := (:*:)) where
 	type Morphing (Into List) (Identity <:.:> (Construction Maybe <:.:> Construction Maybe := (:*:)) := (:*:)) = List
-	morphing (premorph -> T_U (Identity x :*: T_U (future :*: past))) = attached $ run @(->) @(State _)
+	morphing (premorph -> T_U (Identity x :*: T_U (future :*: past))) = attached ! run @(->) @(State _)
 		# modify . item @Push @List <<- past
 		# item @Push x (lift future)
 
@@ -248,12 +249,12 @@
 ----------------------------------------- Prefixed list --------------------------------------------
 
 instance Setoid key => Morphable (Lookup Key) (Prefixed List key) where
-	type Morphing (Lookup Key) (Prefixed List key) = (->) key <:.> Maybe
-	morphing (run . premorph -> list) = TU $ \key -> lookup @Key key =<< Prefixed <-|- run list
+	type Morphing (Lookup Key) (Prefixed List key) = (->) key <::> Maybe
+	morphing (run . premorph -> list) = TT ! \key -> lookup @Key key =<< Prefixed <-|- run list
 
 ------------------------------------ Prefixed non-empty list ---------------------------------------
 
 instance Setoid key => Morphable (Lookup Key) (Prefixed (Construction Maybe) key) where
-	type Morphing (Lookup Key) (Prefixed (Construction Maybe) key) = (->) key <:.> Maybe
-	morphing (run . premorph -> Construct x xs) = TU $ \key -> extract <-|- search key where
-		search key = key == attached x ? Just x $ find @Element # Predicate ((key ==) . attached) =<< xs
+	type Morphing (Lookup Key) (Prefixed (Construction Maybe) key) = (->) key <::> Maybe
+	morphing (run . premorph -> Construct x xs) = TT ! \key -> extract <-|- search key where
+		search key = key == attached x ? Just x ! find @Element # Predicate ((key ==) . attached) =<< xs
diff --git a/Pandora/Paradigm/Structure/Some/Rose.hs b/Pandora/Paradigm/Structure/Some/Rose.hs
--- a/Pandora/Paradigm/Structure/Some/Rose.hs
+++ b/Pandora/Paradigm/Structure/Some/Rose.hs
@@ -4,7 +4,7 @@
 
 import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (($), (#))
+import Pandora.Pattern.Category ((#))
 import Pandora.Pattern.Functor.Contravariant ((>-|-))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Pattern.Transformer.Liftable (lift)
@@ -19,7 +19,7 @@
 import Pandora.Paradigm.Primary.Functor.Predicate (Predicate (Predicate), equate)
 import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct)
 import Pandora.Paradigm.Schemes (TU (TU), P_Q_T (P_Q_T), type (<:.>))
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (!))
 import Pandora.Paradigm.Inventory.Store (Store (Store))
 import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing)
 	, Morph (Lookup, Element, Key), premorph, find)
@@ -32,24 +32,24 @@
 type Rose = Maybe <:.> Construction List
 
 instance Nullable Rose where
-	null = Predicate $ \case { TU Nothing -> True ; _ -> False }
+	null = Predicate ! \case { TU Nothing -> True ; _ -> False }
 
 -- FIXME: If we want to remove root node, we ruin the whole tree
 --instance Substructure Root Rose where
 --	type Available Root Rose = Maybe
 --	type Substance Root Rose = Identity
---	substructure = P_Q_T $ \rose -> case run # lower rose of
---		Nothing -> Store $ Nothing :*: TU . Tag . TU . ((Construct % empty) . extract <-|-)
---		Just nonempty_rose -> Store $ Just (Identity # extract nonempty_rose) :*: \case
---			Just (Identity new) -> lift . TU . Just . Construct new $ deconstruct nonempty_rose
+--	substructure = P_Q_T ! \rose -> case run # lower rose of
+--		Nothing -> Store ! Nothing :*: TU . Tag . TU . ((Construct % empty) . extract <-|-)
+--		Just nonempty_rose -> Store ! Just (Identity # extract nonempty_rose) :*: \case
+--			Just (Identity new) -> lift . TU . Just . Construct new ! deconstruct nonempty_rose
 --			Nothing -> lift empty
 
 --instance Substructure Just Rose where
 --	type Available Just Rose = Identity
 --	type Substance Just Rose = List <:.> Construction List
---	substructure = P_Q_T $ \rose -> case run . extract . run # rose of
---		Nothing -> Store $ Identity empty :*: (lift empty !.)
---		Just (Construct x xs) -> Store $ Identity (TU xs) :*: lift . lift . Construct x . run . extract
+--	substructure = P_Q_T ! \rose -> case run . extract . run # rose of
+--		Nothing -> Store ! Identity empty :*: constant (lift empty)
+--		Just (Construct x xs) -> Store ! Identity (TU xs) :*: lift . lift . Construct x . run . extract
 
 --------------------------------------- Non-empty rose tree ----------------------------------------
 
@@ -58,30 +58,30 @@
 instance Substructure Root (Construction List) where
 	type Available Root (Construction List) = Identity
 	type Substance Root (Construction List) = Identity
-	substructure = P_Q_T $ \rose -> Store $ Identity (Identity # extract (lower rose)) :*: lift . (Construct % deconstruct (lower rose)) . extract . extract
+	substructure = P_Q_T ! \rose -> Store ! Identity (Identity # extract (lower rose)) :*: lift . (Construct % deconstruct (lower rose)) . extract . extract
 
 instance Substructure Tail (Construction List) where
 	type Available Tail (Construction List) = Identity
 	type Substance Tail (Construction List) = List <:.> Construction List
-	substructure = P_Q_T $ \rose -> case extract # run rose of
-		Construct x xs -> Store $ Identity (TU xs) :*: lift . Construct x . run . extract
+	substructure = P_Q_T ! \rose -> case extract # run rose of
+		Construct x xs -> Store ! Identity (TU xs) :*: lift . Construct x . run . extract
 
 --------------------------------------- Prefixed rose tree -----------------------------------------
 
 instance Setoid k => Morphable (Lookup Key) (Prefixed Rose k) where
 	type Morphing (Lookup Key) (Prefixed Rose k) = (->) (Nonempty List k) <:.> Maybe
 	morphing prefixed_rose_tree = case run # premorph prefixed_rose_tree of
-		TU Nothing -> TU $ \_ -> Nothing
-		TU (Just tree) -> TU $ find_rose_sub_tree % tree
+		TU Nothing -> TU ! \_ -> Nothing
+		TU (Just tree) -> TU ! find_rose_sub_tree % tree
 
 -- TODO: Ineffiecient - we iterate over all branches in subtree, but we need to short-circuit on the first matching part of
 --instance Setoid k => Morphable (Vary Element) (Prefixed Rose k) where
 --	type Morphing (Vary Element) (Prefixed Rose k) = ((:*:) (Nonempty List k) <:.> Identity) <:.:> Prefixed Rose k := (->)
---	morphing (run . run . premorph -> Nothing) = T_U $ \(TU (Construct key _ :*: Identity value)) -> Prefixed . lift $ Construct (key :*: value) empty
---	morphing (run . run . premorph -> Just (Construct focused subtree)) = T_U $ \(TU (breadcrumbs :*: Identity value)) -> case breadcrumbs of
---		Construct key Nothing -> Prefixed . lift $ attached focused == key ? Construct (key :*: value) subtree $ Construct focused subtree
---		Construct key (Just keys) -> Prefixed . lift $ attached focused != key ? Construct focused subtree
---			$ Construct focused $ vary @Element @_ @_ @(Nonempty (Prefixed Rose k)) keys value =||$> subtree
+--	morphing (run . run . premorph -> Nothing) = T_U ! \(TU (Construct key _ :*: Identity value)) -> Prefixed . lift ! Construct (key :*: value) empty
+--	morphing (run . run . premorph -> Just (Construct focused subtree)) = T_U ! \(TU (breadcrumbs :*: Identity value)) -> case breadcrumbs of
+--		Construct key Nothing -> Prefixed . lift ! attached focused == key ? Construct (key :*: value) subtree ! Construct focused subtree
+--		Construct key (Just keys) -> Prefixed . lift ! attached focused != key ? Construct focused subtree
+--			! Construct focused ! vary @Element @_ @_ @(Nonempty (Prefixed Rose k)) keys value =||!> subtree
 
 ---------------------------------- Non-empty prefixed rose tree ------------------------------------
 
@@ -89,18 +89,18 @@
 --instance Setoid k => Morphable (Vary Element) (Prefixed (Construction List) k) where
 --	type Morphing (Vary Element) (Prefixed (Construction List) k) =
 --		((:*:) (Nonempty List k) <:.> Identity) <:.:> Prefixed (Construction List) k := (->)
---	morphing (run . premorph -> Construct x (TU Nothing)) = T_U $ \(TU (breadcrumbs :*: Identity value)) -> case breadcrumbs of
---		Construct key Nothing -> Prefixed $ attached x == key ? Construct (key :*: value) empty $ Construct x empty
---		Construct _ (Just _) -> Prefixed $ Construct x (TU Nothing)
---	morphing (run . premorph -> Construct x (TU (Just subtree))) = T_U $ \(TU (breadcrumbs :*: Identity value)) -> case breadcrumbs of
---		Construct key Nothing -> Prefixed $ attached x != key ? Construct x # lift subtree
---			$ Construct (key :*: value) (lift subtree)
---		Construct key (Just keys) -> Prefixed $ attached x != key ? Construct x # lift subtree
---			$ Construct (key :*: value) . lift $ vary @Element @_ @_ @(Nonempty (Prefixed Rose k)) keys value =||$> subtree
+--	morphing (run . premorph -> Construct x (TU Nothing)) = T_U ! \(TU (breadcrumbs :*: Identity value)) -> case breadcrumbs of
+--		Construct key Nothing -> Prefixed ! attached x == key ? Construct (key :*: value) empty ! Construct x empty
+--		Construct _ (Just _) -> Prefixed ! Construct x (TU Nothing)
+--	morphing (run . premorph -> Construct x (TU (Just subtree))) = T_U ! \(TU (breadcrumbs :*: Identity value)) -> case breadcrumbs of
+--		Construct key Nothing -> Prefixed ! attached x != key ? Construct x # lift subtree
+--			! Construct (key :*: value) (lift subtree)
+--		Construct key (Just keys) -> Prefixed ! attached x != key ? Construct x # lift subtree
+--			! Construct (key :*: value) . lift ! vary @Element @_ @_ @(Nonempty (Prefixed Rose k)) keys value =||!> subtree
 
 find_rose_sub_tree :: forall k a . Setoid k => Nonempty List k -> Nonempty Rose := k :*: a -> Maybe a
-find_rose_sub_tree (Construct k Nothing) tree = k == attached (extract tree) ? Just (extract $ extract tree) $ Nothing
-find_rose_sub_tree (Construct k (Just ks)) tree = k != attached (extract tree) ? Nothing $ find_rose_sub_tree ks =<< subtree where
+find_rose_sub_tree (Construct k Nothing) tree = k == attached (extract tree) ? Just (extract ! extract tree) ! Nothing
+find_rose_sub_tree (Construct k (Just ks)) tree = k != attached (extract tree) ? Nothing ! find_rose_sub_tree ks =<< subtree where
 
 	subtree :: Maybe :. Nonempty Rose := k :*: a
 	subtree = find @Element # attached . extract >-|- equate (extract ks) # deconstruct tree
diff --git a/Pandora/Paradigm/Structure/Some/Splay.hs b/Pandora/Paradigm/Structure/Some/Splay.hs
--- a/Pandora/Paradigm/Structure/Some/Splay.hs
+++ b/Pandora/Paradigm/Structure/Some/Splay.hs
@@ -1,11 +1,10 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 {-# LANGUAGE AllowAmbiguousTypes #-}
-
 module Pandora.Paradigm.Structure.Some.Splay where
 
 import Pandora.Core.Functor (type (~>), type (:.), type (:=))
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (($), (#))
+import Pandora.Pattern.Category ((#))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((=<<)))
 import Pandora.Paradigm.Primary ()
@@ -15,9 +14,9 @@
 import Pandora.Paradigm.Primary.Functor.Tagged (type (:#))
 import Pandora.Paradigm.Primary.Functor.Wye (Wye (Left, Right))
 import Pandora.Paradigm.Primary.Transformer.Construction (Construction (Construct), deconstruct)
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, unite)
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (!))
 import Pandora.Paradigm.Inventory.Optics (over)
-import Pandora.Paradigm.Schemes (TU (TU), type (<:.>))
+import Pandora.Paradigm.Schemes (TT (TT), type (<::>))
 import Pandora.Paradigm.Structure.Ability.Morphable (Morphable (Morphing, morphing), Morph (Rotate, Into), premorph, rotate, into)
 import Pandora.Paradigm.Structure.Ability.Nonempty (Nonempty)
 import Pandora.Paradigm.Structure.Ability.Substructure (sub)
@@ -27,38 +26,38 @@
 
 instance Morphable (Rotate (Left Zig)) Binary where
 	type Morphing (Rotate (Left Zig)) Binary = Binary
-	morphing (premorph -> binary) = unite $ run . rotate @(Left Zig) =<< run binary
+	morphing (premorph -> binary) = TT ! run . rotate @(Left Zig) =<< run binary
 
 instance Morphable (Rotate (Right Zig)) Binary where
 	type Morphing (Rotate (Right Zig)) Binary = Binary
-	morphing (premorph -> binary) = unite $ run . rotate @(Right Zig) =<< run binary
+	morphing (premorph -> binary) = TT ! run . rotate @(Right Zig) =<< run binary
 
 instance Morphable (Rotate (Left (Zig Zig))) Binary where
 	type Morphing (Rotate (Left (Zig Zig))) Binary = Binary
-	morphing (premorph -> binary) = unite $ run . rotate @(Left (Zig Zig)) =<< run binary
+	morphing (premorph -> binary) = TT ! run . rotate @(Left (Zig Zig)) =<< run binary
 
 instance Morphable (Rotate (Right (Zig Zig))) Binary where
 	type Morphing (Rotate (Right (Zig Zig))) Binary = Binary
-	morphing (premorph -> binary) = unite $ run . rotate @(Right (Zig Zig)) =<< run binary
+	morphing (premorph -> binary) = TT ! run . rotate @(Right (Zig Zig)) =<< run binary
 
 instance Morphable (Rotate (Left (Zig Zag))) Binary where
 	type Morphing (Rotate (Left (Zig Zag))) Binary = Binary
-	morphing (premorph -> binary) = unite $ run . rotate @(Left (Zig Zag)) =<< run binary
+	morphing (premorph -> binary) = TT ! run . rotate @(Left (Zig Zag)) =<< run binary
 
 instance Morphable (Rotate (Right (Zig Zag))) Binary where
 	type Morphing (Rotate (Right (Zig Zag))) Binary = Binary
-	morphing (premorph -> binary) = unite $ run . rotate @(Right (Zig Zag)) =<< run binary
+	morphing (premorph -> binary) = TT ! run . rotate @(Right (Zig Zag)) =<< run binary
 
 -------------------------------------- Non-empty Splay tree ----------------------------------------
 
 instance Morphable (Rotate (Left Zig)) (Construction Wye) where
 	type Morphing (Rotate (Left Zig)) (Construction Wye) = Binary
-	morphing :: forall a . (:#) (Rotate (Left Zig)) <:.> Construction Wye := a -> Binary a
-	morphing (premorph -> Construct x xs) = TU $ Construct <-|- parent <-*- Just nodes where
+	morphing :: forall a . (:#) (Rotate (Left Zig)) <::> Construction Wye := a -> Binary a
+	morphing (premorph -> Construct x xs) = TT ! Construct <-|- parent <-*- Just nodes where
 
 		nodes :: Wye :. Nonempty Binary := a
 		nodes = into @Wye . twosome (branch @Left xs) . Just . Construct x
-			. into @Wye $ twosome (branch @Left =<< deconstruct <-|- branch @Right xs)
+			. into @Wye ! twosome (branch @Left =<< deconstruct <-|- branch @Right xs)
 				(branch @Right =<< deconstruct <-|- branch @Right xs)
 
 		parent :: Maybe a
@@ -66,32 +65,32 @@
 
 instance Morphable (Rotate (Right Zig)) (Construction Wye) where
 	type Morphing (Rotate (Right Zig)) (Construction Wye) = Binary
-	morphing :: forall a . (:#) (Rotate (Right Zig)) <:.> Construction Wye := a -> Binary a
-	morphing (premorph -> Construct x xs) = TU $ Construct <-|- parent <-*- Just nodes where
+	morphing :: forall a . (:#) (Rotate (Right Zig)) <::> Construction Wye := a -> Binary a
+	morphing (premorph -> Construct x xs) = TT ! Construct <-|- parent <-*- Just nodes where
 
 		nodes :: Wye :. Nonempty Binary := a
 		nodes = into @Wye . twosome (branch @Left =<< deconstruct <-|- branch @Left xs) . Just . Construct x
-			. into @Wye $ twosome (branch @Right =<< deconstruct <-|- branch @Left xs) # branch @Right xs
+			. into @Wye ! twosome (branch @Right =<< deconstruct <-|- branch @Left xs) # branch @Right xs
 
 		parent :: Maybe a
 		parent = extract <-|- branch @Left xs
 
--- TODO: Morphing ... = Conclussion Error <:.> Nonempty Binary
+-- TODO: Morphing ... = Conclussion Error <::> Nonempty Binary
 instance Morphable (Rotate (Left (Zig Zig))) (Construction Wye) where
 	type Morphing (Rotate (Left (Zig Zig))) (Construction Wye) = Binary
-	morphing (premorph -> tree) = TU $ run . rotate @(Left Zig) =<< run # rotate @(Left Zig) tree
+	morphing (premorph -> tree) = TT ! run . rotate @(Left Zig) =<< run # rotate @(Left Zig) tree
 
--- TODO: Morphing ... = Conclussion Error <:.> Nonempty Binary
+-- TODO: Morphing ... = Conclussion Error <::> Nonempty Binary
 instance Morphable (Rotate (Right (Zig Zig))) (Construction Wye) where
 	type Morphing (Rotate (Right (Zig Zig))) (Construction Wye) = Binary
-	morphing (premorph -> tree) = TU $ run . rotate @(Right Zig) =<< run # rotate @(Right Zig) tree
+	morphing (premorph -> tree) = TT ! run . rotate @(Right Zig) =<< run # rotate @(Right Zig) tree
 
--- TODO: Morphing ... = Conclussion Error <:.> Nonempty Binary
+-- TODO: Morphing ... = Conclussion Error <::> Nonempty Binary
 instance Morphable (Rotate (Left (Zig Zag))) (Construction Wye) where
 	type Morphing (Rotate (Left (Zig Zag))) (Construction Wye) = Binary
 	morphing = rotate @(Left Zig) . over (sub @Left) (run . rotate @(Right Zig) =<<) . premorph
 
--- TODO: Morphing ... = Conclussion Error <:.> Nonempty Binary
+-- TODO: Morphing ... = Conclussion Error <::> Nonempty Binary
 instance Morphable (Rotate (Right (Zig Zag))) (Construction Wye) where
 	type Morphing (Rotate (Right (Zig Zag))) (Construction Wye) = Binary
 	morphing = rotate @(Right Zig) . over (sub @Right) (run . rotate @(Left Zig) =<<) . premorph
diff --git a/Pandora/Paradigm/Structure/Some/Stream.hs b/Pandora/Paradigm/Structure/Some/Stream.hs
--- a/Pandora/Paradigm/Structure/Some/Stream.hs
+++ b/Pandora/Paradigm/Structure/Some/Stream.hs
@@ -4,7 +4,7 @@
 
 import Pandora.Core.Functor (type (:=), type (:=>))
 import Pandora.Pattern.Semigroupoid ((.))
-import Pandora.Pattern.Category (($), (#))
+import Pandora.Pattern.Category ((#))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<-|-)))
 import Pandora.Pattern.Functor.Extendable (Extendable ((<<=)))
 import Pandora.Paradigm.Primary.Algebraic.Product ((:*:) ((:*:)), twosome)
@@ -16,7 +16,7 @@
 import Pandora.Paradigm.Structure.Ability.Zipper (Zippable (Breadcrumbs))
 import Pandora.Paradigm.Schemes.T_U (T_U (T_U), type (<:.:>))
 import Pandora.Paradigm.Primary.Algebraic (point)
-import Pandora.Paradigm.Controlflow.Effect.Interpreted (run)
+import Pandora.Paradigm.Controlflow.Effect.Interpreted (run, (!))
 
 type Stream = Construction Identity
 
@@ -27,16 +27,16 @@
 	type Morphing (Rotate Left) (Identity <:.:> (Stream <:.:> Stream := (:*:)) := (:*:)) =
 		Identity <:.:> (Stream <:.:> Stream := (:*:)) := (:*:)
 	morphing (run . premorph -> Identity x :*: T_U (bs :*: fs)) = twosome # Identity (extract bs)
-		$ twosome # extract (deconstruct bs) # Construct x (point fs)
+		! twosome # extract (deconstruct bs) # Construct x (point fs)
 
 instance Morphable (Rotate Right) (Identity <:.:> (Stream <:.:> Stream := (:*:)) := (:*:)) where
 	type Morphing (Rotate Right) (Identity <:.:> (Stream <:.:> Stream := (:*:)) := (:*:)) = Identity <:.:> (Stream <:.:> Stream := (:*:)) := (:*:)
 	morphing (run . premorph -> Identity x :*: T_U (bs :*: fs)) = twosome # Identity (extract fs)
-		$ twosome # Construct x (point bs) # extract (deconstruct fs)
+		! twosome # Construct x (point bs) # extract (deconstruct fs)
 
 instance {-# OVERLAPS #-} Extendable (->) (Identity <:.:> (Stream <:.:> Stream := (:*:)) := (:*:)) where
-	f <<= z = let move rtt = extract . deconstruct $ point . rtt .-+ z
+	f <<= z = let move rtt = extract . deconstruct ! point . rtt .-+ z
 		in f <-|- T_U (Identity z :*: twosome # move (rotate @Left) # move (rotate @Right))
 
 repeat :: a :=> Stream
-repeat x = Construct x . Identity $ repeat x
+repeat x = Construct x . Identity ! repeat x
diff --git a/Pandora/Pattern.hs b/Pandora/Pattern.hs
--- a/Pandora/Pattern.hs
+++ b/Pandora/Pattern.hs
@@ -6,5 +6,6 @@
 import Pandora.Pattern.Functor as Exports
 import Pandora.Pattern.Morphism as Exports
 import Pandora.Pattern.Groupoid as Exports
+import Pandora.Pattern.Kernel as Exports
 import Pandora.Pattern.Category as Exports
 import Pandora.Pattern.Semigroupoid as Exports
diff --git a/Pandora/Pattern/Category.hs b/Pandora/Pattern/Category.hs
--- a/Pandora/Pattern/Category.hs
+++ b/Pandora/Pattern/Category.hs
@@ -3,7 +3,6 @@
 import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
 
 infixl 2 #
-infixr 0 $
 
 {- |
 > When providing a new instance, you should ensure it satisfies:
@@ -13,9 +12,6 @@
 
 class Semigroupoid m => Category m where
 	identity :: m a a
-
-	($) :: m (m a b) (m a b)
-	($) = identity . identity
 
 	(#) :: m (m a b) (m a b)
 	(#) = identity . identity
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
@@ -2,7 +2,7 @@
 
 import Pandora.Pattern.Category (Category)
 
-infixl 4 >-|-, >$<
+infixl 4 >-|-, >!<
 
 {- |
 > When providing a new instance, you should ensure it satisfies:
@@ -13,5 +13,5 @@
 class (Category source, Category target) => Contravariant source target t where
 	(>-|-) :: source a b -> target (t b) (t a)
 
-(>$<) :: Contravariant source target t => source a b -> target (t b) (t a)
-(>$<) = (>-|-)
+(>!<) :: Contravariant source target t => source a b -> target (t b) (t a)
+(>!<) = (>-|-)
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
@@ -5,9 +5,9 @@
 import Pandora.Pattern.Betwixt (Betwixt)
 import Pandora.Pattern.Semigroupoid (Semigroupoid)
 
-infixl 4 <-|-, <$>
-infixl 3 <-|-|-, <$$>
-infixl 4 <-|-|-|-, <$$$>
+infixl 4 <-|-, <!>
+infixl 3 <-|-|-, <!!>
+infixl 2 <-|-|-|-, <!!!>
 
 {- |
 > When providing a new instance, you should ensure it satisfies:
@@ -18,23 +18,20 @@
 class (Semigroupoid source, Semigroupoid target) => Covariant source target t where
 	(<-|-) :: source a b -> target (t a) (t b)
 
-(<-|-|-) :: forall source target t u a b
-	. (Covariant source (Betwixt source target) u, Covariant (Betwixt source target) target t)
-	=> source a b -> target (t (u a)) (t (u b))
-(<-|-|-) s = ((<-|-) ((<-|-) @source @(Betwixt source target) @u s))
+	(<-|-|-) :: (Covariant source (Betwixt source target) u, Covariant (Betwixt source target) target t)
+		=> source a b -> target (t (u a)) (t (u b))
+	(<-|-|-) s = ((<-|-) ((<-|-) @source @(Betwixt source target) @_ s))
 
-(<-|-|-|-) :: forall source target t u v a b
-	. (Covariant source (Betwixt source (Betwixt source target)) v, Covariant (Betwixt source (Betwixt source target)) (Betwixt (Betwixt source target) target) u, Covariant (Betwixt (Betwixt source target) target) target t)
-	=> source a b -> target (t (u (v a))) (t (u (v b)))
-(<-|-|-|-) s = ((<-|-) @(Betwixt (Betwixt source target) target) @target ((<-|-) @(Betwixt source (Betwixt source target)) @(Betwixt (Betwixt source target) target) @u ((<-|-) @source @(Betwixt source (Betwixt source target)) @v s)))
+	(<-|-|-|-) :: (Covariant source (Betwixt source (Betwixt source target)) v, Covariant (Betwixt source (Betwixt source target)) (Betwixt (Betwixt source target) target) u, Covariant (Betwixt (Betwixt source target) target) target t)
+		=> source a b -> target (t (u (v a))) (t (u (v b)))
+	(<-|-|-|-) s = ((<-|-) @(Betwixt (Betwixt source target) target) @target ((<-|-) @(Betwixt source (Betwixt source target)) @(Betwixt (Betwixt source target) target) @_ ((<-|-) @source @(Betwixt source (Betwixt source target)) @_ s)))
 
-(<$>) :: Covariant source target t => source a b -> target (t a) (t b)
-(<$>) = (<-|-)
+(<!>) :: Covariant source target t => source a b -> target (t a) (t b)
+(<!>) = (<-|-)
 
-(<$$>) :: (Covariant source (Betwixt source target) u, Covariant (Betwixt source target) target t) => source a b -> target (t (u a)) (t (u b))
-(<$$>) = (<-|-|-)
+(<!!>) :: (Covariant source target t, Covariant source (Betwixt source target) u, Covariant (Betwixt source target) target t) => source a b -> target (t (u a)) (t (u b))
+(<!!>) = (<-|-|-)
 
-(<$$$>) :: forall source target t u v a b
-	. (Covariant source (Betwixt source (Betwixt source target)) v, Covariant (Betwixt source (Betwixt source target)) (Betwixt (Betwixt source target) target) u, Covariant (Betwixt (Betwixt source target) target) target t)
+(<!!!>) :: (Covariant source target t, Covariant source (Betwixt source (Betwixt source target)) v, Covariant (Betwixt source (Betwixt source target)) (Betwixt (Betwixt source target) target) u, Covariant (Betwixt (Betwixt source target) target) target t)
 	=> source a b -> target (t (u (v a))) (t (u (v b)))
-(<$$$>) s = (<-|-|-|-) s
+(<!!!>) s = (<-|-|-|-) s
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
@@ -6,11 +6,11 @@
 > Interpreted of morphisms: invmap g j . invmap f h = invmap (g . f) (h . j)
 -}
 
-infixl 4 <$<
+infixl 4 <!<
 
 class Invariant (t :: * -> *) where
-	{-# MINIMAL (<$<) #-}
-	(<$<) :: (a -> b) -> (b -> a) -> t a -> t b
-	-- | Prefix version of '<$<'
+	{-# MINIMAL (<!<) #-}
+	(<!<) :: (a -> b) -> (b -> a) -> t a -> t b
+	-- | Prefix version of '<!<'
 	invmap :: (a -> b) -> (b -> a) -> t a -> t b
-	invmap f g x = (f <$< g) x
+	invmap f g x = (f <!< g) x
diff --git a/Pandora/Pattern/Functor/Traversable.hs b/Pandora/Pattern/Functor/Traversable.hs
--- a/Pandora/Pattern/Functor/Traversable.hs
+++ b/Pandora/Pattern/Functor/Traversable.hs
@@ -13,15 +13,15 @@
 > * Numeratority of traversing: g . (f <<--) ≡ (g . f <<--)
 > * Numeratority of sequencing: f . (identity <<--)= (identity <<--) . (f <-|-)
 > * Preserving point: p (point x) ≡ point x
-> * Preserving apply: f (x <-*- y) ≡ f x <-*- f y
+> * Preserving apply: f (x <.-*- y) ≡ f x <.-*- f y
 -}
 
-infixl 5 <<-, -<<-<<-
+infixl 5 <<-, <<-<<-
 
 class Covariant source target t => Traversable source target t where
 	(<<-) :: (Covariant source target u, Monoidal (Straight source) (Straight target) (:*:) (:*:) u) => source a (u b) -> target (t a) (u (t b))
 
-(-<<-<<-) :: forall t u v category a b .
+(<<-<<-) :: forall t u v category a b .
 	(Traversable category category t, Covariant category category u, Monoidal (Straight category) (Straight category) (:*:) (:*:) u, Traversable category category v)
 	=> category a (u b) -> category (v (t a)) (u (v (t b)))
-(-<<-<<-) f = ((<<-) ((<<-) @category @category @t f))
+(<<-<<-) f = ((<<-) ((<<-) @category @category @t f))
diff --git a/Pandora/Pattern/Kernel.hs b/Pandora/Pattern/Kernel.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Kernel.hs
@@ -0,0 +1,13 @@
+module Pandora.Pattern.Kernel (Kernel (..)) where
+
+import Pandora.Pattern.Semigroupoid (Semigroupoid ((.)))
+import Pandora.Pattern.Category (Category (identity))
+
+{- |
+> When providing a new instance, you should ensure it satisfies:
+> * Left zero morphism: constant . f ≡ constant . g
+> * Most general morphism: f . k = constant
+-}
+
+class Category m => Kernel m where
+	constant :: m a (m i a)
diff --git a/pandora.cabal b/pandora.cabal
--- a/pandora.cabal
+++ b/pandora.cabal
@@ -1,5 +1,5 @@
 name:                pandora
-version:             0.4.8
+version:             0.4.9
 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
@@ -71,6 +71,7 @@
     Pandora.Paradigm.Primary.Transformer.Yoneda
     -- Schemes of functor compositions
     Pandora.Paradigm.Schemes
+    Pandora.Paradigm.Schemes.TT
     Pandora.Paradigm.Schemes.TU
     Pandora.Paradigm.Schemes.TUT
     Pandora.Paradigm.Schemes.TUVW
@@ -96,7 +97,7 @@
     -- Tools for datastructures
     Pandora.Paradigm.Inventory
     Pandora.Paradigm.Inventory.Accumulator
-    Pandora.Paradigm.Inventory.Environment
+    Pandora.Paradigm.Inventory.Provision
     Pandora.Paradigm.Inventory.Equipment
     Pandora.Paradigm.Inventory.Imprint
     Pandora.Paradigm.Inventory.Optics
@@ -134,10 +135,11 @@
 
     Pandora.Pattern
     Pandora.Pattern.Betwixt
-	-- Algebra typeclasses
+    -- Algebra typeclasses
     Pandora.Pattern.Semigroupoid
     Pandora.Pattern.Category
     Pandora.Pattern.Groupoid
+    Pandora.Pattern.Kernel
     Pandora.Pattern.Morphism
     -- Functor typeclassess
     Pandora.Pattern.Functor