Add splitAt

src/Data/Array.purs

@@ -69,6 +69,7 @@ module Data.Array
   , concatMap
   , filter
   , partition
+  , splitAt
   , filterA
   , mapMaybe
   , catMaybes
@@ -600,6 +601,16 @@ foreign import partition
   -> Array a
   -> { yes :: Array a, no :: Array a }
 
+-- | Splits an array into two pieces, where the first array has `n` elements
+-- | and the second array has the remaining elements.
+-- |
+-- | ```purescript
+-- | splitAt 3 [1, 2, 3, 4, 5] == Tuple [1, 2, 3] [4, 5]
+-- | ```
+splitAt :: forall a. Int -> Array a -> Tuple (Array a) (Array a)
+splitAt n xs | n <= 0 = Tuple [] xs
+splitAt n xs = Tuple (slice 0 n xs) (slice n (length xs) xs)
+
 -- | Filter where the predicate returns a `Boolean` in some `Applicative`.
 -- |
 -- | ```purescript

src/Data/Array/NonEmpty.purs

@@ -48,6 +48,7 @@ module Data.Array.NonEmpty
   , concat
   , concatMap
   , filter
+  , splitAt
   , partition
   , filterA
   , mapMaybe
@@ -296,6 +297,9 @@ filterA
   -> f (Array a)
 filterA f = adaptAny $ A.filterA f
 
+splitAt :: forall a. Int -> NonEmptyArray a -> Tuple (Array a) (Array a)
+splitAt n xs = A.splitAt n $ toArray xs
+
 mapMaybe :: forall a b. (a -> Maybe b) -> NonEmptyArray a -> Array b
 mapMaybe f = adaptAny $ A.mapMaybe f
 

test/Test/Data/Array.purs

@@ -202,6 +202,14 @@ testArray = do
   log "filter should remove items that don't match a predicate"
   assert $ A.filter odd (A.range 0 10) == [1, 3, 5, 7, 9]
 
+  log "splitAt should split the array at the given number of elements"
+  assert $ A.splitAt 3 [1, 2, 3, 4, 5] == Tuple [1, 2, 3] [4, 5]
+  assert $ A.splitAt 1 [1, 2, 3] == Tuple [1] [2, 3]
+  assert $ A.splitAt 3 [1, 2, 3] == Tuple [1, 2, 3] []
+  assert $ A.splitAt 4 [1, 2, 3] == Tuple [1, 2, 3] []
+  assert $ A.splitAt 0 [1, 2, 3] == Tuple [] [1, 2, 3]
+  assert $ A.splitAt (-1) [1, 2, 3] == Tuple [] [1, 2, 3]
+
   log "filterA should remove items that don't match a predicate while using an applicative behaviour"
   assert $ A.filterA (Just <<< odd) (A.range 0 10) == Just [1, 3, 5, 7, 9]
   assert $ A.filterA (const Nothing) (A.range 0 10) == Nothing

test/Test/Data/Array/NonEmpty.purs

@@ -166,6 +166,14 @@ testNonEmptyArray = do
   log "filter should remove items that don't match a predicate"
   assert $ NEA.filter odd (NEA.range 0 10) == [1, 3, 5, 7, 9]
 
+  log "splitAt should split the array at the given number of elements"
+  assert $ NEA.splitAt 3 (fromArray [1, 2, 3, 4, 5]) == Tuple [1, 2, 3] [4, 5]
+  assert $ NEA.splitAt 1 (fromArray [1, 2, 3]) == Tuple [1] [2, 3]
+  assert $ NEA.splitAt 3 (fromArray [1, 2, 3]) == Tuple [1, 2, 3] []
+  assert $ NEA.splitAt 4 (fromArray [1, 2, 3]) == Tuple [1, 2, 3] []
+  assert $ NEA.splitAt 0 (fromArray [1, 2, 3]) == Tuple [] [1, 2, 3]
+  assert $ NEA.splitAt (-1) (fromArray [1, 2, 3]) == Tuple [] [1, 2, 3]
+
   log "filterA should remove items that don't match a predicate while using an applicative behaviour"
   assert $ NEA.filterA (Just <<< odd) (NEA.range 0 10) == Just [1, 3, 5, 7, 9]
   assert $ NEA.filterA (const Nothing) (NEA.range 0 10) == Nothing