More updates for 0.7

Author: garyb

docs/Control.Monad.Eff.Unsafe.md

@@ -0,0 +1,13 @@
+## Module Control.Monad.Eff.Unsafe
+
+#### `unsafeInterleaveEff`
+
+``` purescript
+unsafeInterleaveEff :: forall eff1 eff2 a. Eff eff1 a -> Eff eff2 a
+```
+
+Change the type of an effectful computation, allowing it to be run in another context.
+
+Note: use of this function can result in arbitrary side-effects.
+
+

docs/Control.Monad.Eff.md

@@ -0,0 +1,88 @@
+## Module Control.Monad.Eff
+
+#### `Eff`
+
+``` purescript
+data Eff :: # ! -> * -> *
+```
+
+##### Instances
+``` purescript
+instance functorEff :: Functor (Eff e)
+instance applyEff :: Apply (Eff e)
+instance applicativeEff :: Applicative (Eff e)
+instance bindEff :: Bind (Eff e)
+instance monadEff :: Monad (Eff e)
+```
+
+The `Eff` type constructor is used to represent _native_ effects.
+
+See [Handling Native Effects with the Eff Monad](https://github.com/purescript/purescript/wiki/Handling-Native-Effects-with-the-Eff-Monad) for more details.
+
+The first type parameter is a row of effects which represents the contexts in which a computation can be run, and the second type parameter is the return type.
+
+#### `Pure`
+
+``` purescript
+type Pure a = forall e. Eff e a
+```
+
+The `Pure` type synonym represents _pure_ computations, i.e. ones in which all effects have been handled.
+
+The `runPure` function can be used to run pure computations and obtain their result.
+
+#### `runPure`
+
+``` purescript
+runPure :: forall a. Pure a -> a
+```
+
+Run a pure computation and return its result.
+
+Note: since this function has a rank-2 type, it may cause problems to apply this function using the `$` operator. The recommended approach
+is to use parentheses instead.
+
+#### `untilE`
+
+``` purescript
+untilE :: forall e. Eff e Boolean -> Eff e Unit
+```
+
+Loop until a condition becomes `true`.
+
+`untilE b` is an effectful computation which repeatedly runs the effectful computation `b`,
+until its return value is `true`.
+
+#### `whileE`
+
+``` purescript
+whileE :: forall e a. Eff e Boolean -> Eff e a -> Eff e Unit
+```
+
+Loop while a condition is `true`.
+
+`whileE b m` is effectful computation which runs the effectful computation `b`. If its result is
+`true`, it runs the effectful computation `m` and loops. If not, the computation ends.
+
+#### `forE`
+
+``` purescript
+forE :: forall e. Number -> Number -> (Number -> Eff e Unit) -> Eff e Unit
+```
+
+Loop over a consecutive collection of numbers.
+
+`forE lo hi f` runs the computation returned by the function `f` for each of the inputs
+between `lo` (inclusive) and `hi` (exclusive).
+
+#### `foreachE`
+
+``` purescript
+foreachE :: forall e a. Array a -> (a -> Eff e Unit) -> Eff e Unit
+```
+
+Loop over an array of values.
+
+`foreach xs f` runs the computation returned by the function `f` for each of the inputs `xs`.
+
+

docs/Prelude.Unsafe.md

@@ -7,11 +7,16 @@ var jscs = require("gulp-jscs");
 var plumber = require("gulp-plumber");
 var purescript = require("gulp-purescript");
 
-var paths = [
+var sources = [
   "src/**/*.purs",
   "bower_components/purescript-*/src/**/*.purs"
 ];
 
+var foreigns = [
+  "src/**/*.js",
+  "bower_components/purescript-*/src/**/*.js"
+];
+
 gulp.task("lint", function() {
   return gulp.src("src/**/*.js")
     .pipe(jshint())
@@ -20,30 +25,24 @@ gulp.task("lint", function() {
 });
 
 gulp.task("make", ["lint"], function() {
-  return gulp.src(paths)
+  return gulp.src(sources)
     .pipe(plumber())
-    .pipe(purescript.pscMake());
+    .pipe(purescript.pscMake({ ffi: foreigns }));
 });
 
-var docTasks = [];
-
-var docTask = function(name) {
-  var taskName = "docs-" + name.toLowerCase();
-  gulp.task(taskName, function () {
-    return gulp.src("src/" + name.replace(/\./g, "/") + ".purs")
-      .pipe(plumber())
-      .pipe(purescript.pscDocs())
-      .pipe(gulp.dest("docs/" + name + ".md"));
-  });
-  docTasks.push(taskName);
-};
-
-["Control.Monad.Eff", "Control.Monad.Eff.Unsafe"].forEach(docTask);
-
-gulp.task("docs", docTasks);
+gulp.task("docs", function () {
+  return gulp.src(sources)
+    .pipe(plumber())
+    .pipe(purescript.pscDocs({
+      docgen: {
+        "Control.Monad.Eff": "docs/Control.Monad.Eff.md",
+        "Control.Monad.Eff.Unsafe": "docs/Control.Monad.Eff.Unsafe.md"
+      }
+    }));
+});
 
 gulp.task("dotpsci", function () {
-  return gulp.src(paths)
+  return gulp.src(sources)
     .pipe(plumber())
     .pipe(purescript.dotPsci());
 });

docs/Prelude.md

@@ -3,34 +3,34 @@
 
 // module Control.Monad.Eff
 
-exports.returnE = function(a) {
-  return function() {
+exports.returnE = function (a) {
+  return function () {
     return a;
   };
 };
 
-exports.bindE = function(a) {
-  return function(f) {
-    return function() {
+exports.bindE = function (a) {
+  return function (f) {
+    return function () {
       return f(a())();
     };
   };
 };
 
-exports.runPure = function(f) {
+exports.runPure = function (f) {
   return f();
 };
 
-exports.untilE = function(f) {
-  return function() {
+exports.untilE = function (f) {
+  return function () {
     while (!f());
     return {};
   };
 };
 
-exports.whileE = function(f) {
-  return function(a) {
-    return function() {
+exports.whileE = function (f) {
+  return function (a) {
+    return function () {
       while (f()) {
         a();
       }
@@ -39,10 +39,10 @@ exports.whileE = function(f) {
   };
 };
 
-exports.forE = function(lo) {
-  return function(hi) {
-    return function(f) {
-      return function() {
+exports.forE = function (lo) {
+  return function (hi) {
+    return function (f) {
+      return function () {
         for (var i = lo; i < hi; i++) {
           f(i)();
         }
@@ -51,9 +51,9 @@ exports.forE = function(lo) {
   };
 };
 
-exports.foreachE = function(as) {
-  return function(f) {
-    return function() {
+exports.foreachE = function (as) {
+  return function (f) {
+    return function () {
       for (var i = 0, l = as.length; i < l; i++) {
         f(as[i])();
       }

gulpfile.js

@@ -12,25 +12,9 @@ module Control.Monad.Eff
 -- | The first type parameter is a row of effects which represents the contexts in which a computation can be run, and the second type parameter is the return type.
 foreign import data Eff :: # ! -> * -> *
 
-foreign import returnE
-  """
-  function returnE(a) {
-    return function() {
-      return a;
-    };
-  }
-  """ :: forall e a. a -> Eff e a
+foreign import returnE :: forall e a. a -> Eff e a
 
-foreign import bindE
-  """
-  function bindE(a) {
-    return function(f) {
-      return function() {
-        return f(a())();
-      };
-    };
-  }
-  """ :: forall e a b. Eff e a -> (a -> Eff e b) -> Eff e b
+foreign import bindE :: forall e a b. Eff e a -> (a -> Eff e b) -> Eff e b
 
 -- | The `Pure` type synonym represents _pure_ computations, i.e. ones in which all effects have been handled.
 -- |
@@ -41,12 +25,7 @@ type Pure a = forall e. Eff e a
 -- |
 -- | Note: since this function has a rank-2 type, it may cause problems to apply this function using the `$` operator. The recommended approach
 -- | is to use parentheses instead.
-foreign import runPure
-  """
-  function runPure(f) {
-    return f();
-  }
-  """ :: forall a. Pure a -> a
+foreign import runPure :: forall a. Pure a -> a
 
 instance functorEff :: Functor (Eff e) where
   map = liftA1
@@ -66,65 +45,21 @@ instance monadEff :: Monad (Eff e)
 -- |
 -- | `untilE b` is an effectful computation which repeatedly runs the effectful computation `b`,
 -- | until its return value is `true`.
-foreign import untilE
-  """
-  function untilE(f) {
-    return function() {
-      while (!f());
-      return {};
-    };
-  }
-  """ :: forall e. Eff e Boolean -> Eff e Unit
+foreign import untilE :: forall e. Eff e Boolean -> Eff e Unit
 
 -- | Loop while a condition is `true`.
 -- |
 -- | `whileE b m` is effectful computation which runs the effectful computation `b`. If its result is
 -- | `true`, it runs the effectful computation `m` and loops. If not, the computation ends.
-foreign import whileE
-  """
-  function whileE(f) {
-    return function(a) {
-      return function() {
-        while (f()) {
-          a();
-        }
-        return {};
-      };
-    };
-  }
-  """ :: forall e a. Eff e Boolean -> Eff e a -> Eff e Unit
+foreign import whileE :: forall e a. Eff e Boolean -> Eff e a -> Eff e Unit
 
 -- | Loop over a consecutive collection of numbers.
 -- |
 -- | `forE lo hi f` runs the computation returned by the function `f` for each of the inputs
 -- | between `lo` (inclusive) and `hi` (exclusive).
-foreign import forE
-  """
-  function forE(lo) {
-    return function(hi) {
-      return function(f) {
-        return function() {
-          for (var i = lo; i < hi; i++) {
-            f(i)();
-          }
-        };
-      };
-    };
-  }
-  """ :: forall e. Number -> Number -> (Number -> Eff e Unit) -> Eff e Unit
+foreign import forE :: forall e. Number -> Number -> (Number -> Eff e Unit) -> Eff e Unit
 
 -- | Loop over an array of values.
 -- |
 -- | `foreach xs f` runs the computation returned by the function `f` for each of the inputs `xs`.
-foreign import foreachE
-  """
-  function foreachE(as) {
-    return function(f) {
-      return function() {
-        for (var i = 0; i < as.length; i++) {
-          f(as[i])();
-        }
-      };
-    };
-  }
-  """ :: forall e a. Array a -> (a -> Eff e Unit) -> Eff e Unit
+foreign import foreachE :: forall e a. Array a -> (a -> Eff e Unit) -> Eff e Unit

src/Control/Monad/Eff.js

@@ -1,8 +1,8 @@
 /* global exports */
 "use strict";
 
-// module Control.Monad.Eff.Unsafe where
+// module Control.Monad.Eff.Unsafe
 
-exports.unsafeInterleaveEff = function(f) {
+exports.unsafeInterleaveEff = function (f) {
   return f;
 };

src/Control/Monad/Eff.purs

@@ -5,9 +5,4 @@ import Control.Monad.Eff
 -- | Change the type of an effectful computation, allowing it to be run in another context.
 -- |
 -- | Note: use of this function can result in arbitrary side-effects.
-foreign import unsafeInterleaveEff
-  """
-  function unsafeInterleaveEff(f) {
-    return f;
-  }
-  """ :: forall eff1 eff2 a. Eff eff1 a -> Eff eff2 a
+foreign import unsafeInterleaveEff :: forall eff1 eff2 a. Eff eff1 a -> Eff eff2 a