delete even more functions, yay

Author: jdegoes

MODULES.md

@@ -86,14 +86,6 @@ liftEff' :: forall e1 e2 a. Eff (err :: Exception | e2) a -> Aff e1 e2 (Either E
 
 Lifts a synchronous computation and makes explicit any failure from exceptions.
 
-#### `throw`
-
-``` purescript
-throw :: forall e1 e2 a. Error -> Aff e1 e2 a
-```
-
-Throws the specified exception through the error callback.
-
 #### `semigroupAff`
 
 ``` purescript
@@ -147,4 +139,14 @@ instance monadAff :: Monad (Aff e1 e2)
 
 ``` purescript
 instance monadEffAff :: MonadEff e2 (Aff e1 e2)
-```
+```
+
+
+#### `monadErrorAff`
+
+``` purescript
+instance monadErrorAff :: MonadError Error (Aff e1 e2)
+```
+
+Allows users to catch and throw errors on the error channel of the 
+asynchronous computation. See documentation in `purescript-transformers`.

README.md

@@ -2,7 +2,7 @@
 
 An asynchronous effect monad for PureScript.
 
-The moral equivalent of `ErrorT (ContT Unit (Eff (async :: Async e1 | e2)) a`, for synchronous effects `e1`, asynchronous effects `e2`, and value `a`.
+The moral equivalent of `ErrorT (ContT Unit (Eff (async :: Async e1 | e2)) a`, for synchronous effects `e2`, asynchronous effects `e1`, and value `a`.
 
 `Aff` lets you say goodbyte to monad transformers and callback hell!
 
@@ -41,7 +41,7 @@ For maximum type safety, `Aff` separates the effects of the synchronous part fro
 
 Asynchronous effects are represented with an `async :: Async e1` effect label, where `e1` is the row of effects for actions to occur at some point in the future.
 
-The library contains instances for `Semigroup`, `Monoid`, `Apply`, `Applicative`, `Bind`, `Monad`, and `MonadEff`. These instances allow you to compose `Aff`-ectful code as easily as `Eff`, as well as interop with existing `Eff` code.
+The library contains instances for `Semigroup`, `Monoid`, `Apply`, `Applicative`, `Bind`, `Monad`, `MonadEff`. and `MonadError`. These instances allow you to compose `Aff`-ectful code as easily as `Eff`, as well as interop with existing `Eff` code.
 
 ## Escaping Callback Hell
 
@@ -109,15 +109,18 @@ attempt :: forall e1 e2 a. Aff e1 e2 a -> Aff e1 e2 (Either Error a)
 
 This returns an `Either Error a` you can use to recover gracefully from failure.
 
-The "opposite" of `attempt` is `throw`, which allows you to "throw" an exception:
+`Aff` has a `MonadError` instance, which comes with two functions: `catchError`, and `throwError`.
+
+These are defined in [purescript-transformers](http://github.com/purescript/purescript-transformers).
+Here's an example of how you can use them:
 
 ```purescript
-do resp <- Ajax.get "http://foo.com"
-   if resp.statusCode != 200 then throw myErr 
+do resp <- (Ajax.get "http://foo.com") `catchError` (\e -> pure defaultResponse)
+   if resp.statusCode != 200 then throwError myErr 
    else pure resp.body
 ```
 
-Thrown exceptions are propagated on the error channel, and can be recovered from using `attempt`.
+Thrown exceptions are propagated on the error channel, and can be recovered from using `attempt` or `catchError`.
 
 # Documentation
 

bower.json

@@ -19,12 +19,13 @@
     "package.json"
   ],
   "dependencies": {
-    "purescript-tuples":    "~0.3.0",
-    "purescript-either":    "~0.1.4",
-    "purescript-monoid":    "~0.2.0",
-    "purescript-exceptions": "~0.2.2",
-    "purescript-control":   "~0.2.2",
-    "purescript-maybe":     "~0.2.1",
-    "purescript-monad-eff": "~0.1.0"
+    "purescript-tuples":        "~0.3.0",
+    "purescript-either":        "~0.1.4",
+    "purescript-monoid":        "~0.2.0",
+    "purescript-exceptions":    "~0.2.2",
+    "purescript-control":       "~0.2.2",
+    "purescript-maybe":         "~0.2.1",
+    "purescript-monad-eff":     "~0.1.0",
+    "purescript-transformers":  "~0.5.1"
   }
 }

src/Control/Monad/Aff.purs

@@ -8,17 +8,17 @@ module Control.Monad.Aff
   , liftEff'
   , makeAff
   , runAff
-  , throw
   )
   where 
 
-  import Data.Either(Either(..))
+  import Data.Either(Either(..), either)
   import Data.Monoid(Monoid, mempty)
   import Control.Apply
   import Control.Monad.Eff
   import Control.Monad.Eff.Exception(Error(), Exception(), catchException)
   import Control.Monad.Eff.Unsafe(unsafeInterleaveEff)
   import Control.Monad.Eff.Class
+  import Control.Monad.Error.Class(MonadError)
 
   -- | An effect constructor which accepts a row of effects. `Async e` 
   -- | represents the effect of asynchronous computations which perform effects 
@@ -64,10 +64,6 @@ module Control.Monad.Aff
   liftEff' :: forall e1 e2 a. Eff (err :: Exception | e2) a -> Aff e1 e2 (Either Error a)
   liftEff' eff = Aff (\_ f -> unsafeInterleaveEff (unsafeInterleaveEff (catchException (pure <$> Left) (Right <$> eff)) >>= f))
 
-  -- | Throws the specified exception through the error callback.
-  throw :: forall e1 e2 a. Error -> Aff e1 e2 a
-  throw e = Aff (\ex _ -> unsafeInterleaveEff (ex e))
-
   instance semigroupAff :: (Semigroup a) => Semigroup (Aff e1 e2 a) where
     (<>) a b = (<>) <$> a <*> b
 
@@ -90,3 +86,10 @@ module Control.Monad.Aff
 
   instance monadEffAff :: MonadEff e2 (Aff e1 e2) where
     liftEff fa = Aff (\_ h -> unsafeInterleaveEff (unsafeInterleaveEff fa >>= h))
+
+  -- | Allows users to catch and throw errors on the error channel of the 
+  -- | asynchronous computation. See documentation in `purescript-transformers`.
+  instance monadErrorAff :: MonadError Error (Aff e1 e2) where
+    throwError e = Aff (\ex _ -> unsafeInterleaveEff (ex e))
+
+    catchError aff ex = attempt aff >>= either ex pure