Use NonEmpty for group operations

Author: garyb

bower.json

@@ -17,6 +17,7 @@
   ],
   "dependencies": {
     "purescript-foldable-traversable": "^2.0.0",
+    "purescript-nonempty": "^3.0.0",
     "purescript-partial": "^1.1.0",
     "purescript-st": "^2.0.0",
     "purescript-tailrec": "^2.0.0",

src/Data/Array.purs

@@ -118,6 +118,7 @@ import Control.Monad.Rec.Class (class MonadRec, Step(..), tailRecM2)
 import Data.Foldable (class Foldable, foldl, foldr)
 import Data.Foldable (foldl, foldr, foldMap, fold, intercalate, elem, notElem, find, findMap, any, all) as Exports
 import Data.Maybe (Maybe(..), maybe, isJust, fromJust)
+import Data.NonEmpty (NonEmpty, (:|))
 import Data.Traversable (scanl, scanr) as Exports
 import Data.Traversable (sequence)
 import Data.Tuple (Tuple(..))
@@ -505,27 +506,27 @@ span p = go []
 -- | ```purescript
 -- | group [1,1,2,2,1] == [[1,1],[2,2],[1]]
 -- | ```
-group :: forall a. Eq a => Array a -> Array (Array a)
+group :: forall a. Eq a => Array a -> Array (NonEmpty Array a)
 group xs = groupBy eq xs
 
 -- | Sort and then group the elements of an array into arrays.
 -- |
 -- | ```purescript
 -- | group' [1,1,2,2,1] == [[1,1,1],[2,2]]
 -- | ```
-group' :: forall a. Ord a => Array a -> Array (Array a)
+group' :: forall a. Ord a => Array a -> Array (NonEmpty Array a)
 group' = group <<< sort
 
 -- | Group equal, consecutive elements of an array into arrays, using the
 -- | specified equivalence relation to detemine equality.
-groupBy :: forall a. (a -> a -> Boolean) -> Array a -> Array (Array a)
+groupBy :: forall a. (a -> a -> Boolean) -> Array a -> Array (NonEmpty Array a)
 groupBy op = go []
   where
-  go :: Array (Array a) -> Array a -> Array (Array a)
+  go :: Array (NonEmpty Array a) -> Array a -> Array (NonEmpty Array a)
   go acc xs = case uncons xs of
     Just o ->
       let sp = span (op o.head) o.tail
-      in go ((o.head : sp.init) : acc) sp.rest
+      in go ((o.head :| sp.init) : acc) sp.rest
     Nothing -> reverse acc
 
 -- | Remove the duplicates from an array, creating a new array.

test/Test/Data/Array.purs

@@ -8,6 +8,8 @@ import Control.Monad.Eff.Console (log, CONSOLE)
 import Data.Array (range, replicate, 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, mapWithIndex, filterM, filter, concat, concatMap, reverse, alterAt, modifyAt, updateAt, deleteAt, insertAt, findLastIndex, findIndex, elemLastIndex, elemIndex, (!!), uncons, init, tail, last, head, insertBy, insert, snoc, (:), length, null, singleton, fromFoldable)
 import Data.Foldable (for_, foldMapDefaultR, class Foldable, all)
 import Data.Maybe (Maybe(..), isNothing, fromJust)
+import Data.NonEmpty ((:|))
+import Data.NonEmpty as NE
 import Data.Tuple (Tuple(..))
 import Data.Unfoldable (replicateA)
 
@@ -240,13 +242,13 @@ testArray = do
   assert $ spanResult.rest == [4, 5, 6, 7]
 
   log "group should group consecutive equal elements into arrays"
-  assert $ group [1, 2, 2, 3, 3, 3, 1] == [[1], [2, 2], [3, 3, 3], [1]]
+  assert $ group [1, 2, 2, 3, 3, 3, 1] == [NE.singleton 1, 2 :| [2], 3:| [3, 3], NE.singleton 1]
 
   log "group' should sort then group consecutive equal elements into arrays"
-  assert $ group' [1, 2, 2, 3, 3, 3, 1] == [[1, 1], [2, 2], [3, 3, 3]]
+  assert $ group' [1, 2, 2, 3, 3, 3, 1] == [1 :| [1], 2 :| [2], 3 :| [3, 3]]
 
   log "groupBy should group consecutive equal elements into arrays based on an equivalence relation"
-  assert $ groupBy (\x y -> odd x && odd y) [1, 1, 2, 2, 3, 3] == [[1, 1], [2], [2], [3, 3]]
+  assert $ groupBy (\x y -> odd x && odd y) [1, 1, 2, 2, 3, 3] == [1 :| [1], NE.singleton 2, NE.singleton 2, 3 :| [3]]
 
   log "nub should remove duplicate elements from the list, keeping the first occurence"
   assert $ nub [1, 2, 2, 3, 4, 1] == [1, 2, 3, 4]