diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -169,3 +169,19 @@
 * Define `Equipment` datatype to use `Comonad` `Product` transformer
 * Define adaptable `retrieve` method of `Equipment`
 * Extract `Imprint` from `Environment` module
+
+# 0.2.5
+* Define `Semiring` typeclass
+* Define `Stream` module and type
+* Move `Liftable` and `Lowerable` modules from `Functor` to `Transformer` submodule
+* Define `Hoistable` module and typeclass
+* Rename `TUV` joint schema to `TUT`
+* Modify `UTU` joint schema internals
+* Remove `&&` and `||` `Boolean` operators (use `*` and `+` instead)
+* Define precedence for `*` and `+`
+* Change superclass of `Group` class - `Quasiring` instead of `Monoid`
+* Rename `Jet`'s constructor to `Jet` (previously - `:-`)
+* Rename `Group`'s method from `inverse` to `invert`
+* Remove `not` method of `Boolean`, (use `invert` instead)
+* Remove `Injective` and `Has` type families
+* Change superclasseses for `Liftable` and `Lowerable` classes to provide a law
diff --git a/Pandora/Paradigm/Basis.hs b/Pandora/Paradigm/Basis.hs
--- a/Pandora/Paradigm/Basis.hs
+++ b/Pandora/Paradigm/Basis.hs
@@ -13,6 +13,7 @@
 import Pandora.Paradigm.Basis.Conclusion as Exports
 import Pandora.Paradigm.Basis.Maybe as Exports
 import Pandora.Paradigm.Basis.Endo as Exports
+import Pandora.Paradigm.Basis.Kan as Exports
 import Pandora.Paradigm.Basis.Jet as Exports
 import Pandora.Paradigm.Basis.Jack as Exports
 import Pandora.Paradigm.Basis.Proxy as Exports
diff --git a/Pandora/Paradigm/Basis/Constant.hs b/Pandora/Paradigm/Basis/Constant.hs
--- a/Pandora/Paradigm/Basis/Constant.hs
+++ b/Pandora/Paradigm/Basis/Constant.hs
@@ -12,9 +12,10 @@
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
 import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))
+import Pandora.Pattern.Object.Quasiring (Quasiring (one))
 import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))
 import Pandora.Pattern.Object.Lattice (Lattice)
-import Pandora.Pattern.Object.Group (Group (inverse))
+import Pandora.Pattern.Object.Group (Group (invert))
 
 newtype Constant a b = Constant a
 
@@ -48,6 +49,9 @@
 instance Ringoid a => Ringoid (Constant a b) where
 	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
 
@@ -57,4 +61,4 @@
 instance Lattice a => Lattice (Constant a b) where
 
 instance Group a => Group (Constant a b) where
-	inverse (Constant x) = Constant $ inverse x
+	invert (Constant x) = Constant $ invert x
diff --git a/Pandora/Paradigm/Basis/Continuation.hs b/Pandora/Paradigm/Basis/Continuation.hs
--- a/Pandora/Paradigm/Basis/Continuation.hs
+++ b/Pandora/Paradigm/Basis/Continuation.hs
@@ -8,7 +8,7 @@
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
 import Pandora.Pattern.Functor.Monad (Monad)
-import Pandora.Pattern.Functor.Liftable (Liftable (lift))
+import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Functor.Divariant (($))
 
 newtype Continuation r t a = Continuation { continue :: (->) ::|:. a :. t := r }
diff --git a/Pandora/Paradigm/Basis/Free.hs b/Pandora/Paradigm/Basis/Free.hs
--- a/Pandora/Paradigm/Basis/Free.hs
+++ b/Pandora/Paradigm/Basis/Free.hs
@@ -8,7 +8,7 @@
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
-import Pandora.Pattern.Functor.Liftable (Liftable (lift))
+import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Functor.Divariant (($))
 
 data Free t a = Pure a | Impure (t :. Free t := a)
diff --git a/Pandora/Paradigm/Basis/Identity.hs b/Pandora/Paradigm/Basis/Identity.hs
--- a/Pandora/Paradigm/Basis/Identity.hs
+++ b/Pandora/Paradigm/Basis/Identity.hs
@@ -18,9 +18,10 @@
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
 import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))
+import Pandora.Pattern.Object.Quasiring (Quasiring (one))
 import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))
 import Pandora.Pattern.Object.Lattice (Lattice)
-import Pandora.Pattern.Object.Group (Group (inverse))
+import Pandora.Pattern.Object.Group (Group (invert))
 
 newtype Identity a = Identity a
 
@@ -71,6 +72,9 @@
 instance Ringoid a => Ringoid (Identity a) where
 	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
 
@@ -80,4 +84,4 @@
 instance Lattice a => Lattice (Identity a) where
 
 instance Group a => Group (Identity a) where
-	inverse (Identity x) = Identity $ inverse x
+	invert (Identity x) = Identity $ invert x
diff --git a/Pandora/Paradigm/Basis/Jack.hs b/Pandora/Paradigm/Basis/Jack.hs
--- a/Pandora/Paradigm/Basis/Jack.hs
+++ b/Pandora/Paradigm/Basis/Jack.hs
@@ -9,7 +9,7 @@
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>), traverse))
 import Pandora.Pattern.Functor.Distributive (Distributive ((>>-), distribute))
-import Pandora.Pattern.Functor.Liftable (Liftable (lift))
+import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Functor.Divariant (($))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)), Boolean (False))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)), Ordering (Less, Greater))
diff --git a/Pandora/Paradigm/Basis/Jet.hs b/Pandora/Paradigm/Basis/Jet.hs
--- a/Pandora/Paradigm/Basis/Jet.hs
+++ b/Pandora/Paradigm/Basis/Jet.hs
@@ -7,18 +7,16 @@
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))
 
-infixr 6 :-
-
-data Jet t a = a :- Jet t (t a)
+data Jet t a = Jet a (Jet t (t a))
 
 instance Covariant t => Covariant (Jet t) where
-	f <$> a :- as = f a :- f <$$> as
+	f <$> Jet a as = Jet (f a) (f <$$> as)
 
 instance Traversable t => Traversable (Jet t) where
-	a :- as ->> f = (:-) <$> f a <*> as ->>> f
+	Jet a as ->> f = Jet <$> f a <*> as ->>> f
 
 instance (forall u . Avoidable u) => Pointable (Jet t) where
-	point x = x :- empty
+	point x = Jet x empty
 
 instance Covariant t => Extractable (Jet t) where
-	extract (x :- _) = x
+	extract (Jet x _) = x
diff --git a/Pandora/Paradigm/Basis/Kan.hs b/Pandora/Paradigm/Basis/Kan.hs
--- a/Pandora/Paradigm/Basis/Kan.hs
+++ b/Pandora/Paradigm/Basis/Kan.hs
@@ -4,15 +4,22 @@
 import Pandora.Pattern.Functor.Contravariant (Contravariant ((>$<)))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Divariant (($))
+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
 
-newtype Lan (t :: * -> *) (u :: * -> *) (b :: *) (a :: *) =
-	Lan { lan :: (t b -> a) -> u b }
+newtype Lan t u b a = Lan ((t b -> a) -> u b)
 
 instance Contravariant (Lan t u b) where
 	f >$< Lan x = Lan $ x . (f .)
 
-newtype Ran (t :: * -> *) (u :: * -> *) (b :: *) (a :: *) =
-	Ran { ran :: (a -> t b) -> u b }
+instance Interpreted (Lan t u b) where
+	type Primary (Lan t u b) a = (t b -> a) -> u b
+	run (Lan x) = x
 
+newtype Ran t u b a = Ran ((a -> t b) -> u b)
+
 instance Covariant (Ran t u b) where
 	f <$> Ran x = Ran $ x . (. f)
+
+instance Interpreted (Ran t u b) where
+	type Primary (Ran t u b) a = (a -> t b) -> u b
+	run (Ran x) = x
diff --git a/Pandora/Paradigm/Basis/Product.hs b/Pandora/Paradigm/Basis/Product.hs
--- a/Pandora/Paradigm/Basis/Product.hs
+++ b/Pandora/Paradigm/Basis/Product.hs
@@ -1,4 +1,4 @@
-module Pandora.Paradigm.Basis.Product (Product (..), type (:*:), Has, Injective
+module Pandora.Paradigm.Basis.Product (Product (..), type (:*:)
 	, delta, swap, attached, curry, uncurry) where
 
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
@@ -9,13 +9,14 @@
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
 import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))
 import Pandora.Pattern.Functor.Divariant (($))
-import Pandora.Pattern.Object.Setoid (Setoid ((==)), (&&))
+import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
 import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))
+import Pandora.Pattern.Object.Quasiring (Quasiring (one))
 import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))
 import Pandora.Pattern.Object.Lattice (Lattice)
-import Pandora.Pattern.Object.Group (Group (inverse))
+import Pandora.Pattern.Object.Group (Group (invert))
 
 infixr 1 :*:
 
@@ -45,7 +46,7 @@
 	f <-> g = \(x :*: y) -> f x :*: g y
 
 instance (Setoid a, Setoid b) => Setoid (Product a b) where
-	(x :*: y) == (x' :*: y') = x == x' && y == y'
+	(x :*: y) == (x' :*: y') = (x == x') * (y == y')
 
 instance (Semigroup a, Semigroup b) => Semigroup (Product a b) where
 	(x :*: y) + (x' :*: y') = x + x' :*: y + y'
@@ -56,6 +57,9 @@
 instance (Ringoid a, Ringoid b) => Ringoid (Product a b) where
 	(x :*: y) * (x' :*: y') = x * x' :*: y * y'
 
+instance (Quasiring a, Quasiring b) => Quasiring (Product a b) where
+	one = one :*: one
+
 instance (Infimum a, Infimum b) => Infimum (Product a b) where
 	(x :*: y) /\ (x' :*: y') = x /\ x' :*: y /\ y'
 
@@ -65,7 +69,7 @@
 instance (Lattice a, Lattice b) => Lattice (Product a b) where
 
 instance (Group a, Group b) => Group (Product a b) where
-	inverse (x :*: y) = inverse x :*: inverse y
+	invert (x :*: y) = invert x :*: invert y
 
 delta :: a -> a :*: a
 delta x = x :*: x
@@ -81,16 +85,3 @@
 
 uncurry :: (a -> b -> c) -> (a :*: b -> c)
 uncurry f (x :*: y) = f x y
-
--- Constraint on the content of some type
-type family Has x xs where
-	Has x (x :*: xs) = ()
-	Has x (y :*: xs) = Has x xs
-	Has x x = ()
-
--- All elements of the left product are in the right product
-type family Injective xs ys where
-	Injective (x :*: xs) ys = (Has x ys, Injective xs ys)
-	Injective x (x :*: ys) = ()
-	Injective x (y :*: ys) = Has x ys
-	Injective x x = ()
diff --git a/Pandora/Paradigm/Basis/Tagged.hs b/Pandora/Paradigm/Basis/Tagged.hs
--- a/Pandora/Paradigm/Basis/Tagged.hs
+++ b/Pandora/Paradigm/Basis/Tagged.hs
@@ -1,5 +1,6 @@
 module Pandora.Paradigm.Basis.Tagged (Tagged (..), retag, tagself, type (:#)) where
 
+import Pandora.Core.Functor (type (|->), type (~>))
 import Pandora.Pattern.Category ((.))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
@@ -18,9 +19,10 @@
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
 import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))
+import Pandora.Pattern.Object.Quasiring (Quasiring (one))
 import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))
 import Pandora.Pattern.Object.Lattice (Lattice)
-import Pandora.Pattern.Object.Group (Group (inverse))
+import Pandora.Pattern.Object.Group (Group (invert))
 
 newtype Tagged tag a = Tag a
 
@@ -73,6 +75,9 @@
 instance Ringoid a => Ringoid (Tagged tag a) where
 	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
 
@@ -82,10 +87,10 @@
 instance Lattice a => Lattice (Tagged tag a) where
 
 instance Group a => Group (Tagged tag a) where
-	inverse (Tag x) = Tag $ inverse x
+	invert (Tag x) = Tag $ invert x
 
-retag :: Tagged old a -> Tagged new a
+retag :: Tagged old ~> Tagged new
 retag (Tag x) = Tag x
 
-tagself :: a -> Tagged a a
+tagself :: a |-> Tagged a
 tagself = Tag
diff --git a/Pandora/Paradigm/Basis/Twister.hs b/Pandora/Paradigm/Basis/Twister.hs
--- a/Pandora/Paradigm/Basis/Twister.hs
+++ b/Pandora/Paradigm/Basis/Twister.hs
@@ -12,10 +12,11 @@
 import Pandora.Pattern.Functor.Extendable (Extendable ((=>>), extend))
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Functor.Comonad (Comonad)
-import Pandora.Pattern.Functor.Lowerable (Lowerable (lower))
+import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Pattern.Functor.Divariant (($))
-import Pandora.Pattern.Object.Setoid (Setoid ((==)), (&&))
+import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
+import Pandora.Pattern.Object.Ringoid ((*))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
 
 data Twister t a = Twister a (t :. Twister t := a)
@@ -49,7 +50,7 @@
 	lower (Twister _ xs) = extract <$> xs
 
 instance (Setoid a, forall b . Setoid b => Setoid (t b)) => Setoid (Twister t a) where
-	Twister x xs == Twister y ys = x == y && xs == ys
+	Twister x xs == Twister y ys = (x == y) * (xs == ys)
 
 instance (Semigroup a, forall b . Semigroup b => Semigroup (t b)) => Semigroup (Twister t a) where
 	Twister x xs + Twister y ys = Twister (x + y) $ xs + ys
diff --git a/Pandora/Paradigm/Basis/Yoneda.hs b/Pandora/Paradigm/Basis/Yoneda.hs
--- a/Pandora/Paradigm/Basis/Yoneda.hs
+++ b/Pandora/Paradigm/Basis/Yoneda.hs
@@ -9,7 +9,7 @@
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
-import Pandora.Pattern.Functor.Liftable (Liftable (lift))
+import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
 import Pandora.Pattern.Functor.Divariant (($))
 
 newtype Yoneda t a = Yoneda
diff --git a/Pandora/Paradigm/Controlflow/Joint/Schemes.hs b/Pandora/Paradigm/Controlflow/Joint/Schemes.hs
--- a/Pandora/Paradigm/Controlflow/Joint/Schemes.hs
+++ b/Pandora/Paradigm/Controlflow/Joint/Schemes.hs
@@ -3,5 +3,5 @@
 import Pandora.Paradigm.Controlflow.Joint.Schemes.UTU as Exports
 import Pandora.Paradigm.Controlflow.Joint.Schemes.UT as Exports
 import Pandora.Paradigm.Controlflow.Joint.Schemes.TUVW as Exports
-import Pandora.Paradigm.Controlflow.Joint.Schemes.TUV as Exports
+import Pandora.Paradigm.Controlflow.Joint.Schemes.TUT as Exports
 import Pandora.Paradigm.Controlflow.Joint.Schemes.TU as Exports
diff --git a/Pandora/Paradigm/Controlflow/Joint/Schemes/TU.hs b/Pandora/Paradigm/Controlflow/Joint/Schemes/TU.hs
--- a/Pandora/Paradigm/Controlflow/Joint/Schemes/TU.hs
+++ b/Pandora/Paradigm/Controlflow/Joint/Schemes/TU.hs
@@ -1,6 +1,14 @@
 module Pandora.Paradigm.Controlflow.Joint.Schemes.TU (TU (..)) where
 
 import Pandora.Core.Functor (type (:.), type (:=))
+import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Extractable (Extractable (extract))
+import Pandora.Pattern.Functor.Divariant (($))
+import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
+import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
+import Pandora.Pattern.Transformer.Hoistable (Hoistable (hoist))
 import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
 
 newtype TU ct cu t u a = TU (t :. u := a)
@@ -8,3 +16,12 @@
 instance Interpreted (TU ct cu t u) where
 	type Primary (TU ct cu t u) a = t :. u := a
 	run (TU x) = x
+
+instance Pointable t => Liftable (TU Covariant Covariant t) where
+	lift = TU . point
+
+instance Extractable t => Lowerable (TU Covariant Covariant t) where
+	lower (TU x) = extract x
+
+instance Covariant t => Hoistable (TU Covariant Covariant t) where
+	hoist f (TU x) = TU $ f <$> x
diff --git a/Pandora/Paradigm/Controlflow/Joint/Schemes/TUT.hs b/Pandora/Paradigm/Controlflow/Joint/Schemes/TUT.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Controlflow/Joint/Schemes/TUT.hs
@@ -0,0 +1,10 @@
+module Pandora.Paradigm.Controlflow.Joint.Schemes.TUT (TUT (..)) where
+
+import Pandora.Core.Functor (type (:.), type (:=))
+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
+
+newtype TUT ct cu cv t u t' a = TUT (t :. u :. t' := a)
+
+instance Interpreted (TUT ct cu cv t u t') where
+	type Primary (TUT ct cu cv t u t') a = t :. u :. t' := a
+	run (TUT x) = x
diff --git a/Pandora/Paradigm/Controlflow/Joint/Schemes/TUV.hs b/Pandora/Paradigm/Controlflow/Joint/Schemes/TUV.hs
deleted file mode 100644
--- a/Pandora/Paradigm/Controlflow/Joint/Schemes/TUV.hs
+++ /dev/null
@@ -1,10 +0,0 @@
-module Pandora.Paradigm.Controlflow.Joint.Schemes.TUV (TUV (..)) where
-
-import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
-
-newtype TUV ct cu cv t u v a = TUV (t :. u :. v := a)
-
-instance Interpreted (TUV ct cu cv t u v) where
-	type Primary (TUV ct cu cv t u v) a = t :. u :. v := a
-	run (TUV x) = x
diff --git a/Pandora/Paradigm/Controlflow/Joint/Schemes/UT.hs b/Pandora/Paradigm/Controlflow/Joint/Schemes/UT.hs
--- a/Pandora/Paradigm/Controlflow/Joint/Schemes/UT.hs
+++ b/Pandora/Paradigm/Controlflow/Joint/Schemes/UT.hs
@@ -1,6 +1,12 @@
 module Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (..)) where
 
 import Pandora.Core.Functor (type (:.), type (:=))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Pointable (Pointable (point))
+import Pandora.Pattern.Functor.Extractable (Extractable (extract))
+import Pandora.Pattern.Functor.Divariant (($))
+import Pandora.Pattern.Transformer.Liftable (Liftable (lift))
+import Pandora.Pattern.Transformer.Lowerable (Lowerable (lower))
 import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
 
 newtype UT ct cu t u a = UT (u :. t := a)
@@ -8,3 +14,9 @@
 instance Interpreted (UT ct cu t u) where
 	type Primary (UT ct cu t u) a = u :. t := a
 	run (UT x) = x
+
+instance Pointable t => Liftable (UT Covariant Covariant t) where
+	lift x = UT $ point <$> x
+
+instance Extractable t => Lowerable (UT Covariant Covariant t) where
+	lower (UT x) = extract <$> x
diff --git a/Pandora/Paradigm/Controlflow/Joint/Schemes/UTU.hs b/Pandora/Paradigm/Controlflow/Joint/Schemes/UTU.hs
--- a/Pandora/Paradigm/Controlflow/Joint/Schemes/UTU.hs
+++ b/Pandora/Paradigm/Controlflow/Joint/Schemes/UTU.hs
@@ -3,8 +3,8 @@
 import Pandora.Core.Functor (type (:.), type (:=))
 import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
 
-newtype UTU ct cu t u a = UTU (u :. t u := a)
+newtype UTU ct cu t u u' a = UTU (u :. t :. u' := a)
 
-instance Interpreted (UTU ct cu t u) where
-	type Primary (UTU ct cu t u) a = u :. t u := a
+instance Interpreted (UTU ct cu t u u') where
+	type Primary (UTU ct cu t u u') a = u :. t :. u' := a
 	run (UTU x) = x
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
@@ -4,6 +4,7 @@
 
 import Pandora.Paradigm.Basis.Product (Product ((:*:)), type (:*:), attached)
 import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))
+import Pandora.Paradigm.Controlflow.Joint.Transformer.Comonadic (Comonadic (flick, bring), (:<) (TC))
 import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
 import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)
 import Pandora.Paradigm.Controlflow.Joint.Schemes.TU (TU (TU))
@@ -25,11 +26,15 @@
 instance Extendable (Equipment e) where
 	Equipment (e :*: x) =>> f = Equipment . (:*:) e . f . Equipment $ e :*: x
 
-type instance Schematic Comonad (Equipment e) u = TU Covariant Covariant ((:*:) e) u
-
 instance Interpreted (Equipment e) where
 	type Primary (Equipment e) a = e :*: a
 	run (Equipment x) = x
+
+type instance Schematic Comonad (Equipment e) u = TU Covariant Covariant ((:*:) e) u
+
+instance Comonadic (Equipment e) where
+	flick (TC (TU x)) = extract x
+	bring (TC (TU x)) = Equipment $ extract <$> x
 
 type Equipped e t = Adaptable t (Equipment e)
 
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
@@ -20,7 +20,7 @@
 import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
 import Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))
 import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)
-import Pandora.Paradigm.Controlflow.Joint.Schemes.TUV (TUV (TUV))
+import Pandora.Paradigm.Controlflow.Joint.Schemes.TUT (TUT (TUT))
 import Pandora.Paradigm.Basis.Predicate (Predicate (predicate))
 import Pandora.Paradigm.Basis.Product (Product ((:*:)), type (:*:), attached, delta, uncurry)
 
@@ -55,27 +55,27 @@
 	run (State x) = x
 
 type instance Schematic Monad (State s) u =
-	TUV Covariant Covariant Covariant ((->) s) u ((:*:) s)
+	TUT Covariant Covariant Covariant ((->) s) u ((:*:) s)
 
 instance Monadic (State s) where
-	lay x = TM . TUV $ \s -> (s :*:) <$> x
-	wrap x = TM . TUV $ point <$> run x
+	lay x = TM . TUT $ \s -> (s :*:) <$> x
+	wrap x = TM . TUT $ point <$> run x
 
 type Stateful s = Adaptable (State s)
 
-instance Covariant u => Covariant (TUV Covariant Covariant Covariant ((->) s) u ((:*:) s)) where
-	f <$> TUV x = TUV $ \old -> f <$$> x old
+instance Covariant u => Covariant (TUT Covariant Covariant Covariant ((->) s) u ((:*:) s)) where
+	f <$> TUT x = TUT $ \old -> f <$$> x old
 
-instance Bindable u => Applicative (TUV Covariant Covariant Covariant ((->) s) u ((:*:) s)) where
-	TUV f <*> TUV x = TUV $ \old -> f old >>= \(new :*: g) -> g <$$> x new
+instance Bindable u => Applicative (TUT Covariant Covariant Covariant ((->) s) u ((:*:) s)) where
+	TUT f <*> TUT x = TUT $ \old -> f old >>= \(new :*: g) -> g <$$> x new
 
-instance Pointable u => Pointable (TUV Covariant Covariant Covariant ((->) s) u ((:*:) s)) where
-	point x = TUV $ \s -> point $ s :*: x
+instance Pointable u => Pointable (TUT Covariant Covariant Covariant ((->) s) u ((:*:) s)) where
+	point x = TUT $ \s -> point $ s :*: x
 
-instance Bindable u => Bindable (TUV Covariant Covariant Covariant ((->) s) u ((:*:) s)) where
-	TUV x >>= f = TUV $ \old -> x old >>= \(new :*: y) -> ($ new) . run . f $ y
+instance Bindable u => Bindable (TUT Covariant Covariant Covariant ((->) s) u ((:*:) s)) where
+	TUT x >>= f = TUT $ \old -> x old >>= \(new :*: y) -> ($ new) . run . f $ y
 
-instance Monad u => Monad (TUV Covariant Covariant Covariant ((->) s) u ((:*:) s)) where
+instance Monad u => Monad (TUT Covariant Covariant Covariant ((->) s) u ((:*:) s)) where
 
 current :: Stateful s t => t s
 current = adapt $ State delta
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
@@ -14,7 +14,7 @@
 import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))
 import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
 import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)
-import Pandora.Paradigm.Controlflow.Joint.Schemes.TUV (TUV (TUV))
+import Pandora.Paradigm.Controlflow.Joint.Schemes.TUT (TUT (TUT))
 import Pandora.Paradigm.Controlflow.Joint.Transformer.Comonadic (Comonadic (flick, bring), (:<) (TC))
 
 newtype Store p a = Store ((:*:) p :. (->) p := a)
@@ -36,22 +36,22 @@
 	run (Store x) = x
 
 type instance Schematic Comonad (Store p) u =
-	TUV Covariant Covariant Covariant ((:*:) p) u ((->) p)
+	TUT Covariant Covariant Covariant ((:*:) p) u ((->) p)
 
 instance Comonadic (Store p) where
-	flick (TC (TUV (p :*: f))) = ($ p) <$> f
-	bring (TC (TUV (p :*: f))) = Store $ p :*: extract f
+	flick (TC (TUT (p :*: f))) = ($ p) <$> f
+	bring (TC (TUT (p :*: f))) = Store $ p :*: extract f
 
 type Storable s x = Adaptable x (Store s)
 
-instance Covariant u => Covariant (TUV Covariant Covariant Covariant ((:*:) p) u ((->) p)) where
-	f <$> TUV (p :*: x) = TUV . (:*:) p $ f <$$> x
+instance Covariant u => Covariant (TUT Covariant Covariant Covariant ((:*:) p) u ((->) p)) where
+	f <$> TUT (p :*: x) = TUT . (:*:) p $ f <$$> x
 
-instance Extractable u => Extractable (TUV Covariant Covariant Covariant ((:*:) p) u ((->) p)) where
-	extract (TUV (p :*: x)) = extract x p
+instance Extractable u => Extractable (TUT Covariant Covariant Covariant ((:*:) p) u ((->) p)) where
+	extract (TUT (p :*: x)) = extract x p
 
-instance Extendable u => Extendable (TUV Covariant Covariant Covariant ((:*:) p) u ((->) p)) where
-	TUV (old :*: x) =>> f = TUV . (:*:) old $ x =>> (\x' new -> f . TUV . (:*:) new $ x')
+instance Extendable u => Extendable (TUT Covariant Covariant Covariant ((:*:) p) u ((->) p)) where
+	TUT (old :*: x) =>> f = TUT . (:*:) old $ x =>> (\x' new -> f . TUT . (:*:) new $ x')
 
 position :: Storable s t => t a -> s
 position = attached . run @(Store _) . adapt
diff --git a/Pandora/Paradigm/Structure/Specific.hs b/Pandora/Paradigm/Structure/Specific.hs
--- a/Pandora/Paradigm/Structure/Specific.hs
+++ b/Pandora/Paradigm/Structure/Specific.hs
@@ -1,5 +1,6 @@
 module Pandora.Paradigm.Structure.Specific (module Exports) where
 
-import Pandora.Paradigm.Structure.Specific.Binary as Exports
-import Pandora.Paradigm.Structure.Specific.Graph as Exports
+import Pandora.Paradigm.Structure.Specific.Stream as Exports
 import Pandora.Paradigm.Structure.Specific.Stack as Exports
+import Pandora.Paradigm.Structure.Specific.Graph as Exports
+import Pandora.Paradigm.Structure.Specific.Binary as Exports
diff --git a/Pandora/Paradigm/Structure/Specific/Stream.hs b/Pandora/Paradigm/Structure/Specific/Stream.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Structure/Specific/Stream.hs
@@ -0,0 +1,6 @@
+module Pandora.Paradigm.Structure.Specific.Stream (Stream) where
+
+import Pandora.Paradigm.Basis.Identity (Identity)
+import Pandora.Paradigm.Basis.Twister (Twister)
+
+type Stream = Twister Identity
diff --git a/Pandora/Pattern/Functor.hs b/Pandora/Pattern/Functor.hs
--- a/Pandora/Pattern/Functor.hs
+++ b/Pandora/Pattern/Functor.hs
@@ -2,8 +2,6 @@
 
 import Pandora.Pattern.Functor.Bivariant as Exports
 import Pandora.Pattern.Functor.Divariant as Exports
-import Pandora.Pattern.Functor.Lowerable as Exports
-import Pandora.Pattern.Functor.Liftable as Exports
 import Pandora.Pattern.Functor.Comonad as Exports
 import Pandora.Pattern.Functor.Monad as Exports
 import Pandora.Pattern.Functor.Representable as Exports
diff --git a/Pandora/Pattern/Functor/Liftable.hs b/Pandora/Pattern/Functor/Liftable.hs
deleted file mode 100644
--- a/Pandora/Pattern/Functor/Liftable.hs
+++ /dev/null
@@ -1,7 +0,0 @@
-module Pandora.Pattern.Functor.Liftable (Liftable (..)) where
-
-import Pandora.Core.Functor (type (~>))
-import Pandora.Pattern.Functor.Covariant (Covariant)
-
-class Liftable t where
-	lift :: Covariant u => u ~> t u
diff --git a/Pandora/Pattern/Functor/Lowerable.hs b/Pandora/Pattern/Functor/Lowerable.hs
deleted file mode 100644
--- a/Pandora/Pattern/Functor/Lowerable.hs
+++ /dev/null
@@ -1,7 +0,0 @@
-module Pandora.Pattern.Functor.Lowerable (Lowerable (..)) where
-
-import Pandora.Core.Functor (type (~>))
-import Pandora.Pattern.Functor.Covariant (Covariant)
-
-class Lowerable t where
-	lower :: Covariant u => t u ~> u
diff --git a/Pandora/Pattern/Object.hs b/Pandora/Pattern/Object.hs
--- a/Pandora/Pattern/Object.hs
+++ b/Pandora/Pattern/Object.hs
@@ -5,6 +5,7 @@
 import Pandora.Pattern.Object.Group as Exports
 import Pandora.Pattern.Object.Monoid as Exports
 import Pandora.Pattern.Object.Quasiring as Exports
+import Pandora.Pattern.Object.Semiring as Exports
 import Pandora.Pattern.Object.Ringoid as Exports
 import Pandora.Pattern.Object.Semigroup as Exports
 import Pandora.Pattern.Object.Chain as Exports
diff --git a/Pandora/Pattern/Object/Chain.hs b/Pandora/Pattern/Object/Chain.hs
--- a/Pandora/Pattern/Object/Chain.hs
+++ b/Pandora/Pattern/Object/Chain.hs
@@ -1,13 +1,6 @@
 module Pandora.Pattern.Object.Chain (Ordering (..), order, Chain (..)) where
 
-import Pandora.Pattern.Object.Setoid (Boolean (True, False), Setoid)
-
-data Ordering = Less | Equal | Greater
-
-order :: a -> a -> a -> Ordering -> a
-order x _ _ Less = x
-order _ y _ Equal = y
-order _ _ z Greater = z
+import Pandora.Pattern.Object.Setoid (Setoid ((==)), Boolean (True, False))
 
 {- |
 > When providing a new instance, you should ensure it satisfies the three laws:
@@ -28,3 +21,27 @@
 	x > y = order False False True (x <=> y)
 	(>=) :: a -> a -> Boolean
 	x >= y = order False True True (x <=> y)
+
+data Ordering = Less | Equal | Greater
+
+order :: a -> a -> a -> Ordering -> a
+order x _ _ Less = x
+order _ y _ Equal = y
+order _ _ z Greater = z
+
+instance Setoid Ordering where
+	Less == Less = True
+	Equal == Equal = True
+	Greater == Greater = True
+	_ == _ = False
+
+instance Chain Ordering where
+	Less <=> Less = Equal
+	Less <=> Equal = Less
+	Less <=> Greater = Less
+	Equal <=> Less = Greater
+	Equal <=> Equal = Equal
+	Equal <=> Greater = Less
+	Greater <=> Less = Greater
+	Greater <=> Equal = Greater
+	Greater <=> Greater = Equal
diff --git a/Pandora/Pattern/Object/Group.hs b/Pandora/Pattern/Object/Group.hs
--- a/Pandora/Pattern/Object/Group.hs
+++ b/Pandora/Pattern/Object/Group.hs
@@ -1,13 +1,13 @@
 module Pandora.Pattern.Object.Group (Group (..)) where
 
-import Pandora.Pattern.Object.Monoid (Monoid)
+import Pandora.Pattern.Object.Quasiring (Quasiring)
 
 {- |
 > When providing a new instance, you should ensure it satisfies the two laws:
-> * Right absorption: x + inverse x ≡ zero
-> * Left absorption: inverse x + x ≡ zero
+> * Right absorption: x * invert x ≡ zero
+> * Left absorption: invert x * x ≡ zero
 -}
 
-class Monoid a => Group a where
-	{-# MINIMAL inverse #-}
-	inverse :: a -> a
+class Quasiring a => Group a where
+	{-# MINIMAL invert #-}
+	invert :: a -> a
diff --git a/Pandora/Pattern/Object/Ringoid.hs b/Pandora/Pattern/Object/Ringoid.hs
--- a/Pandora/Pattern/Object/Ringoid.hs
+++ b/Pandora/Pattern/Object/Ringoid.hs
@@ -2,6 +2,8 @@
 
 import Pandora.Pattern.Object.Semigroup (Semigroup)
 
+infixl 7 *
+
 {- |
 > When providing a new instance, you should ensure it satisfies the two laws:
 > * Left distributivity: x * (y + z) ≡ x * y + x * z
diff --git a/Pandora/Pattern/Object/Semigroup.hs b/Pandora/Pattern/Object/Semigroup.hs
--- a/Pandora/Pattern/Object/Semigroup.hs
+++ b/Pandora/Pattern/Object/Semigroup.hs
@@ -1,5 +1,7 @@
 module Pandora.Pattern.Object.Semigroup (Semigroup (..)) where
 
+infixl 6 +
+
 {- |
 > When providing a new instance, you should ensure it satisfies the one law:
 > * Associativity: x + (y + z) ≡ (x + y) + z
diff --git a/Pandora/Pattern/Object/Semiring.hs b/Pandora/Pattern/Object/Semiring.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Object/Semiring.hs
@@ -0,0 +1,10 @@
+module Pandora.Pattern.Object.Semiring (Semiring) where
+
+import Pandora.Pattern.Object.Ringoid (Ringoid)
+
+{- |
+> When providing a new instance, you should ensure it satisfies one law:
+> * Associativity: x * (y * z) ≡ (x * y) * z
+-}
+
+class Ringoid a => Semiring a where
diff --git a/Pandora/Pattern/Object/Setoid.hs b/Pandora/Pattern/Object/Setoid.hs
--- a/Pandora/Pattern/Object/Setoid.hs
+++ b/Pandora/Pattern/Object/Setoid.hs
@@ -1,24 +1,30 @@
-module Pandora.Pattern.Object.Setoid (Boolean (..), (&&), (||), (?), not, bool, Setoid (..)) where
+module Pandora.Pattern.Object.Setoid (Boolean (..), (?), bool, Setoid (..)) where
 
-infixr ||
+import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
+import Pandora.Pattern.Object.Ringoid (Ringoid ((*)))
+import Pandora.Pattern.Object.Monoid (Monoid (zero))
+import Pandora.Pattern.Object.Quasiring (Quasiring (one))
+import Pandora.Pattern.Object.Group (Group (invert))
+
 infixr 1 ?
-infixr 3 &&
 infix 4 ==, /=
 
-data Boolean = True | False
+{- |
+> When providing a new instance, you should ensure it satisfies the four laws:
+> * Reflexivity: x == x ≡ True
+> * Symmetry: x == y ≡ y == x
+> * Transitivity: x == y * y == z ≡ True ===> x == z ≡ True
+> * Negation: x /= y ≡ not (x == y)
+-}
 
-(&&) :: Boolean -> Boolean -> Boolean
-True && True = True
-_ && _ = False
+class Setoid a where
+	{-# MINIMAL (==) #-}
+	(==) :: a -> a -> Boolean
 
-(||) :: Boolean -> Boolean -> Boolean
-True || _ = True
-_ || True = True
-_ || _ = False
+	(/=) :: a -> a -> Boolean
+	(/=) x y = invert (x == y)
 
-not :: Boolean -> Boolean
-not True = False
-not False = True
+data Boolean = True | False
 
 bool :: a -> a -> Boolean -> a
 bool x _ False = x
@@ -28,17 +34,25 @@
 (?) True x _ = x
 (?) False _ y = y
 
-{- |
-> When providing a new instance, you should ensure it satisfies the four laws:
-> * Reflexivity: x == x ≡ True
-> * Symmetry: x == y ≡ y == x
-> * Transitivity: x == y && y == z ≡ True ===> x == z ≡ True
-> * Negation: x /= y ≡ not (x == y)
--}
+instance Setoid Boolean where
+	True == True = True
+	False == False = True
+	_ == _ = False
 
-class Setoid a where
-	{-# MINIMAL (==) #-}
-	(==) :: a -> a -> Boolean
+instance Semigroup Boolean where
+	False + False = False
+	_ + _ = True
 
-	(/=) :: a -> a -> Boolean
-	(/=) x y = not (x == y)
+instance Ringoid Boolean where
+	True * True = True
+	_ * _ = False
+
+instance Monoid Boolean where
+	zero = False
+
+instance Quasiring Boolean where
+	one = True
+
+instance Group Boolean where
+	invert False = True
+	invert True = False
diff --git a/Pandora/Pattern/Transformer.hs b/Pandora/Pattern/Transformer.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Transformer.hs
@@ -0,0 +1,5 @@
+module Pandora.Pattern.Transformer (module Exports) where
+
+import Pandora.Pattern.Transformer.Lowerable as Exports
+import Pandora.Pattern.Transformer.Liftable as Exports
+import Pandora.Pattern.Transformer.Hoistable as Exports
diff --git a/Pandora/Pattern/Transformer/Hoistable.hs b/Pandora/Pattern/Transformer/Hoistable.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Transformer/Hoistable.hs
@@ -0,0 +1,6 @@
+module Pandora.Pattern.Transformer.Hoistable (Hoistable (..)) where
+
+import Pandora.Core.Functor (type (~>))
+
+class Hoistable t where
+	hoist :: u ~> v -> t u ~> t v
diff --git a/Pandora/Pattern/Transformer/Liftable.hs b/Pandora/Pattern/Transformer/Liftable.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Transformer/Liftable.hs
@@ -0,0 +1,12 @@
+module Pandora.Pattern.Transformer.Liftable (Liftable (..)) where
+
+import Pandora.Core.Functor (type (~>))
+import Pandora.Pattern.Functor.Pointable (Pointable)
+
+{- |
+> When providing a new instance, you should ensure it satisfies one law:
+> * Interchange: lift . point ≡ point
+-}
+
+class Liftable t where
+	lift :: Pointable u => u ~> t u
diff --git a/Pandora/Pattern/Transformer/Lowerable.hs b/Pandora/Pattern/Transformer/Lowerable.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Transformer/Lowerable.hs
@@ -0,0 +1,12 @@
+module Pandora.Pattern.Transformer.Lowerable (Lowerable (..)) where
+
+import Pandora.Core.Functor (type (~>))
+import Pandora.Pattern.Functor.Extractable (Extractable)
+
+{- |
+> When providing a new instance, you should ensure it satisfies one law:
+> * Interchange: extract . lower ≡ extract
+-}
+
+class Lowerable t where
+	lower :: Extractable u => t u ~> u
diff --git a/pandora.cabal b/pandora.cabal
--- a/pandora.cabal
+++ b/pandora.cabal
@@ -1,5 +1,5 @@
 name:                pandora
-version:             0.2.4
+version:             0.2.5
 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
@@ -60,7 +60,7 @@
     Pandora.Paradigm.Controlflow.Joint.Adaptable
     Pandora.Paradigm.Controlflow.Joint.Schemes
     Pandora.Paradigm.Controlflow.Joint.Schemes.TU
-    Pandora.Paradigm.Controlflow.Joint.Schemes.TUV
+    Pandora.Paradigm.Controlflow.Joint.Schemes.TUT
     Pandora.Paradigm.Controlflow.Joint.Schemes.TUVW
     Pandora.Paradigm.Controlflow.Joint.Schemes.UT
     Pandora.Paradigm.Controlflow.Joint.Schemes.UTU
@@ -80,6 +80,7 @@
     Pandora.Paradigm.Structure.Cartesian
     Pandora.Paradigm.Structure.Nonempty
     Pandora.Paradigm.Structure.Specific
+    Pandora.Paradigm.Structure.Specific.Stream
     Pandora.Paradigm.Structure.Specific.Stack
     Pandora.Paradigm.Structure.Specific.Graph
     Pandora.Paradigm.Structure.Specific.Binary
@@ -102,8 +103,6 @@
     Pandora.Pattern.Functor.Extendable
     Pandora.Pattern.Functor.Extractable
     Pandora.Pattern.Functor.Invariant
-    Pandora.Pattern.Functor.Liftable
-    Pandora.Pattern.Functor.Lowerable
     Pandora.Pattern.Functor.Monad
     Pandora.Pattern.Functor.Pointable
     Pandora.Pattern.Functor.Representable
@@ -120,7 +119,14 @@
     Pandora.Pattern.Object.Ringoid
     Pandora.Pattern.Object.Semigroup
     Pandora.Pattern.Object.Semilattice
+    Pandora.Pattern.Object.Semiring
     Pandora.Pattern.Object.Setoid
+    -- Pandora.Pattern.Object.Property.Boolean
+    -- Typeclassess about object composition of functors
+    Pandora.Pattern.Transformer
+    Pandora.Pattern.Transformer.Hoistable
+    Pandora.Pattern.Transformer.Liftable
+    Pandora.Pattern.Transformer.Lowerable
   default-extensions:
     DataKinds, ConstraintKinds, ExistentialQuantification, GADTs, QuantifiedConstraints
     FlexibleContexts, FlexibleInstances, KindSignatures, LiberalTypeSynonyms, LambdaCase