No monomorphic proxies

src/Type/Data/Boolean.purs

@@ -41,32 +41,32 @@ class And lhs rhs out | lhs rhs -> out
 instance andTrue :: And True rhs rhs
 instance andFalse :: And False rhs False
 
-and :: forall l r o. And l r o => BProxy l -> BProxy r -> BProxy o
-and _ _ = BProxy
+and :: forall proxy l r o. And l r o => proxy l -> proxy r -> Proxy o
+and _ _ = Proxy
 
 -- | Or two `Boolean` types together
 class Or :: Boolean -> Boolean -> Boolean -> Constraint
 class Or lhs rhs output | lhs rhs -> output
 instance orTrue :: Or True rhs True
 instance orFalse :: Or False rhs rhs
 
-or :: forall l r o. Or l r o => BProxy l -> BProxy r -> BProxy o
-or _ _ = BProxy
+or :: forall proxy l r o. Or l r o => proxy l -> proxy r -> Proxy o
+or _ _ = Proxy
 
 -- | Not a `Boolean`
 class Not :: Boolean -> Boolean -> Constraint
 class Not bool output | bool -> output
 instance notTrue :: Not True False
 instance notFalse :: Not False True
 
-not :: forall i o. Not i o => BProxy i -> BProxy o
-not _ = BProxy
+not :: forall proxy i o. Not i o => proxy i -> Proxy o
+not _ = Proxy
 
 -- | If - dispatch based on a boolean
 class If :: forall k. Boolean -> k -> k -> k -> Constraint
 class If bool onTrue onFalse output | bool onTrue onFalse -> output
 instance ifTrue :: If True onTrue onFalse onTrue
 instance ifFalse :: If False onTrue onFalse onFalse
 
-if_ :: forall b t e o. If b t e o => BProxy b -> Proxy t -> Proxy e -> Proxy o
+if_ :: forall proxy b t e o. If b t e o => proxy b -> Proxy t -> Proxy e -> Proxy o
 if_ _ _ _ = Proxy

src/Type/Data/Ordering.purs

@@ -14,7 +14,7 @@ module Type.Data.Ordering
 
 import Prim.Ordering (LT, EQ, GT, Ordering) as PO
 import Data.Ordering (Ordering(..))
-import Type.Data.Boolean (True, False, BProxy(..))
+import Type.Data.Boolean (True, False)
 import Type.Proxy (Proxy(..))
 
 -- | Value proxy for `Ordering` types
@@ -45,8 +45,8 @@ instance appendOrderingLT :: Append PO.LT rhs PO.LT
 instance appendOrderingEQ :: Append PO.EQ rhs rhs
 instance appendOrderingGT :: Append PO.GT rhs PO.GT
 
-append :: forall l r o. Append l r o => OProxy l -> OProxy r -> OProxy o
-append _ _ = OProxy
+append :: forall proxy l r o. Append l r o => proxy l -> proxy r -> Proxy o
+append _ _ = Proxy
 
 -- | Invert an `Ordering`
 class Invert :: PO.Ordering -> PO.Ordering -> Constraint
@@ -55,8 +55,8 @@ instance invertOrderingLT :: Invert PO.LT PO.GT
 instance invertOrderingEQ :: Invert PO.EQ PO.EQ
 instance invertOrderingGT :: Invert PO.GT PO.LT
 
-invert :: forall i o. Invert i o => OProxy i -> OProxy o
-invert _ = OProxy
+invert :: forall proxy i o. Invert i o => proxy i -> Proxy o
+invert _ = Proxy
 
 class Equals :: PO.Ordering -> PO.Ordering -> Boolean -> Constraint
 class Equals lhs rhs out | lhs rhs -> out
@@ -71,5 +71,5 @@ instance equalsLTGT :: Equals PO.LT PO.GT False
 instance equalsGTLT :: Equals PO.GT PO.LT False
 instance equalsGTEQ :: Equals PO.GT PO.EQ False
 
-equals :: forall l r o. Equals l r o => OProxy l -> OProxy r -> BProxy o
-equals _ _ = BProxy
+equals :: forall proxy l r o. Equals l r o => proxy l -> proxy r -> Proxy o
+equals _ _ = Proxy

src/Type/Data/Symbol.purs

@@ -10,18 +10,18 @@ module Type.Data.Symbol
 
 import Prim.Symbol (class Append, class Compare, class Cons)
 import Data.Symbol (SProxy(..), class IsSymbol, reflectSymbol, reifySymbol)
-import Type.Data.Ordering (OProxy(..), EQ)
+import Type.Data.Ordering (EQ)
 import Type.Data.Ordering (class Equals) as Ordering
-import Type.Data.Boolean (BProxy(..))
+import Type.Proxy (Proxy(..))
 
-compare :: forall l r o. Compare l r o => SProxy l -> SProxy r -> OProxy o
-compare _ _ = OProxy
+compare :: forall proxy l r o. Compare l r o => proxy l -> proxy r -> Proxy o
+compare _ _ = Proxy
 
-append :: forall l r o. Append l r o => SProxy l -> SProxy r -> SProxy o
-append _ _ = SProxy
+append :: forall proxy l r o. Append l r o => proxy l -> proxy r -> Proxy o
+append _ _ = Proxy
 
-uncons :: forall h t s. Cons h t s => SProxy s -> {head :: SProxy h, tail :: SProxy t}
-uncons _ = {head : SProxy, tail : SProxy}
+uncons :: forall proxy h t s. Cons h t s => proxy s -> {head :: Proxy h, tail :: Proxy t}
+uncons _ = {head : Proxy, tail : Proxy}
 
 class Equals :: Symbol -> Symbol -> Boolean -> Constraint
 class Equals lhs rhs out | lhs rhs -> out
@@ -31,5 +31,5 @@ instance equalsSymbol
       Ordering.Equals EQ ord out)
   => Equals lhs rhs out
 
-equals :: forall l r o. Equals l r o => SProxy l -> SProxy r -> BProxy o
-equals _ _ = BProxy
+equals :: forall proxy l r o. Equals l r o => proxy l -> proxy r -> Proxy o
+equals _ _ = Proxy

src/Type/RowList.purs

@@ -13,7 +13,6 @@ import Prim.RowList (RowList, Cons, Nil, class RowToList)
 import Type.Equality (class TypeEquals)
 import Type.Data.Symbol as Symbol
 import Type.Data.Boolean as Boolean
-import Type.Data.RowList (RLProxy)
 import Type.Data.RowList (RLProxy(..)) as RLProxy
 
 -- | Convert a RowList to a row of types.
@@ -40,9 +39,9 @@ instance rowListRemoveCons
   :: ( RowListRemove label tail tailOutput
      , Symbol.Equals label key eq
      , Boolean.If eq
-         (RLProxy tailOutput)
-         (RLProxy (Cons key head tailOutput))
-         (RLProxy output)
+         tailOutput
+         (Cons key head tailOutput)
+         output
      )
   => RowListRemove label (Cons key head tail) output
 
@@ -51,7 +50,7 @@ class RowListSet :: forall k. Symbol -> k -> RowList k -> RowList k -> Constrain
 class RowListSet label typ input output | label typ input -> output
 
 instance rowListSetImpl
-  :: ( TypeEquals (Symbol.SProxy label) (Symbol.SProxy label')
+  :: ( TypeEquals label label'
      , TypeEquals typ typ'
      , RowListRemove label input lacking )
   => RowListSet label typ input (Cons label' typ' lacking)
@@ -64,9 +63,9 @@ instance rowListNubNil
   :: RowListNub Nil Nil
 
 instance rowListNubCons
-  :: ( TypeEquals (Symbol.SProxy label) (Symbol.SProxy label')
+  :: ( TypeEquals label label'
      , TypeEquals head head'
-     , TypeEquals (RLProxy nubbed) (RLProxy nubbed')
+     , TypeEquals nubbed nubbed'
      , RowListRemove label tail removed
      , RowListNub removed nubbed )
   => RowListNub (Cons label head tail) (Cons label' head' nubbed')
@@ -76,10 +75,10 @@ class RowListAppend :: forall k. RowList k -> RowList k -> RowList k -> Constrai
 class RowListAppend lhs rhs out | lhs rhs -> out
 
 instance rowListAppendNil
-  :: TypeEquals (RLProxy rhs) (RLProxy out)
+  :: TypeEquals rhs out
   => RowListAppend Nil rhs out
 
 instance rowListAppendCons
   :: ( RowListAppend tail rhs out'
-     , TypeEquals (RLProxy (Cons label head out')) (RLProxy out) )
+     , TypeEquals (Cons label head out') out )
   => RowListAppend (Cons label head tail) rhs out