Add intersperse with tests

src/Data/Array.purs

@@ -64,6 +64,7 @@ module Data.Array
   , modifyAtIndices
   , alterAt
 
+  , intersperse
   , reverse
   , concat
   , concatMap
@@ -123,6 +124,7 @@ 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 Control.Monad.ST.Internal as STI
 import Data.Array.NonEmpty.Internal (NonEmptyArray(..))
 import Data.Array.ST as STA
 import Data.Array.ST.Iterator as STAI
@@ -551,6 +553,31 @@ alterAt i f xs = maybe Nothing go (xs !! i)
 -- Transformations -------------------------------------------------------------
 --------------------------------------------------------------------------------
 
+-- | Inserts the given element in between each element in the array. The array
+-- | must have two or more elements for this operation to take effect.
+-- |
+-- | ```purescript
+-- | intersperse " " [ "a", "b" ] == [ "a", " ", "b" ]
+-- | intersperse 0 [ 1, 2, 3, 4, 5 ] == [ 1, 0, 2, 0, 3, 0, 4, 0, 5 ]
+-- | ```
+-- |
+-- | If the array has one or zero elements, the input array is returned.
+-- | ```purescript
+-- | intersperse " " [] == []
+-- | intersperse " " ["a"] == ["a"]
+-- | ```
+intersperse :: forall a. a -> Array a -> Array a
+intersperse a arr = case length arr of
+  len | len < 2 -> arr
+      | otherwise -> STA.run do
+          let unsafeGetElem idx = unsafePartial (unsafeIndex arr idx)
+          out <- STA.empty
+          _ <- STA.push (unsafeGetElem 0) out
+          STI.for 1 len \idx -> do
+            _ <- STA.push a out
+            void (STA.push (unsafeGetElem idx) out)
+          pure out
+
 -- | Reverse an array, creating a new array.
 -- |
 -- | ```purescript

test/Test/Data/Array.purs

@@ -187,6 +187,14 @@ testArray = do
   log "alterAt should return Nothing if the index is out of A.range"
   assert $ (A.alterAt 1 (Just <<< (_ + 1)) nil) == Nothing
 
+  log "intersperse should return the original array when given an array with zero or one elements"
+  assert $ (A.intersperse " " []) == []
+  assert $ (A.intersperse " " ["a"]) == ["a"]
+
+  log "intersperse should insert the given element in-between each element in an array with two or more elements"
+  assert $ (A.intersperse " " ["a", "b"]) == ["a", " ", "b"]
+  assert $ (A.intersperse 0 [ 1, 2, 3, 4, 5 ]) == [ 1, 0, 2, 0, 3, 0, 4, 0, 5 ]
+
   log "reverse should reverse the order of items in an array"
   assert $ (A.reverse [1, 2, 3]) == [3, 2, 1]
   assert $ (A.reverse nil) == nil