Drop IsForeign, general updates

Author: garyb

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,18 @@
+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 (readArrayWith, readNumber, readString)
+
+import Example.Util.Value (foreignValue)
+
+main :: Eff (console :: CONSOLE) Unit
+main = do
+  logShow $ runExcept $
+    readArrayWith readString =<< foreignValue """["hello", "world"]"""
+  logShow $ runExcept $
+    readArrayWith readNumber =<< 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/Either.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/JSONArrays.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 } }"""

examples/JSONSimpleTypes.purs

@@ -3,34 +3,27 @@ module Example.Objects 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, writeObject, unsafeFromForeign)
-import Data.Foreign.Class (class AsForeign, class IsForeign, (.=), readJSON, readProp, write)
+import Data.Foreign (F, Foreign, readNumber)
+import Data.Foreign.Index ((!))
 
--- | To parse objects of a particular type, we need to define some helper
---   data types as making class instances for records is not possible.
-data Point = Point { x :: Number, y :: Number }
+import Example.Util.Value (foreignValue)
+
+newtype Point = Point { x :: Number, y :: Number }
 
 instance showPoint :: Show Point where
-  show (Point o) = "(Point { x: " <> show o.x <> ", y: " <> show o.y <> " })"
-
-instance pointAsForeign :: AsForeign Point where
-  write (Point o) = writeObject [ "x" .= o.x
-                                , "y" .= o.y
-                                ]
-
--- | The IsForeign implementations for these types are basically boilerplate,
---   type inference takes care of most of the work so we don't have to
---   explicitly define the type each of the properties we're parsing.
-instance pointIsForeign :: IsForeign Point where
-  read value = do
-    x <- readProp "x" value
-    y <- readProp "y" value
-    pure $ Point { x: x, y: y }
+  show (Point { x, y }) =
+    "(Point { x: " <> show x <> ", y: " <> show y <> " })"
+
+readPoint :: Foreign -> F Point
+readPoint value = do
+  x <- value ! "x" >>= readNumber
+  y <- value ! "y" >>= readNumber
+  pure $ Point { x, y }
 
 main :: Eff (console :: CONSOLE) Unit
 main = do
-  logShow $ runExcept $ readJSON """{ "x": 1, "y": 2 }""" :: F Point
-  log $ unsafeFromForeign $ write $ Point { x: 1.0, y: 2.0 }
+  logShow $ runExcept $
+    readPoint =<< foreignValue """{ "x": 1, "y": 2 }"""

examples/MaybeNullable.purs

@@ -6,36 +6,40 @@ 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, readArrayWith, readBoolean, readNumber, readString)
+import Data.Foreign.Index ((!))
 
--- | See the `Objects` example for an explanation of how to parse objects
---   like this.
-data Point = Point { x :: Number, y :: Number }
+import Example.Util.Value (foreignValue)
+
+newtype Point = Point { x :: Number, y :: Number }
 
 instance showPoint :: Show Point where
   show (Point o) = "(Point { x: " <> show o.x <> ", y: " <> show o.y <> " })"
 
-instance pointIsForeign :: IsForeign Point where
-  read value = do
-    x <- readProp "x" value
-    y <- readProp "y" value
-    pure $ Point { x: x, y: y }
+readPoint :: Foreign -> F Point
+readPoint value = do
+  x <- value ! "x" >>= readNumber
+  y <- value ! "y" >>= readNumber
+  pure $ Point { x: x, y: y }
 
 main :: Eff (console :: CONSOLE) Unit
 main = do
 
   -- When trying to parse invalid JSON we catch an exception from
   -- `JSON.parse` and pass it on.
-  logShow $ runExcept $ readJSON "not even JSON" :: F String
+  logShow $ runExcept $
+    readString =<< foreignValue "not even JSON"
 
   -- When attempting to coerce one type to another we get an error.
-  logShow $ runExcept $ readJSON "26" :: F Boolean
+  logShow $ runExcept $
+    readBoolean =<< foreignValue "26"
 
   -- When parsing fails in an array, we're told at which index the value that
   -- failed to parse was, along with the reason the value didn't parse.
-  logShow $ runExcept $ readJSON "[1, true, 3]" :: F (Array Boolean)
+  logShow $ runExcept $
+    readArrayWith readBoolean =<< foreignValue "[1, true, 3]"
 
   -- When parsing fails in an object, we're the name of the property which
   -- failed to parse was, along with the reason the value didn't parse.
-  logShow $ runExcept $ readJSON """{ "x": 1, "y": false }""" :: F Point
+  logShow $ runExcept $
+    readPoint =<< foreignValue """{ "x": 1, "y": false }"""