Merge pull request #64 from purescript/unsafe-partial

Rename Unsafe to Partial, test on build

Author: garyb

.travis.yml

@@ -13,7 +13,7 @@ install:
   - npm install
   - bower install
 script:
-  - npm run build
+  - npm test
 after_success:
 - >-
   test $TRAVIS_TAG &&

package.json

@@ -2,7 +2,8 @@
   "private": true,
   "scripts": {
     "clean": "rimraf output && rimraf .pulp-cache",
-    "build": "jshint src && jscs src && pulp build"
+    "build": "jshint src && jscs src && pulp build",
+    "test": "jshint src && jscs src && pulp test"
   },
   "devDependencies": {
     "jscs": "^2.8.0",

src/Data/Array/Partial.js

@@ -0,0 +1,10 @@
+/* global exports */
+"use strict";
+
+// module Data.Array.Partial
+
+exports.unsafeIndexImpl = function (xs) {
+  return function (n) {
+    return xs[n];
+  };
+};

src/Data/Array/Partial.purs

@@ -0,0 +1,42 @@
+-- | Partial helper functions for working with immutable arrays.
+module Data.Array.Partial
+  ( unsafeIndex
+  , head
+  , tail
+  , last
+  , init
+  ) where
+
+import Prelude
+
+import Data.Array (length, slice)
+
+-- | Find the element of an array at the specified index.
+unsafeIndex :: forall a. Partial => Array a -> Int -> a
+unsafeIndex = unsafeIndexImpl
+
+foreign import unsafeIndexImpl :: forall a. Array a -> Int -> a
+
+-- | Get the first element of a non-empty array.
+-- |
+-- | Running time: `O(1)`.
+head :: forall a. Partial => Array a -> a
+head xs = unsafeIndex xs 0
+
+-- | Get all but the first element of a non-empty array.
+-- |
+-- | Running time: `O(n)`, where `n` is the length of the array.
+tail :: forall a. Partial => Array a -> Array a
+tail xs = slice 1 (length xs) xs
+
+-- | Get the last element of a non-empty array.
+-- |
+-- | Running time: `O(1)`.
+last :: forall a. Partial => Array a -> a
+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. Partial => Array a -> Array a
+init xs = slice 0 (length xs - 1) xs

test/Test/Data/Array.purs

@@ -4,24 +4,17 @@ import Prelude
 
 import Control.Monad.Eff (Eff)
 import Control.Monad.Eff.Console (log, CONSOLE)
-import Data.Foldable (for_, foldMapDefaultR, class Foldable, all)
-import Test.Assert (assert)
 
 import Data.Array (range, foldM, unzip, zip, zipWithA, zipWith, intersectBy, intersect, (\\), deleteBy, delete, unionBy, union, nubBy, nub, groupBy, group', group, span, dropWhile, drop, takeWhile, take, sortBy, sort, catMaybes, mapMaybe, filterM, filter, concat, concatMap, reverse, alterAt, modifyAt, updateAt, deleteAt, insertAt, findLastIndex, findIndex, elemLastIndex, elemIndex, (!!), uncons, init, tail, last, head, insertBy, insert, snoc, (:), length, null, replicate, replicateM, singleton, fromFoldable)
+import Data.Foldable (for_, foldMapDefaultR, class Foldable, all)
 import Data.Maybe (Maybe(..), isNothing, fromJust)
 import Data.Tuple (Tuple(..))
 
 import Partial.Unsafe (unsafePartial)
 
 import Test.Assert (assert, ASSERT)
 
-testArray :: forall t.
-        Eff
-          ( console :: CONSOLE
-          , assert :: ASSERT
-          | t
-          )
-          Unit
+testArray :: forall eff. Eff (console :: CONSOLE, assert :: ASSERT | eff) Unit
 testArray = do
 
   log "singleton should construct an array with a single value"

test/Test/Data/Array/Partial.purs

@@ -0,0 +1,29 @@
+module Test.Data.Array.Partial (testArrayPartial) where
+
+import Prelude
+
+import Control.Monad.Eff (Eff)
+import Control.Monad.Eff.Console (log, CONSOLE)
+
+import Data.Array.Partial (init, last, tail, head)
+
+import Partial.Unsafe (unsafePartial)
+
+import Test.Assert (assert, ASSERT)
+
+testArrayPartial :: forall eff. Eff (console :: CONSOLE, assert :: ASSERT | eff) Unit
+testArrayPartial = do
+
+  log "head should return the first item in an array"
+  assert $ unsafePartial $ head [1, 2, 3] == 1
+  assert $ unsafePartial $ head [1] == 1
+
+  log "tail should return all but the first item in an array"
+  assert $ unsafePartial $ tail [1, 2, 3] == [2, 3]
+
+  log "last should return the last item of an array"
+  assert $ unsafePartial $ last [1, 2, 3] == 3
+  assert $ unsafePartial $ last [1] == 1
+
+  log "init should return all but the last item of an array"
+  assert $ unsafePartial $ init [1, 2, 3] == [1, 2]

test/Test/Data/Array/ST.purs

@@ -12,13 +12,7 @@ import Data.Maybe (Maybe(..), isNothing)
 
 import Test.Assert (assert, ASSERT)
 
-testArrayST :: forall t.
-        Eff
-          ( console :: CONSOLE
-          , assert :: ASSERT
-          | t
-          )
-          Unit
+testArrayST :: forall eff. Eff (console :: CONSOLE, assert :: ASSERT | eff) Unit
 testArrayST = do
 
   log "emptySTArray should produce an empty array"

test/Test/Main.purs

@@ -1,21 +1,17 @@
 module Test.Main where
 
 import Prelude (bind, Unit)
+
 import Control.Monad.Eff (Eff)
 import Control.Monad.Eff.Console (CONSOLE)
+
 import Test.Assert (ASSERT)
 import Test.Data.Array (testArray)
+import Test.Data.Array.Partial (testArrayPartial)
 import Test.Data.Array.ST (testArrayST)
-import Test.Data.Array.Unsafe (testArrayUnsafe)
 
-main :: forall t.
-      Eff
-        ( console :: CONSOLE
-        , assert :: ASSERT
-        | t
-        )
-        Unit
+main :: forall eff. Eff (console :: CONSOLE, assert :: ASSERT | eff) Unit
 main = do
   testArray
   testArrayST
-  testArrayUnsafe
+  testArrayPartial