update docs

Author: jdegoes

MODULES.md

@@ -21,6 +21,13 @@ type PureAff a = forall e. Aff e a
 
 A pure asynchronous computation, having no effects.
 
+#### `Canceler`
+
+``` purescript
+type Canceler e = Error -> Aff e Boolean
+```
+
+
 #### `launchAff`
 
 ``` purescript
@@ -46,7 +53,8 @@ makeAff :: forall e a. ((Error -> Eff e Unit) -> (a -> Eff e Unit) -> Eff e Unit
 ```
 
 Creates an asynchronous effect from a function that accepts error and 
-success callbacks.
+success callbacks. This function can be used for asynchronous computations
+that cannot be canceled.
 
 #### `later`
 
@@ -67,7 +75,7 @@ Runs the asynchronous computation later (off the current execution context).
 #### `forkAff`
 
 ``` purescript
-forkAff :: forall e a. Aff e a -> Aff e Unit
+forkAff :: forall e a. Aff e a -> Aff e (Canceler e)
 ```
 
 Forks the specified asynchronous computation so subsequent monadic binds 
@@ -97,6 +105,14 @@ liftEff' :: forall e a. Eff (err :: Exception | e) a -> Aff e (Either Error a)
 
 Lifts a synchronous computation and makes explicit any failure from exceptions.
 
+#### `nonCanceler`
+
+``` purescript
+nonCanceler :: forall e. Canceler e
+```
+
+A constant function that always returns a pure false value.
+
 #### `semigroupAff`
 
 ``` purescript
@@ -191,171 +207,171 @@ instance monadPlusAff :: MonadPlus (Aff e)
 
 
 
-## Module Control.Monad.Aff.Class
+## Module Control.Monad.Aff.AVar
 
-#### `MonadAff`
+#### `AVAR`
 
 ``` purescript
-class MonadAff e m where
-  liftAff :: forall a. Aff e a -> m a
+data AVAR :: !
 ```
 
 
-#### `monadAffAff`
+#### `AVar`
 
 ``` purescript
-instance monadAffAff :: MonadAff e (Aff e)
+data AVar :: * -> *
 ```
 
 
-
-## Module Control.Monad.Aff.Par
-
-#### `Par`
+#### `AffAVar`
 
 ``` purescript
-newtype Par e a
-  = Par (AffQueue e a)
+type AffAVar e a = Aff (avar :: AVAR | e) a
 ```
 
 
-#### `runPar`
+#### `makeVar`
 
 ``` purescript
-runPar :: forall e a. Par e a -> AffQueue e a
+makeVar :: forall e a. AffAVar e (AVar a)
 ```
 
-Extracts the `Aff` from the `Par`.
+Makes a new asynchronous avar.
 
-#### `semigroupPar`
+#### `makeVar'`
 
 ``` purescript
-instance semigroupPar :: (Semigroup a) => Semigroup (Par e a)
+makeVar' :: forall e a. a -> AffAVar e (AVar a)
 ```
 
+Makes a avar and sets it to some value.
 
-#### `monoidPar`
+#### `takeVar`
 
 ``` purescript
-instance monoidPar :: (Monoid a) => Monoid (Par e a)
+takeVar :: forall e a. AVar a -> AffAVar e a
 ```
 
+Takes the next value from the asynchronous avar.
 
-#### `functorPar`
+#### `putVar`
 
 ``` purescript
-instance functorPar :: Functor (Par e)
+putVar :: forall e a. AVar a -> a -> AffAVar e Unit
 ```
 
+Puts a new value into the asynchronous avar. If the avar has
+been killed, this will result in an error.
 
-#### `applyPar`
+#### `modifyVar`
 
 ``` purescript
-instance applyPar :: Apply (Par e)
+modifyVar :: forall e a. (a -> a) -> AVar a -> AffAVar e Unit
 ```
 
+Modifies the value at the head of the avar (will suspend until one is available).
 
-#### `applicativePar`
+#### `killVar`
 
 ``` purescript
-instance applicativePar :: Applicative (Par e)
+killVar :: forall e a. AVar a -> Error -> AffAVar e Unit
 ```
 
+Kills an asynchronous avar.
 
-#### `altPar`
+
+## Module Control.Monad.Aff.Class
+
+#### `MonadAff`
 
 ``` purescript
-instance altPar :: Alt (Par e)
+class MonadAff e m where
+  liftAff :: forall a. Aff e a -> m a
 ```
 
-Returns the first value, or the first error if both error.
 
-#### `plusPar`
+#### `monadAffAff`
 
 ``` purescript
-instance plusPar :: Plus (Par e)
+instance monadAffAff :: MonadAff e (Aff e)
 ```
 
 
-#### `alternativePar`
 
-``` purescript
-instance alternativePar :: Alternative (Par e)
-```
+## Module Control.Monad.Aff.Par
 
+#### `Par`
 
+``` purescript
+newtype Par e a
+  = Par (AffAVar e a)
+```
 
-## Module Control.Monad.Aff.Queue
 
-#### `QueueFx`
+#### `runPar`
 
 ``` purescript
-data QueueFx :: !
+runPar :: forall e a. Par e a -> AffAVar e a
 ```
 
+Extracts the `Aff` from the `Par`.
 
-#### `Queue`
+#### `semigroupPar`
 
 ``` purescript
-data Queue :: * -> *
+instance semigroupPar :: (Semigroup a) => Semigroup (Par e a)
 ```
 
 
-#### `AffQueue`
+#### `monoidPar`
 
 ``` purescript
-type AffQueue e a = Aff (queue :: QueueFx | e) a
+instance monoidPar :: (Monoid a) => Monoid (Par e a)
 ```
 
 
-#### `makeQueue`
+#### `functorPar`
 
 ``` purescript
-makeQueue :: forall e a. AffQueue e (Queue a)
+instance functorPar :: Functor (Par e)
 ```
 
-Makes a new asynchronous queue.
 
-#### `makeQueue'`
+#### `applyPar`
 
 ``` purescript
-makeQueue' :: forall e a. a -> AffQueue e (Queue a)
+instance applyPar :: Apply (Par e)
 ```
 
-Makes a queue and sets it to some value.
 
-#### `takeQueue`
+#### `applicativePar`
 
 ``` purescript
-takeQueue :: forall e a. Queue a -> AffQueue e a
+instance applicativePar :: Applicative (Par e)
 ```
 
-Takes the next value from the asynchronous queue.
 
-#### `putQueue`
+#### `altPar`
 
 ``` purescript
-putQueue :: forall e a. Queue a -> a -> AffQueue e Unit
+instance altPar :: Alt (Par e)
 ```
 
-Puts a new value into the asynchronous queue. If the queue has
-been killed, this will result in an error.
+Returns the first value, or the first error if both error.
 
-#### `modifyQueue`
+#### `plusPar`
 
 ``` purescript
-modifyQueue :: forall e a. (a -> a) -> Queue a -> AffQueue e Unit
+instance plusPar :: Plus (Par e)
 ```
 
-Modifies the value at the head of the queue (will suspend until one is available).
 
-#### `killQueue`
+#### `alternativePar`
 
 ``` purescript
-killQueue :: forall e a. Queue a -> Error -> AffQueue e Unit
+instance alternativePar :: Alternative (Par e)
 ```
 
-Kills an asynchronous queue.
 
 
 ## Module Control.Monad.Aff.Unsafe