Add some basic tests

Author: garyb

Gruntfile.js

@@ -196,23 +196,23 @@ modifyAt :: forall a. Int -> (a -> a) -> [a] -> [a]
 
 Apply a function to the element at the specified index, creating a new array.
 
-#### `deleteBy`
+#### `delete`
 
 ``` purescript
-deleteBy :: forall a. (a -> a -> Boolean) -> a -> [a] -> [a]
+delete :: forall a. (Eq a) => a -> [a] -> [a]
 ```
 
-Delete the first element of an array which matches the specified value, under the
-equivalence relation provided in the first argument, creating a new array.
+Delete the first element of an array which is equal to the specified value,
+creating a new array.
 
-#### `delete`
+#### `deleteBy`
 
 ``` purescript
-delete :: forall a. (Eq a) => a -> [a] -> [a]
+deleteBy :: forall a. (a -> a -> Boolean) -> a -> [a] -> [a]
 ```
 
-Delete the first element of an array which is equal to the specified value,
-creating a new array.
+Delete the first element of an array which matches the specified value, under the
+equivalence relation provided in the first argument, creating a new array.
 
 #### `(\\)`
 
@@ -223,22 +223,22 @@ creating a new array.
 Delete the first occurrence of each element in the second array from the first array,
 creating a new array.
 
-#### `intersectBy`
+#### `intersect`
 
 ``` purescript
-intersectBy :: forall a. (a -> a -> Boolean) -> [a] -> [a] -> [a]
+intersect :: forall a. (Eq a) => [a] -> [a] -> [a]
 ```
 
-Calculate the intersection of two arrays, using the specified equivalence relation
-to compare elements, creating a new array.
+Calculate the intersection of two arrays, creating a new array.
 
-#### `intersect`
+#### `intersectBy`
 
 ``` purescript
-intersect :: forall a. (Eq a) => [a] -> [a] -> [a]
+intersectBy :: forall a. (a -> a -> Boolean) -> [a] -> [a] -> [a]
 ```
 
-Calculate the intersection of two arrays, creating a new array.
+Calculate the intersection of two arrays, using the specified equivalence relation
+to compare elements, creating a new array.
 
 #### `concatMap`
 
@@ -662,4 +662,7 @@ init :: forall a. [a] -> [a]
 
 Get all but the last element of a non-empty array.
 
-Running time: `O(n)`, where `n` is the length of the array.
+Running time: `O(n)`, where `n` is the length of the array.
+
+
+

README.md

@@ -0,0 +1,41 @@
+"use strict";
+
+var gulp = require("gulp");
+var plumber = require("gulp-plumber");
+var purescript = require("gulp-purescript");
+var jsvalidate = require("gulp-jsvalidate");
+var run = require("gulp-run");
+
+var paths = [
+  "src/**/*.purs",
+  "bower_components/purescript-*/src/**/*.purs",
+  "test/**/*.purs"
+];
+
+gulp.task("make", function() {
+  return gulp.src(paths)
+    .pipe(plumber())
+    .pipe(purescript.pscMake());
+});
+
+gulp.task("jsvalidate", ["make"], function () {
+  return gulp.src("output/**/*.js")
+    .pipe(plumber())
+    .pipe(jsvalidate());
+});
+
+gulp.task("docs", function () {
+  return gulp.src("src/**/*.purs")
+    .pipe(plumber())
+    .pipe(purescript.pscDocs())
+    .pipe(gulp.dest("README.md"));
+});
+
+gulp.task("test", function() {
+  return gulp.src(paths)
+    .pipe(plumber())
+    .pipe(purescript.psc({ main: "Test.Main" }))
+    .pipe(run("node"));
+});
+
+gulp.task("default", ["jsvalidate", "docs"]);

gulpfile.js

@@ -1,8 +1,10 @@
 {
   "private": true,
-  "dependencies": {
-    "grunt": "~0.4.4",
-    "grunt-purescript": "~0.5.1",
-    "grunt-contrib-clean": "~0.6.0"
+  "devDependencies": {
+    "gulp": "^3.8.11",
+    "gulp-jsvalidate": "^1.0.1",
+    "gulp-plumber": "^1.0.0",
+    "gulp-purescript": "^0.3.1",
+    "gulp-run": "^1.6.7"
   }
 }

package.json

@@ -32,11 +32,11 @@ module Data.Array
   , deleteAt
   , updateAt
   , modifyAt
-  , deleteBy
   , delete
+  , deleteBy
   , (\\)
-  , intersectBy
   , intersect
+  , intersectBy
   , concatMap
   , filter
   , range
@@ -132,9 +132,10 @@ findIndex f xs = runFn4 findIndexJS Just Nothing f xs
 
 foreign import findIndexJS
   """
-  function findIndexJS (just, nothing, f, arr) {
+  function findIndexJS(just, nothing, f, arr) {
     for (var i = 0, l = arr.length; i < l; i++) {
       if (f(arr[i])) return just(i);
+    }
     return nothing;
   };
   """ :: forall a. Fn4 (Int -> Maybe Int) (Maybe Int) (a -> Boolean) [a] (Maybe Int)
@@ -145,7 +146,7 @@ findLastIndex f xs = runFn4 findLastIndexJS Just Nothing f xs
 
 foreign import findLastIndexJS
   """
-  function findLastIndex (just, nothing, f, arr) {
+  function findLastIndexJS(just, nothing, f, arr) {
     for (var i = arr.length - 1; i >= 0; i--) {
       if (f(arr[i])) return just(i);
     }
@@ -264,17 +265,17 @@ foreign import updateAt
 modifyAt :: forall a. Int -> (a -> a) -> [a] -> [a]
 modifyAt i f xs = maybe xs (\x -> updateAt i (f x) xs) (xs !! i)
 
+-- | Delete the first element of an array which is equal to the specified value,
+-- | creating a new array.
+delete :: forall a. (Eq a) => a -> [a] -> [a]
+delete = deleteBy (==)
+
 -- | Delete the first element of an array which matches the specified value, under the
 -- | equivalence relation provided in the first argument, creating a new array.
 deleteBy :: forall a. (a -> a -> Boolean) -> a -> [a] -> [a]
 deleteBy _ _ [] = []
 deleteBy eq x ys = maybe ys (\i -> deleteAt i one ys) (findIndex (eq x) ys)
 
--- | Delete the first element of an array which is equal to the specified value,
--- | creating a new array.
-delete :: forall a. (Eq a) => a -> [a] -> [a]
-delete = deleteBy (==)
-
 infix 5 \\
 
 -- | Delete the first occurrence of each element in the second array from the first array,
@@ -286,17 +287,17 @@ infix 5 \\
   go [] _  = []
   go xs (y:ys) = go (delete y xs) ys
 
+-- | Calculate the intersection of two arrays, creating a new array.
+intersect :: forall a. (Eq a) => [a] -> [a] -> [a]
+intersect = intersectBy (==)
+
 -- | Calculate the intersection of two arrays, using the specified equivalence relation
 -- | to compare elements, creating a new array.
 intersectBy :: forall a. (a -> a -> Boolean) -> [a] -> [a] -> [a]
 intersectBy _  [] _  = []
 intersectBy _  _  [] = []
 intersectBy eq xs ys = filter (\x -> isJust (findIndex (eq x) ys)) xs
 
--- | Calculate the intersection of two arrays, creating a new array.
-intersect :: forall a. (Eq a) => [a] -> [a] -> [a]
-intersect = intersectBy (==)
-
 -- | Apply a function to each element in an array, and flatten the results
 -- | into a single, new array.
 foreign import concatMap

src/Data/Array.purs

@@ -0,0 +1,15 @@
+module Test.Common where
+
+import Control.Monad.Eff (Eff())
+
+foreign import data Assert :: !
+
+foreign import assert
+  """
+  function assert(success) {
+    return function () {
+      if (success) return {};
+      throw new Error("Assertion failed");
+    };
+  }
+  """ :: forall e. Boolean -> Eff (assert :: Assert | e) Unit