Use/reexport solved type classes of Prim

Author: LiamGoodacre

src/Type/Data/Ordering.purs

@@ -1,28 +1,21 @@
 module Type.Data.Ordering
-  ( kind Ordering
-  , LT
-  , EQ
-  , GT
+  ( module Prim.Ordering
   , OProxy(..)
   , class IsOrdering
   , reflectOrdering
   , reifyOrdering
-  , class AppendOrdering
-  , appendOrdering
-  , class InvertOrdering
-  , invertOrdering
+  , class Append
+  , append
+  , class Invert
+  , invert
   , class Equals
   , equals
   ) where
 
+import Prim.Ordering (kind Ordering, LT, EQ, GT)
 import Data.Ordering (Ordering(..))
 import Type.Data.Boolean (kind Boolean, True, False, BProxy(..))
 
-foreign import kind Ordering
-foreign import data LT :: Ordering
-foreign import data EQ :: Ordering
-foreign import data GT :: Ordering
-
 -- | Value proxy for `Ordering` types
 data OProxy (ordering :: Ordering) = OProxy
 
@@ -42,27 +35,27 @@ reifyOrdering GT f = f (OProxy :: OProxy GT)
 
 -- | Append two `Ordering` types together
 -- | Reflective of the semigroup for value level `Ordering`
-class AppendOrdering (lhs :: Ordering)
-                     (rhs :: Ordering)
-                     (output :: Ordering) |
-                     lhs -> rhs output
-instance appendOrderingLT :: AppendOrdering LT rhs LT
-instance appendOrderingEQ :: AppendOrdering EQ rhs rhs
-instance appendOrderingGT :: AppendOrdering GT rhs GT
+class Append (lhs :: Ordering)
+             (rhs :: Ordering)
+             (output :: Ordering) |
+             lhs -> rhs output
+instance appendOrderingLT :: Append LT rhs LT
+instance appendOrderingEQ :: Append EQ rhs rhs
+instance appendOrderingGT :: Append GT rhs GT
 
-appendOrdering :: forall l r o. AppendOrdering l r o => OProxy l -> OProxy r -> OProxy o
-appendOrdering _ _ = OProxy
+append :: forall l r o. Append l r o => OProxy l -> OProxy r -> OProxy o
+append _ _ = OProxy
 
 -- | Invert an `Ordering`
-class InvertOrdering (ordering :: Ordering)
-                     (result :: Ordering) |
-                     ordering -> result
-instance invertOrderingLT :: InvertOrdering LT GT
-instance invertOrderingEQ :: InvertOrdering EQ EQ
-instance invertOrderingGT :: InvertOrdering GT LT
+class Invert (ordering :: Ordering)
+             (result :: Ordering) |
+             ordering -> result
+instance invertOrderingLT :: Invert LT GT
+instance invertOrderingEQ :: Invert EQ EQ
+instance invertOrderingGT :: Invert GT LT
 
-invertOrdering :: forall i o. InvertOrdering i o => OProxy i -> OProxy o
-invertOrdering _ = OProxy
+invert :: forall i o. Invert i o => OProxy i -> OProxy o
+invert _ = OProxy
 
 class Equals (lhs :: Ordering)
              (rhs :: Ordering)

src/Type/Data/Symbol.purs

@@ -1,54 +1,35 @@
 module Type.Data.Symbol
-  ( module Data.Symbol
-  , class CompareSymbol
-  , compareSymbol
-  , class AppendSymbol
-  , appendSymbol
+  ( module Prim.Symbol
+  , module Data.Symbol
+  , append
+  , compare
+  , uncons
   , class Equals
   , equals
-  , class ConsSymbol
-  , unconsSymbol
   ) where
 
+import Prim.Symbol (class Append, class Compare, class Cons)
 import Data.Symbol (SProxy(..), class IsSymbol, reflectSymbol, reifySymbol)
 import Type.Data.Ordering (OProxy(..), kind Ordering, EQ)
 import Type.Data.Ordering (class Equals) as Ordering
 import Type.Data.Boolean (kind Boolean, BProxy(..))
 
--- | Compare two `Symbol` types
-class CompareSymbol (lhs :: Symbol)
-                    (rhs :: Symbol)
-                    (out :: Ordering) |
-                    lhs rhs -> out
+compare :: forall l r o. Compare l r o => SProxy l -> SProxy r -> OProxy o
+compare _ _ = OProxy
 
-compareSymbol :: forall l r o. CompareSymbol l r o => SProxy l -> SProxy r -> OProxy o
-compareSymbol _ _ = OProxy
+append :: forall l r o. Append l r o => SProxy l -> SProxy r -> SProxy o
+append _ _ = SProxy
 
-
--- | Append two `Symbol` types together
-class AppendSymbol (lhs :: Symbol)
-                   (rhs :: Symbol)
-                   (out :: Symbol) |
-                   lhs rhs -> out, lhs out -> rhs, rhs out -> lhs
-
-appendSymbol :: forall l r o. AppendSymbol l r o => SProxy l -> SProxy r -> SProxy o
-appendSymbol _ _ = SProxy
-
-class ConsSymbol (head :: Symbol)
-                 (tail :: Symbol)
-                 (sym :: Symbol) |
-                 sym -> head tail, head tail -> sym
-
-unconsSymbol :: forall h t s. ConsSymbol h t s => SProxy s -> {head :: SProxy h, tail :: SProxy t}
-unconsSymbol _ = {head : SProxy, tail : SProxy}
+uncons :: forall h t s. Cons h t s => SProxy s -> {head :: SProxy h, tail :: SProxy t}
+uncons _ = {head : SProxy, tail : SProxy}
 
 class Equals (lhs :: Symbol)
              (rhs :: Symbol)
              (out :: Boolean) |
              lhs rhs -> out
 
 instance equalsSymbol
-  :: (CompareSymbol lhs rhs ord,
+  :: (Compare lhs rhs ord,
       Ordering.Equals EQ ord out)
   => Equals lhs rhs out
 

src/Type/Prelude.purs

@@ -10,7 +10,7 @@ module Type.Prelude
 import Type.Data.Boolean (kind Boolean, True, False, BProxy(..), class IsBoolean, reflectBoolean, reifyBoolean)
 import Type.Data.Ordering (kind Ordering, LT, EQ, GT, OProxy(..), class IsOrdering, reflectOrdering, reifyOrdering)
 import Type.Proxy (Proxy(..))
-import Type.Data.Symbol (SProxy(..), class IsSymbol, reflectSymbol, reifySymbol, class CompareSymbol, compareSymbol, class AppendSymbol, appendSymbol)
+import Type.Data.Symbol (SProxy(..), class IsSymbol, reflectSymbol, reifySymbol, class Compare, compare, class Append, append, class Cons, uncons)
 import Type.Equality (class TypeEquals, from, to)
-import Type.Row (class RowLacks, class RowToList, class ListToRow, RProxy(..), RLProxy(..))
+import Type.Row (class Lacks, class RowToList, class ListToRow, RProxy(..), RLProxy(..))
 

src/Type/Row.purs

@@ -1,12 +1,8 @@
 module Type.Row
   ( RProxy(..)
-  , class RowLacks
-  , class RowLacking
-  , kind RowList
-  , Nil
-  , Cons
+  , module Prim.Row
+  , module Prim.RowList
   , RLProxy(..)
-  , class RowToList
   , class ListToRow
   , class RowListRemove
   , class RowListSet
@@ -16,58 +12,16 @@ module Type.Row
   , type (+)
   ) where
 
-import Prim.Row (class Cons, class Union)
+import Prim.Row (class Lacks, class Nub, class Cons)
+import Prim.RowList (kind RowList, Cons, Nil, class RowToList)
 import Type.Equality (class TypeEquals)
 import Type.Data.Symbol as Symbol
 import Type.Data.Boolean as Boolean
 
 data RProxy (row :: # Type) = RProxy
 
--- Must not be exported
-foreign import data Entry :: Type
-
--- | If you get "No type class instance was found" for this class, then your
--- | `row` shouldn't contain the label `key`.
-class RowLacking (entry :: Type)
-                 (key :: Symbol)
-                 (typ :: Type)
-                 (row :: # Type) |
-                 entry typ -> key row
-
-instance rowLacking :: RowLacking entry key entry row
-
--- | Encodes the constraint that a given row does not contain a specific key.
-class RowLacks (key :: Symbol)
-               (row :: # Type)
-
--- Append `Entry` at label `key` to the right of `row` then lookup `key` on the
--- left - if we check via instance solving that the `typ` we get back is
--- `Entry`, then `row` lacks `key`.  In the case that `row` doesn't lack
--- `key`, we get a "No type class instance found" error for:
--- `RowLacking Entry key typ row`.
-instance rowLacks
-  :: ( Cons key Entry () keyEntry
-     , Union row keyEntry rowKeyEntry
-     , Cons key typ ignored rowKeyEntry
-     , RowLacking Entry key typ row )
-  => RowLacks key row
-
-
--- | A type-level list representation of a row
-foreign import kind RowList
-foreign import data Nil :: RowList
-foreign import data Cons :: Symbol -> Type -> RowList -> RowList
-
 data RLProxy (rowList :: RowList) = RLProxy
 
--- | Extract the collection of entries in a closed row of types.
--- | The list of entries is sorted by label and preserves duplicates.
--- | The inverse of this operation is `ListToRow`.
--- | Solved by the compiler.
-class RowToList (row :: # Type)
-                (list :: RowList) |
-                row -> list
-
 -- | Convert a RowList to a row of types.
 -- | The inverse of this operation is `RowToList`.
 class ListToRow (list :: RowList)