diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -14,6 +14,9 @@
 
 # Changelog
 
+* 2.0.1.0
+  - Simplified type synonyms for Which. Added Reinterpreted constraint synonym.
+
 * 2.0.0.0
   - Breaking change: the prime (xxx') version of functions are now consistently the simpler or non-polymorphic version.
     - This is more consistent with 'Control.Lens' as well.
diff --git a/data-diverse.cabal b/data-diverse.cabal
--- a/data-diverse.cabal
+++ b/data-diverse.cabal
@@ -1,5 +1,5 @@
 name:                data-diverse
-version:             2.0.0.0
+version:             2.0.1.0
 synopsis:            Extensible records and polymorphic variants.
 description:         "Data.Diverse.Many" is an extensible record for any size encoded efficiently as (Seq Any).
                      "Data.Diverse.Which" is a polymorphic variant of possibilities encoded as (Int, Any).
diff --git a/src/Data/Diverse/Which.hs b/src/Data/Diverse/Which.hs
--- a/src/Data/Diverse/Which.hs
+++ b/src/Data/Diverse/Which.hs
@@ -31,28 +31,33 @@
     , diversify
     , diversify'
     , diversify0
+    , DiversifyL
     , diversifyL
     , DiversifyN
     , diversifyN
       -- ** Inverse Injection
     , Reinterpret
+    , Reinterpreted
     , reinterpret
     , Reinterpret'
     , reinterpret'
+    , ReinterpretL
+    , ReinterpretedL
     , reinterpretL
+    , ReinterpretL'
     , reinterpretL'
     , ReinterpretN'
     , reinterpretN'
 
       -- * Catamorphism
     , Switch
-    , Switcher(..)
-    , which
     , switch
+    , which
+    , Switcher(..)
     , SwitchN
-    , SwitcherN(..)
-    , whichN
     , switchN
+    , whichN
+    , SwitcherN(..)
     ) where
 
 import Data.Diverse.Which.Internal
diff --git a/src/Data/Diverse/Which/Internal.hs b/src/Data/Diverse/Which/Internal.hs
--- a/src/Data/Diverse/Which/Internal.hs
+++ b/src/Data/Diverse/Which/Internal.hs
@@ -6,6 +6,7 @@
 {-# LANGUAGE EmptyCase #-}
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE FunctionalDependencies #-}
 {-# LANGUAGE GADTs #-}
 {-# LANGUAGE KindSignatures #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
@@ -50,28 +51,33 @@
     , diversify
     , diversify'
     , diversify0
+    , DiversifyL
     , diversifyL
     , DiversifyN
     , diversifyN
       -- ** Inverse Injection
     , Reinterpret
+    , Reinterpreted
     , reinterpret
     , Reinterpret'
     , reinterpret'
+    , ReinterpretL
+    , ReinterpretedL
     , reinterpretL
+    , ReinterpretL'
     , reinterpretL'
     , ReinterpretN'
     , reinterpretN'
 
       -- * Catamorphism
     , Switch
-    , Switcher(..)
-    , which
     , switch
+    , which
+    , Switcher(..)
     , SwitchN
-    , SwitcherN(..)
-    , whichN
     , switchN
+    , whichN
+    , SwitcherN(..)
     ) where
 
 import Control.Applicative
@@ -357,7 +363,7 @@
 -----------------------------------------------------------------
 
 -- | A friendlier constraint synonym for 'diversify'.
-type Diversify (branch :: [Type]) (tree :: [Type]) = Reduce (Which branch) (Switcher (CaseDiversify branch tree) (Which tree) branch)
+type Diversify (branch :: [Type]) (tree :: [Type]) = Switch (CaseDiversify branch tree) (Which tree) branch
 
 -- | Convert a 'Which' to another 'Which' that may include other possibilities.
 -- That is, @branch@ is equal or is a subset of @tree@.
@@ -398,6 +404,14 @@
 
 ------------------------------------------------------------------
 
+-- | A friendlier constraint synonym for 'diversifyL'.
+type DiversifyL (ls :: [k]) (branch :: [Type]) (tree :: [Type]) =
+    ( Diversify branch tree
+    , branch ~ KindsAtLabels ls tree
+    , UniqueLabels ls tree
+    , IsDistinct ls
+    )
+
 -- | A variation of 'diversify' where @branch@is additionally specified by a labels list.
 --
 -- @
@@ -406,22 +420,16 @@
 --     y'' = 'diversifyL' \@'[Bar, Foo] y' :: 'Which' '[Tagged Foo Bool, Tagged Bar Int]
 -- 'switch' y'' ('Data.Diverse.CaseFunc.CaseFunc' \@'Data.Typeable.Typeable' (show . typeRep . (pure \@Proxy))) \`shouldBe` \"Tagged * Bar Int"
 -- @
-diversifyL
-    :: forall ls branch tree.
-       ( Diversify branch tree
-       , branch ~ KindsAtLabels ls tree
-       , UniqueLabels ls tree
-       , IsDistinct ls
-       )
-    => Which branch -> Which tree
+diversifyL :: forall ls branch tree. (DiversifyL ls branch tree) => Which branch -> Which tree
 diversifyL = which (CaseDiversify @branch @tree @_ @branch)
 
 ------------------------------------------------------------------
 
 -- | A friendlier constraint synonym for 'diversifyN'.
-type DiversifyN (indices :: [Nat]) (branch :: [Type]) (tree :: [Type]) =
-    ( Reduce (Which branch) (SwitcherN (CaseDiversifyN indices) (Which tree) 0 branch)
-    , KindsAtIndices indices tree ~ branch)
+type DiversifyN (ns :: [Nat]) (branch :: [Type]) (tree :: [Type]) =
+    ( SwitchN Which (CaseDiversifyN ns) (Which tree) 0 branch
+    , KindsAtIndices ns tree ~ branch
+    )
 
 -- | A variation of 'diversify' which uses a Nat list @indices@ to specify how to reorder the fields, where
 --
@@ -438,25 +446,28 @@
 --     y'' = 'diversifyN' \@[1,0] \@_ \@[Bool, Int] y'
 -- 'switch' y'' ('Data.Diverse.CaseFunc.CaseFunc' \@'Data.Typeable.Typeable' (show . typeRep . (pure \@Proxy))) \`shouldBe` \"Int"
 -- @
-diversifyN :: forall indices branch tree. (DiversifyN indices branch tree) => Which branch -> Which tree
-diversifyN = whichN (CaseDiversifyN @indices @_ @0 @branch)
+diversifyN :: forall ns branch tree. (DiversifyN ns branch tree) => Which branch -> Which tree
+diversifyN = whichN (CaseDiversifyN @ns @_ @0 @branch)
 
-data CaseDiversifyN (indices :: [Nat]) r (n :: Nat) (branch' :: [Type]) = CaseDiversifyN
+data CaseDiversifyN (ns :: [Nat]) r (n :: Nat) (branch' :: [Type]) = CaseDiversifyN
 
-type instance CaseResult (CaseDiversifyN indices r n) x = r
+type instance CaseResult (CaseDiversifyN ns r n) x = r
 
-instance ReiterateN (CaseDiversifyN indices r) n branch' where
+instance ReiterateN (CaseDiversifyN ns r) n branch' where
     reiterateN CaseDiversifyN = CaseDiversifyN
 
-instance MemberAt (KindAtIndex n indices) x tree =>
-         Case (CaseDiversifyN indices (Which tree) n) (x ': branch') where
-    case' CaseDiversifyN v = pickN @(KindAtIndex n indices) v
+instance MemberAt (KindAtIndex n ns) x tree =>
+         Case (CaseDiversifyN ns (Which tree) n) (x ': branch') where
+    case' CaseDiversifyN v = pickN @(KindAtIndex n ns) v
 
 ------------------------------------------------------------------
 
 -- | A friendlier constraint synonym for 'reinterpret'.
-type Reinterpret branch tree = Reduce (Which tree) (Switcher (CaseReinterpret branch tree) (Either (Which (Complement tree branch)) (Which branch)) tree)
+type Reinterpret (branch :: [Type]) (tree :: [Type]) = Switch (CaseReinterpret branch tree) (Either (Which (Complement tree branch)) (Which branch)) tree
 
+-- | A variation of 'Reinterpret' that exposes @branchlessTree ~ Complement tree branch@
+type Reinterpreted branch tree branchlessTree = (Reinterpret branch tree, branchlessTree ~ Complement tree branch)
+
 -- | Convert a 'Which' into possibly another 'Which' with a totally different typelist.
 -- Returns either a 'Which' with the 'Right' value, or a 'Which' with the 'Left'over @compliment@ types.
 --
@@ -471,7 +482,8 @@
 --     let c = 'reinterpret' @[String, Int] a
 --     c \`shouldBe` Right ('pick' (5 :: Int)) :: 'Which' '[String, Int]
 -- @
-reinterpret :: forall branch tree. Reinterpret branch tree => Which tree -> Either (Which (Complement tree branch)) (Which branch)
+reinterpret :: forall branch tree. (Reinterpret branch tree) =>
+    Which tree -> Either (Which (Complement tree branch)) (Which branch)
 reinterpret = which (CaseReinterpret @branch @tree @_ @tree)
 
 data CaseReinterpret (branch :: [Type]) (tree :: [Type]) r (tree' :: [Type]) = CaseReinterpret
@@ -497,10 +509,10 @@
 ------------------------------------------------------------------
 
 -- | A friendlier constraint synonym for 'reinterpret''.
-type Reinterpret' branch tree = Reduce (Which tree) (Switcher (CaseReinterpret' branch tree) (Maybe (Which branch)) tree)
+type Reinterpret' (branch :: [Type]) (tree :: [Type]) = Switch (CaseReinterpret' branch tree) (Maybe (Which branch)) tree
 
 -- | Variation of 'reinterpret' which returns a Maybe.
-reinterpret' :: forall branch tree. Reinterpret' branch tree => Which tree -> Maybe (Which branch)
+reinterpret' :: forall branch tree. (Reinterpret' branch tree) => Which tree -> Maybe (Which branch)
 reinterpret' = which (CaseReinterpret' @branch @tree @_ @tree)
 
 data CaseReinterpret' (branch :: [Type]) (tree :: [Type]) r (tree' :: [Type]) = CaseReinterpret'
@@ -522,6 +534,17 @@
 
 ------------------------------------------------------------------
 
+-- | A friendlier constraint synonym for 'reinterpretL'.
+type ReinterpretL (ls :: [k]) (branch :: [Type]) (tree :: [Type]) =
+    ( Reinterpret branch tree
+    , branch ~ KindsAtLabels ls tree
+    , UniqueLabels ls tree
+    , IsDistinct ls
+    )
+
+-- | A variation of 'ReinterpretL' that exposes @branchlessTree ~ Complement tree branch@
+type ReinterpretedL ls branch tree branchlessTree = (ReinterpretL ls branch tree, branchlessTree ~ Complement tree branch)
+
 -- | A variation of 'reinterpret' where the @branch@ is additionally specified with a labels list.
 --
 -- @
@@ -530,37 +553,31 @@
 --     x = 'pick' \@[Tagged Foo Bool, Tagged Bar Int] (5 :: Tagged Bar Int)
 -- y' \`shouldBe` Right x
 -- @
-reinterpretL
-    :: forall ls branch tree.
-       ( Reinterpret branch tree
-       , branch ~ KindsAtLabels ls tree
-       , UniqueLabels ls tree
-       , IsDistinct ls
-       )
-    => Which tree
-    -> Either (Which (Complement tree branch)) (Which branch)
+reinterpretL :: forall ls branch tree. (ReinterpretL ls branch tree)
+  => Which tree -> Either (Which (Complement tree branch)) (Which branch)
 reinterpretL = which (CaseReinterpret @branch @tree @_ @tree)
 
+-- | A friendlier constraint synonym for 'reinterpretL'.
+type ReinterpretL' (ls :: [k]) (branch :: [Type]) (tree :: [Type]) =
+    ( Reinterpret' branch tree
+    , branch ~ KindsAtLabels ls tree
+    , UniqueLabels ls tree
+    , IsDistinct ls
+    )
+
 -- | Variation of 'reinterpretL' which returns a Maybe.
-reinterpretL'
-    :: forall ls branch tree.
-       ( Reinterpret' branch tree
-       , branch ~ KindsAtLabels ls tree
-       , UniqueLabels ls tree
-       , IsDistinct ls
-       )
-    => Which tree
-    -> Maybe (Which branch)
+reinterpretL' :: forall ls branch tree. (ReinterpretL' ls branch tree)
+  => Which tree -> Maybe (Which branch)
 reinterpretL' = which (CaseReinterpret' @branch @tree @_ @tree)
 
 ------------------------------------------------------------------
 
 -- | A friendlier constraint synonym for 'reinterpretN'.
-type ReinterpretN' (indices :: [Nat]) (branch :: [Type]) (tree :: [Type]) =
-    ( Reduce (Which tree) (SwitcherN (CaseReinterpretN' indices) (Maybe (Which branch)) 0 tree)
-    , KindsAtIndices indices tree ~ branch)
+type ReinterpretN' (ns :: [Nat]) (branch :: [Type]) (tree :: [Type]) =
+    ( SwitchN Which (CaseReinterpretN' ns) (Maybe (Which branch)) 0 tree
+    , KindsAtIndices ns tree ~ branch)
 
--- | A limited variation of 'reinterpret' which uses a Nat list @n@ to specify how to reorder the fields, where
+-- | A limited variation of 'reinterpret'' which uses a Nat list @n@ to specify how to reorder the fields, where
 --
 -- @
 -- indices[branch_idx] = tree_idx
@@ -574,8 +591,9 @@
 -- Also it returns a Maybe instead of Either.
 --
 -- This is so that the same @indices@ can be used in 'narrowN'.
-reinterpretN' :: forall (indices :: [Nat]) branch tree. (ReinterpretN' indices branch tree) => Which tree -> Maybe (Which branch)
-reinterpretN' = whichN (CaseReinterpretN' @indices @_ @0 @tree)
+reinterpretN' :: forall ns branch tree. (ReinterpretN' ns branch tree)
+  => Which tree -> Maybe (Which branch)
+reinterpretN' = whichN (CaseReinterpretN' @ns @_ @0 @tree)
 
 data CaseReinterpretN' (indices :: [Nat]) r (n :: Nat) (tree' :: [Type]) = CaseReinterpretN'
 
@@ -617,7 +635,6 @@
 
 -- | Terminating case of the loop, ensuring that a instance of @Case '[]@
 -- with an empty typelist is not required.
--- You can't reduce 'zilch'
 instance (Case (c r) '[x], r ~ CaseResult (c r) x) => Reduce (Which '[x]) (Switcher c r '[x]) where
     reduce (Switcher c) v = case obvious v of
             a -> case' c a
@@ -630,13 +647,9 @@
 
 ------------------------------------------------------------------
 
--- | A friendlier constraint synonym for 'switch'.
+-- | A friendlier constraint synonym for 'reinterpretN'.
 type Switch c r xs = Reduce (Which xs) (Switcher c r xs)
 
--- | Catamorphism for 'Which'. This is equivalent to @flip 'switch'@.
-which :: Switch c r xs => c r xs -> Which xs -> r
-which = reduce . Switcher
-
 -- | A switch/case statement for 'Which'. This is equivalent to @flip 'which'@
 --
 -- Use 'Case' instances like 'Data.Diverse.Cases.Cases' to apply a 'Which' of functions to a variant of values.
@@ -658,8 +671,12 @@
 --
 -- Or you may use your own custom instance of 'Case'.
 switch :: Switch c r xs => Which xs -> c r xs -> r
-switch = flip which
+switch w c = reduce (Switcher c) w
 
+-- | Catamorphism for 'Which'. This is @flip 'switch'@.
+which :: Switch c r xs => c r xs -> Which xs -> r
+which = flip switch
+
 ------------------------------------------------------------------
 
 -- | 'SwitcherN' is a variation of 'Switcher' which __'reiterateN'__s through the possibilities in a 'Which',
@@ -691,12 +708,9 @@
     reduce (SwitcherN c) v = case obvious v of
             a -> case' c a
 
--- | A friendlier constraint synonym for 'switch'.
-type SwitchN c r n xs = Reduce (Which xs) (SwitcherN c r n xs)
-
 -- | Catamorphism for 'Which'. This is equivalent to @flip 'switchN'@.
-whichN :: SwitchN c r n xs => c r n xs -> Which xs -> r
-whichN = reduce . SwitcherN
+whichN :: SwitchN w c r n xs => c r n xs -> w xs -> r
+whichN = flip switchN
 
 -- | A switch/case statement for 'Which'. This is equivalent to @flip 'whichN'@
 --
@@ -714,13 +728,16 @@
 -- @
 --
 -- Or you may use your own custom instance of 'Case'.
-switchN :: SwitchN c r n xs => Which xs -> c r n xs -> r
-switchN = flip whichN
+class SwitchN w c r (n :: Nat) xs where
+    switchN :: w xs -> c r n xs -> r
 
+instance Reduce (Which xs) (SwitcherN c r n xs) => SwitchN Which c r n xs where
+    switchN w c = reduce (SwitcherN c) w
+
 -----------------------------------------------------------------
 
 -- | Two 'Which'es are only equal iff they both contain the equivalnet value at the same type index.
-instance (Reduce (Which (x ': xs)) (Switcher CaseEqWhich Bool (x ': xs))) =>
+instance (Switch CaseEqWhich Bool (x ': xs)) =>
          Eq (Which (x ': xs)) where
     l@(Which i _) == (Which j u) =
         if i /= j
@@ -746,8 +763,8 @@
 -----------------------------------------------------------------
 
 -- | A 'Which' with a type at smaller type index is considered smaller.
-instance ( Reduce (Which (x ': xs)) (Switcher CaseEqWhich Bool (x ': xs))
-         , Reduce (Which (x ': xs)) (Switcher CaseOrdWhich Ordering (x ': xs))
+instance ( Switch CaseEqWhich Bool (x ': xs)
+         , Switch CaseOrdWhich Ordering (x ': xs)
          ) =>
          Ord (Which (x ': xs)) where
     compare l@(Which i _) (Which j u) =
@@ -774,7 +791,7 @@
 ------------------------------------------------------------------
 
 -- | @show ('pick'' \'A') == "pick \'A'"@
-instance (Reduce (Which (x ': xs)) (Switcher CaseShowWhich ShowS (x ': xs))) =>
+instance (Switch CaseShowWhich ShowS (x ': xs)) =>
          Show (Which (x ': xs)) where
     showsPrec d v = showParen (d > app_prec) (which (CaseShowWhich 0) v)
       where