Update for PureScript 0.11

.eslintrc.json

@@ -0,0 +1,28 @@
+{
+  "parserOptions": {
+    "ecmaVersion": 5
+  },
+  "extends": "eslint:recommended",
+  "env": {
+    "commonjs": true
+  },
+  "rules": {
+    "strict": [2, "global"],
+    "block-scoped-var": 2,
+    "consistent-return": 2,
+    "eqeqeq": [2, "smart"],
+    "guard-for-in": 2,
+    "no-caller": 2,
+    "no-extend-native": 2,
+    "no-loop-func": 2,
+    "no-new": 2,
+    "no-param-reassign": 2,
+    "no-return-assign": 2,
+    "no-unused-expressions": 2,
+    "no-use-before-define": 2,
+    "radix": [2, "always"],
+    "indent": [2, 2],
+    "quotes": [2, "double"],
+    "semi": [2, "always"]
+  }
+}

.gitignore

@@ -1,7 +1,6 @@
 /.*
 !/.gitignore
-!/.jscsrc
-!/.jshintrc
+!/.eslintrc.json
 !/.travis.yml
 /bower_components/
 /node_modules/

.travis.yml

@@ -1,7 +1,7 @@
 language: node_js
 dist: trusty
 sudo: required
-node_js: 6
+node_js: stable
 env:
   - PATH=$HOME/purescript:$PATH
 install:

bower.json

@@ -21,16 +21,16 @@
     "package.json"
   ],
   "dependencies": {
-    "purescript-arrays": "^3.0.0",
-    "purescript-either": "^2.0.0",
-    "purescript-foldable-traversable": "^2.0.0",
-    "purescript-functions": "^2.0.0",
-    "purescript-integers": "^2.0.0",
-    "purescript-lists": "^3.0.0",
-    "purescript-strings": "^2.0.0",
-    "purescript-transformers": "^2.0.0"
+    "purescript-arrays": "^4.0.0",
+    "purescript-either": "^3.0.0",
+    "purescript-foldable-traversable": "^3.0.0",
+    "purescript-functions": "^3.0.0",
+    "purescript-integers": "^3.0.0",
+    "purescript-lists": "^4.0.0",
+    "purescript-strings": "^3.0.0",
+    "purescript-transformers": "^3.0.0"
   },
   "devDependencies": {
-    "purescript-console": "^2.0.0"
+    "purescript-console": "^3.0.0"
   }
 }

examples/Applicative.purs

@@ -6,19 +6,24 @@ import Control.Monad.Eff (Eff)
 import Control.Monad.Eff.Console (CONSOLE, logShow)
 import Control.Monad.Except (runExcept)
 
-import Data.Foreign (F)
-import Data.Foreign.Class (class IsForeign, readJSON, readProp)
+import Data.Foreign (F, Foreign, readNumber)
+import Data.Foreign.Index ((!))
+
+import Example.Util.Value (foreignValue)
 
 data Point = Point Number Number Number
 
 instance showPoint :: Show Point where
   show (Point x y z) = "(Point " <> show [x, y, z] <> ")"
 
-instance pointIsForeign :: IsForeign Point where
-  read value = Point <$> readProp "x" value
-                     <*> readProp "y" value
-                     <*> readProp "z" value
+readPoint :: Foreign -> F Point
+readPoint value = do
+  Point
+    <$> (value ! "x" >>= readNumber)
+    <*> (value ! "y" >>= readNumber)
+    <*> (value ! "z" >>= readNumber)
 
 main :: Eff (console :: CONSOLE) Unit
-main = logShow $ runExcept $
-  readJSON """{ "x": 1, "y": 2, "z": 3 }""" :: F Point
+main =
+  logShow $ runExcept $
+    readPoint =<< foreignValue """{ "x": 1, "y": 2, "z": 3 }"""

examples/Arrays.purs

@@ -0,0 +1,19 @@
+module Example.Arrays where
+
+import Prelude
+
+import Control.Monad.Eff (Eff)
+import Control.Monad.Eff.Console (CONSOLE, logShow)
+import Control.Monad.Except (runExcept)
+
+import Data.Foreign (readArray, readNumber, readString)
+import Data.Traversable (traverse)
+
+import Example.Util.Value (foreignValue)
+
+main :: Eff (console :: CONSOLE) Unit
+main = do
+  logShow $ runExcept $
+    traverse readString =<< readArray =<< foreignValue """["hello", "world"]"""
+  logShow $ runExcept $
+    traverse readNumber =<< readArray =<< foreignValue """[1, 2, 3, 4]"""

examples/Complex.purs

@@ -6,35 +6,43 @@ import Control.Monad.Eff (Eff)
 import Control.Monad.Eff.Console (CONSOLE, logShow)
 import Control.Monad.Except (runExcept)
 
-import Data.Foreign (F)
-import Data.Foreign.Class (class IsForeign, readJSON, readProp)
-import Data.Foreign.NullOrUndefined (unNullOrUndefined)
+import Data.Foreign (F, Foreign, readArray, readBoolean, readNumber, readString, readNullOrUndefined)
+import Data.Foreign.Index ((!))
+import Data.Traversable (traverse)
 import Data.Maybe (Maybe)
 
-data SomeObject = SomeObject { foo :: String
-                             , bar :: Boolean
-                             , baz :: Number
-                             , list :: Array ListItem }
+import Example.Util.Value (foreignValue)
+
+newtype SomeObject =
+  SomeObject
+    { foo :: String
+    , bar :: Boolean
+    , baz :: Number
+    , list :: Array ListItem
+    }
 
 instance showSomeObject :: Show SomeObject where
   show (SomeObject o) =
     "(SomeObject { foo: " <> show o.foo <>
     ", bar: " <> show o.bar <>
     ", baz: " <> show o.baz <>
     ", list: " <> show o.list <>
-    " })"
+    "})"
 
-instance objectIsForeign :: IsForeign SomeObject where
-  read value = do
-    foo  <- readProp "foo"  value
-    bar  <- readProp "bar"  value
-    baz  <- readProp "baz"  value
-    list <- readProp "list" value
-    pure $ SomeObject { foo: foo, bar: bar, baz: baz, list: list }
+readSomeObject :: Foreign -> F SomeObject
+readSomeObject value = do
+  foo <- value ! "foo" >>= readString
+  bar <- value ! "bar" >>= readBoolean
+  baz <- value ! "baz" >>= readNumber
+  list <- value ! "list" >>= readArray >>= traverse readListItem
+  pure $ SomeObject { foo, bar, baz, list }
 
-data ListItem = ListItem { x :: Number
-                         , y :: Number
-                         , z :: Maybe Number }
+newtype ListItem =
+  ListItem
+    { x :: Number
+    , y :: Number
+    , z :: Maybe Number
+    }
 
 instance showListItem :: Show ListItem where
   show (ListItem o) =
@@ -43,14 +51,14 @@ instance showListItem :: Show ListItem where
     ", z: " <> show o.z <>
     " })"
 
-instance listItemIsForeign :: IsForeign ListItem where
-  read value = do
-    x <- readProp "x" value
-    y <- readProp "y" value
-    z <- unNullOrUndefined <$> readProp "z" value
-    pure $ ListItem { x: x, y: y, z: z }
+readListItem :: Foreign -> F ListItem
+readListItem value = do
+  x <- value ! "x" >>= readNumber
+  y <- value ! "y" >>= readNumber
+  z <- value ! "z" >>= readNullOrUndefined >>= traverse readNumber
+  pure $ ListItem { x, y, z }
 
 main :: Eff (console :: CONSOLE) Unit
 main = do
   let json = """{"foo":"hello","bar":true,"baz":1,"list":[{"x":1,"y":2},{"x":3,"y":4,"z":999}]}"""
-  logShow $ runExcept $ readJSON json :: F SomeObject
+  logShow $ runExcept $ readSomeObject =<< foreignValue json

examples/MaybeNullable.purs

@@ -3,19 +3,19 @@ module Example.MaybeNullable where
 import Prelude
 
 import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Console (CONSOLE, log, logShow)
+import Control.Monad.Eff.Console (CONSOLE, logShow)
 import Control.Monad.Except (runExcept)
 
-import Data.Foreign (F, unsafeFromForeign)
-import Data.Foreign.Class (readJSON, write)
-import Data.Foreign.Null (Null(..), unNull)
-import Data.Maybe (Maybe(..))
+import Data.Foreign (readBoolean, readNull)
+import Data.Traversable (traverse)
+
+import Example.Util.Value (foreignValue)
 
 -- Parsing values that are allowed to null or undefined is possible by
 -- using Maybe types.
 main :: Eff (console :: CONSOLE) Unit
 main = do
-  logShow $ unNull <$> runExcept (readJSON "null" :: F (Null Boolean))
-  logShow $ unNull <$> runExcept (readJSON "true" :: F (Null Boolean))
-  log $ unsafeFromForeign $ write $ Null Nothing :: Null Boolean
-  log $ unsafeFromForeign $ write $ Null $ Just true
+  logShow $ runExcept $
+    traverse readBoolean =<< readNull =<< foreignValue "null"
+  logShow $ runExcept $
+    traverse readBoolean =<< readNull =<< foreignValue "true"

examples/Nested.purs

@@ -6,9 +6,10 @@ import Control.Monad.Eff (Eff)
 import Control.Monad.Eff.Console (CONSOLE, logShow)
 import Control.Monad.Except (runExcept)
 
-import Data.Foreign (F)
-import Data.Foreign.Class (class IsForeign, readJSON, readProp)
-import Data.Foreign.Index (prop)
+import Data.Foreign (F, Foreign, readNumber, readString)
+import Data.Foreign.Index ((!))
+
+import Example.Util.Value (foreignValue)
 
 data Foo = Foo Bar Baz
 
@@ -25,12 +26,13 @@ instance showBar :: Show Bar where
 instance showBaz :: Show Baz where
   show (Baz n) = "(Baz " <> show n <> ")"
 
-instance fooIsForeign :: IsForeign Foo where
-  read value = do
-    s <- value # (prop "foo" >=> readProp "bar")
-    n <- value # (prop "foo" >=> readProp "baz")
-    pure $ Foo (Bar s) (Baz n)
+readFoo :: Foreign -> F Foo
+readFoo value = do
+  s <- value ! "foo" ! "bar" >>= readString
+  n <- value ! "foo" ! "baz" >>= readNumber
+  pure $ Foo (Bar s) (Baz n)
 
 main :: Eff (console :: CONSOLE) Unit
-main = do
-  logShow $ runExcept $ readJSON """{ "foo": { "bar": "bar", "baz": 1 } }""" :: F Foo
+main =
+  logShow $ runExcept $
+    readFoo =<< foreignValue """{ "foo": { "bar": "bar", "baz": 1 } }"""