Merge branch 'master' of github.com:purescript/purescript-arrays into compiler/0.12

Author: kritzcreek

src/Data/Array/NonEmpty.purs

@@ -66,6 +66,8 @@ module Data.Array.NonEmpty
 
   , nub
   , nubBy
+  , nubEq
+  , nubByEq
   , union
   , union'
   , unionBy

src/Data/Array/ST.js

@@ -54,6 +54,16 @@ exports.copyImpl = function (xs) {
   };
 };
 
+exports.sortByImpl = function (comp) {
+  return function (xs) {
+    return function () {
+      return xs.sort(function (x, y) {
+        return comp(x)(y);
+      });
+    };
+  };
+};
+
 exports.toAssocArray = function (xs) {
   return function () {
     var n = xs.length;

src/Data/Array/ST.purs

@@ -13,6 +13,9 @@ module Data.Array.ST
   , modify
   , pushAll
   , splice
+  , sort
+  , sortBy
+  , sortWith
   , freeze
   , thaw
   , unsafeFreeze
@@ -67,6 +70,38 @@ foreign import empty :: forall h a. ST h (STArray h a)
 thaw :: forall h a. Array a -> ST h (STArray h a)
 thaw = copyImpl
 
+-- | Sort a mutable array in place.
+sort :: forall a h. Ord a => STArray h a -> ST h (STArray h a)
+sort = sortBy compare
+
+-- | Sort a mutable array in place using a comparison function.
+sortBy
+  :: forall a h
+   . (a -> a -> Ordering)
+  -> STArray h a
+  -> ST h (STArray h a)
+sortBy comp = sortByImpl comp'
+  where
+  comp' x y = case comp x y of
+    GT -> 1
+    EQ -> 0
+    LT -> -1
+
+foreign import sortByImpl
+  :: forall a h
+   . (a -> a -> Int)
+  -> STArray h a
+  -> ST h (STArray h a)
+
+-- | Sort a mutable array in place based on a projection.
+sortWith
+  :: forall a b h
+   . Ord b
+  => (a -> b)
+  -> STArray h a
+  -> ST h (STArray h a)
+sortWith f = sortBy (comparing f)
+
 -- | Create an immutable copy of a mutable array.
 freeze :: forall h a. STArray h a -> ST h (Array a)
 freeze = copyImpl

test/Test/Data/Array/NonEmpty.purs

@@ -2,8 +2,6 @@ module Test.Data.Array.NonEmpty (testNonEmptyArray) where
 
 import Prelude
 
-import Effect (Effect)
-import Effect.Console (log)
 import Data.Array.NonEmpty as NEA
 import Data.Const (Const(..))
 import Data.Foldable (for_, sum, traverse_)
@@ -13,6 +11,8 @@ import Data.Monoid.Additive (Additive(..))
 import Data.Semigroup.Foldable (foldMap1)
 import Data.Semigroup.Traversable (traverse1)
 import Data.Tuple (Tuple(..))
+import Effect (Effect)
+import Effect.Console (log, logShow)
 import Partial.Unsafe (unsafePartial)
 import Test.Assert (assert)
 
@@ -234,9 +234,12 @@ testNonEmptyArray = do
   log "nub should remove duplicate elements from the list, keeping the first occurence"
   assert $ NEA.nub (fromArray [1, 2, 2, 3, 4, 1]) == fromArray [1, 2, 3, 4]
 
-  log "nubBy should remove duplicate items from the list using a supplied predicate"
+  log "nubEq should remove duplicate elements from the list, keeping the first occurence"
+  assert $ NEA.nubEq (fromArray [1, 2, 2, 3, 4, 1]) == fromArray [1, 2, 3, 4]
+
+  log "nubByEq should remove duplicate items from the list using a supplied predicate"
   let nubPred = \x y -> if odd x then false else x == y
-  assert $ NEA.nubBy nubPred (fromArray [1, 2, 2, 3, 3, 4, 4, 1]) == fromArray [1, 2, 3, 3, 4, 1]
+  assert $ NEA.nubByEq nubPred (fromArray [1, 2, 2, 3, 3, 4, 4, 1]) == fromArray [1, 2, 3, 3, 4, 1]
 
   log "union should produce the union of two arrays"
   assert $ NEA.union (fromArray [1, 2, 3]) (fromArray [2, 3, 4]) == fromArray [1, 2, 3, 4]

test/Test/Data/Array/ST.purs

@@ -1,14 +1,15 @@
 module Test.Data.Array.ST (testArrayST) where
 
 import Prelude
-import Effect (Effect)
-import Effect.Console (log)
+
 import Control.Monad.ST (ST)
 import Control.Monad.ST as ST
 import Data.Array.ST (STArray)
 import Data.Array.ST as STA
 import Data.Foldable (all)
 import Data.Maybe (Maybe(..), isNothing)
+import Effect (Effect)
+import Effect.Console (log)
 import Test.Assert (assert)
 
 run :: forall a. (forall r. ST r (STArray r a)) -> Array a
@@ -134,6 +135,21 @@ testArrayST = do
     void $ STA.poke 1 2 arr
     pure arr) == [1]
 
+  log "sort should reorder a list into ascending order based on the result of compare"
+  assert $ run (
+    STA.sort =<< STA.unsafeThaw [1, 3, 2, 5, 6, 4]
+  ) == [1, 2, 3, 4, 5, 6]
+
+  log "sortBy should reorder a list into ascending order based on the result of a comparison function"
+  assert $ run (
+    STA.sortBy (flip compare) =<< STA.unsafeThaw [1, 3, 2, 5, 6, 4]
+  ) == [6, 5, 4, 3, 2, 1]
+
+  log "sortWith should reorder a list into ascending order based on the result of compare over a projection"
+  assert $ run (
+    STA.sortWith identity =<< STA.unsafeThaw [1, 3, 2, 5, 6, 4]
+  ) == [1, 2, 3, 4, 5, 6]
+
   log "splice should be able to delete multiple items at a specified index"
 
   assert $ run (do