More tests, STArray fixes for negative indices

Author: garyb

bower.json

@@ -17,7 +17,6 @@
   ],
   "dependencies": {
     "purescript-foldable-traversable": "~0.4.0",
-    "purescript-functions": "~0.1.0",
     "purescript-st": "~0.1.0"
   },
   "devDependencies": {

docs/Data.Array.md

@@ -307,6 +307,12 @@ sortBy :: forall a. (a -> a -> Ordering) -> Array a -> Array a
 Sort the elements of an array in increasing order, where elements are compared using
 the specified partial ordering, creating a new array.
 
+#### `slice`
+
+``` purescript
+slice :: forall a. Int -> Int -> Array a -> Array a
+```
+
 #### `take`
 
 ``` purescript

src/Data/Array.purs

@@ -46,6 +46,7 @@ module Data.Array
   , sort
   , sortBy
 
+  , slice
   , take
   , takeWhile
   , drop
@@ -325,7 +326,7 @@ foreign import sortImpl :: forall a. (a -> a -> Int) -> Array a -> Array a
 -- Subarrays -------------------------------------------------------------------
 --------------------------------------------------------------------------------
 
--- | Extract a subarray by a start index and length.
+-- | Extract a subarray by a start and end index.
 foreign import slice :: forall a. Int -> Int -> Array a -> Array a
 
 -- | Keep only a number of elements from the start of an array, creating a new

src/Data/Array/ST.js

@@ -11,43 +11,61 @@ exports.emptySTArray = function () {
   return [];
 };
 
-exports.peekSTArrayImpl = function (just, nothing, arr, i) {
-  return function () {
-    return i < arr.length ? just(arr[i]) : nothing;
+exports.peekSTArrayImpl = function (just) {
+  return function (nothing) {
+    return function (xs) {
+      return function (i) {
+        return function () {
+          return i >= 0 && i < xs.length ? just(xs[i]) : nothing;
+        };
+      };
+    };
   };
 };
 
-exports.pokeSTArrayImpl = function (arr, i, a) {
-  return function () {
-    var ret = i < arr.length;
-    if (ret) arr[i] = a;
-    return ret;
+exports.pokeSTArray = function (xs) {
+  return function (i) {
+    return function (a) {
+      return function () {
+        var ret = i >= 0 && i < xs.length;
+        if (ret) xs[i] = a;
+        return ret;
+      };
+    };
   };
 };
 
-exports.pushAllSTArrayImpl = function (arr, as) {
-  return function () {
-    return arr.push.apply(arr, as);
+exports.pushAllSTArray = function (xs) {
+  return function (as) {
+    return function () {
+      return xs.push.apply(xs, as);
+    };
   };
 };
 
-exports.spliceSTArrayImpl = function (arr, i, howMany, bs) {
-  return function () {
-    return arr.splice.apply(arr, [i, howMany].concat(bs));
+exports.spliceSTArray = function (xs) {
+  return function (i) {
+    return function (howMany) {
+      return function (bs) {
+        return function () {
+          return xs.splice.apply(xs, [i, howMany].concat(bs));
+        };
+      };
+    };
   };
 };
 
-exports.copyImpl = function (arr) {
+exports.copyImpl = function (xs) {
   return function () {
-    return arr.slice();
+    return xs.slice();
   };
 };
 
-exports.toAssocArray = function (arr) {
+exports.toAssocArray = function (xs) {
   return function () {
-    var n = arr.length;
+    var n = xs.length;
     var as = new Array(n);
-    for (var i = 0; i < n; i++) as[i] = { value: arr[i], index: i };
+    for (var i = 0; i < n; i++) as[i] = { value: xs[i], index: i };
     return as;
   };
 };

src/Data/Array/ST.purs

@@ -18,7 +18,6 @@ module Data.Array.ST
 
 import Control.Monad.Eff (Eff())
 import Control.Monad.ST (ST())
-import Data.Function (Fn2(), runFn2, Fn3(), runFn3, Fn4(), runFn4)
 import Data.Maybe (Maybe(..))
 
 -- | A reference to a mutable array.
@@ -42,56 +41,34 @@ foreign import runSTArray :: forall a r. (forall h. Eff (st :: ST h | r) (STArra
 -- | Create an empty mutable array.
 foreign import emptySTArray :: forall a h r. Eff (st :: ST h | r) (STArray h a)
 
-foreign import peekSTArrayImpl :: forall a h e r. Fn4 (a -> r)
-                                                  r
-                                                  (STArray h a)
-                                                  Int
-                                                  (Eff (st :: ST h | e) r)
+-- | Create a mutable copy of an immutable array.
+thaw :: forall a h r. Array a -> Eff (st :: ST h | r) (STArray h a)
+thaw = copyImpl
 
--- | Read the value at the specified index in a mutable array.
-peekSTArray :: forall a h r. STArray h a -> Int -> Eff (st :: ST h | r) (Maybe a)
-peekSTArray = runFn4 peekSTArrayImpl Just Nothing
+-- | Create an immutable copy of a mutable array.
+freeze :: forall a h r. STArray h a -> Eff (st :: ST h | r) (Array a)
+freeze = copyImpl
 
--- | Change the value at the specified index in a mutable array.
-pokeSTArray :: forall a h r. STArray h a -> Int -> a -> Eff (st :: ST h | r) Boolean
-pokeSTArray = runFn3 pokeSTArrayImpl
+foreign import copyImpl :: forall a b h r. a -> Eff (st :: ST h | r) b
 
-foreign import pokeSTArrayImpl :: forall a h e. Fn3 (STArray h a)
-                                                    Int
-                                                    a
-                                                    (Eff (st :: ST h | e) Boolean)
+-- | Read the value at the specified index in a mutable array.
+peekSTArray :: forall a h r. STArray h a -> Int -> Eff (st :: ST h | r) (Maybe a)
+peekSTArray = peekSTArrayImpl Just Nothing
 
--- | Append the values in an immutable array to the end of a mutable array.
-pushAllSTArray :: forall a h r. STArray h a -> Array a -> Eff (st :: ST h | r) Int
-pushAllSTArray = runFn2 pushAllSTArrayImpl
+foreign import peekSTArrayImpl :: forall a h e r. (a -> r) -> r -> (STArray h a) -> Int -> (Eff (st :: ST h | e) r)
 
-foreign import pushAllSTArrayImpl :: forall a h r. Fn2 (STArray h a)
-                                                   (Array a)
-                                                   (Eff (st :: ST h | r) Int)
+-- | Change the value at the specified index in a mutable array.
+foreign import pokeSTArray :: forall a h r. STArray h a -> Int -> a -> Eff (st :: ST h | r) Boolean
 
 -- | Append an element to the end of a mutable array.
 pushSTArray :: forall a h r. STArray h a -> a -> Eff (st :: ST h | r) Int
 pushSTArray arr a = pushAllSTArray arr [a]
 
--- | Remove and/or insert elements from/into a mutable array at the specified index.
-spliceSTArray :: forall a h r. STArray h a -> Int -> Int -> Array a -> Eff (st :: ST h | r) (Array a)
-spliceSTArray = runFn4 spliceSTArrayImpl
-
-foreign import spliceSTArrayImpl :: forall a h r. Fn4 (STArray h a)
-                                                      Int
-                                                      Int
-                                                      (Array a)
-                                                      (Eff (st :: ST h | r) (Array a))
-
--- | Create an immutable copy of a mutable array.
-freeze :: forall a h r. STArray h a -> Eff (st :: ST h | r) (Array a)
-freeze = copyImpl
-
--- | Create a mutable copy of an immutable array.
-thaw :: forall a h r. Array a -> Eff (st :: ST h | r) (STArray h a)
-thaw = copyImpl
+-- | Append the values in an immutable array to the end of a mutable array.
+foreign import pushAllSTArray :: forall a h r. STArray h a -> Array a -> Eff (st :: ST h | r) Int
 
-foreign import copyImpl :: forall a b h r. a -> Eff (st :: ST h | r) b
+-- | Remove and/or insert elements from/into a mutable array at the specified index.
+foreign import spliceSTArray :: forall a h r. STArray h a -> Int -> Int -> Array a -> Eff (st :: ST h | r) (Array a)
 
 -- | Create an immutable copy of a mutable array, where each element
 -- | is labelled with its index in the original array.

src/Data/Array/Unsafe.purs

@@ -5,8 +5,7 @@
 
 module Data.Array.Unsafe where
 
-import Data.Maybe.Unsafe (fromJust)
-import qualified Data.Array as A
+import Data.Array (length, slice)
 
 -- | Find the element of an array at the specified index.
 -- |
@@ -23,16 +22,16 @@ head xs = unsafeIndex xs 0
 -- |
 -- | Running time: `O(n)`, where `n` is the length of the array.
 tail :: forall a. Array a -> Array a
-tail xs = (fromJust (A.uncons xs)).tail
+tail xs = slice 1 (length xs) xs
 
 -- | Get the last element of a non-empty array.
 -- |
 -- | Running time: `O(1)`.
 last :: forall a. Array a -> a
-last xs = unsafeIndex xs (A.length xs - one)
+last xs = unsafeIndex xs (length xs - 1)
 
 -- | Get all but the last element of a non-empty array.
 -- |
 -- | Running time: `O(n)`, where `n` is the length of the array.
 init :: forall a. Array a -> Array a
-init = fromJust <<< A.init
+init xs = slice 0 (length xs - 1) xs

test/Test/Data/Array.purs

@@ -1,8 +1,9 @@
 module Test.Data.Array (testArray) where
 
-import Console (log, print)
+import Console (log)
 import Data.Array
-import Data.Maybe (Maybe(..))
+import Data.Maybe (Maybe(..), isNothing)
+import Data.Maybe.Unsafe (fromJust)
 import Test.Assert (assert)
 
 testArray = do
@@ -22,7 +23,12 @@ testArray = do
   assert $ replicate 0 "foo" == []
   assert $ replicate (-1) "foo" == []
 
-  -- replicateM
+  log "replicateM should perform the monadic action the correct number of times"
+  assert $ replicateM 3 (Just 1) == Just [1, 1, 1]
+  assert $ replicateM 1 (Just 1) == Just [1]
+  assert $ replicateM 0 (Just 1) == Just []
+  assert $ replicateM (-1) (Just 1) == Just []
+
   -- some
   -- many
 
@@ -70,7 +76,16 @@ testArray = do
   log "init should return Nothing for an empty array"
   assert $ init nil == Nothing
 
-  -- uncons
+  log "uncons should return nothing when used on an empty array"
+  assert $ isNothing (uncons nil)
+
+  log "uncons should split an array into a head and tail record when there is at least one item"
+  let u1 = uncons [1]
+  assert $ (fromJust u1).head == 1
+  assert $ (fromJust u1).tail == []
+  let u2 = uncons [1, 2, 3]
+  assert $ (fromJust u2).head == 1
+  assert $ (fromJust u2).tail == [2, 3]
 
   log "(!!) should return Just x when the index is within the bounds of the array"
   assert $ [1, 2, 3] !! 0 == (Just 1)