add forkAff

Author: jdegoes

MODULES.md

@@ -67,6 +67,15 @@ makeAff :: forall e a. ((Error -> Eff e Unit) -> (a -> Eff e Unit) -> EffA e Uni
 Creates an asynchronous effect from a function that accepts error and 
 success callbacks.
 
+#### `forkAff`
+
+``` purescript
+forkAff :: forall e a. Aff e a -> Aff e Unit
+```
+
+Forks the specified asynchronous computation so subsequent monadic binds 
+will not block on the result of the computation.
+
 #### `attempt`
 
 ``` purescript

README.md

@@ -79,20 +79,19 @@ do response <- ajaxGet' req
    liftEff $ trace response.body
 ```
 
-## Converting from Eff
+## Eff
 
-All purely synchronous computations (`Eff`) can be converted to `Aff` computations with `liftEff` defined in `Control.Monad.Eff.Class` (see [here](https://github.com/paf31/purescript-monad-eff)).
+All purely synchronous computations (`Eff`) can be lifted to asynchronous computations with `liftEff` defined in `Control.Monad.Eff.Class` (see [here](https://github.com/paf31/purescript-monad-eff)).
 
 ```purescript
 import Control.Monad.Eff.Class
 
 liftEff $ trace "Hello world!"
 ```
 
-This lets you write your whole program in `Aff`, and still call out to synchronous `Eff` code.
+This lets you write your whole program in `Aff`, and still call out to synchronous code.
 
-If your `Eff` code throws exceptions (`err :: Exception`), you can remove the exceptions using `liftEff'`
-to bring the exception to the value level as an `Either Error a`:
+If your `Eff` code throws exceptions (`err :: Exception`), you can remove the exceptions using `liftEff'`, which brings exceptions to the value level as an `Either Error a`:
 
 ```purescript
 do e <- liftEff' myExcFunc
@@ -140,6 +139,18 @@ do resp <- (Ajax.get "http://foo.com") `catchError` (\e -> pure defaultResponse)
 
 Thrown exceptions are propagated on the error channel, and can be recovered from using `attempt` or `catchError`.
 
+## Variables
+
+The `Control.Monad.Aff.Var` module contains asynchronous variables. These can 
+be used as low-level building blocks for asynchronous programs.
+
+```purescript
+do v <- makeVar
+   forkAff (myRunner v)
+   a <- takeVar
+   return a
+```
+
 # Documentation
 
 [MODULES.md](MODULES.md)

src/Control/Monad/Aff.purs

@@ -4,6 +4,7 @@ module Control.Monad.Aff
   , EffA()
   , PureAff(..)
   , attempt
+  , forkAff
   , launchAff
   , liftEff'
   , makeAff
@@ -57,6 +58,26 @@ module Control.Monad.Aff
   makeAff :: forall e a. ((Error -> Eff e Unit) -> (a -> Eff e Unit) -> EffA e Unit) -> Aff e a
   makeAff = Aff
 
+  -- | Forks the specified asynchronous computation so subsequent monadic binds 
+  -- | will not block on the result of the computation.
+  foreign import forkAff """
+    function forkAff(aff) {
+      return function(error) {
+        return function(success) {
+          return function() {
+            try {
+              aff(function(){})(function(){})();
+
+              success({})();
+            } catch (e) {
+              error(e)();
+            }
+          }
+        }
+      }
+    }
+  """ :: forall e a. Aff e a -> Aff e Unit
+
   -- | Promotes any error to the value level of the asynchronous monad.
   attempt :: forall e a. Aff e a -> Aff e (Either Error a)
   attempt (Aff fa) = Aff (\_ f -> fa (Left >>> f) (Right >>> f))