Update to v0.14.0-rc3 (#31)

* Update packages.dhall to prepare-0.14 bootstrap

* Update CI to use v0.14.0-rc3 PS release

* Fix Proxy usage

* Update `fromRight` usage

Author: JordanMartinez

.github/workflows/ci.yml

@@ -15,6 +15,8 @@ jobs:
 
       - name: Set up a PureScript toolchain
         uses: purescript-contrib/setup-purescript@main
+        with:
+          purescript: "0.14.0-rc3"
 
       - name: Cache PureScript dependencies
         uses: actions/cache@v2

packages.dhall

@@ -1,4 +1,4 @@
 let upstream =
-      https://github.com/purescript/package-sets/releases/download/psc-0.13.8-20200831/packages.dhall sha256:cdb3529cac2cd8dd780f07c80fd907d5faceae7decfcaa11a12037df68812c83
+      https://raw.githubusercontent.com/purescript/package-sets/prepare-0.14/src/packages.dhall
 
 in  upstream

src/Data/Argonaut/Decode/Generic/Rep.purs

@@ -22,10 +22,11 @@ import Data.Array (uncons)
 import Data.Bifunctor (lmap)
 import Data.Either (Either(..), note)
 import Data.Generic.Rep as Rep
-import Data.Symbol (class IsSymbol, SProxy(..), reflectSymbol)
+import Data.Symbol (class IsSymbol, reflectSymbol)
 import Foreign.Object as FO
 import Partial.Unsafe (unsafeCrashWith)
 import Prim.TypeError (class Fail, Text)
+import Type.Proxy (Proxy(..))
 
 class DecodeRep r where
   decodeRepWith :: Encoding -> Json -> Either JsonDecodeError r
@@ -86,13 +87,13 @@ construct e valuesArray decodingErr = do
 
 instance decodeRepConstructorNoArgs :: IsSymbol name => DecodeRep (Rep.Constructor name Rep.NoArguments) where
   decodeRepWith e j = do
-    let name = reflectSymbol (SProxy :: SProxy name)
+    let name = reflectSymbol (Proxy :: Proxy name)
     {tag, decodingErr} <- withTag e j name
     construct e [] decodingErr
 else
 instance decodeRepConstructorArg :: (IsSymbol name, DecodeJson a) => DecodeRep (Rep.Constructor name (Rep.Argument a)) where
   decodeRepWith e j = do
-    let name = reflectSymbol (SProxy :: SProxy name)
+    let name = reflectSymbol (Proxy :: Proxy name)
     {tag, values, decodingErr} <- withTagAndValues e j name
     if e.unwrapSingleArguments
       then construct e [values] decodingErr
@@ -102,7 +103,7 @@ instance decodeRepConstructorArg :: (IsSymbol name, DecodeJson a) => DecodeRep (
 else
 instance decodeRepConstructor :: (IsSymbol name, DecodeRepArgs a) => DecodeRep (Rep.Constructor name a) where
   decodeRepWith e j = do
-    let name = reflectSymbol (SProxy :: SProxy name)
+    let name = reflectSymbol (Proxy :: Proxy name)
     {tag, values, decodingErr} <- withTagAndValues e j name
     valuesArray <- note (decodingErr $ AtKey e.valuesKey $ TypeMismatch "Array") (toArray values)
     construct e valuesArray decodingErr
@@ -150,7 +151,7 @@ instance decodeLiteralSumInst :: (DecodeLiteral a, DecodeLiteral b) => DecodeLit
 
 instance decodeLiteralConstructor :: (IsSymbol name) => DecodeLiteral (Rep.Constructor name (Rep.NoArguments)) where
   decodeLiteral tagNameTransform j = do
-    let name = reflectSymbol (SProxy :: SProxy name)
+    let name = reflectSymbol (Proxy :: Proxy name)
     let decodingErr = Named name
     tag <- note (decodingErr $ TypeMismatch "String") (toString j)
     when (tag /= tagNameTransform name) $

src/Data/Argonaut/Encode/Generic/Rep.purs

@@ -18,10 +18,11 @@ import Data.Argonaut.Types.Generic.Rep (Encoding, defaultEncoding)
 import Data.Argonaut.Core (Json, fromArray, fromObject, fromString)
 import Data.Argonaut.Encode.Class (class EncodeJson, encodeJson)
 import Data.Generic.Rep as Rep
-import Data.Symbol (class IsSymbol, SProxy(..), reflectSymbol)
+import Data.Symbol (class IsSymbol, reflectSymbol)
 import Foreign.Object as FO
 import Partial.Unsafe (unsafeCrashWith)
 import Prim.TypeError (class Fail, Text)
+import Type.Proxy (Proxy(..))
 
 class EncodeRep r where
   encodeRepWith :: Encoding -> r -> Json
@@ -39,7 +40,7 @@ instance encodeRepSum :: (EncodeRep a, EncodeRep b) => EncodeRep (Rep.Sum a b) w
 instance encodeRepConstructor :: (IsSymbol name, EncodeRepArgs a) => EncodeRep (Rep.Constructor name a) where
   encodeRepWith e (Rep.Constructor a) =
     fromObject
-      $ FO.insert e.tagKey (fromString (reflectSymbol (SProxy :: SProxy name)))
+      $ FO.insert e.tagKey (fromString (reflectSymbol (Proxy :: Proxy name)))
       $ FO.insert e.valuesKey values
       $ FO.empty
     where
@@ -89,9 +90,9 @@ instance encodeLiteralSumInst :: (EncodeLiteral a, EncodeLiteral b) => EncodeLit
   encodeLiteral tagNameTransform (Rep.Inr b) = encodeLiteral tagNameTransform b
 
 instance encodeLiteralConstructor :: (IsSymbol name) => EncodeLiteral (Rep.Constructor name Rep.NoArguments) where
-  encodeLiteral tagNameTransform _ = fromString <<< tagNameTransform $ reflectSymbol (SProxy :: SProxy name)
+  encodeLiteral tagNameTransform _ = fromString <<< tagNameTransform $ reflectSymbol (Proxy :: Proxy name)
 
-type FailMessage = 
+type FailMessage =
   Text """`encodeLiteralSum` can only be used with sum types, where all of the constructors are nullary. This is because a string literal cannot be encoded into a product type."""
 
 instance encodeLiteralConstructorCannotBeProduct

test/Main.purs

@@ -11,14 +11,14 @@ import Data.Argonaut.Encode.Class (class EncodeJson, encodeJson)
 import Data.Argonaut.Encode.Generic.Rep (class EncodeLiteral, encodeLiteralSumWithTransform, genericEncodeJson, genericEncodeJsonWith)
 import Data.Argonaut.Parser (jsonParser)
 import Data.Argonaut.Types.Generic.Rep (Encoding, defaultEncoding)
-import Data.Either (Either(..), either, fromRight)
+import Data.Either (Either(..), either)
 import Data.Generic.Rep (class Generic)
 import Data.Generic.Rep.Show (genericShow)
 import Data.String (toLower, toUpper)
 import Effect (Effect)
 import Effect.Console (log)
 import Effect.Exception (throw)
-import Partial.Unsafe (unsafePartial)
+import Partial.Unsafe (unsafeCrashWith)
 import Test.Assert (assert)
 
 data Example
@@ -144,7 +144,7 @@ main = do
   testLiteralSumWithTransform tagNameTransform original string = do
     let json = encodeLiteralSumWithTransform tagNameTransform original
     let parsed = decodeLiteralSumWithTransform tagNameTransform json
-    let parsed' = decodeLiteralSumWithTransform tagNameTransform <<< unsafePartial fromRight $ jsonParser string
+    let parsed' = decodeLiteralSumWithTransform tagNameTransform <<< either unsafeCrashWith identity $ jsonParser string
     log $ "Original:  " <> show original
     log $ "To JSON:   " <> stringify json
     log $ "From JSON: " <> show parsed