Update dependencies

bower.json

@@ -22,12 +22,11 @@
   },
   "license": "MIT",
   "dependencies": {
-    "purescript-argonaut-core": "^1.0.0",
-    "purescript-generics": "^1.0.0",
-    "purescript-integers": "^1.0.0"
+    "purescript-argonaut-core": "^2.0.0",
+    "purescript-generics": "^3.0.0",
+    "purescript-integers": "^2.0.0"
   },
   "devDependencies": {
-    "purescript-strongcheck": "^1.1.1",
-    "purescript-strongcheck-generics": "garyb/purescript-strongcheck-generics#0.9.1-updates"
+    "purescript-strongcheck": "^2.0.0"
   }
 }

package.json

@@ -6,9 +6,9 @@
     "test": "pulp test"
   },
   "devDependencies": {
-    "pulp": "^9.0.0",
+    "pulp": "^9.0.1",
     "purescript-psa": "^0.3.9",
-    "purescript": "^0.9.1",
-    "rimraf": "^2.5.0"
+    "purescript": "^0.10.1",
+    "rimraf": "^2.5.4"
   }
 }

src/Data/Argonaut/Decode/Class.purs

@@ -7,12 +7,10 @@ module Data.Argonaut.Decode.Class
 
 import Prelude
 
-import Control.Alt ((<|>))
-import Control.Bind ((=<<))
-import Data.Bifunctor (lmap)
 import Data.Argonaut.Core (Json, JArray, JObject, isNull, foldJsonNull, foldJsonBoolean, foldJsonNumber, foldJsonString, toArray, toNumber, toObject, toString, toBoolean)
 import Data.Array (zipWithA)
-import Data.Either (either, Either(..))
+import Data.Bifunctor (lmap)
+import Data.Either (Either(..))
 import Data.Foldable (find)
 import Data.Generic (class Generic, GenericSpine(..), GenericSignature(..), fromSpine, toSignature)
 import Data.Int (fromNumber)
@@ -23,6 +21,7 @@ import Data.String (charAt, toChar)
 import Data.StrMap as SM
 import Data.Traversable (traverse, for)
 import Data.Tuple (Tuple(..))
+
 import Type.Proxy (Proxy(..))
 
 class DecodeJson a where
@@ -132,13 +131,10 @@ instance decodeList :: DecodeJson a => DecodeJson (List a) where
     <<< (traverse decodeJson <=< map (map fromFoldable) decodeJArray)
 
 instance decodeMap :: (Ord a, DecodeJson a, DecodeJson b) => DecodeJson (M.Map a b) where
-  decodeJson = map M.fromList <<< decodeJson
+  decodeJson = map (M.fromFoldable :: List (Tuple a b) -> M.Map a b) <<< decodeJson
 
 decodeJArray :: Json -> Either String JArray
 decodeJArray = maybe (Left "Value is not an Array") Right <<< toArray
 
 decodeJOject :: Json -> Either String JObject
 decodeJOject = maybe (Left "Value is not an Object") Right <<< toObject
-
-decodeMaybe :: forall a. DecodeJson a => Json -> Maybe a
-decodeMaybe = either (const Nothing) pure <<< decodeJson

src/Data/Argonaut/Decode/Combinators.purs

@@ -5,7 +5,7 @@ import Prelude
 import Data.Argonaut.Core (JObject)
 import Data.Argonaut.Decode.Class (class DecodeJson, decodeJson)
 import Data.Either (Either(..))
-import Data.Maybe (Maybe(Just, Nothing), maybe)
+import Data.Maybe (Maybe(..), maybe)
 import Data.StrMap as SM
 
 getField :: forall a. DecodeJson a => JObject -> String -> Either String a

src/Data/Argonaut/Encode/Class.purs

@@ -53,7 +53,7 @@ instance encodeJsonEither :: (EncodeJson a, EncodeJson b) => EncodeJson (Either
     where
     obj :: forall c. EncodeJson c => String -> c -> Json
     obj tag x =
-      fromObject $ SM.fromList $
+      fromObject $ SM.fromFoldable $
         Tuple "tag" (fromString tag) : Tuple "value" (encodeJson x) : Nil
 
 instance encodeJsonUnit :: EncodeJson Unit where

test/Test/Main.purs

@@ -5,13 +5,13 @@ import Prelude
 import Control.Monad.Eff.Console (log, logShow)
 
 import Data.Argonaut.Core (JObject, Json, toObject, fromObject, fromArray, fromString, fromNumber, fromBoolean, jsonNull)
-import Data.Argonaut.Decode (decodeJson, gDecodeJson')
-import Data.Argonaut.Encode (encodeJson, gEncodeJson, gEncodeJson', (~>), (:=))
+import Data.Argonaut.Decode (decodeJson)
+import Data.Argonaut.Encode (encodeJson, gEncodeJson, (:=), (~>))
 import Data.Array (zipWith, nubBy, length)
 import Data.Either (Either(..))
 import Data.Foldable (foldl)
 import Data.Function (on)
-import Data.Generic (class Generic, isValidSpine)
+import Data.Generic (class Generic)
 import Data.List (fromFoldable)
 import Data.Maybe (Maybe(..), maybe, isJust)
 import Data.StrMap as SM
@@ -21,7 +21,6 @@ import Test.StrongCheck (SC, quickCheck, quickCheck', (<?>))
 import Test.StrongCheck.Arbitrary (class Arbitrary, arbitrary)
 import Test.StrongCheck.Data.AlphaNumString (AlphaNumString(..))
 import Test.StrongCheck.Gen (Gen, Size, showSample, sized, frequency, oneOf, vectorOf)
-import Test.StrongCheck.Generic (GenericValue, runGenericValue)
 
 main :: SC () Unit
 main = do
@@ -155,10 +154,6 @@ derive instance genericUser :: Generic User
 
 genericsCheck :: SC () Unit
 genericsCheck = do
-  log "Check that gDecodeJson' and gEncodeJson' form an isomorphism"
-  quickCheck prop_iso_generic
-  log "Check that gDecodeJson' returns a valid spine"
-  quickCheck prop_decoded_spine_valid
   log "Print samples of values encoded with gEncodeJson"
   logShow $ gEncodeJson 5
   logShow $ gEncodeJson [1, 2, 3, 5]
@@ -189,17 +184,6 @@ genericsCheck = do
             }
         ]
     }
-  where
-
-  prop_iso_generic :: GenericValue -> Boolean
-  prop_iso_generic genericValue =
-    Right val.spine == gDecodeJson' val.signature (gEncodeJson' val.spine)
-    where val = runGenericValue genericValue
-
-  prop_decoded_spine_valid :: GenericValue -> Boolean
-  prop_decoded_spine_valid genericValue =
-    Right true == (isValidSpine val.signature <$> gDecodeJson' val.signature (gEncodeJson' val.spine))
-    where val = runGenericValue genericValue
 
 eitherCheck :: SC () Unit
 eitherCheck = do