Use NonEmptyArray when grouping

Author: garyb

src/Data/Array.purs

@@ -25,7 +25,7 @@
 -- |   `Data.Foldable.or` tests whether an array of `Boolean` values contains
 -- |   at least one `true` value.
 -- | * `Traversable`, which provides the PureScript version of a for-loop,
--- |   allowing you to iterate over an array and accumulate effects.
+-- |   allowing you to STAI.iterate over an array and accumulate effects.
 -- |
 module Data.Array
   ( fromFoldable
@@ -114,22 +114,24 @@ module Data.Array
   ) where
 
 import Prelude
+
 import Control.Alt ((<|>))
 import Control.Alternative (class Alternative)
 import Control.Lazy (class Lazy, defer)
 import Control.Monad.Rec.Class (class MonadRec, Step(..), tailRecM2)
 import Control.Monad.ST as ST
-import Data.Array.ST (unsafeFreeze, emptySTArray, pokeSTArray, pushSTArray, modifySTArray, withArray)
-import Data.Array.ST.Iterator (iterator, iterate, pushWhile)
+import Data.Array.ST as STA
+import Data.Array.ST.Iterator as STAI
+import Data.Array.NonEmpty.Internal (NonEmptyArray)
 import Data.Foldable (class Foldable, foldl, foldr, traverse_)
 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, traverse)
 import Data.Tuple (Tuple(..), uncurry)
 import Data.Unfoldable (class Unfoldable, unfoldr)
 import Partial.Unsafe (unsafePartial)
+import Unsafe.Coerce (unsafeCoerce)
 
 -- | Convert an `Array` into an `Unfoldable` structure.
 toUnfoldable :: forall f. Unfoldable f => Array ~> f
@@ -656,7 +658,7 @@ mapWithIndex f xs =
 -- |
 updateAtIndices :: forall t a. Foldable t => t (Tuple Int a) -> Array a -> Array a
 updateAtIndices us xs =
-  ST.run (withArray (\res -> traverse_ (uncurry $ pokeSTArray res) us) xs)
+  ST.run (STA.withArray (\res -> traverse_ (uncurry $ STA.pokeSTArray res) us) xs)
 
 -- | Apply a function to the element at the specified indices,
 -- | creating a new array. Out-of-bounds indices will have no effect.
@@ -669,7 +671,7 @@ updateAtIndices us xs =
 -- |
 modifyAtIndices :: forall t a. Foldable t => t Int -> (a -> a) -> Array a -> Array a
 modifyAtIndices is f xs =
-  ST.run (withArray (\res -> traverse_ (\i -> modifySTArray res i f) is) xs)
+  ST.run (STA.withArray (\res -> traverse_ (\i -> STA.modifySTArray res i f) is) xs)
 
 --------------------------------------------------------------------------------
 -- Sorting ---------------------------------------------------------------------
@@ -836,15 +838,15 @@ span p arr =
 -- | ```purescript
 -- | group [1,1,2,2,1] == [NonEmpty 1 [1], NonEmpty 2 [2], NonEmpty 1 []]
 -- | ```
-group :: forall a. Eq a => Array a -> Array (NonEmpty Array a)
+group :: forall a. Eq a => Array a -> Array (NonEmptyArray a)
 group xs = groupBy eq xs
 
 -- | Sort and then group the elements of an array into arrays.
 -- |
 -- | ```purescript
 -- | group' [1,1,2,2,1] == [NonEmpty 1 [1,1],NonEmpty 2 [2]]
 -- | ```
-group' :: forall a. Ord a => Array a -> Array (NonEmpty Array a)
+group' :: forall a. Ord a => Array a -> Array (NonEmptyArray a)
 group' = group <<< sort
 
 -- | Group equal, consecutive elements of an array into arrays, using the
@@ -855,17 +857,18 @@ group' = group <<< sort
 -- |    = [NonEmpty 1 [3], NonEmpty 2 [] , NonEmpty 4 [], NonEmpty 3 [3]]
 -- | ```
 -- |
-groupBy :: forall a. (a -> a -> Boolean) -> Array a -> Array (NonEmpty Array a)
+groupBy :: forall a. (a -> a -> Boolean) -> Array a -> Array (NonEmptyArray a)
 groupBy op xs =
   ST.run do
-    result <- emptySTArray
-    iter <- iterator (xs !! _)
-    iterate iter \x -> void do
-      sub <- emptySTArray
-      pushWhile (op x) iter sub
-      sub_ <- unsafeFreeze sub
-      pushSTArray result (x :| sub_)
-    unsafeFreeze result
+    result <- STA.emptySTArray
+    iter <- STAI.iterator (xs !! _)
+    STAI.iterate iter \x -> void do
+      sub <- STA.emptySTArray
+      STAI.pushWhile (op x) iter sub
+      _ <- STA.pushSTArray sub x
+      grp <- STA.unsafeFreeze sub
+      STA.pushSTArray result ((unsafeCoerce :: Array ~> NonEmptyArray) grp)
+    STA.unsafeFreeze result
 
 -- | Remove the duplicates from an array, creating a new array.
 -- |
@@ -1032,14 +1035,14 @@ zip = zipWith Tuple
 unzip :: forall a b. Array (Tuple a b) -> Tuple (Array a) (Array b)
 unzip xs =
   ST.run do
-    fsts <- emptySTArray
-    snds <- emptySTArray
-    iter <- iterator (xs !! _)
-    iterate iter \(Tuple fst snd) -> do
-      void $ pushSTArray fsts fst
-      void $ pushSTArray snds snd
-    fsts' <- unsafeFreeze fsts
-    snds' <- unsafeFreeze snds
+    fsts <- STA.emptySTArray
+    snds <- STA.emptySTArray
+    iter <- STAI.iterator (xs !! _)
+    STAI.iterate iter \(Tuple fst snd) -> do
+      void $ STA.pushSTArray fsts fst
+      void $ STA.pushSTArray snds snd
+    fsts' <- STA.unsafeFreeze fsts
+    snds' <- STA.unsafeFreeze snds
     pure $ Tuple fsts' snds'
 
 -- | Perform a fold using a monadic step function.

src/Data/Array/NonEmpty.purs

@@ -1,5 +1,5 @@
 module Data.Array.NonEmpty
-  ( NonEmptyArray
+  ( module Data.Array.NonEmpty.Internal
   , fromArray
   , fromNonEmpty
   , toArray
@@ -93,71 +93,27 @@ module Data.Array.NonEmpty
 
 import Prelude
 
-import Control.Alt (class Alt)
 import Control.Alternative (class Alternative)
 import Control.Lazy (class Lazy)
 import Control.Monad.Rec.Class (class MonadRec)
 import Data.Array as A
+import Data.Array.NonEmpty.Internal (NonEmptyArray)
 import Data.Bifunctor (bimap)
-import Data.Eq (class Eq1)
 import Data.Foldable (class Foldable)
-import Data.FoldableWithIndex (class FoldableWithIndex)
-import Data.FunctorWithIndex (class FunctorWithIndex)
 import Data.Maybe (Maybe(..), fromJust)
 import Data.NonEmpty (NonEmpty, (:|))
-import Data.Ord (class Ord1)
-import Data.Semigroup.Foldable (class Foldable1, foldMap1Default)
-import Data.Semigroup.Traversable (class Traversable1, sequence1Default)
-import Data.Traversable (class Traversable)
-import Data.TraversableWithIndex (class TraversableWithIndex)
+import Data.Semigroup.Foldable (class Foldable1)
 import Data.Tuple (Tuple)
 import Data.Unfoldable (class Unfoldable)
 import Partial.Unsafe (unsafePartial)
-
-newtype NonEmptyArray a = NonEmptyArray (Array a)
-
-instance showNonEmptyArray :: Show a => Show (NonEmptyArray a) where
-  show (NonEmptyArray xs) = "(NonEmptyArray " <> show xs <> ")"
-
-derive newtype instance eqNonEmptyArray :: Eq a => Eq (NonEmptyArray a)
-derive newtype instance eq1NonEmptyArray :: Eq1 NonEmptyArray
-
-derive newtype instance ordNonEmptyArray :: Ord a => Ord (NonEmptyArray a)
-derive newtype instance ord1NonEmptyArray :: Ord1 NonEmptyArray 
-
-derive newtype instance functorNonEmptyArray :: Functor NonEmptyArray
-derive newtype instance functorWithIndexNonEmptyArray :: FunctorWithIndex Int NonEmptyArray
-
-derive newtype instance foldableNonEmptyArray :: Foldable NonEmptyArray
-derive newtype instance foldableWithIndexNonEmptyArray :: FoldableWithIndex Int NonEmptyArray
-
-instance foldable1NonEmptyArray :: Foldable1 NonEmptyArray where
-  foldMap1 = foldMap1Default
-  fold1 = fold1Impl (<>)
-
-derive newtype instance traversableNonEmptyArray :: Traversable NonEmptyArray
-derive newtype instance traversableWithIndexNonEmptyArray :: TraversableWithIndex Int NonEmptyArray
-
-instance traversable1NonEmptyArray :: Traversable1 NonEmptyArray where
-  traverse1 = traverse1Impl apply map
-  sequence1 = sequence1Default
-
-derive newtype instance applyNonEmptyArray :: Apply NonEmptyArray
-
-derive newtype instance applicativeNonEmptyArray :: Applicative NonEmptyArray
-
-derive newtype instance bindNonEmptyArray :: Bind NonEmptyArray
-
-derive newtype instance monadNonEmptyArray :: Monad NonEmptyArray
-
-derive newtype instance altNonEmptyArray :: Alt NonEmptyArray
+import Unsafe.Coerce (unsafeCoerce)
 
 -- | Internal - adapt an Array transform to NonEmptyArray
 --
 -- Note that this is unsafe: if the transform returns an empty array, this can
 -- explode at runtime.
 unsafeAdapt :: forall a b. (Array a -> Array b) -> NonEmptyArray a -> NonEmptyArray b
-unsafeAdapt f = NonEmptyArray <<< adaptAny f
+unsafeAdapt f = unsafeFromArray <<< adaptAny f
 
 -- | Internal - adapt an Array transform to NonEmptyArray,
 --   with polymorphic result.
@@ -173,18 +129,21 @@ adaptMaybe f = unsafePartial $ fromJust <<< f <<< toArray
 
 fromArray :: forall a. Array a -> Maybe (NonEmptyArray a)
 fromArray xs
-  | A.length xs > 0 = Just (NonEmptyArray xs)
-  | otherwise       = Nothing
+  | A.length xs > 0 = Just (unsafeFromArray xs)
+  | otherwise = Nothing
 
 -- | INTERNAL
 unsafeFromArray :: forall a. Array a -> NonEmptyArray a
-unsafeFromArray = NonEmptyArray
+unsafeFromArray = unsafeCoerce
+
+unsafeFromArrayF :: forall f a. f (Array a) -> f (NonEmptyArray a)
+unsafeFromArrayF = unsafeCoerce
 
 fromNonEmpty :: forall a. NonEmpty Array a -> NonEmptyArray a
 fromNonEmpty (x :| xs) = cons' x xs
 
 toArray :: forall a. NonEmptyArray a -> Array a
-toArray (NonEmptyArray xs) = xs
+toArray = unsafeCoerce
 
 toNonEmpty :: forall a. NonEmptyArray a -> NonEmpty Array a
 toNonEmpty = uncons >>> \{head: x, tail: xs} -> x :| xs
@@ -199,7 +158,7 @@ toUnfoldable :: forall f a. Unfoldable f => NonEmptyArray a -> f a
 toUnfoldable = adaptAny A.toUnfoldable
 
 singleton :: forall a. a -> NonEmptyArray a
-singleton = NonEmptyArray <<< A.singleton
+singleton = unsafeFromArray <<< A.singleton
 
 range :: Int -> Int -> NonEmptyArray Int
 range x y = unsafeFromArray $ A.range x y
@@ -208,14 +167,14 @@ infix 8 range as ..
 
 -- | Replicate an item at least once
 replicate :: forall a. Int -> a -> NonEmptyArray a
-replicate i x = NonEmptyArray $ A.replicate (max 1 i) x
+replicate i x = unsafeFromArray $ A.replicate (max 1 i) x
 
 some
   :: forall f a
    . Alternative f
   => Lazy (f (Array a))
   => f a -> f (NonEmptyArray a)
-some = map NonEmptyArray <<< A.some
+some = unsafeFromArrayF <<< A.some
 
 length :: forall a. NonEmptyArray a -> Int
 length = adaptAny A.length
@@ -279,19 +238,19 @@ findLastIndex :: forall a. (a -> Boolean) -> NonEmptyArray a -> Maybe Int
 findLastIndex x = adaptAny $ A.findLastIndex x
 
 insertAt :: forall a. Int -> a -> NonEmptyArray a -> Maybe (NonEmptyArray a)
-insertAt i x = map NonEmptyArray <<< A.insertAt i x <<< toArray
+insertAt i x = unsafeFromArrayF <<< A.insertAt i x <<< toArray
 
 deleteAt :: forall a. Int -> NonEmptyArray a -> Maybe (Array a)
 deleteAt i = adaptAny $ A.deleteAt i
 
 updateAt :: forall a. Int -> a -> NonEmptyArray a -> Maybe (NonEmptyArray a)
-updateAt i x = map NonEmptyArray <<< A.updateAt i x <<< toArray
+updateAt i x = unsafeFromArrayF <<< A.updateAt i x <<< toArray
 
 updateAtIndices :: forall t a. Foldable t => t (Tuple Int a) -> NonEmptyArray a -> NonEmptyArray a
 updateAtIndices pairs = unsafeAdapt $ A.updateAtIndices pairs
 
 modifyAt :: forall a. Int -> (a -> a) -> NonEmptyArray a -> Maybe (NonEmptyArray a)
-modifyAt i f = map NonEmptyArray <<< A.modifyAt i f <<< toArray
+modifyAt i f = unsafeFromArrayF <<< A.modifyAt i f <<< toArray
 
 modifyAtIndices :: forall t a. Foldable t => t Int -> (a -> a) -> NonEmptyArray a -> NonEmptyArray a
 modifyAtIndices is f = unsafeAdapt $ A.modifyAtIndices is f
@@ -303,7 +262,7 @@ reverse :: forall a. NonEmptyArray a -> NonEmptyArray a
 reverse = unsafeAdapt A.reverse
 
 concat :: forall a. NonEmptyArray (NonEmptyArray a) -> NonEmptyArray a
-concat = NonEmptyArray <<< A.concat <<< toArray <<< map toArray
+concat = unsafeFromArray <<< A.concat <<< toArray <<< map toArray
 
 concatMap :: forall a b. (a -> NonEmptyArray b) -> NonEmptyArray a -> NonEmptyArray b
 concatMap = flip bind
@@ -439,7 +398,7 @@ zipWith
   -> NonEmptyArray a
   -> NonEmptyArray b
   -> NonEmptyArray c
-zipWith f xs ys = NonEmptyArray $ A.zipWith f (toArray xs) (toArray ys)
+zipWith f xs ys = unsafeFromArray $ A.zipWith f (toArray xs) (toArray ys)
 
 
 zipWithA
@@ -449,13 +408,13 @@ zipWithA
   -> NonEmptyArray a
   -> NonEmptyArray b
   -> m (NonEmptyArray c)
-zipWithA f xs ys = NonEmptyArray <$> A.zipWithA f (toArray xs) (toArray ys)
+zipWithA f xs ys = unsafeFromArrayF $ A.zipWithA f (toArray xs) (toArray ys)
 
 zip :: forall a b. NonEmptyArray a -> NonEmptyArray b -> NonEmptyArray (Tuple a b)
-zip xs ys = NonEmptyArray $ toArray xs `A.zip` toArray ys
+zip xs ys = unsafeFromArray $ toArray xs `A.zip` toArray ys
 
 unzip :: forall a b. NonEmptyArray (Tuple a b) -> Tuple (NonEmptyArray a) (NonEmptyArray b)
-unzip = bimap NonEmptyArray NonEmptyArray <<< A.unzip <<< toArray
+unzip = bimap unsafeFromArray unsafeFromArray <<< A.unzip <<< toArray
 
 foldM :: forall m a b. Monad m => (a -> b -> m a) -> a -> NonEmptyArray b -> m a
 foldM f acc = adaptAny $ A.foldM f acc
@@ -465,14 +424,3 @@ foldRecM f acc = adaptAny $ A.foldRecM f acc
 
 unsafeIndex :: forall a. Partial => NonEmptyArray a -> Int -> a
 unsafeIndex = adaptAny A.unsafeIndex
-
--- we use FFI here to avoid the unnecessary copy created by `tail`
-foreign import fold1Impl :: forall a. (a -> a -> a) -> NonEmptyArray a -> a
-
-foreign import traverse1Impl
-  :: forall m a b
-   . (forall a' b'. (m (a' -> b') -> m a' -> m b'))
-  -> (forall a' b'. (a' -> b') -> m a' -> m b')
-  -> (a -> m b)
-  -> NonEmptyArray a
-  -> m (NonEmptyArray b)

src/Data/Array/NonEmpty.js renamed to src/Data/Array/NonEmpty/Internal.js

@@ -0,0 +1,63 @@
+module Data.Array.NonEmpty.Internal (NonEmptyArray) where
+
+import Prelude
+
+import Control.Alt (class Alt)
+import Data.Eq (class Eq1)
+import Data.Foldable (class Foldable)
+import Data.FoldableWithIndex (class FoldableWithIndex)
+import Data.FunctorWithIndex (class FunctorWithIndex)
+import Data.Ord (class Ord1)
+import Data.Semigroup.Foldable (class Foldable1, foldMap1Default)
+import Data.Semigroup.Traversable (class Traversable1, sequence1Default)
+import Data.Traversable (class Traversable)
+import Data.TraversableWithIndex (class TraversableWithIndex)
+
+newtype NonEmptyArray a = NonEmptyArray (Array a)
+
+instance showNonEmptyArray :: Show a => Show (NonEmptyArray a) where
+  show (NonEmptyArray xs) = "(NonEmptyArray " <> show xs <> ")"
+
+derive newtype instance eqNonEmptyArray :: Eq a => Eq (NonEmptyArray a)
+derive newtype instance eq1NonEmptyArray :: Eq1 NonEmptyArray
+
+derive newtype instance ordNonEmptyArray :: Ord a => Ord (NonEmptyArray a)
+derive newtype instance ord1NonEmptyArray :: Ord1 NonEmptyArray
+
+derive newtype instance functorNonEmptyArray :: Functor NonEmptyArray
+derive newtype instance functorWithIndexNonEmptyArray :: FunctorWithIndex Int NonEmptyArray
+
+derive newtype instance foldableNonEmptyArray :: Foldable NonEmptyArray
+derive newtype instance foldableWithIndexNonEmptyArray :: FoldableWithIndex Int NonEmptyArray
+
+instance foldable1NonEmptyArray :: Foldable1 NonEmptyArray where
+  foldMap1 = foldMap1Default
+  fold1 = fold1Impl (<>)
+
+derive newtype instance traversableNonEmptyArray :: Traversable NonEmptyArray
+derive newtype instance traversableWithIndexNonEmptyArray :: TraversableWithIndex Int NonEmptyArray
+
+instance traversable1NonEmptyArray :: Traversable1 NonEmptyArray where
+  traverse1 = traverse1Impl apply map
+  sequence1 = sequence1Default
+
+derive newtype instance applyNonEmptyArray :: Apply NonEmptyArray
+
+derive newtype instance applicativeNonEmptyArray :: Applicative NonEmptyArray
+
+derive newtype instance bindNonEmptyArray :: Bind NonEmptyArray
+
+derive newtype instance monadNonEmptyArray :: Monad NonEmptyArray
+
+derive newtype instance altNonEmptyArray :: Alt NonEmptyArray
+
+-- we use FFI here to avoid the unnecessary copy created by `tail`
+foreign import fold1Impl :: forall a. (a -> a -> a) -> NonEmptyArray a -> a
+
+foreign import traverse1Impl
+  :: forall m a b
+   . (forall a' b'. (m (a' -> b') -> m a' -> m b'))
+  -> (forall a' b'. (a' -> b') -> m a' -> m b')
+  -> (a -> m b)
+  -> NonEmptyArray a
+  -> m (NonEmptyArray b)