Updates for 1.0 core libraries

Author: paf31

bower.json

@@ -14,10 +14,10 @@
     "url": "git://github.com/paf31/purescript-freet.git"
   },
   "dependencies": {
-    "purescript-console": "^0.1.0",
-    "purescript-control": "~0.3.0",
-    "purescript-tailrec": "~0.3.0",
-    "purescript-transformers": "~0.8.1",
-    "purescript-exists": "~0.2.0"
+    "purescript-console": "^1.0.0-rc.1",
+    "purescript-control": "^1.0.0-rc.1",
+    "purescript-tailrec": "^1.0.0-rc.1",
+    "purescript-transformers": "^1.0.0-rc.1",
+    "purescript-exists": "^1.0.0-rc.1"
   }
 }

docs/Control/Monad/Free/Trans.md

@@ -12,13 +12,13 @@ The free monad transformer for the functor `f`.
 
 ##### Instances
 ``` purescript
-instance functorFreeT :: (Functor f, Functor m) => Functor (FreeT f m)
-instance applyFreeT :: (Functor f, Monad m) => Apply (FreeT f m)
-instance applicativeFreeT :: (Functor f, Monad m) => Applicative (FreeT f m)
-instance bindFreeT :: (Functor f, Monad m) => Bind (FreeT f m)
-instance monadFreeT :: (Functor f, Monad m) => Monad (FreeT f m)
-instance monadTransFreeT :: (Functor f) => MonadTrans (FreeT f)
-instance monadRecFreeT :: (Functor f, Monad m) => MonadRec (FreeT f m)
+(Functor f, Functor m) => Functor (FreeT f m)
+(Functor f, Monad m) => Apply (FreeT f m)
+(Functor f, Monad m) => Applicative (FreeT f m)
+(Functor f, Monad m) => Bind (FreeT f m)
+(Functor f, Monad m) => Monad (FreeT f m)
+(Functor f) => MonadTrans (FreeT f)
+(Functor f, Monad m) => MonadRec (FreeT f m)
 ```
 
 #### `freeT`
@@ -48,23 +48,23 @@ Lift an action from the functor `f` to a `FreeT` action.
 #### `hoistFreeT`
 
 ``` purescript
-hoistFreeT :: forall f m n a. (Functor f, Functor n) => (forall a. m a -> n a) -> FreeT f m a -> FreeT f n a
+hoistFreeT :: forall f m n a. (Functor f, Functor n) => (forall b. m b -> n b) -> FreeT f m a -> FreeT f n a
 ```
 
 Change the underlying `Monad` for a `FreeT` action.
 
 #### `interpret`
 
 ``` purescript
-interpret :: forall f g m a. (Functor f, Functor m) => (forall a. f a -> g a) -> FreeT f m a -> FreeT g m a
+interpret :: forall f g m a. (Functor f, Functor m) => (forall b. f b -> g b) -> FreeT f m a -> FreeT g m a
 ```
 
 Change the base functor `f` for a `FreeT` action.
 
 #### `bimapFreeT`
 
 ``` purescript
-bimapFreeT :: forall f g m n a. (Functor f, Functor n) => (forall a. f a -> g a) -> (forall a. m a -> n a) -> FreeT f m a -> FreeT g n a
+bimapFreeT :: forall f g m n a. (Functor f, Functor n) => (forall b. f b -> g b) -> (forall b. m b -> n b) -> FreeT f m a -> FreeT g n a
 ```
 
 Change the base functor `f` and the underlying `Monad` for a `FreeT` action.

src/Control/Monad/Free/Trans.purs

@@ -18,8 +18,8 @@ import Data.Either (Either(..))
 import Data.Bifunctor (bimap)
 
 import Control.Bind ((<=<))
-import Control.Monad.Rec.Class (MonadRec, tailRecM)
-import Control.Monad.Trans (MonadTrans)
+import Control.Monad.Rec.Class (class MonadRec, tailRecM)
+import Control.Monad.Trans (class MonadTrans)
 
 -- | Instead of implementing `bind` directly, we capture the bind using this data structure, to
 -- | evaluate later.
@@ -42,14 +42,14 @@ resume = tailRecM go
   where
   go :: FreeT f m a -> m (Either (FreeT f m a) (Either a (f (FreeT f m a))))
   go (FreeT f) = map Right (f unit)
-  go (Bind e) = runExists (\(Bound m f) ->
-    case m unit of
+  go (Bind e) = runExists (\(Bound bound f) ->
+    case bound unit of
       FreeT m -> do
         e <- m unit
         case e of
-          Left a -> return (Left (f a))
-          Right fc -> return (Right (Right (map (\h -> h >>= f) fc)))
-      Bind e1 -> runExists (\(Bound m1 f1) -> return (Left (bind (m1 unit) (\z -> f1 z >>= f)))) e1) e
+          Left a -> pure (Left (f a))
+          Right fc -> pure (Right (Right (map (\h -> h >>= f) fc)))
+      Bind e1 -> runExists (\(Bound m1 f1) -> pure (Left (bind (m1 unit) (\z -> f1 z >>= f)))) e1) e
 
 instance functorFreeT :: (Functor f, Functor m) => Functor (FreeT f m) where
   map f (FreeT m) = FreeT \_ -> map (bimap f (map (map f))) (m unit)
@@ -77,11 +77,11 @@ instance monadRecFreeT :: (Functor f, Monad m) => MonadRec (FreeT f m) where
       e <- f s
       case e of
         Left s1 -> go s1
-        Right a -> return a
+        Right a -> pure a
 
 -- | Lift an action from the functor `f` to a `FreeT` action.
 liftFreeT :: forall f m a. (Functor f, Monad m) => f a -> FreeT f m a
-liftFreeT fa = FreeT \_ -> return (Right (map pure fa))
+liftFreeT fa = FreeT \_ -> pure (Right (map pure fa))
 
 -- | Change the underlying `Monad` for a `FreeT` action.
 hoistFreeT :: forall f m n a. (Functor f, Functor n) => (forall b. m b -> n b) -> FreeT f m a -> FreeT f n a
@@ -101,7 +101,7 @@ runFreeT :: forall f m a. (Functor f, MonadRec m) => (f (FreeT f m a) -> m (Free
 runFreeT interp = tailRecM (go <=< resume)
   where
   go :: Either a (f (FreeT f m a)) -> m (Either (FreeT f m a) a)
-  go (Left a) = return (Right a)
+  go (Left a) = pure (Right a)
   go (Right fc) = do
     c <- interp fc
-    return (Left c)
+    pure (Left c)

test/Main.purs

@@ -6,50 +6,36 @@ import Control.Apply
 import Control.Monad.Eff
 import Control.Monad.Eff.Class
 import Control.Monad.Eff.Console
-import Control.Monad.Aff
 import Control.Monad.Trans
 import Control.Monad.Free.Trans
 import Control.Monad.Rec.Class
 
-import Node.ReadLine
-
-data TeletypeF a = WriteLine String a | ReadLine (String -> a)
+data TeletypeF a
+  = WriteLine String a
+  | ReadLine (String -> a)
 
 instance functorTeletypeF :: Functor TeletypeF where
   map f (WriteLine s a) = WriteLine s (f a)
-  map f (ReadLine k) = ReadLine (f <<< k) 
+  map f (ReadLine k) = ReadLine (f <<< k)
 
 type Teletype = FreeT TeletypeF
 
-writeLine :: forall m. (Monad m) => String -> FreeT TeletypeF m Unit
+writeLine :: forall m. Monad m => String -> FreeT TeletypeF m Unit
 writeLine s = liftFreeT (WriteLine s unit)
 
-readLine :: forall m. (Monad m) =>  FreeT TeletypeF m String
+readLine :: forall m. Monad m =>  FreeT TeletypeF m String
 readLine = liftFreeT (ReadLine id)
 
-runTeletype :: forall a eff. Teletype (Aff (console :: CONSOLE | eff)) a -> Aff (console :: CONSOLE | eff) a
-runTeletype = runFreeT interp
+mockTeletype :: forall a eff. Teletype (Eff (console :: CONSOLE | eff)) a -> Eff (console :: CONSOLE | eff) a
+mockTeletype = runFreeT interp
   where
-  interp :: TeletypeF                      (Teletype (Aff (console :: CONSOLE | eff)) a) -> 
-            Aff (console :: CONSOLE | eff) (Teletype (Aff (console :: CONSOLE | eff)) a)
-  interp (WriteLine s next) = do
-    liftEff (log s)
-    return next
-  interp (ReadLine k) = do
-    s <- readLine
-    return (k s)
-    
-  readLine :: forall eff. Aff (console :: CONSOLE | eff) String
-  readLine = makeAff \_ k -> void do
-    interface <- createInterface noCompletion
-    setPrompt "> " 2 interface
-    setLineHandler interface \s -> close interface *> k s
-    line <- prompt interface
-    return line
-
-main = runAff print return $ runTeletype $ forever do
+    interp (WriteLine s next) = do
+      liftEff (log s)
+      pure next
+    interp (ReadLine k) = do
+      pure (k "Fake input")
+
+main = mockTeletype $ forever do
+  lift $ log "Enter some input:"
   s <- readLine
-  lift $ do
-    liftEff $ log "Please wait..."
-    later' 1000 $ return unit
-  writeLine ("You typed: " ++ s)
+  writeLine ("You typed: " <> s)