fix: Remove exponential type level if statement.

Author: mchav

src/DataFrame/Typed/Schema.hs

@@ -66,7 +66,6 @@ import GHC.TypeLits
 import Type.Reflection (SomeTypeRep, Typeable, someTypeRep)
 
 import DataFrame.Internal.Column (Columnable)
-import DataFrame.Internal.Types (If)
 import DataFrame.Typed.Types (Column)
 
 -- | Look up the element type of a column by name.
@@ -121,10 +120,11 @@ type family SubsetSchema (names :: [Symbol]) (cols :: [Type]) :: [Type] where
 type family ExcludeSchema (names :: [Symbol]) (cols :: [Type]) :: [Type] where
     ExcludeSchema names '[] = '[]
     ExcludeSchema names (Column n a ': rest) =
-        If
-            (IsElem n names)
-            (ExcludeSchema names rest)
-            (Column n a ': ExcludeSchema names rest)
+        ExcludeSchemaHelper (IsElem n names) n a names rest
+
+type family ExcludeSchemaHelper (found :: Bool) (n :: Symbol) (a :: Type) (names :: [Symbol]) (rest :: [Type]) :: [Type] where
+    ExcludeSchemaHelper 'True  n a names rest = ExcludeSchema names rest
+    ExcludeSchemaHelper 'False n a names rest = Column n a ': ExcludeSchema names rest
 
 -- | Type-level elem for Symbols
 type family IsElem (x :: Symbol) (xs :: [Symbol]) :: Bool where
@@ -197,14 +197,14 @@ type family
 -- | Assert that a column name is present in the schema.
 type family AssertAllPresent (name :: [Symbol]) (cols :: [Type]) :: Constraint where
     AssertAllPresent (name ': rest) cols =
-        If
-            (HasName name cols)
-            (AssertAllPresent rest cols)
-            ( TypeError
-                ('Text "Column '" ':<>: 'Text name ':<>: 'Text "' not found in schema")
-            )
+        AssertAllPresentHelper (HasName name cols) name rest cols
     AssertAllPresent '[] cols = ()
 
+type family AssertAllPresentHelper (found :: Bool) (name :: Symbol) (rest :: [Symbol]) (cols :: [Type]) :: Constraint where
+    AssertAllPresentHelper 'True  name rest cols = AssertAllPresent rest cols
+    AssertAllPresentHelper 'False name rest cols =
+        TypeError ('Text "Column '" ':<>: 'Text name ':<>: 'Text "' not found in schema")
+
 {- | Strip 'Maybe' from all columns. Used by 'filterAllJust'.
 
 @Column "x" (Maybe Double)@ becomes @Column "x" Double@.
@@ -232,13 +232,21 @@ type family StripMaybeAt (name :: Symbol) (cols :: [Type]) :: [Type] where
 type family SharedNames (left :: [Type]) (right :: [Type]) :: [Symbol] where
     SharedNames '[] right = '[]
     SharedNames (Column n _ ': rest) right =
-        If (HasName n right) (n ': SharedNames rest right) (SharedNames rest right)
+        SharedNamesHelper (HasName n right) n rest right
+
+type family SharedNamesHelper (found :: Bool) (n :: Symbol) (rest :: [Type]) (right :: [Type]) :: [Symbol] where
+    SharedNamesHelper 'True  n rest right = n ': SharedNames rest right
+    SharedNamesHelper 'False n rest right = SharedNames rest right
 
 -- | Columns from @left@ whose names do NOT appear in @right@.
 type family UniqueLeft (left :: [Type]) (rightNames :: [Symbol]) :: [Type] where
     UniqueLeft '[] _ = '[]
     UniqueLeft (Column n a ': rest) rn =
-        If (IsElem n rn) (UniqueLeft rest rn) (Column n a ': UniqueLeft rest rn)
+        UniqueLeftHelper (IsElem n rn) n a rest rn
+
+type family UniqueLeftHelper (found :: Bool) (n :: Symbol) (a :: Type) (rest :: [Type]) (rn :: [Symbol]) :: [Type] where
+    UniqueLeftHelper 'True  n a rest rn = UniqueLeft rest rn
+    UniqueLeftHelper 'False n a rest rn = Column n a ': UniqueLeft rest rn
 
 -- | Wrap column types in Maybe.
 type family WrapMaybe (cols :: [Type]) :: [Type] where
@@ -249,23 +257,26 @@ type family WrapMaybe (cols :: [Type]) :: [Type] where
 type family WrapMaybeColumns (names :: [Symbol]) (cols :: [Type]) :: [Type] where
     WrapMaybeColumns names '[] = '[]
     WrapMaybeColumns names (Column n a ': rest) =
-        If
-            (IsElem n names)
-            (Column n (Maybe a) ': WrapMaybeColumns names rest)
-            (Column n a ': WrapMaybeColumns names rest)
+        WrapMaybeColumnsHelper (IsElem n names) n a names rest
+
+type family WrapMaybeColumnsHelper (found :: Bool) (n :: Symbol) (a :: Type) (names :: [Symbol]) (rest :: [Type]) :: [Type] where
+    WrapMaybeColumnsHelper 'True  n a names rest = Column n (Maybe a) ': WrapMaybeColumns names rest
+    WrapMaybeColumnsHelper 'False n a names rest = Column n a ': WrapMaybeColumns names rest
 
 -- | Columns in left whose names collide with right (excluding keys).
 type family CollidingColumns (left :: [Type]) (right :: [Type]) (keys :: [Symbol]) :: [Type] where
     CollidingColumns '[] _ _ = '[]
     CollidingColumns (Column n a ': rest) right keys =
-        If
-            (IsElem n keys)
-            (CollidingColumns rest right keys)
-            ( If
-                (HasName n right)
-                (Column n (These a (Lookup n right)) ': CollidingColumns rest right keys)
-                (CollidingColumns rest right keys)
-            )
+        CollidingColumnsHelper1 (IsElem n keys) n a rest right keys
+
+type family CollidingColumnsHelper1 (isKey :: Bool) (n :: Symbol) (a :: Type) (rest :: [Type]) (right :: [Type]) (keys :: [Symbol]) :: [Type] where
+    CollidingColumnsHelper1 'True  n a rest right keys = CollidingColumns rest right keys
+    CollidingColumnsHelper1 'False n a rest right keys =
+        CollidingColumnsHelper2 (HasName n right) n a rest right keys
+
+type family CollidingColumnsHelper2 (inRight :: Bool) (n :: Symbol) (a :: Type) (rest :: [Type]) (right :: [Type]) (keys :: [Symbol]) :: [Type] where
+    CollidingColumnsHelper2 'True  n a rest right keys = Column n (These a (Lookup n right)) ': CollidingColumns rest right keys
+    CollidingColumnsHelper2 'False n a rest right keys = CollidingColumns rest right keys
 
 -- | Inner join result schema.
 type family InnerJoinSchema (keys :: [Symbol]) (left :: [Type]) (right :: [Type]) :: [Type] where
@@ -322,18 +333,15 @@ type family
                 )
             )
 
--------------------------------------------------------------------------------
--- GroupBy helpers
--------------------------------------------------------------------------------
-
 -- | Extract Column entries from a schema whose names appear in @keys@.
 type family GroupKeyColumns (keys :: [Symbol]) (cols :: [Type]) :: [Type] where
     GroupKeyColumns keys '[] = '[]
     GroupKeyColumns keys (Column n a ': rest) =
-        If
-            (IsElem n keys)
-            (Column n a ': GroupKeyColumns keys rest)
-            (GroupKeyColumns keys rest)
+        GroupKeyColumnsHelper (IsElem n keys) n a keys rest
+
+type family GroupKeyColumnsHelper (found :: Bool) (n :: Symbol) (a :: Type) (keys :: [Symbol]) (rest :: [Type]) :: [Type] where
+    GroupKeyColumnsHelper 'True  n a keys rest = Column n a ': GroupKeyColumns keys rest
+    GroupKeyColumnsHelper 'False n a keys rest = GroupKeyColumns keys rest
 
 -- | Provides runtime evidence of a schema: a list of (name, TypeRep) pairs.
 class KnownSchema (cols :: [Type]) where