Merge pull request #28 from afcondon/examplesForv07

simple edits to make examples work in PSv0.7

examples/Applicative.purs

@@ -5,6 +5,7 @@ import Prelude
 import Data.Foreign
 import Data.Foreign.Index
 import Data.Foreign.Class
+import Control.Monad.Eff.Console
 
 data Point = Point Number Number Number
 
@@ -16,5 +17,5 @@ instance pointIsForeign :: IsForeign Point where
                      <*> readProp "y" value
                      <*> readProp "z" value
 
-main = Console.print $
+main = print $
   readJSON """{ "x": 1, "y": 2, "z": 3 }""" :: F Point

examples/Complex.purs

@@ -6,11 +6,12 @@ import Data.Foreign
 import Data.Foreign.Class
 import Data.Foreign.NullOrUndefined
 import Data.Maybe (Maybe())
+import Control.Monad.Eff.Console
 
 data SomeObject = SomeObject { foo :: String
                              , bar :: Boolean
                              , baz :: Number
-                             , list :: [ListItem] }
+                             , list :: Array ListItem }
 
 instance showSomeObject :: Show SomeObject where
   show (SomeObject o) =
@@ -48,4 +49,4 @@ instance listItemIsForeign :: IsForeign ListItem where
 
 main = do
   let json = """{"foo":"hello","bar":true,"baz":1,"list":[{"x":1,"y":2},{"x":3,"y":4,"z":999}]}"""
-  Console.print $ readJSON json :: F SomeObject
+  print $ readJSON json :: F SomeObject

examples/JSONArrays.purs

@@ -4,7 +4,8 @@ import Prelude
 
 import Data.Foreign
 import Data.Foreign.Class
+import Control.Monad.Eff.Console
 
 main = do
-  Console.print $ readJSON """["hello", "world"]""" :: F (Array String)
-  Console.print $ readJSON """[1, 2, 3, 4]""" :: F (Array Number)
+  print $ readJSON """["hello", "world"]""" :: F (Array String)
+  print $ readJSON """[1, 2, 3, 4]""" :: F (Array Number)

examples/JSONSimpleTypes.purs

@@ -4,10 +4,11 @@ import Prelude
 
 import Data.Foreign
 import Data.Foreign.Class
+import Control.Monad.Eff.Console
 
 -- Parsing of the simple JSON String, Number and Boolean types is provided
 -- out of the box.
 main = do
-  Console.print $ readJSON "\"a JSON string\"" :: F String
-  Console.print $ readJSON "42" :: F Number
-  Console.print $ readJSON "true" :: F Boolean
+  print $ readJSON "\"a JSON string\"" :: F String
+  print $ readJSON "42" :: F Number
+  print $ readJSON "true" :: F Boolean

examples/MaybeNullable.purs

@@ -5,9 +5,10 @@ import Prelude
 import Data.Foreign
 import Data.Foreign.Null
 import Data.Foreign.Class
+import Control.Monad.Eff.Console
 
 -- Parsing values that are allowed to null or undefined is possible by
 -- using Maybe types.
 main = do
-  Console.print $ runNull <$> readJSON "null" :: F (Null Boolean)
-  Console.print $ runNull <$> readJSON "true" :: F (Null Boolean)
+  print $ runNull <$> readJSON "null" :: F (Null Boolean)
+  print $ runNull <$> readJSON "true" :: F (Null Boolean)

examples/Nested.purs

@@ -6,6 +6,7 @@ import Control.Bind ((>=>))
 import Data.Foreign
 import Data.Foreign.Class
 import Data.Foreign.Index
+import Control.Monad.Eff.Console
 
 data Foo = Foo Bar Baz
 
@@ -24,9 +25,9 @@ instance showBaz :: Show Baz where
 
 instance fooIsForeign :: IsForeign Foo where
   read value = do
-    s <- value # prop "foo" >=> readProp "bar"
-    n <- value # prop "foo" >=> readProp "baz"
+    s <- value # (prop "foo" >=> readProp "bar")
+    n <- value # (prop "foo" >=> readProp "baz")
     return $ Foo (Bar s) (Baz n)
 
 main = do
-  Console.print $ readJSON """{ "foo": { "bar": "bar", "baz": 1 } }""" :: F Foo
+  print $ readJSON """{ "foo": { "bar": "bar", "baz": 1 } }""" :: F Foo

examples/Objects.purs

@@ -5,8 +5,7 @@ import Prelude
 import Data.Either
 import Data.Foreign
 import Data.Foreign.Class
-import Control.Monad.Eff
-import Debug.Trace
+import Control.Monad.Eff.Console
 
 -- | To parse objects of a particular type, we need to define some helper
 --   data types as making class instances for records is not possible.
@@ -25,4 +24,4 @@ instance pointIsForeign :: IsForeign Point where
     return $ Point { x: x, y: y }
 
 main = do
-  Console.print $ readJSON """{ "x": 1, "y": 2 }""" :: F Point
+  print $ readJSON """{ "x": 1, "y": 2 }""" :: F Point

examples/ParseErrors.purs

@@ -4,6 +4,7 @@ import Prelude
 
 import Data.Foreign
 import Data.Foreign.Class
+import Control.Monad.Eff.Console
 
 -- | See the `Objects` example for an explanation of how to parse objects
 --   like this.
@@ -22,15 +23,15 @@ main = do
 
   -- When trying to parse invalid JSON we catch an exception from
   -- `JSON.parse` and pass it on.
-  Console.print $ readJSON "not even JSON" :: F String
+  print $ readJSON "not even JSON" :: F String
 
   -- When attempting to coerce one type to another we get an error.
-  Console.print $ readJSON "26" :: F Boolean
+  print $ readJSON "26" :: F Boolean
 
   -- 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.
-  Console.print $ readJSON "[1, true, 3]" :: F (Array Boolean)
+  print $ readJSON "[1, true, 3]" :: F (Array Boolean)
 
   -- 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.
-  Console.print $ readJSON """{ "x": 1, "y": false }""" :: F Point
+  print $ readJSON """{ "x": 1, "y": false }""" :: F Point

examples/Union.purs

@@ -5,6 +5,7 @@ import Prelude
 import Data.Foreign
 import Data.Foreign.Index
 import Data.Foreign.Class
+import Control.Monad.Eff.Console
 
 data StringList = Nil | Cons String StringList
 
@@ -22,7 +23,7 @@ instance stringListIsForeign :: IsForeign StringList where
 
 main = do
 
-  Console.print $ readJSON """
+  print $ readJSON """
     { "nil": false
     , "head": "Hello"
     , "tail":
@@ -34,7 +35,7 @@ main = do
     }
     """ :: F StringList
 
-  Console.print $ readJSON """
+  print $ readJSON """
     { "nil": false
     , "head": "Hello"
     , "tail":