feat(partitionwhile): add partitionWhile function

Author: djcsdy

index.test.ts

@@ -1,5 +1,5 @@
 import test from "ava";
-import {filterFirst, find, findIndex, foldMap, partition} from "./index";
+import {filterFirst, find, findIndex, foldMap, partition, partitionWhile} from "./index";
 
 test("filterFirst", t => {
     t.deepEqual(filterFirst([1, 2, 3, 4, 3, 2, 1], n => n < 3), [1, 2, 4, 3, 2, 1]);
@@ -56,4 +56,24 @@ test("partition", t => {
     ], [
         {type: "error"}
     ]]);
+});
+
+test("partitionWhile", t => {
+    t.deepEqual(partitionWhile(["abc", "def", "ghi"], (_: string, i: number) => (i % 2 === 0)),
+        [["abc"], ["def", "ghi"]]);
+
+    const results: Array<Result<string>> = [
+        {type: "success", value: "hello"},
+        {type: "error"},
+        {type: "success", value: "goodbye"}
+    ];
+
+    const partitionedResults: [Array<Success<string>>, Array<Result<string>>] = partitionWhile(results, isSuccess);
+
+    t.deepEqual(partitionedResults, [[
+        {type: "success", value: "hello"}
+    ], [
+        {type: "error"},
+        {type: "success", value: "goodbye"}
+    ]]);
 });

index.ts

@@ -465,6 +465,27 @@ export function partitionFn<T>(predicate: (element: T, index: number) => boolean
     return array => partition(array, predicate);
 }
 
+export function partitionWhile<T, U extends T>(array: ArrayLike<T>,
+                                               predicate: (element: T) => element is U): [U[], T[]];
+export function partitionWhile<T>(array: ArrayLike<T>, predicate: (element: T, index: number) => boolean): [T[], T[]];
+export function partitionWhile<T>(array: ArrayLike<T>, predicate: (element: T, index: number) => boolean): [T[], T[]] {
+    let i;
+    for (i = 0; i < array.length; ++i) {
+        if (!predicate(array[i], i)) {
+            break;
+        }
+    }
+
+    return [take(array, i), drop(array, i)];
+}
+
+export function partitionWhileFn<T, U extends T>(
+    predicate: (element: T) => element is U): (array: ReadonlyArray<T>) => [U[], T[]];
+export function partitionWhileFn<T>(predicate: (element: T) => boolean): (array: ReadonlyArray<T>) => [T[], T[]];
+export function partitionWhileFn<T>(predicate: (element: T) => boolean): (array: ReadonlyArray<T>) => [T[], T[]] {
+    return array => partitionWhile(array, predicate);
+}
+
 export function keyBy<TElement, TKey extends Key>(
     array: ArrayLike<TElement>,
     f: (element: TElement) => TKey