stack-safe Foldable/Traversable Array instances

Also change fold{l,r}Array to for loops because they're faster.

Author: hdgarrood

.jscsrc

@@ -0,0 +1,12 @@
+{
+  "preset": "grunt",
+  "disallowSpacesInAnonymousFunctionExpression": null,
+  "requireSpacesInAnonymousFunctionExpression": {
+    "beforeOpeningRoundBrace": true,
+    "beforeOpeningCurlyBrace": true
+  },
+  "disallowSpacesInsideObjectBrackets": null,
+  "requireSpacesInsideObjectBrackets": "all",
+  "validateQuoteMarks": "\"",
+  "requireCurlyBraces": null
+}

.jshintrc

@@ -0,0 +1,19 @@
+{
+  "bitwise": true,
+  "eqeqeq": true,
+  "forin": true,
+  "freeze": true,
+  "funcscope": true,
+  "futurehostile": true,
+  "globalstrict": true,
+  "latedef": true,
+  "maxparams": 1,
+  "noarg": true,
+  "nocomma": true,
+  "nonew": true,
+  "notypeof": true,
+  "singleGroups": true,
+  "undef": true,
+  "unused": true,
+  "eqnull": true
+}

bower.json

@@ -28,6 +28,7 @@
     "purescript-maybe": "~0.3.0"
   },
   "devDependencies": {
-    "purescript-console": "~0.1.0"
+    "purescript-console": "~0.1.0",
+    "purescript-assert": "~0.1.0"
   }
 }

docs/Data.Foldable.md

@@ -11,6 +11,7 @@ class Foldable f where
 
 ##### Instances
 ``` purescript
+instance foldableArray :: Foldable Array
 instance foldableMaybe :: Foldable Maybe
 instance foldableFirst :: Foldable First
 instance foldableLast :: Foldable Last

docs/Data.Traversable.md

@@ -10,6 +10,7 @@ class (Functor t, Foldable t) <= Traversable t where
 
 ##### Instances
 ``` purescript
+instance traversableArray :: Traversable Array
 instance traversableMaybe :: Traversable Maybe
 instance traversableFirst :: Traversable First
 instance traversableLast :: Traversable Last

gulpfile.js

@@ -3,18 +3,29 @@
 
 var gulp = require("gulp");
 var plumber = require("gulp-plumber");
+var jshint = require("gulp-jshint");
+var jscs = require("gulp-jscs");
 var purescript = require("gulp-purescript");
+var run = require("gulp-run");
 
 var sources = [
   "src/**/*.purs",
   "bower_components/purescript-*/src/**/*.purs"
 ];
 
 var foreigns = [
+  "src/**/*.js",
   "bower_components/purescript-*/src/**/*.js"
 ];
 
-gulp.task("make", function() {
+gulp.task("lint", function() {
+  return gulp.src("src/**/*.js")
+    .pipe(jshint())
+    .pipe(jshint.reporter())
+    .pipe(jscs());
+});
+
+gulp.task("make", ["lint"], function() {
   return gulp.src(sources)
     .pipe(plumber())
     .pipe(purescript.pscMake({ ffi: foreigns }));
@@ -39,4 +50,13 @@ gulp.task("dotpsci", function () {
     .pipe(purescript.dotPsci());
 });
 
+gulp.task("test", ["make"], function() {
+  return gulp.src(sources.concat(["test/Main.purs"]))
+    .pipe(plumber())
+    .pipe(purescript.psc({ main: "Test.Main"
+                         , ffi: foreigns.concat(["test/Main.js"])
+                         }))
+    .pipe(run("node"));
+});
+
 gulp.task("default", ["make", "docs", "dotpsci"]);

package.json

@@ -4,6 +4,8 @@
     "gulp": "^3.8.11",
     "gulp-plumber": "^1.0.0",
     "gulp-purescript": "^0.5.0",
-    "gulp-run": "^1.6.7"
+    "gulp-run": "^1.6.7",
+    "gulp-jscs": "^1.6.0",
+    "gulp-jshint": "^1.10.0"
   }
 }

src/Data/Foldable.js

@@ -0,0 +1,30 @@
+/* global exports */
+"use strict";
+
+// module Data.Foldable
+
+exports.foldrArray = function (f) {
+  return function (init) {
+    return function (xs) {
+      var acc = init;
+      var len = xs.length;
+      for (var i = 0; i < len; i++) {
+        acc = f(xs[i])(acc);
+      }
+      return acc;
+    };
+  };
+};
+
+exports.foldlArray = function (f) {
+  return function (init) {
+    return function (xs) {
+      var acc = init;
+      var len = xs.length;
+      for (var i = 0; i < len; i++) {
+        acc = f(acc)(xs[i]);
+      }
+      return acc;
+    };
+  };
+};

src/Data/Foldable.purs

@@ -38,6 +38,14 @@ class Foldable f where
   foldl :: forall a b. (b -> a -> b) -> b -> f a -> b
   foldMap :: forall a m. (Monoid m) => (a -> m) -> f a -> m
 
+instance foldableArray :: Foldable Array where
+  foldr = foldrArray
+  foldl = foldlArray
+  foldMap f xs = foldr (\x acc -> f x <> acc) mempty xs
+
+foreign import foldrArray :: forall a b. (a -> b -> b) -> b -> Array a -> b
+foreign import foldlArray :: forall a b. (b -> a -> b) -> b -> Array a -> b
+
 instance foldableMaybe :: Foldable Maybe where
   foldr _ z Nothing  = z
   foldr f z (Just x) = x `f` z

src/Data/Traversable.js

@@ -0,0 +1,50 @@
+/* global exports */
+"use strict";
+
+// module Data.Traversable
+
+exports.traverseArrayImpl = function () {
+  function Cont (fn) {
+    this.fn = fn;
+  }
+
+  function consArray(x) {
+    return function (xs) {
+      return [x].concat(xs);
+    };
+  }
+
+  return function (apply) {
+    return function (map) {
+      return function (pure) {
+        return function (f) {
+          /* jshint maxparams: 2 */
+          var buildFrom = function (x, ys) {
+            return apply(map(consArray)(f(x)))(ys);
+          };
+
+          /* jshint maxparams: 3 */
+          var go = function (acc, currentLen, xs) {
+            if (currentLen === 0) {
+              return acc;
+            } else {
+              var last = xs[currentLen - 1];
+              return new Cont(function () {
+                return go(buildFrom(last, acc), currentLen - 1, xs);
+              });
+            }
+          };
+
+          return function (array) {
+            var result = go(pure([]), array.length, array);
+            while (result instanceof Cont) {
+              result = result.fn();
+            }
+
+            return result;
+          };
+        };
+      };
+    };
+  };
+}();