Replace monomorphic proxies by Type.Proxy.Proxy and polymorphic variables

Author: kl0tl

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