Remove use of uncons in implementation of span

Author: hdgarrood

src/Data/Array.purs

@@ -493,18 +493,30 @@ dropWhile p xs = (span p xs).rest
 -- | ```purescript
 -- | span (\n -> n % 2 == 1) [1,3,2,4,5] == { init: [1,3], rest: [2,4,5] }
 -- | ```
+-- |
+-- | Running time: `O(n)`.
 span
   :: forall a
    . (a -> Boolean)
   -> Array a
   -> { init :: Array a, rest :: Array a }
-span p = go []
+span p arr =
+  case breakIndex of
+    Just 0 ->
+      { init: [], rest: arr }
+    Just i ->
+      { init: slice 0 i arr, rest: slice i (length arr) arr }
+    Nothing ->
+      { init: arr, rest: [] }
   where
-  go :: Array a -> Array a -> { init :: Array a, rest :: Array a }
-  go acc xs =
-    case uncons xs of
-      Just { head: x, tail: xs' } | p x -> go (x : acc) xs'
-      _ -> { init: reverse acc, rest: xs }
+  breakIndex = go 0
+  go i =
+    -- This looks like a good opportunity to use the Monad Maybe instance,
+    -- but it's important to write out an explicit case expression here in
+    -- order to ensure that TCO is triggered.
+    case index arr i of
+      Just x -> if p x then go (i+1) else Just i
+      Nothing -> Nothing
 
 -- | Group equal, consecutive elements of an array into arrays.
 -- |

test/Test/Data/Array.purs

@@ -237,9 +237,30 @@ testArray = do
   assert $ (drop (-2) [1, 2, 3]) == [1, 2, 3]
 
   log "span should split an array in two based on a predicate"
-  let spanResult = span (_ < 4) [1, 2, 3, 4, 5, 6, 7]
-  assert $ spanResult.init == [1, 2, 3]
-  assert $ spanResult.rest == [4, 5, 6, 7]
+  let testSpan { p, input, init_, rest_ } = do
+        let result = span p input
+        assert $ result.init == init_
+        assert $ result.rest == rest_
+
+  let oneToSeven = [1, 2, 3, 4, 5, 6, 7]
+  testSpan { p: (_ < 4), input: oneToSeven, init_: [1, 2, 3], rest_: [4, 5, 6, 7] }
+
+  log "span with all elements satisfying the predicate"
+  testSpan { p: const true, input: oneToSeven, init_: oneToSeven, rest_: [] }
+
+  log "span with no elements satisfying the predicate"
+  testSpan { p: const false, input: oneToSeven, init_: [], rest_: oneToSeven }
+
+  log "span with large inputs: 10000"
+  let testBigSpan n =
+        testSpan { p: (_ < n), input: range 1 n, init_: range 1 (n-1), rest_: [n] }
+  testBigSpan 10000
+
+  log "span with large inputs: 40000"
+  testBigSpan 40000
+
+  log "span with large inputs: 100000"
+  testBigSpan 100000
 
   log "group should group consecutive equal elements into arrays"
   assert $ group [1, 2, 2, 3, 3, 3, 1] == [NE.singleton 1, 2 :| [2], 3:| [3, 3], NE.singleton 1]