Merge pull request #5 from ethul/topic/purescript-0.9

Updates for PureScript 0.9.1

Author: ethul

bower.json

@@ -10,13 +10,14 @@
     "url": "git://github.com/ethul/purescript-freeap.git"
   },
   "dependencies": {
-    "purescript-exists": "~0.2.0",
-    "purescript-const": "~0.5.0"
+    "purescript-exists": "^1.0.0",
+    "purescript-const": "^1.0.0"
   },
   "devDependencies": {
-    "purescript-either": "~0.2.3",
-    "purescript-integers": "~0.2.1",
-    "purescript-generics": "~0.6.2",
-    "purescript-console": "~0.1.1"
+    "purescript-either": "^1.0.0",
+    "purescript-integers": "^1.0.0",
+    "purescript-generics": "^1.0.0",
+    "purescript-console": "^1.0.0",
+    "purescript-exceptions": "~1.0.0"
   }
 }

src/Control/Applicative/Free.purs

@@ -1,26 +1,23 @@
 module Control.Applicative.Free
-  ( FreeAp()
-  , NaturalTransformation()
+  ( FreeAp
   , liftFreeAp
   , retractFreeAp
   , foldFreeAp
   , hoistFreeAp
   , analyzeFreeAp
   ) where
 
-import Prelude (Applicative, Apply, Functor, Unit(), (<<<), apply, flip, id, map, pure, unit)
+import Prelude (class Applicative, class Apply, class Functor, type (~>), Unit, (<<<), apply, flip, id, map, pure, unit)
 
-import Data.Const (Const(..), getConst)
-import Data.Exists (Exists(), mkExists, runExists)
-import Data.Monoid (Monoid)
+import Data.Const (Const(Const), getConst)
+import Data.Exists (Exists, mkExists, runExists)
+import Data.Monoid (class Monoid)
 
 -- | The free applicative functor for a type constructor `f`.
 data FreeAp f a = Pure a | Ap (Exists (ApF f a))
 
 data ApF f a i = ApF (Unit -> f i) (Unit -> FreeAp f (i -> a))
 
-type NaturalTransformation f g = forall a. f a -> g a
-
 ap :: forall f a i. (Unit -> f i) -> (Unit -> FreeAp f (i -> a)) -> FreeAp f a
 ap v k = Ap (mkExists (ApF v k))
 
@@ -37,13 +34,13 @@ retractFreeAp (Ap x) = runExists (\(ApF v k') -> apply (retractFreeAp (k' unit))
 
 -- | Run a free applicative functor with a natural transformation from
 -- | the type constructor `f` to the applicative functor `g`.
-foldFreeAp :: forall f g a. (Applicative g) => NaturalTransformation f g -> FreeAp f a -> g a
+foldFreeAp :: forall f g a. (Applicative g) => (f ~> g) -> FreeAp f a -> g a
 foldFreeAp k (Pure a) = pure a
 foldFreeAp k (Ap x) = runExists (\(ApF v k') -> apply (map (flip id) (k (v unit))) (foldFreeAp k (k' unit))) x
 
 -- | Natural transformation from `FreeAp f a` to `FreeAp g a` given a
 -- | natural transformation from `f` to `g`.
-hoistFreeAp :: forall f g a. NaturalTransformation f g -> FreeAp f a -> FreeAp g a
+hoistFreeAp :: forall f g a. (f ~> g) -> FreeAp f a -> FreeAp g a
 hoistFreeAp k (Pure a) = Pure a
 hoistFreeAp k (Ap x) = runExists (\(ApF v k') -> ap (\_ -> k (v unit)) (\_ -> hoistFreeAp k (k' unit))) x
 

test/Test/Control/Applicative/Free.purs

@@ -2,8 +2,8 @@ module Test.Control.Applicative.Free
   ( checkAnalyze
   ) where
 
-import Prelude (Unit(), (==), (++), unit, apply, map)
-import Control.Applicative.Free (FreeAp(), liftFreeAp, analyzeFreeAp)
+import Prelude (Unit, (==), (<>), unit, apply, map)
+import Control.Applicative.Free (FreeAp, liftFreeAp, analyzeFreeAp)
 import Data.Either (Either(..))
 
 data M r = A r | B r
@@ -28,4 +28,4 @@ expected = "AB"
 checkAnalyze :: Either String String
 checkAnalyze = if result == expected
                then Right result
-               else Left (result ++ " is not " ++ expected)
+               else Left (result <> " is not " <> expected)

test/Test/Control/Applicative/Free/Validation.purs

@@ -1,16 +1,16 @@
 module Test.Control.Applicative.Free.Validation
-  ( User()
+  ( User
   , runForm
   ) where
 
-import Prelude (Show, show, (<<<), (==), (<$>), (<*>), (++))
+import Prelude (class Show, show, (<<<), (==), (<$>), (<*>), (<>))
 
-import Control.Applicative.Free (FreeAp(), foldFreeAp, liftFreeAp)
+import Control.Applicative.Free (FreeAp, foldFreeAp, liftFreeAp)
+import Control.Monad.Eff.Exception.Unsafe (unsafeThrow)
 
 import Data.Either (Either(..))
 import Data.Int (fromString)
 import Data.Maybe (maybe)
-import Data.Maybe.Unsafe (unsafeThrow)
 
 type Validator a = String -> Either String a
 
@@ -22,10 +22,10 @@ field :: forall a. String -> Validator a -> Form a
 field n v = liftFreeAp (Field { name: n, validator: v })
 
 nes :: String -> Form String
-nes n = field n (\v -> if v == "" then Left (n ++ ": Invalid NES") else Right v)
+nes n = field n (\v -> if v == "" then Left (n <> ": Invalid NES") else Right v)
 
 int :: String -> Form Int
-int n = field n (maybe (Left (n ++ ": Invalid Int")) Right <<< fromString)
+int n = field n (maybe (Left (n <> ": Invalid Int")) Right <<< fromString)
 
 newtype User = User { firstName :: String, lastName :: String, age :: Int }
 
@@ -48,7 +48,7 @@ runForm first last age =
          "First name" -> v first
          "Last name" -> v last
          "Age" -> v age
-         _ -> unsafeThrow ("Unexpected field: " ++ n)
+         _ -> unsafeThrow ("Unexpected field: " <> n)
 
 instance showUser :: Show User where
-  show (User m) = m.firstName ++ " " ++ m.lastName ++ " " ++ show m.age
+  show (User m) = m.firstName <> " " <> m.lastName <> " " <> show m.age

test/Test/Main.purs

@@ -1,23 +1,23 @@
 module Test.Main where
 
-import Prelude (Unit(), bind)
+import Prelude (Unit, bind)
 
-import Control.Monad.Eff (Eff())
-import Control.Monad.Eff.Console (CONSOLE(), log, print)
+import Control.Monad.Eff (Eff)
+import Control.Monad.Eff.Console (CONSOLE, log, logShow)
 
-import qualified Test.Control.Applicative.Free.Validation as Validation
-import qualified Test.Control.Applicative.Free as FreeTest
+import Test.Control.Applicative.Free.Validation as Validation
+import Test.Control.Applicative.Free as FreeTest
 
 main :: Eff (console :: CONSOLE) Unit
 main = do
   log "\nvalid case:"
-  print (Validation.runForm "Joe" "Smith" "28")
+  logShow (Validation.runForm "Joe" "Smith" "28")
 
   log "\nempty last name:"
-  print (Validation.runForm "Larry" "" "45")
+  logShow (Validation.runForm "Larry" "" "45")
 
   log "\ninvalid age:"
-  print (Validation.runForm "Sue" "Larry" "A")
+  logShow (Validation.runForm "Sue" "Larry" "A")
 
   log "\nanalyze:"
-  print FreeTest.checkAnalyze
+  logShow FreeTest.checkAnalyze