Merge pull request #16 from kRITZCREEK/compiler/0.12

Updates for 0.12

Author: garyb

bower.json

@@ -16,15 +16,16 @@
     "package.json"
   ],
   "dependencies": {
-    "purescript-argonaut-core": "^3.1.1",
-    "purescript-codec": "^2.1.0",
-    "purescript-generics-rep": "^5.4.0",
-    "purescript-variant": "^4.0.0",
-    "purescript-typelevel-prelude": "^2.6.0",
-    "purescript-type-equality": "^2.1.0"
+    "purescript-argonaut-core": "^4.0.0",
+    "purescript-codec": "v3.0.0",
+    "purescript-generics-rep": "^6.0.0",
+    "purescript-variant": "^5.0.0",
+    "purescript-ordered-collections": "^1.0.0",
+    "purescript-typelevel-prelude": "^3.0.0",
+    "purescript-type-equality": "^3.0.0"
   },
   "devDependencies": {
-    "purescript-argonaut-codecs": "^3.2.0",
-    "purescript-quickcheck": "^4.6.1"
+    "purescript-argonaut-codecs": "^4.0.0",
+    "purescript-quickcheck": "^5.0.0"
   }
 }

package.json

@@ -6,9 +6,9 @@
     "test": "pulp test"
   },
   "devDependencies": {
-    "pulp": "^11.0.0",
-    "purescript": "^0.11.5",
-    "purescript-psa": "^0.5.1",
-    "rimraf": "^2.6.1"
+    "pulp": "^12.0.0",
+    "purescript": "^0.12.0",
+    "purescript-psa": "^0.6.0",
+    "rimraf": "^2.6.2"
   }
 }

src/Data/Codec/Argonaut.purs

@@ -37,18 +37,19 @@ import Data.Codec (BasicCodec, Codec, GCodec(..), basicCodec, bihoistGCodec, dec
 import Data.Codec (decode, encode, (~), (<~<)) as Exports
 import Data.Either (Either(..), note)
 import Data.Generic.Rep (class Generic)
-import Data.Generic.Rep.Show (genericShow)
 import Data.Int as I
 import Data.List ((:))
 import Data.List as L
 import Data.Maybe (Maybe(..), maybe, fromJust)
 import Data.Profunctor.Star (Star(..))
-import Data.StrMap as SM
 import Data.String as S
+import Data.String.CodeUnits as SCU
 import Data.Symbol (class IsSymbol, SProxy, reflectSymbol)
 import Data.Traversable (traverse)
 import Data.Tuple (Tuple(..))
+import Foreign.Object as FO
 import Partial.Unsafe (unsafePartial)
+import Prim.Row as Row
 import Unsafe.Coerce (unsafeCoerce)
 
 -- | Codec type for `Json` values.
@@ -68,7 +69,13 @@ derive instance ordJsonDecodeError ∷ Ord JsonDecodeError
 derive instance genericJsonDecodeError ∷ Generic JsonDecodeError _
 
 instance showJsonDecodeError ∷ Show JsonDecodeError where
-  show err = genericShow err
+  show = case _ of
+    TypeMismatch s -> "(TypeMismatch " <> show s <> ")"
+    UnexpectedValue j -> "(UnexpectedValue " <> J.stringify j <> ")"
+    AtIndex i e -> "(AtIndex " <> show i <> " " <> show e <> ")"
+    AtKey k e -> "(AtKey " <> show k <> " " <> show e <> ")"
+    Named s e -> "(Named " <> show s <> " " <> show e <> ")"
+    MissingValue -> "MissingValue"
 
 -- | Prints a `JsonDecodeError` as a somewhat readable error message.
 printJsonDecodeError ∷ JsonDecodeError → String
@@ -85,11 +92,11 @@ printJsonDecodeError err =
 
 -- | The "identity codec" for `Json` values.
 json ∷ JsonCodec J.Json
-json = basicCodec pure id
+json = basicCodec pure identity
 
 -- | A codec for `null` values in `Json`.
-null ∷ JsonCodec J.JNull
-null = jsonPrimCodec "Null" J.toNull J.fromNull
+null ∷ JsonCodec Unit
+null = jsonPrimCodec "Null" J.toNull (const J.jsonNull)
 
 -- | A codec for `Boolean` values in `Json`.
 boolean ∷ JsonCodec Boolean
@@ -107,22 +114,26 @@ int = jsonPrimCodec "Int" (I.fromNumber <=< J.toNumber) (J.fromNumber <<< I.toNu
 string ∷ JsonCodec String
 string = jsonPrimCodec "String" J.toString J.fromString
 
+-- | A codec for `Codepoint` values in `Json`.
+codePoint ∷ JsonCodec S.CodePoint
+codePoint = jsonPrimCodec "CodePoint" (S.codePointAt 0 <=< J.toString) (J.fromString <<< S.singleton)
+
 -- | A codec for `Char` values in `Json`.
 char ∷ JsonCodec Char
-char = jsonPrimCodec "Char" (S.toChar <=< J.toString) (J.fromString <<< S.singleton)
+char = jsonPrimCodec "Char" (SCU.toChar <=< J.toString) (J.fromString <<< SCU.singleton)
 
 -- | A codec for `Void` values.
 void ∷ JsonCodec Void
 void = jsonPrimCodec "Void" (const Nothing) absurd
 
--- | A codec for a `JArray` values in `Json`. This does not decode the values
+-- | A codec for `Array Json` values in `Json`. This does not decode the values
 -- | of the array, for that use `array` for a general array decoder, or
 -- | `indexedArray` with `index` to decode fixed length array encodings.
-jarray ∷ JsonCodec J.JArray
+jarray ∷ JsonCodec (Array J.Json)
 jarray = jsonPrimCodec "Array" J.toArray J.fromArray
 
 -- | A codec for `JObject` values in `Json`.
-jobject ∷ JsonCodec J.JObject
+jobject ∷ JsonCodec (FO.Object J.Json)
 jobject = jsonPrimCodec "Object" J.toObject J.fromObject
 
 -- | A codec for `Array` values.
@@ -144,7 +155,7 @@ array codec = GCodec dec enc
 type JIndexedCodec a =
   Codec
     (Either JsonDecodeError)
-    J.JArray
+    (Array J.Json)
     (L.List J.Json)
     a a
 
@@ -181,27 +192,27 @@ index ix codec = GCodec dec enc
 type JPropCodec a =
   Codec
     (Either JsonDecodeError)
-    J.JObject
-    (L.List J.JAssoc)
+    (FO.Object J.Json)
+    (L.List (Tuple String J.Json))
     a a
 
 -- | A codec for objects that are encoded with specific properties.
 object ∷ ∀ a. String → JPropCodec a → JsonCodec a
 object name =
   bihoistGCodec
     (\r → ReaderT (BF.lmap (Named name) <<< runReaderT r <=< decode jobject))
-    (mapWriter (BF.rmap (J.fromObject <<< SM.fromFoldable)))
+    (mapWriter (BF.rmap (J.fromObject <<< FO.fromFoldable)))
 
 -- | A codec for a property of an object.
 prop ∷ ∀ a. String → JsonCodec a → JPropCodec a
 prop key codec = GCodec dec enc
   where
-  dec ∷ ReaderT J.JObject (Either JsonDecodeError) a
+  dec ∷ ReaderT (FO.Object J.Json) (Either JsonDecodeError) a
   dec = ReaderT \obj →
-    BF.lmap (AtKey key) case SM.lookup key obj of
+    BF.lmap (AtKey key) case FO.lookup key obj of
       Just val → decode codec val
       Nothing → Left MissingValue
-  enc ∷ Star (Writer (L.List J.JAssoc)) a a
+  enc ∷ Star (Writer (L.List (Tuple String J.Json))) a a
   enc = Star \val → writer $ Tuple val (pure (Tuple key (encode codec val)))
 
 -- | The starting value for a object-record codec. Used with `recordProp` it
@@ -223,32 +234,32 @@ record = GCodec (pure {}) (Star \val → writer (Tuple val L.Nil))
 recordProp
   ∷ ∀ p a r r'
   . IsSymbol p
-  ⇒ RowCons p a r r'
+  ⇒ Row.Cons p a r r'
   ⇒ SProxy p
   → JsonCodec a
   → JPropCodec (Record r)
   → JPropCodec (Record r')
 recordProp p codecA codecR =
   let key = reflectSymbol p in GCodec (dec' key) (enc' key)
   where
-    dec' ∷ String → ReaderT J.JObject (Either JsonDecodeError) (Record r')
+    dec' ∷ String → ReaderT (FO.Object J.Json) (Either JsonDecodeError) (Record r')
     dec' key = ReaderT \obj → do
       r ← decode codecR obj
-      a ← BF.lmap (AtKey key) case SM.lookup key obj of
+      a ← BF.lmap (AtKey key) case FO.lookup key obj of
         Just val → decode codecA val
         Nothing → Left MissingValue
       pure $ unsafeSet key a r
-    enc' ∷ String → Star (Writer (L.List J.JAssoc)) (Record r') (Record r')
+    enc' ∷ String → Star (Writer (L.List (Tuple String J.Json))) (Record r') (Record r')
     enc' key = Star \val →
       writer $ Tuple val
         $ Tuple key (encode codecA (unsafeGet key val))
         : encode codecR (unsafeForget val)
     unsafeForget ∷ Record r' → Record r
     unsafeForget = unsafeCoerce
     unsafeSet ∷ String → a → Record r → Record r'
-    unsafeSet key a = unsafeCoerce <<< SM.insert key a <<< unsafeCoerce
+    unsafeSet key a = unsafeCoerce <<< FO.insert key a <<< unsafeCoerce
     unsafeGet ∷ String → Record r' → a
-    unsafeGet s = unsafePartial fromJust <<< SM.lookup s <<< unsafeCoerce
+    unsafeGet s = unsafePartial fromJust <<< FO.lookup s <<< unsafeCoerce
 
 jsonPrimCodec
   ∷ ∀ a

src/Data/Codec/Argonaut/Common.purs

@@ -14,7 +14,7 @@ import Data.List as L
 import Data.Map as M
 import Data.Maybe (Maybe(..))
 import Data.Profunctor (dimap)
-import Data.StrMap as SM
+import Foreign.Object as FO
 import Data.Tuple (Tuple(..), fst, snd)
 
 -- | A codec for `Maybe` values.
@@ -80,5 +80,5 @@ map codecA = dimap M.toUnfoldable M.fromFoldable <<< array <<< tuple codecA
 -- | A codec for `StrMap` values.
 -- |
 -- | Encodes as an array of two-element key/value arrays in JSON.
-strMap ∷ ∀ a. JsonCodec a → JsonCodec (SM.StrMap a)
-strMap = dimap SM.toUnfoldable SM.fromFoldable <<< array <<< tuple string
+foreignObject ∷ ∀ a. JsonCodec a → JsonCodec (FO.Object a)
+foreignObject = dimap FO.toUnfoldable FO.fromFoldable <<< array <<< tuple string

src/Data/Codec/Argonaut/Compat.purs

@@ -15,7 +15,7 @@ import Data.Codec.Argonaut.Common (either, list, map, tuple) as Common
 import Data.Either (Either)
 import Data.Functor as F
 import Data.Maybe (Maybe(..))
-import Data.StrMap as SM
+import Foreign.Object as FO
 import Data.Traversable (traverse)
 import Data.Tuple (Tuple(..))
 
@@ -42,17 +42,17 @@ maybe codec = basicCodec dec enc
 -- | Encodes as a JSON object with the keys as properties.
 -- |
 -- | ```purescript
--- | encode (strMap int) (Data.StrMap.fromFoldable [Tuple "a" 1, Tuple "b" 2]) == "{ \"a\": 1, \"b\": 2}"
+-- | encode (foreignObject int) (Foreign.Object.fromFoldable [Tuple "a" 1, Tuple "b" 2]) == "{ \"a\": 1, \"b\": 2}"
 -- | ```
-strMap ∷ ∀ a. JsonCodec a → JsonCodec (SM.StrMap a)
-strMap codec =
+foreignObject ∷ ∀ a. JsonCodec a → JsonCodec (FO.Object a)
+foreignObject codec =
   mapCodec
-    (BF.lmap (Named "StrMap") <<< F.map fromArray <<< traverse decodeItem <<< SM.toUnfoldable)
+    (BF.lmap (Named "StrMap") <<< F.map fromArray <<< traverse decodeItem <<< FO.toUnfoldable)
     (F.map (encode codec))
     jobject
   where
-  fromArray ∷ ∀ v. Array (Tuple String v) → SM.StrMap v
-  fromArray = SM.fromFoldable
+  fromArray ∷ ∀ v. Array (Tuple String v) → FO.Object v
+  fromArray = FO.fromFoldable
   decodeItem ∷ Tuple String J.Json → Either JsonDecodeError (Tuple String a)
   decodeItem (Tuple key value) =
     BF.bimap (AtKey key) (Tuple key) (decode codec value)

src/Data/Codec/Argonaut/Migration.purs

@@ -12,8 +12,8 @@ import Data.Argonaut.Core as J
 import Data.Codec (basicCodec)
 import Data.Codec.Argonaut (JsonCodec)
 import Data.Maybe (Maybe(..), maybe, fromMaybe)
-import Data.StrMap as SM
-import Data.StrMap.ST as SMST
+import Foreign.Object as FO
+import Foreign.Object.ST as FOST
 import Data.Tuple (Tuple(..), uncurry)
 
 -- | When dealing with a JSON object that may be missing a field, this codec
@@ -37,12 +37,12 @@ addDefaultOrUpdateField field = alterField field <<< map Just
 -- | codec can be used to alter the JSON before parsing to ensure the new field
 -- | name is used instead
 renameField ∷ String → String → JsonCodec J.Json
-renameField oldName newName = basicCodec (pure <<< dec) id
+renameField oldName newName = basicCodec (pure <<< dec) identity
   where
   dec ∷ J.Json → J.Json
-  dec j = J.foldJsonObject j (J.fromObject <<< rename) j
-  rename ∷ J.JObject → J.JObject
-  rename obj = maybe obj (uncurry (SM.insert newName)) (SM.pop oldName obj)
+  dec j = J.caseJsonObject j (J.fromObject <<< rename) j
+  rename ∷ FO.Object J.Json → FO.Object J.Json
+  rename obj = maybe obj (uncurry (FO.insert newName)) (FO.pop oldName obj)
 
 -- | Prepares an object from a legacy codec for use in a `Variant` or
 -- | `taggedSum` codec.
@@ -65,29 +65,29 @@ renameField oldName newName = basicCodec (pure <<< dec) id
 -- | If the tag field is missing from the input, it will also be missing in the
 -- | output.
 nestForTagged ∷ JsonCodec J.Json
-nestForTagged = basicCodec (pure <<< dec) id
+nestForTagged = basicCodec (pure <<< dec) identity
   where
   dec ∷ J.Json → J.Json
-  dec j = J.foldJsonObject j (J.fromObject <<< rewrite) j
-  rewrite ∷ J.JObject → J.JObject
+  dec j = J.caseJsonObject j (J.fromObject <<< rewrite) j
+  rewrite ∷ FO.Object J.Json → FO.Object J.Json
   rewrite obj =
-    case SM.pop "tag" obj of
-      Nothing → SM.pureST do
-        result ← SMST.new
-        SMST.poke result "value" (mkValue obj)
-      Just (Tuple tagValue obj') → SM.pureST do
-        result ← SMST.new
-        _ ← SMST.poke result "tag" tagValue
-        SMST.poke result "value" (mkValue obj')
-  mkValue ∷ J.JObject → J.Json
-  mkValue obj = case SM.pop "value" obj of
-    Just (Tuple valueValue obj') | SM.isEmpty obj' → valueValue
+    case FO.pop "tag" obj of
+      Nothing → FO.runST do
+        result ← FOST.new
+        FOST.poke "value" (mkValue obj) result
+      Just (Tuple tagValue obj') → FO.runST do
+        result ← FOST.new
+        _ ← FOST.poke "tag" tagValue result
+        FOST.poke "value" (mkValue obj') result
+  mkValue ∷ FO.Object J.Json → J.Json
+  mkValue obj = case FO.pop "value" obj of
+    Just (Tuple valueValue obj') | FO.isEmpty obj' → valueValue
     _ → J.fromObject obj
 
 alterField ∷ String → (Maybe J.Json → Maybe J.Json) → JsonCodec J.Json
-alterField field f = basicCodec (pure <<< dec) id
+alterField field f = basicCodec (pure <<< dec) identity
   where
   dec ∷ J.Json → J.Json
-  dec j = J.foldJsonObject j (J.fromObject <<< setDefault) j
-  setDefault ∷ J.JObject → J.JObject
-  setDefault = SM.alter f field
+  dec j = J.caseJsonObject j (J.fromObject <<< setDefault) j
+  setDefault ∷ FO.Object J.Json → FO.Object J.Json
+  setDefault = FO.alter f field

src/Data/Codec/Argonaut/Record.purs

@@ -5,8 +5,9 @@ module Data.Codec.Argonaut.Record
   ) where
 
 import Data.Codec.Argonaut as CA
-import Data.Record as Rec
 import Data.Symbol (class IsSymbol, SProxy(..))
+import Prim.Row as Row
+import Record as Rec
 import Type.Equality as TE
 import Type.Row as R
 import Unsafe.Coerce (unsafeCoerce)
@@ -19,8 +20,8 @@ instance rowListCodecNil ∷ RowListCodec R.Nil () () where
 
 instance rowListCodecCons ∷
   ( RowListCodec rs ri' ro'
-  , RowCons sym (CA.JsonCodec a) ri' ri
-  , RowCons sym a ro' ro
+  , Row.Cons sym (CA.JsonCodec a) ri' ri
+  , Row.Cons sym a ro' ro
   , IsSymbol sym
   , TE.TypeEquals co (CA.JsonCodec a)
   ) ⇒ RowListCodec (R.Cons sym co rs) ri ro where

src/Data/Codec/Argonaut/Sum.purs

@@ -14,8 +14,8 @@ import Data.Codec.Argonaut (JsonCodec, JsonDecodeError(..), jobject, json, prop,
 import Data.Either (Either(..))
 import Data.Maybe (Maybe(..), maybe)
 import Data.Profunctor.Star (Star(..))
-import Data.StrMap as SM
-import Data.StrMap.ST as SMST
+import Foreign.Object as FO
+import Foreign.Object.ST as FOST
 import Data.Tuple (Tuple(..))
 
 -- | A helper for defining JSON codecs for "enum" sum types, where every
@@ -74,7 +74,7 @@ taggedSum name printTag parseTag f g = GCodec decodeCase encodeCase
   encodeCase = Star case _ of
     a | Tuple tag value ← g a →
       writer $ Tuple a $ encode jobject $
-        SM.pureST do
-          obj ← SMST.new
-          _ ← SMST.poke obj "tag" (encode string (printTag tag))
-          maybe (pure obj) (SMST.poke obj "value") value
+        FO.runST do
+          obj ← FOST.new
+          _ ← FOST.poke "tag" (encode string (printTag tag)) obj
+          maybe (pure obj) (\v -> FOST.poke "value" v obj) value