Merge pull request #8 from simonyangme/ps-0.11

Updates for PureScript 0.11

Author: felixSchl

bower.json

@@ -16,12 +16,12 @@
     "output"
   ],
   "dependencies": {
-    "purescript-monoid": "^2.0.0",
-    "purescript-transformers": "^2.0.1",
-    "purescript-tuples": "^3.0.0",
-    "purescript-lists": "^3.2.0",
-    "purescript-tailrec": "^2.0.0",
-    "purescript-mmorph": "felixschl/purescript-mmorph#e3cbc72abe8c3dcafdf1648cb63ddb1fac1dcb7f",
-    "purescript-prelude": "^2.4.0"
+    "purescript-monoid": "^3.0.0",
+    "purescript-transformers": "^3.0.0",
+    "purescript-tuples": "^4.0.0",
+    "purescript-lists": "^4.0.0",
+    "purescript-tailrec": "^3.0.0",
+    "purescript-mmorph": "^3.0.0",
+    "purescript-prelude": "^3.0.0"
   }
 }

package.json

@@ -6,7 +6,7 @@
   },
   "devDependencies": {
     "bower": "^1.7.9",
-    "pulp": "^10.0.0",
+    "pulp": "^11.0.0",
     "rimraf": "^2.4.1"
   }
 }

src/Pipes.purs

@@ -100,7 +100,7 @@ next = go
         Pure    r    -> pure (Left r)
 
 -- | Convert a `F.Foldable` to a `Producer`
-each :: forall a f m. (Monad m, Foldable f) => f a -> Producer_ a m Unit
+each :: forall a f m. Monad m => Foldable f => f a -> Producer_ a m Unit
 each xs = F.foldr (\a p -> yield a *> p) (pure unit) xs
 
 -- | Discards a value

src/Pipes/Internal.purs

@@ -6,7 +6,7 @@ import Data.Tuple (Tuple(Tuple))
 import Control.Alt (class Alt, (<|>))
 import Control.Alternative (class Alternative)
 import Control.Monad.Eff.Class (class MonadEff, liftEff)
-import Control.Monad.Except.Trans (class MonadError, catchError, throwError)
+import Control.Monad.Except.Trans (class MonadError, catchError, class MonadThrow, throwError)
 import Control.Monad.Trans.Class (class MonadTrans, lift)
 import Control.Monad.Reader.Class (class MonadAsk, class MonadReader, local, ask)
 import Control.Monad.State.Class (class MonadState, state)
@@ -141,9 +141,10 @@ instance proxyAlternative :: (MonadPlus m) => Alternative (Proxy a' a b' b m)
 -- instance proxyMonadPlus :: (MonadPlus m) => MonadPlus (Proxy a' a b' b m)
 -- instance proxyMonadZero :: (MonadZero m) => MonadZero (Proxy a' a b' b m)
 
-instance proxyMonadError :: (MonadError e m) => MonadError e (Proxy a' a b' b m) where
+instance proxyMonadThrow :: (MonadThrow e m) => MonadThrow e (Proxy a' a b' b m) where
     throwError = lift <<< throwError
 
+instance proxyMonadError :: (MonadError e m) => MonadError e (Proxy a' a b' b m) where
     catchError (Request a' fa) f = Request a' (\a  -> catchError (fa  a ) f)
     catchError (Respond b fb') f = Respond b  (\b' -> catchError (fb' b') f)
     catchError (Pure r)        f = Pure r

src/Pipes/ListT.purs

@@ -5,7 +5,7 @@ import Control.Alt (class Alt, alt)
 import Control.Alternative (class Alternative)
 import Control.Monad.Eff.Class (class MonadEff, liftEff)
 import Control.Monad.Except.Trans
-    (ExceptT, runExceptT, class MonadError, class MonadTrans, lift, catchError, throwError)
+    (ExceptT, runExceptT, class MonadError, class MonadTrans, lift, catchError, class MonadThrow, throwError)
 import Control.Monad.Maybe.Trans (MaybeT, runMaybeT)
 import Control.Monad.Reader.Class (class MonadAsk, class MonadReader, local, ask)
 import Control.Monad.Rec.Class (class MonadRec)
@@ -33,7 +33,7 @@ runListT l = runEffect (enumerate (l *> empty))
 runListTRec :: forall a m. (MonadRec m) => ListT m a -> m Unit
 runListTRec l = runEffectRec (enumerate (l *> empty))
 
-every :: forall a m t. (Monad m, Enumerable t) => t m a -> Producer_ a m Unit
+every :: forall a m t. Monad m => Enumerable t => t m a -> Producer_ a m Unit
 every it = discard >\\ enumerate (toListT it)
 
 instance listTFunctor :: (Monad m) => Functor (ListT m) where
@@ -106,8 +106,10 @@ instance listTMonadAsk :: (MonadAsk r m) => MonadAsk r (ListT m) where
 instance listTMonadReader :: (MonadReader r m) => MonadReader r (ListT m) where
     local f (Select l) = Select (local f l)
 
-instance listTMonadError :: (MonadError e m) => MonadError e (ListT m) where
+instance listTMonadThrow :: (MonadThrow e m) => MonadThrow e (ListT m) where
     throwError = lift <<< throwError
+
+instance listTMonadError :: (MonadError e m) => MonadError e (ListT m) where
     catchError (Select l) f = Select (l `catchError` (enumerate <<< f))
 
 class Enumerable t where

src/Pipes/Prelude.purs

@@ -58,7 +58,8 @@ sequence = mapM id
      forward each element of the result.
 -}
 mapFoldable :: forall a b m t r
-             . (Monad m, Foldable t)
+             . Monad m
+            => Foldable t
             => (a -> t b)
             -> Pipe a b m r
 mapFoldable f = for cat (\a -> each (f a))
@@ -117,7 +118,7 @@ drop = loop
   where
     loop 0 = cat
     loop n =  do
-      await
+      _ <- await
       loop (n-1)
 
 {-| dropWhile discards values going downstream until one violates the
@@ -135,7 +136,7 @@ dropWhile predicate = go
                 cat
 
 -- | Flatten all 'Foldable' elements flowing downstream
-concat :: forall a m f r. (Monad m, Foldable f) => Pipe (f a) a m r
+concat :: forall a m f r. Monad m => Foldable f => Pipe (f a) a m r
 concat = for cat each
 
 -- | Outputs the indices of all elements that satisfied the predicate
@@ -183,7 +184,7 @@ chain f = for cat $ \a -> do
     yield a
 
 -- | Convert `Show`able values to `String`s
-show :: forall a m r. (Monad m, Show a) => Pipe a String m r
+show :: forall a m r. Monad m => Show a => Pipe a String m r
 show = map Prelude.show
 
 -- | Evaluate all values flowing downstream to WHNF
@@ -270,11 +271,11 @@ or :: forall m. Monad m => Producer Boolean m Unit -> m Boolean
 or = any id
 
 -- | elem returns `True` if p has an element equal to a, `False` otherwise
-elem :: forall a m. (Monad m, Eq a) => a -> Producer a m Unit -> m Boolean
+elem :: forall a m. Monad m => Eq a => a -> Producer a m Unit -> m Boolean
 elem a = any (a == _)
 
 -- | notElem returns `False` if p has an element equal to a, `True` otherwise
-notElem :: forall a m. (Monad m, Eq a) => a -> Producer a m Unit -> m Boolean
+notElem :: forall a m. Monad m => Eq a => a -> Producer a m Unit -> m Boolean
 notElem a = all (a /= _)
 
 -- | Find the first element of a `Producer` that satisfies the predicate
@@ -318,7 +319,7 @@ length :: forall a m. Monad m => Producer a m Unit -> m Int
 length = fold (\n _ -> n + 1) 0 id
 
 -- | Find the maximum element of a `Producer`
-maximum :: forall a m. (Monad m, Ord a) => Producer a m Unit -> m (Maybe a)
+maximum :: forall a m. Monad m => Ord a => Producer a m Unit -> m (Maybe a)
 maximum = fold step Nothing id
   where
     step x a = Just $ case x of
@@ -328,7 +329,7 @@ maximum = fold step Nothing id
             | otherwise = y
 
 -- | Find the minimum element of a `Producer`
-minimum :: forall a m. (Monad m, Ord a) => Producer a m Unit -> m (Maybe a)
+minimum :: forall a m. Monad m => Ord a => Producer a m Unit -> m (Maybe a)
 minimum = fold step Nothing id
   where
     step x a = Just $ case x of