rough sketch of asynchronous variable package and impl of unsafeInterleaveAff

Author: jdegoes

Gruntfile.js

@@ -17,13 +17,25 @@ module.exports = function(grunt) {
             src: "src/**/*.purs",
             dest: "MODULES.md"
         }
+    },
+    jsvalidate: {
+      options:{
+        globals: {},
+        esprimaOptions: {},
+        verbose: false
+      },
+      targetName:{
+        files:{
+          src:['output/**/*.js']
+        }
+      }
     }
-
   });
 
   grunt.loadNpmTasks("grunt-contrib-clean");
   grunt.loadNpmTasks("grunt-purescript");
+  grunt.loadNpmTasks('grunt-jsvalidate');
 
-  grunt.registerTask("make", ["pscMake", "dotPsci", "pscDocs"]);
+  grunt.registerTask("make", ["pscMake", "jsvalidate", "dotPsci", "pscDocs"]);
   grunt.registerTask("default", ["make"]);
 };

MODULES.md

@@ -173,4 +173,72 @@ instance alternativeAff :: Alternative (Aff e)
 
 ``` purescript
 instance monadPlusAff :: MonadPlus (Aff e)
-```
+```
+
+
+
+## Module Control.Monad.Aff.Unsafe
+
+#### `unsafeInterleaveAff`
+
+``` purescript
+unsafeInterleaveAff :: forall e1 e2 a. Aff e1 a -> Aff e2 a
+```
+
+
+
+## Module Control.Monad.Aff.Var
+
+#### `VarF`
+
+``` purescript
+data VarF :: !
+```
+
+
+#### `Var`
+
+``` purescript
+data Var :: * -> *
+```
+
+
+#### `AffVar`
+
+``` purescript
+type AffVar e a = Aff (var :: VarF | e) a
+```
+
+
+#### `makeVar`
+
+``` purescript
+makeVar :: forall e a. AffVar e (Var a)
+```
+
+Makes a new asynchronous variable.
+
+#### `takeVar`
+
+``` purescript
+takeVar :: forall e a. Var a -> AffVar e a
+```
+
+Takes the next value from the asynchronous variable.
+
+#### `putVar`
+
+``` purescript
+putVar :: forall e a. Var a -> a -> AffVar e Unit
+```
+
+Puts a new value into the asynchronous variable. If the variable has
+been killed, this will result in an error.
+
+#### `killVar`
+
+``` purescript
+killVar :: forall e a. Var a -> Error -> AffVar e Unit
+```
+
+Kills an asynchronous variable.

package.json

@@ -3,6 +3,7 @@
   "dependencies": {
     "grunt": "~0.4.5",
     "grunt-purescript": "~0.6.0",
-    "grunt-contrib-clean": "~0.6.0"
+    "grunt-contrib-clean": "~0.6.0",
+    "grunt-jsvalidate": "~0.2.2"
   }
 }

src/Control/Monad/Aff/Unsafe.purs

@@ -0,0 +1,8 @@
+module Control.Monad.Aff.Unsafe where
+  import Control.Monad.Aff
+
+  foreign import unsafeInterleaveAff """
+    function unsafeInterleaveAff(aff) {
+      return aff;
+    }
+  """ :: forall e1 e2 a. Aff e1 a -> Aff e2 a

src/Control/Monad/Aff/Var.purs

@@ -0,0 +1,122 @@
+-- | A low-level primitive for building asynchronous code.
+module Control.Monad.Aff.Var
+  ( AffVar()
+  , Var()
+  , VarF()
+  , killVar
+  , makeVar
+  , putVar
+  , takeVar
+  ) where
+
+  import Control.Monad.Aff
+  import Control.Monad.Eff.Exception(Error())
+
+  foreign import data VarF :: !
+
+  foreign import data Var :: * -> *
+
+  type AffVar e a = Aff (var :: VarF | e) a
+
+  -- | Makes a new asynchronous variable.
+  foreign import makeVar """
+    function makeVar(error) {
+      return function(success) {
+        return function() {
+          success({
+            consumers: [],
+            producers: [],
+            error: undefined 
+          });
+        }
+      }
+    }
+  """ :: forall e a. AffVar e (Var a)
+
+  -- | Takes the next value from the asynchronous variable.
+  foreign import takeVar """
+    function takeVar(avar) {
+      return function(error) {
+        return function(success) {
+          return function() {
+            if (avar.error !== undefined) {
+              error(avar.error)();
+            } else if (avar.producers.length > 0) {
+              var producer = avar.producers.shift();
+
+              producer(error, success);
+            } else {
+              avar.consumers.push({error: error, success: success});
+            }
+          }
+        }
+      } 
+    }
+  """ :: forall e a. Var a -> AffVar e a
+
+  -- | Puts a new value into the asynchronous variable. If the variable has
+  -- | been killed, this will result in an error.
+  foreign import putVar """
+    function putVar(avar) {
+      return function(a) {
+        return function(error) {
+          return function(success) {
+            return function() {
+              if (avar.error !== undefined) {
+                error(avar.error)();
+              } else if (avar.consumers.length == 0) {
+                avar.producer.push(function(error, success) {
+                  success(a)();
+                });
+              } else {
+                var consumer = avar.shift();
+
+                try {
+                  consumer.success(a)();
+
+                  success({})();
+                } catch (e) {
+                  error(e)();                  
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  """ :: forall e a. Var a -> a -> AffVar e Unit
+
+  -- | Kills an asynchronous variable.
+  foreign import killVar """
+    function killVar(avar) {
+      return function(e) {
+        return function(error) {
+          return function(success) {
+            return function() {
+              if (avar.error !== undefined) {
+                error(avar.error);
+              } else {
+                var errors = [];
+
+                avar.error = e;
+
+                while (avar.consumers.length > 0) {
+                  var consumer = avar.shift();
+
+                  try {
+                    consumer.error(e)();
+                  } catch (e) {
+                    errors.push(e);              
+                  }
+                }
+
+                if (errors.length > 0) error(errors[0])();
+                else success({})();
+              }
+            }
+          }
+        }
+      }
+    }
+  """ :: forall e a. Var a -> Error -> AffVar e Unit
+