Update for typelevel-prelude 5 & PS 0.13 (#41)

Author: garyb

bower.json

@@ -28,7 +28,7 @@
     "purescript-unsafe-coerce": "^4.0.0",
     "purescript-partial": "^2.0.0",
     "purescript-maybe": "^4.0.0",
-    "purescript-typelevel-prelude": "^4.0.0",
+    "purescript-typelevel-prelude": "^5.0.0",
     "purescript-lists": "^5.0.0",
     "purescript-record": "^2.0.0",
     "purescript-enums": "^4.0.0"

src/Data/Functor/Variant.purs

@@ -33,10 +33,10 @@ import Data.Traversable as TF
 import Data.Variant.Internal (class Contractable, FProxy(..), class VariantFMatchCases) as Exports
 import Data.Variant.Internal (class Contractable, class VariantFMatchCases, class VariantTags, FProxy, RLProxy(..), RProxy(..), VariantFCase, VariantCase, contractWith, lookup, unsafeGet, unsafeHas, variantTags)
 import Partial.Unsafe (unsafeCrashWith)
+import Prim.Row as R
+import Prim.RowList as RL
 import Type.Equality (class TypeEquals)
 import Type.Proxy (Proxy(..))
-import Type.Row as R
-import Prim.Row as Row
 import Unsafe.Coerce (unsafeCoerce)
 
 newtype VariantFRep f a = VariantFRep
@@ -64,12 +64,12 @@ instance functorVariantF ∷ Functor (VariantF r) where
     coerceV ∷ ∀ f a. VariantFRep f a → VariantF r a
     coerceV = unsafeCoerce
 
-class FoldableVFRL (rl :: R.RowList) (row :: # Type) | rl -> row where
+class FoldableVFRL (rl :: RL.RowList) (row :: # Type) | rl -> row where
   foldrVFRL :: forall a b. RLProxy rl -> (a -> b -> b) -> b -> VariantF row a -> b
   foldlVFRL :: forall a b. RLProxy rl -> (b -> a -> b) -> b -> VariantF row a -> b
   foldMapVFRL :: forall a m. Monoid m => RLProxy rl -> (a -> m) -> VariantF row a -> m
 
-instance foldableNil :: FoldableVFRL R.Nil () where
+instance foldableNil :: FoldableVFRL RL.Nil () where
   foldrVFRL _ _ _ = case_
   foldlVFRL _ _ _ = case_
   foldMapVFRL _ _ = case_
@@ -78,41 +78,41 @@ instance foldableCons ::
   ( IsSymbol k
   , TF.Foldable f
   , FoldableVFRL rl r
-  , Row.Cons k (FProxy f) r r'
-  ) => FoldableVFRL (R.Cons k (FProxy f) rl) r' where
+  , R.Cons k (FProxy f) r r'
+  ) => FoldableVFRL (RL.Cons k (FProxy f) rl) r' where
   foldrVFRL _ f b = on k (TF.foldr f b) (foldrVFRL (RLProxy :: RLProxy rl) f b)
     where k = SProxy :: SProxy k
   foldlVFRL _ f b = on k (TF.foldl f b) (foldlVFRL (RLProxy :: RLProxy rl) f b)
     where k = SProxy :: SProxy k
   foldMapVFRL _ f = on k (TF.foldMap f) (foldMapVFRL (RLProxy :: RLProxy rl) f)
     where k = SProxy :: SProxy k
 
-class FoldableVFRL rl row <= TraversableVFRL (rl :: R.RowList) (row :: # Type) | rl -> row where
+class FoldableVFRL rl row <= TraversableVFRL (rl :: RL.RowList) (row :: # Type) | rl -> row where
   traverseVFRL :: forall f a b. Applicative f => RLProxy rl -> (a -> f b) -> VariantF row a -> f (VariantF row b)
 
-instance traversableNil :: TraversableVFRL R.Nil () where
+instance traversableNil :: TraversableVFRL RL.Nil () where
   traverseVFRL _ f = case_
 
 instance traversableCons ::
   ( IsSymbol k
   , TF.Traversable f
   , TraversableVFRL rl r
-  , Row.Cons k (FProxy f) r r'
+  , R.Cons k (FProxy f) r r'
   , R.Union r rx r'
-  ) => TraversableVFRL (R.Cons k (FProxy f) rl) r' where
+  ) => TraversableVFRL (RL.Cons k (FProxy f) rl) r' where
   traverseVFRL _ f = on k (TF.traverse f >>> map (inj k))
     (traverseVFRL (RLProxy :: RLProxy rl) f >>> map expand)
     where k = SProxy :: SProxy k
 
 instance foldableVariantF ::
-  (R.RowToList row rl, FoldableVFRL rl row) =>
+  (RL.RowToList row rl, FoldableVFRL rl row) =>
   TF.Foldable (VariantF row) where
     foldr = foldrVFRL (RLProxy :: RLProxy rl)
     foldl = foldlVFRL (RLProxy :: RLProxy rl)
     foldMap = foldMapVFRL (RLProxy :: RLProxy rl)
 
 instance traversableVariantF ::
-  (R.RowToList row rl, TraversableVFRL rl row) =>
+  (RL.RowToList row rl, TraversableVFRL rl row) =>
   TF.Traversable (VariantF row) where
     traverse = traverseVFRL (RLProxy :: RLProxy rl)
     sequence = TF.sequenceDefault
@@ -192,7 +192,7 @@ on p f g r =
 -- | `show :: Int -> String`, or give the whole record an appropriate type.
 onMatch
   ∷ ∀ rl r r1 r2 r3 a b
-  . R.RowToList r rl
+  . RL.RowToList r rl
   ⇒ VariantFMatchCases rl r1 a b
   ⇒ R.Union r1 r2 r3
   ⇒ Record r
@@ -234,7 +234,7 @@ case_ r = unsafeCrashWith case unsafeCoerce r of
 -- | ```
 match
   ∷ ∀ rl r r1 r2 a b
-  . R.RowToList r rl
+  . RL.RowToList r rl
   ⇒ VariantFMatchCases rl r1 a b
   ⇒ R.Union r1 () r2
   ⇒ Record r
@@ -327,20 +327,20 @@ unvariantF v = case (unsafeCoerce v ∷ VariantFRep UnknownF Unit) of
 revariantF ∷ ∀ r a. UnvariantF r a -> VariantF r a
 revariantF (UnvariantF f) = f inj
 
-class VariantFShows (rl ∷ R.RowList) x where
+class VariantFShows (rl ∷ RL.RowList) x where
   variantFShows ∷ RLProxy rl → Proxy x → L.List (VariantCase → String)
 
-instance showVariantFNil ∷ VariantFShows R.Nil x where
+instance showVariantFNil ∷ VariantFShows RL.Nil x where
   variantFShows _ _ = L.Nil
 
-instance showVariantFCons ∷ (VariantFShows rs x, TypeEquals a (FProxy f), Show (f x), Show x) ⇒ VariantFShows (R.Cons sym a rs) x where
+instance showVariantFCons ∷ (VariantFShows rs x, TypeEquals a (FProxy f), Show (f x), Show x) ⇒ VariantFShows (RL.Cons sym a rs) x where
   variantFShows _ p =
     L.Cons (coerceShow show) (variantFShows (RLProxy ∷ RLProxy rs) p)
     where
     coerceShow ∷ (f x → String) → VariantCase → String
     coerceShow = unsafeCoerce
 
-instance showVariantF ∷ (R.RowToList r rl, VariantTags rl, VariantFShows rl a, Show a) ⇒ Show (VariantF r a) where
+instance showVariantF ∷ (RL.RowToList r rl, VariantTags rl, VariantFShows rl a, Show a) ⇒ Show (VariantF r a) where
   show v1 =
     let
       VariantFRep v = unsafeCoerce v1 ∷ VariantFRep VariantFCase a

src/Data/Variant.purs

@@ -32,7 +32,8 @@ import Data.Symbol (SProxy(..), class IsSymbol, reflectSymbol)
 import Data.Variant.Internal (class Contractable, class VariantMatchCases) as Exports
 import Data.Variant.Internal (class Contractable, class VariantMatchCases, class VariantTags, BoundedDict, BoundedEnumDict, RLProxy(..), RProxy(..), VariantCase, VariantRep(..), contractWith, lookup, lookupCardinality, lookupEq, lookupFirst, lookupFromEnum, lookupLast, lookupOrd, lookupPred, lookupSucc, lookupToEnum, unsafeGet, unsafeHas, variantTags)
 import Partial.Unsafe (unsafeCrashWith)
-import Type.Row as R
+import Prim.Row as R
+import Prim.RowList as RL
 import Unsafe.Coerce (unsafeCoerce)
 
 foreign import data Variant ∷ # Type → Type
@@ -111,7 +112,7 @@ on p f g r =
 -- | `show :: Int -> String`, or give the whole record an appropriate type.
 onMatch
   ∷ ∀ rl r r1 r2 r3 b
-  . R.RowToList r rl
+  . RL.RowToList r rl
   ⇒ VariantMatchCases rl r1 b
   ⇒ R.Union r1 r2 r3
   ⇒ Record r
@@ -153,7 +154,7 @@ case_ r = unsafeCrashWith case unsafeCoerce r of
 -- | ```
 match
   ∷ ∀ rl r r1 r2 b
-  . R.RowToList r rl
+  . RL.RowToList r rl
   ⇒ VariantMatchCases rl r1 b
   ⇒ R.Union r1 () r2
   ⇒ Record r
@@ -239,20 +240,20 @@ unvariant v = case (unsafeCoerce v ∷ VariantRep Unit) of
 revariant ∷ ∀ r. Unvariant r -> Variant r
 revariant (Unvariant f) = f inj
 
-class VariantEqs (rl ∷ R.RowList) where
+class VariantEqs (rl ∷ RL.RowList) where
   variantEqs ∷ RLProxy rl → L.List (VariantCase → VariantCase → Boolean)
 
-instance eqVariantNil ∷ VariantEqs R.Nil where
+instance eqVariantNil ∷ VariantEqs RL.Nil where
   variantEqs _ = L.Nil
 
-instance eqVariantCons ∷ (VariantEqs rs, Eq a) ⇒ VariantEqs (R.Cons sym a rs) where
+instance eqVariantCons ∷ (VariantEqs rs, Eq a) ⇒ VariantEqs (RL.Cons sym a rs) where
   variantEqs _ =
     L.Cons (coerceEq eq) (variantEqs (RLProxy ∷ RLProxy rs))
     where
     coerceEq ∷ (a → a → Boolean) → VariantCase → VariantCase → Boolean
     coerceEq = unsafeCoerce
 
-instance eqVariant ∷ (R.RowToList r rl, VariantTags rl, VariantEqs rl) ⇒ Eq (Variant r) where
+instance eqVariant ∷ (RL.RowToList r rl, VariantTags rl, VariantEqs rl) ⇒ Eq (Variant r) where
   eq v1 v2 =
     let
       c1 = unsafeCoerce v1 ∷ VariantRep VariantCase
@@ -262,13 +263,13 @@ instance eqVariant ∷ (R.RowToList r rl, VariantTags rl, VariantEqs rl) ⇒ Eq
     in
       lookupEq tags eqs c1 c2
 
-class VariantBounded (rl ∷ R.RowList) where
+class VariantBounded (rl ∷ RL.RowList) where
   variantBounded ∷ RLProxy rl → L.List (BoundedDict VariantCase)
 
-instance boundedVariantNil ∷ VariantBounded R.Nil where
+instance boundedVariantNil ∷ VariantBounded RL.Nil where
   variantBounded _ = L.Nil
 
-instance boundedVariantCons ∷ (VariantBounded rs, Bounded a) ⇒ VariantBounded (R.Cons sym a rs) where
+instance boundedVariantCons ∷ (VariantBounded rs, Bounded a) ⇒ VariantBounded (RL.Cons sym a rs) where
   variantBounded _ = L.Cons dict (variantBounded (RLProxy ∷ RLProxy rs))
     where
     dict ∷ BoundedDict VariantCase
@@ -280,7 +281,7 @@ instance boundedVariantCons ∷ (VariantBounded rs, Bounded a) ⇒ VariantBounde
     coerce ∷ a → VariantCase
     coerce = unsafeCoerce
 
-instance boundedVariant ∷ (R.RowToList r rl, VariantTags rl, VariantEqs rl, VariantOrds rl, VariantBounded rl) ⇒ Bounded (Variant r) where
+instance boundedVariant ∷ (RL.RowToList r rl, VariantTags rl, VariantEqs rl, VariantOrds rl, VariantBounded rl) ⇒ Bounded (Variant r) where
   top =
     let
       tags = variantTags (RLProxy ∷ RLProxy rl)
@@ -300,10 +301,10 @@ instance boundedVariant ∷ (R.RowToList r rl, VariantTags rl, VariantEqs rl, Va
 class VariantBounded rl ⇐ VariantBoundedEnums rl where
   variantBoundedEnums ∷ RLProxy rl → L.List (BoundedEnumDict VariantCase)
 
-instance enumVariantNil ∷ VariantBoundedEnums R.Nil where
+instance enumVariantNil ∷ VariantBoundedEnums RL.Nil where
   variantBoundedEnums _ = L.Nil
 
-instance enumVariantCons ∷ (VariantBoundedEnums rs, BoundedEnum a) ⇒ VariantBoundedEnums (R.Cons sym a rs) where
+instance enumVariantCons ∷ (VariantBoundedEnums rs, BoundedEnum a) ⇒ VariantBoundedEnums (RL.Cons sym a rs) where
   variantBoundedEnums _ = L.Cons dict (variantBoundedEnums (RLProxy ∷ RLProxy rs))
     where
     dict ∷ BoundedEnumDict VariantCase
@@ -330,7 +331,7 @@ instance enumVariantCons ∷ (VariantBoundedEnums rs, BoundedEnum a) ⇒ Variant
     coerceCardinality ∷ Cardinality a → Int
     coerceCardinality = unsafeCoerce
 
-instance enumVariant ∷ (R.RowToList r rl, VariantTags rl, VariantEqs rl, VariantOrds rl, VariantBoundedEnums rl) ⇒ Enum (Variant r) where
+instance enumVariant ∷ (RL.RowToList r rl, VariantTags rl, VariantEqs rl, VariantOrds rl, VariantBoundedEnums rl) ⇒ Enum (Variant r) where
   pred a =
     let
       rep = unsafeCoerce a ∷ VariantRep VariantCase
@@ -351,7 +352,7 @@ instance enumVariant ∷ (R.RowToList r rl, VariantTags rl, VariantEqs rl, Varia
     in
       coerce $ lookupSucc rep tags bounds dicts
 
-instance boundedEnumVariant ∷ (R.RowToList r rl, VariantTags rl, VariantEqs rl, VariantOrds rl, VariantBoundedEnums rl) ⇒ BoundedEnum (Variant r) where
+instance boundedEnumVariant ∷ (RL.RowToList r rl, VariantTags rl, VariantEqs rl, VariantOrds rl, VariantBoundedEnums rl) ⇒ BoundedEnum (Variant r) where
   cardinality =
     Cardinality $ lookupCardinality $ variantBoundedEnums (RLProxy ∷ RLProxy rl)
 
@@ -371,20 +372,20 @@ instance boundedEnumVariant ∷ (R.RowToList r rl, VariantTags rl, VariantEqs rl
     in
       coerceV $ lookupToEnum n tags dicts
 
-class VariantOrds (rl ∷ R.RowList) where
+class VariantOrds (rl ∷ RL.RowList) where
   variantOrds ∷ RLProxy rl → L.List (VariantCase → VariantCase → Ordering)
 
-instance ordVariantNil ∷ VariantOrds R.Nil where
+instance ordVariantNil ∷ VariantOrds RL.Nil where
   variantOrds _ = L.Nil
 
-instance ordVariantCons ∷ (VariantOrds rs, Ord a) ⇒ VariantOrds (R.Cons sym a rs) where
+instance ordVariantCons ∷ (VariantOrds rs, Ord a) ⇒ VariantOrds (RL.Cons sym a rs) where
   variantOrds _ =
     L.Cons (coerceOrd compare) (variantOrds (RLProxy ∷ RLProxy rs))
     where
     coerceOrd ∷ (a → a → Ordering) → VariantCase → VariantCase → Ordering
     coerceOrd = unsafeCoerce
 
-instance ordVariant ∷ (R.RowToList r rl, VariantTags rl, VariantEqs rl, VariantOrds rl) ⇒ Ord (Variant r) where
+instance ordVariant ∷ (RL.RowToList r rl, VariantTags rl, VariantEqs rl, VariantOrds rl) ⇒ Ord (Variant r) where
   compare v1 v2 =
     let
       c1 = unsafeCoerce v1 ∷ VariantRep VariantCase
@@ -394,20 +395,20 @@ instance ordVariant ∷ (R.RowToList r rl, VariantTags rl, VariantEqs rl, Varian
     in
       lookupOrd tags ords c1 c2
 
-class VariantShows (rl ∷ R.RowList) where
+class VariantShows (rl ∷ RL.RowList) where
   variantShows ∷ RLProxy rl → L.List (VariantCase → String)
 
-instance showVariantNil ∷ VariantShows R.Nil where
+instance showVariantNil ∷ VariantShows RL.Nil where
   variantShows _ = L.Nil
 
-instance showVariantCons ∷ (VariantShows rs, Show a) ⇒ VariantShows (R.Cons sym a rs) where
+instance showVariantCons ∷ (VariantShows rs, Show a) ⇒ VariantShows (RL.Cons sym a rs) where
   variantShows _ =
     L.Cons (coerceShow show) (variantShows (RLProxy ∷ RLProxy rs))
     where
     coerceShow ∷ (a → String) → VariantCase → String
     coerceShow = unsafeCoerce
 
-instance showVariant ∷ (R.RowToList r rl, VariantTags rl, VariantShows rl) ⇒ Show (Variant r) where
+instance showVariant ∷ (RL.RowToList r rl, VariantTags rl, VariantShows rl) ⇒ Show (Variant r) where
   show v1 =
     let
       VariantRep v = unsafeCoerce v1 ∷ VariantRep VariantCase

src/Data/Variant/Internal.purs

@@ -22,6 +22,8 @@ module Data.Variant.Internal
   , BoundedEnumDict
   , impossible
   , module Exports
+  , module Type.Data.Row
+  , module Type.Data.RowList
   ) where
 
 import Prelude
@@ -32,11 +34,12 @@ import Data.Maybe (Maybe(..))
 import Data.Maybe as M
 import Data.Symbol (class IsSymbol, SProxy(SProxy), reflectSymbol)
 import Partial.Unsafe (unsafeCrashWith)
+import Prim.Row as R
+import Prim.RowList as RL
 import Record.Unsafe (unsafeGet, unsafeHas) as Exports
+import Type.Data.Row (RProxy(..))
+import Type.Data.RowList (RLProxy(..))
 import Type.Equality (class TypeEquals)
-import Type.Row (RProxy(..), RLProxy(..)) as Exports
-import Type.Row (RProxy, RLProxy(..))
-import Type.Row as R
 
 -- | Proxy for a `Functor`.
 data FProxy (a ∷ Type → Type) = FProxy
@@ -46,41 +49,41 @@ newtype VariantRep a = VariantRep
   , value ∷ a
   }
 
-class VariantMatchCases (rl ∷ R.RowList) (vo ∷ # Type) b | rl → vo b
+class VariantMatchCases (rl ∷ RL.RowList) (vo ∷ # Type) b | rl → vo b
 
 instance variantMatchCons
   ∷ ( VariantMatchCases rl vo' b
     , R.Cons sym a vo' vo
     , TypeEquals k (a → b)
     )
-  ⇒ VariantMatchCases (R.Cons sym k rl) vo b
+  ⇒ VariantMatchCases (RL.Cons sym k rl) vo b
 
 instance variantMatchNil
-  ∷ VariantMatchCases R.Nil () b
+  ∷ VariantMatchCases RL.Nil () b
 
-class VariantFMatchCases (rl ∷ R.RowList) (vo ∷ # Type) a b | rl → vo a b
+class VariantFMatchCases (rl ∷ RL.RowList) (vo ∷ # Type) a b | rl → vo a b
 
 instance variantFMatchCons
   ∷ ( VariantFMatchCases rl vo' a b
     , R.Cons sym (FProxy f) vo' vo
     , TypeEquals k (f a → b)
     )
-  ⇒ VariantFMatchCases (R.Cons sym k rl) vo a b
+  ⇒ VariantFMatchCases (RL.Cons sym k rl) vo a b
 
 instance variantFMatchNil
-  ∷ VariantFMatchCases R.Nil () a b
+  ∷ VariantFMatchCases RL.Nil () a b
 
 foreign import data VariantCase ∷ Type
 
 foreign import data VariantFCase ∷ Type → Type
 
-class VariantTags (rl ∷ R.RowList) where
+class VariantTags (rl ∷ RL.RowList) where
   variantTags ∷ RLProxy rl → L.List String
 
-instance variantTagsNil ∷ VariantTags R.Nil where
+instance variantTagsNil ∷ VariantTags RL.Nil where
   variantTags _ = L.Nil
 
-instance variantTagsCons ∷ (VariantTags rs, IsSymbol sym) ⇒ VariantTags (R.Cons sym a rs) where
+instance variantTagsCons ∷ (VariantTags rs, IsSymbol sym) ⇒ VariantTags (RL.Cons sym a rs) where
   variantTags _ = L.Cons (reflectSymbol (SProxy ∷ SProxy sym)) (variantTags (RLProxy ∷ RLProxy rs))
 
 -- | A specialized lookup function which bails early. Foldable's `elem`
@@ -249,7 +252,7 @@ class Contractable gt lt where
   contractWith ∷ ∀ f a. Alternative f ⇒ RProxy gt → RProxy lt → String → a → f a
 
 instance contractWithInstance
-  ∷ ( R.RowToList lt ltl
+  ∷ ( RL.RowToList lt ltl
     , R.Union lt a gt
     , VariantTags ltl
     )