@sayoriqwq/effect-harness 0.0.1

package/repos/effect/packages/effect/test/Array.test.ts

@@ -0,0 +1,1579 @@
+import { describe, it } from "@effect/vitest"
+import { assertNone, assertSome, deepStrictEqual, strictEqual, throws } from "@effect/vitest/utils"
+import { Array as Arr, Equivalence, Number as Num, Option, Order, type Predicate, Result, String as Str } from "effect"
+import { identity, pipe } from "effect/Function"
+import { FastCheck as fc } from "effect/testing"
+
+const symA = Symbol.for("a")
+const symB = Symbol.for("b")
+const symC = Symbol.for("c")
+
+const double = (n: number) => n * 2
+
+describe("Array", () => {
+  it("of", () => {
+    deepStrictEqual(Arr.of(1), [1])
+  })
+
+  it("fromIterable/Array should return the same reference if the iterable is an Array", () => {
+    const i = [1, 2, 3]
+    strictEqual(Arr.fromIterable(i), i)
+  })
+
+  it("fromIterable/Iterable", () => {
+    deepStrictEqual(Arr.fromIterable(new Set([1, 2, 3])), [1, 2, 3])
+  })
+
+  it("ensure", () => {
+    deepStrictEqual(Arr.ensure(1), [1])
+    deepStrictEqual(Arr.ensure(null), [null])
+    deepStrictEqual(Arr.ensure([1]), [1])
+    deepStrictEqual(Arr.ensure([1, 2]), [1, 2])
+    deepStrictEqual(Arr.ensure(new Set([1, 2])), [new Set([1, 2])])
+  })
+
+  describe("iterable inputs", () => {
+    it("prepend", () => {
+      deepStrictEqual(pipe([1, 2, 3], Arr.prepend(0)), [0, 1, 2, 3])
+      deepStrictEqual(pipe([[2]], Arr.prepend([1])), [[1], [2]])
+
+      deepStrictEqual(pipe(new Set([1, 2, 3]), Arr.prepend(0)), [0, 1, 2, 3])
+      deepStrictEqual(pipe(new Set([[2]]), Arr.prepend([1])), [[1], [2]])
+    })
+
+    it("prependAll", () => {
+      deepStrictEqual(pipe([3, 4], Arr.prependAll([1, 2])), [1, 2, 3, 4])
+
+      deepStrictEqual(pipe([3, 4], Arr.prependAll(new Set([1, 2]))), [1, 2, 3, 4])
+      deepStrictEqual(pipe(new Set([3, 4]), Arr.prependAll([1, 2])), [1, 2, 3, 4])
+    })
+
+    it("append", () => {
+      deepStrictEqual(pipe([1, 2, 3], Arr.append(4)), [1, 2, 3, 4])
+      deepStrictEqual(pipe([[1]], Arr.append([2])), [[1], [2]])
+
+      deepStrictEqual(pipe(new Set([1, 2, 3]), Arr.append(4)), [1, 2, 3, 4])
+      deepStrictEqual(pipe(new Set([[1]]), Arr.append([2])), [[1], [2]])
+    })
+
+    it("appendAll", () => {
+      deepStrictEqual(pipe([1, 2], Arr.appendAll([3, 4])), [1, 2, 3, 4])
+
+      deepStrictEqual(pipe([1, 2], Arr.appendAll(new Set([3, 4]))), [1, 2, 3, 4])
+      deepStrictEqual(pipe(new Set([1, 2]), Arr.appendAll([3, 4])), [1, 2, 3, 4])
+    })
+
+    it("scan", () => {
+      const f = (b: number, a: number) => b - a
+      deepStrictEqual(pipe([1, 2, 3], Arr.scan(10, f)), [10, 9, 7, 4])
+      deepStrictEqual(pipe([0], Arr.scan(10, f)), [10, 10])
+      deepStrictEqual(pipe([], Arr.scan(10, f)), [10])
+
+      deepStrictEqual(pipe(new Set([1, 2, 3]), Arr.scan(10, f)), [10, 9, 7, 4])
+      deepStrictEqual(pipe(new Set([0]), Arr.scan(10, f)), [10, 10])
+      deepStrictEqual(pipe(new Set([]), Arr.scan(10, f)), [10])
+    })
+
+    it("scanRight", () => {
+      const f = (b: number, a: number) => a - b
+      deepStrictEqual(pipe([1, 2, 3], Arr.scanRight(10, f)), [-8, 9, -7, 10])
+      deepStrictEqual(pipe([0], Arr.scanRight(10, f)), [-10, 10])
+      deepStrictEqual(pipe([], Arr.scanRight(10, f)), [10])
+
+      deepStrictEqual(pipe(new Set([1, 2, 3]), Arr.scanRight(10, f)), [-8, 9, -7, 10])
+      deepStrictEqual(pipe(new Set([0]), Arr.scanRight(10, f)), [-10, 10])
+      deepStrictEqual(pipe(new Set([]), Arr.scanRight(10, f)), [10])
+    })
+
+    it("tail", () => {
+      assertSome(Arr.tail([1, 2, 3]), [2, 3])
+      assertNone(Arr.tail([]))
+
+      assertSome(Arr.tail(new Set([1, 2, 3])), [2, 3])
+      assertNone(Arr.tail(new Set([])))
+    })
+
+    it("init", () => {
+      assertSome(Arr.init([1, 2, 3]), [1, 2])
+      assertNone(Arr.init([]))
+
+      assertSome(Arr.init(new Set([1, 2, 3])), [1, 2])
+      assertNone(Arr.init(new Set([])))
+    })
+
+    it("take", () => {
+      deepStrictEqual(pipe([1, 2, 3, 4], Arr.take(2)), [1, 2])
+      deepStrictEqual(pipe([1, 2, 3, 4], Arr.take(0)), [])
+      // out of bounds
+      deepStrictEqual(pipe([1, 2, 3, 4], Arr.take(-10)), [])
+      deepStrictEqual(pipe([1, 2, 3, 4], Arr.take(10)), [1, 2, 3, 4])
+
+      deepStrictEqual(pipe(new Set([1, 2, 3, 4]), Arr.take(2)), [1, 2])
+      deepStrictEqual(pipe(new Set([1, 2, 3, 4]), Arr.take(0)), [])
+      // out of bounds
+      deepStrictEqual(pipe(new Set([1, 2, 3, 4]), Arr.take(-10)), [])
+      deepStrictEqual(pipe(new Set([1, 2, 3, 4]), Arr.take(10)), [1, 2, 3, 4])
+    })
+
+    it("takeRight", () => {
+      deepStrictEqual(pipe(Arr.empty(), Arr.takeRight(0)), [])
+      deepStrictEqual(pipe([1, 2], Arr.takeRight(0)), [])
+      deepStrictEqual(pipe([1, 2], Arr.takeRight(1)), [2])
+      deepStrictEqual(pipe([1, 2], Arr.takeRight(2)), [1, 2])
+      // out of bound
+      deepStrictEqual(pipe(Arr.empty(), Arr.takeRight(1)), [])
+      deepStrictEqual(pipe(Arr.empty(), Arr.takeRight(-1)), [])
+      deepStrictEqual(pipe([1, 2], Arr.takeRight(3)), [1, 2])
+      deepStrictEqual(pipe([1, 2], Arr.takeRight(-1)), [])
+
+      deepStrictEqual(pipe(new Set(), Arr.takeRight(0)), [])
+      deepStrictEqual(pipe(new Set([1, 2]), Arr.takeRight(0)), [])
+      deepStrictEqual(pipe(new Set([1, 2]), Arr.takeRight(1)), [2])
+      deepStrictEqual(pipe(new Set([1, 2]), Arr.takeRight(2)), [1, 2])
+      // out of bound
+      deepStrictEqual(pipe(new Set(), Arr.takeRight(1)), [])
+      deepStrictEqual(pipe(new Set(), Arr.takeRight(-1)), [])
+      deepStrictEqual(pipe(new Set([1, 2]), Arr.takeRight(3)), [1, 2])
+      deepStrictEqual(pipe(new Set([1, 2]), Arr.takeRight(-1)), [])
+    })
+
+    it("takeWhile", () => {
+      const f = (n: number) => n % 2 === 0
+      deepStrictEqual(pipe([2, 4, 3, 6], Arr.takeWhile(f)), [2, 4])
+      deepStrictEqual(pipe(Arr.empty(), Arr.takeWhile(f)), [])
+      deepStrictEqual(pipe([1, 2, 4], Arr.takeWhile(f)), [])
+      deepStrictEqual(pipe([2, 4], Arr.takeWhile(f)), [2, 4])
+
+      deepStrictEqual(pipe(new Set([2, 4, 3, 6]), Arr.takeWhile(f)), [2, 4])
+      deepStrictEqual(pipe(new Set<number>(), Arr.takeWhile(f)), [])
+      deepStrictEqual(pipe(new Set([1, 2, 4]), Arr.takeWhile(f)), [])
+      deepStrictEqual(pipe(new Set([2, 4]), Arr.takeWhile(f)), [2, 4])
+    })
+
+    it("takeWhileFilter", () => {
+      const f: (n: number, i: number) => Result.Result<number, string> = (n, i) =>
+        n + i < 5 ? Result.succeed(n * 10) : Result.fail(`stop: ${n}`)
+
+      deepStrictEqual(Arr.takeWhileFilter([], f), [])
+      deepStrictEqual(Arr.takeWhileFilter([1, 2, 3], f), [10, 20])
+      deepStrictEqual(pipe([1, 2, 3], Arr.takeWhileFilter(f)), [10, 20])
+
+      deepStrictEqual(pipe(new Set([1, 2, 3]), Arr.takeWhileFilter(f)), [10, 20])
+      deepStrictEqual(pipe([][Symbol.iterator](), Arr.takeWhileFilter(f)), [])
+    })
+
+    it("span", () => {
+      const f = Arr.span<number>((n) => n % 2 === 1)
+      const assertSpan = (
+        input: Iterable<number>,
+        expectedInit: ReadonlyArray<number>,
+        expectedRest: ReadonlyArray<number>
+      ) => {
+        const [init, rest] = f(input)
+        deepStrictEqual(init, expectedInit)
+        deepStrictEqual(rest, expectedRest)
+      }
+      assertSpan([1, 3, 2, 4, 5], [1, 3], [2, 4, 5])
+      assertSpan(Arr.empty(), Arr.empty(), Arr.empty())
+      assertSpan([1, 3], [1, 3], Arr.empty())
+      assertSpan([2, 4], Arr.empty(), [2, 4])
+
+      assertSpan(new Set([1, 3, 2, 4, 5]), [1, 3], [2, 4, 5])
+      assertSpan(new Set(), Arr.empty(), Arr.empty())
+      assertSpan(new Set([1, 3]), [1, 3], Arr.empty())
+      assertSpan(new Set([2, 4]), Arr.empty(), [2, 4])
+
+      // iterator input
+      assertSpan([1, 3, 2, 4, 5][Symbol.iterator](), [1, 3], [2, 4, 5])
+      assertSpan([][Symbol.iterator](), Arr.empty(), Arr.empty())
+    })
+
+    it("splitWhere", () => {
+      const f = Arr.splitWhere<number>((n) => n % 2 !== 1)
+      const assertSplitWhere = (
+        input: Iterable<number>,
+        expectedInit: ReadonlyArray<number>,
+        expectedRest: ReadonlyArray<number>
+      ) => {
+        const [init, rest] = f(input)
+        deepStrictEqual(init, expectedInit)
+        deepStrictEqual(rest, expectedRest)
+      }
+      assertSplitWhere([1, 3, 2, 4, 5], [1, 3], [2, 4, 5])
+      assertSplitWhere(Arr.empty(), Arr.empty(), Arr.empty())
+      assertSplitWhere([1, 3], [1, 3], Arr.empty())
+      assertSplitWhere([2, 4], Arr.empty(), [2, 4])
+
+      assertSplitWhere(new Set([1, 3, 2, 4, 5]), [1, 3], [2, 4, 5])
+      assertSplitWhere(new Set(), Arr.empty(), Arr.empty())
+      assertSplitWhere(new Set([1, 3]), [1, 3], Arr.empty())
+      assertSplitWhere(new Set([2, 4]), Arr.empty(), [2, 4])
+    })
+
+    it("split", () => {
+      deepStrictEqual(pipe(Arr.empty(), Arr.split(2)), Arr.empty())
+      deepStrictEqual(pipe(Arr.make(1), Arr.split(2)), Arr.make(Arr.make(1)))
+      deepStrictEqual(pipe(Arr.make(1, 2), Arr.split(2)), Arr.make(Arr.make(1), Arr.make(2)))
+      deepStrictEqual(pipe(Arr.make(1, 2, 3, 4, 5), Arr.split(2)), Arr.make(Arr.make(1, 2, 3), Arr.make(4, 5)))
+      deepStrictEqual(
+        pipe(Arr.make(1, 2, 3, 4, 5), Arr.split(3)),
+        Arr.make(Arr.make(1, 2), Arr.make(3, 4), Arr.make(5))
+      )
+    })
+
+    it("drop", () => {
+      deepStrictEqual(pipe(Arr.empty(), Arr.drop(0)), [])
+      deepStrictEqual(pipe([1, 2], Arr.drop(0)), [1, 2])
+      deepStrictEqual(pipe([1, 2], Arr.drop(1)), [2])
+      deepStrictEqual(pipe([1, 2], Arr.drop(2)), [])
+      // out of bound
+      deepStrictEqual(pipe(Arr.empty(), Arr.drop(1)), [])
+      deepStrictEqual(pipe(Arr.empty(), Arr.drop(-1)), [])
+      deepStrictEqual(pipe([1, 2], Arr.drop(3)), [])
+      deepStrictEqual(pipe([1, 2], Arr.drop(-1)), [1, 2])
+
+      deepStrictEqual(pipe(new Set(), Arr.drop(0)), [])
+      deepStrictEqual(pipe(new Set([1, 2]), Arr.drop(0)), [1, 2])
+      deepStrictEqual(pipe(new Set([1, 2]), Arr.drop(1)), [2])
+      deepStrictEqual(pipe(new Set([1, 2]), Arr.drop(2)), [])
+      // out of bound
+      deepStrictEqual(pipe(new Set(), Arr.drop(1)), [])
+      deepStrictEqual(pipe(new Set(), Arr.drop(-1)), [])
+      deepStrictEqual(pipe(new Set([1, 2]), Arr.drop(3)), [])
+      deepStrictEqual(pipe(new Set([1, 2]), Arr.drop(-1)), [1, 2])
+    })
+
+    it("dropRight", () => {
+      deepStrictEqual(pipe([], Arr.dropRight(0)), [])
+      deepStrictEqual(pipe([1, 2], Arr.dropRight(0)), [1, 2])
+      deepStrictEqual(pipe([1, 2], Arr.dropRight(1)), [1])
+      deepStrictEqual(pipe([1, 2], Arr.dropRight(2)), [])
+      // out of bound
+      deepStrictEqual(pipe([], Arr.dropRight(1)), [])
+      deepStrictEqual(pipe([1, 2], Arr.dropRight(3)), [])
+      deepStrictEqual(pipe([], Arr.dropRight(-1)), [])
+      deepStrictEqual(pipe([1, 2], Arr.dropRight(-1)), [1, 2])
+
+      deepStrictEqual(pipe(new Set(), Arr.dropRight(0)), [])
+      deepStrictEqual(pipe(new Set([1, 2]), Arr.dropRight(0)), [1, 2])
+      deepStrictEqual(pipe(new Set([1, 2]), Arr.dropRight(1)), [1])
+      deepStrictEqual(pipe(new Set([1, 2]), Arr.dropRight(2)), [])
+      // out of bound
+      deepStrictEqual(pipe(new Set(), Arr.dropRight(1)), [])
+      deepStrictEqual(pipe(new Set([1, 2]), Arr.dropRight(3)), [])
+      deepStrictEqual(pipe(new Set(), Arr.dropRight(-1)), [])
+      deepStrictEqual(pipe(new Set([1, 2]), Arr.dropRight(-1)), [1, 2])
+    })
+
+    it("dropWhile", () => {
+      const f = Arr.dropWhile<number>((n) => n > 0)
+
+      deepStrictEqual(f([]), [])
+      deepStrictEqual(f([1, 2]), Arr.empty())
+      deepStrictEqual(f([-1, -2]), [-1, -2])
+      deepStrictEqual(f([-1, 2]), [-1, 2])
+      deepStrictEqual(f([1, -2, 3]), [-2, 3])
+
+      deepStrictEqual(f(new Set<number>()), [])
+      deepStrictEqual(f(new Set([1, 2])), Arr.empty())
+      deepStrictEqual(f(new Set([-1, -2])), [-1, -2])
+      deepStrictEqual(f(new Set([-1, 2])), [-1, 2])
+      deepStrictEqual(f(new Set([1, -2, 3])), [-2, 3])
+
+      // iterator input
+      deepStrictEqual(f([1, -2, 3][Symbol.iterator]()), [-2, 3])
+      deepStrictEqual(f([][Symbol.iterator]()), [])
+    })
+
+    it("dropWhileFilter", () => {
+      const f: (n: number, i: number) => Result.Result<number, string> = (n, i) =>
+        n + i < 5 ? Result.succeed(n * 10) : Result.fail(`stop: ${n}`)
+
+      deepStrictEqual(Arr.dropWhileFilter([], f), [])
+      deepStrictEqual(Arr.dropWhileFilter([1, 2, 3], f), [3])
+      deepStrictEqual(pipe([1, 2, 3], Arr.dropWhileFilter(f)), [3])
+
+      deepStrictEqual(pipe(new Set([1, 2, 3]), Arr.dropWhileFilter(f)), [3])
+      deepStrictEqual(pipe([][Symbol.iterator](), Arr.dropWhileFilter(f)), [])
+    })
+
+    it("findFirstIndex", () => {
+      assertNone(pipe([], Arr.findFirstIndex((n) => n % 2 === 0)))
+      assertSome(pipe([1, 2, 3], Arr.findFirstIndex((n) => n % 2 === 0)), 1)
+      assertSome(pipe([1, 2, 3, 1], Arr.findFirstIndex((n) => n % 2 === 0)), 1)
+
+      assertNone(pipe(new Set<number>(), Arr.findFirstIndex((n) => n % 2 === 0)))
+      assertSome(pipe(new Set([1, 2, 3]), Arr.findFirstIndex((n) => n % 2 === 0)), 1)
+      assertSome(pipe(new Set([1, 2, 3, 4]), Arr.findFirstIndex((n) => n % 2 === 0)), 1)
+    })
+
+    it("findLastIndex", () => {
+      assertNone(pipe([], Arr.findLastIndex((n) => n % 2 === 0)))
+      assertSome(pipe([1, 2, 3], Arr.findLastIndex((n) => n % 2 === 0)), 1)
+      assertSome(pipe([1, 2, 3, 4], Arr.findLastIndex((n) => n % 2 === 0)), 3)
+
+      assertNone(pipe(new Set<number>(), Arr.findLastIndex((n) => n % 2 === 0)))
+      assertSome(pipe(new Set([1, 2, 3]), Arr.findLastIndex((n) => n % 2 === 0)), 1)
+      assertSome(pipe(new Set([1, 2, 3, 4]), Arr.findLastIndex((n) => n % 2 === 0)), 3)
+    })
+
+    describe("findFirst", () => {
+      it("boolean-returning overloads", () => {
+        assertNone(pipe([], Arr.findFirst((n) => n % 2 === 0)))
+        assertSome(pipe([1, 2, 3], Arr.findFirst((n) => n % 2 === 0)), 2)
+        assertSome(pipe([1, 2, 3, 4], Arr.findFirst((n) => n % 2 === 0)), 2)
+
+        assertNone(pipe(new Set<number>(), Arr.findFirst((n) => n % 2 === 0)))
+        assertSome(pipe(new Set([1, 2, 3]), Arr.findFirst((n) => n % 2 === 0)), 2)
+        assertSome(pipe(new Set([1, 2, 3, 4]), Arr.findFirst((n) => n % 2 === 0)), 2)
+      })
+
+      it("Option-returning overloads", () => {
+        assertNone(
+          pipe([], Arr.findFirst((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none()))
+        )
+        assertSome(
+          pipe([1, 2, 3], Arr.findFirst((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none())),
+          [2, 1]
+        )
+        assertSome(
+          pipe([1, 2, 3, 4], Arr.findFirst((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none())),
+          [2, 1]
+        )
+
+        assertNone(
+          pipe(new Set<number>(), Arr.findFirst((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none()))
+        )
+        assertSome(
+          pipe(new Set([1, 2, 3]), Arr.findFirst((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none())),
+          [2, 1]
+        )
+        assertSome(
+          pipe(new Set([1, 2, 3, 4]), Arr.findFirst((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none())),
+          [2, 1]
+        )
+      })
+    })
+
+    describe("findFirstWithIndex", () => {
+      it("boolean-returning overloads", () => {
+        assertNone(pipe([], Arr.findFirstWithIndex((n) => n % 2 === 0)))
+        assertSome(pipe([1, 2, 3], Arr.findFirstWithIndex((n) => n % 2 === 0)), [2, 1])
+        assertSome(pipe([1, 2, 3, 4], Arr.findFirstWithIndex((n) => n % 2 === 0)), [2, 1])
+
+        assertNone(pipe(new Set<number>(), Arr.findFirstWithIndex((n) => n % 2 === 0)))
+        assertSome(pipe(new Set([1, 2, 3]), Arr.findFirstWithIndex((n) => n % 2 === 0)), [2, 1])
+        assertSome(pipe(new Set([1, 2, 3, 4]), Arr.findFirstWithIndex((n) => n % 2 === 0)), [2, 1])
+      })
+
+      it("Option-returning overloads", () => {
+        assertNone(
+          pipe([], Arr.findFirstWithIndex((n) => n % 2 === 0 ? Option.some(n + 1) : Option.none()))
+        )
+        assertSome(
+          pipe([1, 2, 3], Arr.findFirstWithIndex((n) => n % 2 === 0 ? Option.some(n + 1) : Option.none())),
+          [3, 1]
+        )
+        assertSome(
+          pipe([1, 2, 3, 4], Arr.findFirstWithIndex((n) => n % 2 === 0 ? Option.some(n + 1) : Option.none())),
+          [3, 1]
+        )
+
+        assertNone(
+          pipe(new Set<number>(), Arr.findFirstWithIndex((n) => n % 2 === 0 ? Option.some(n + 1) : Option.none()))
+        )
+        assertSome(
+          pipe(new Set([1, 2, 3]), Arr.findFirstWithIndex((n) => n % 2 === 0 ? Option.some(n + 1) : Option.none())),
+          [3, 1]
+        )
+        assertSome(
+          pipe(new Set([1, 2, 3, 4]), Arr.findFirstWithIndex((n) => n % 2 === 0 ? Option.some(n + 1) : Option.none())),
+          [3, 1]
+        )
+      })
+    })
+
+    describe("findLast", () => {
+      it("boolean-returning overloads", () => {
+        assertNone(pipe([], Arr.findLast((n) => n % 2 === 0)))
+        assertSome(pipe([1, 2, 3], Arr.findLast((n) => n % 2 === 0)), 2)
+        assertSome(pipe([1, 2, 3, 4], Arr.findLast((n) => n % 2 === 0)), 4)
+
+        assertNone(pipe(new Set<number>(), Arr.findLast((n) => n % 2 === 0)))
+        assertSome(pipe(new Set([1, 2, 3]), Arr.findLast((n) => n % 2 === 0)), 2)
+        assertSome(pipe(new Set([1, 2, 3, 4]), Arr.findLast((n) => n % 2 === 0)), 4)
+      })
+
+      it("Option-returning overloads", () => {
+        assertNone(
+          pipe([], Arr.findLast((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none()))
+        )
+        assertSome(
+          pipe([1, 2, 3], Arr.findLast((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none())),
+          [2, 1]
+        )
+        assertSome(
+          pipe([1, 2, 3, 4], Arr.findLast((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none())),
+          [4, 3]
+        )
+
+        assertNone(
+          pipe(new Set<number>(), Arr.findLast((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none()))
+        )
+        assertSome(
+          pipe(new Set([1, 2, 3]), Arr.findLast((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none())),
+          [2, 1]
+        )
+        assertSome(
+          pipe(new Set([1, 2, 3, 4]), Arr.findLast((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none())),
+          [4, 3]
+        )
+      })
+    })
+
+    it("insertAt", () => {
+      assertNone(Arr.insertAt(1, 1)([]))
+      assertSome(Arr.insertAt(0, 1)([]), [1])
+      assertSome(Arr.insertAt(2, 5)([1, 2, 3, 4]), [1, 2, 5, 3, 4])
+      // out of bound
+      assertNone(Arr.insertAt(-1, 5)([1, 2, 3, 4]))
+      assertNone(Arr.insertAt(10, 5)([1, 2, 3, 4]))
+
+      assertNone(Arr.insertAt(1, 1)(new Set([])))
+      assertSome(Arr.insertAt(0, 1)(new Set([])), [1])
+      assertSome(Arr.insertAt(2, 5)(new Set([1, 2, 3, 4])), [1, 2, 5, 3, 4])
+      // out of bound
+      assertNone(Arr.insertAt(-1, 5)(new Set([1, 2, 3, 4])))
+      assertNone(Arr.insertAt(10, 5)(new Set([1, 2, 3, 4])))
+    })
+
+    it("replace", () => {
+      assertSome(pipe([1, 2, 3], Arr.replace(1, "a")), [1, "a", 3])
+      // out of bound
+      assertNone(pipe([], Arr.replace(1, "a")))
+      assertNone(pipe([1, 2, 3], Arr.replace(-1, "a")))
+      assertNone(pipe([1, 2, 3], Arr.replace(10, "a")))
+
+      assertSome(pipe(new Set([1, 2, 3]), Arr.replace(1, "a")), [1, "a", 3])
+      // out of bound
+      assertNone(pipe(new Set([]), Arr.replace(1, "a")))
+      assertNone(pipe(new Set([1, 2, 3]), Arr.replace(-1, "a")))
+      assertNone(pipe(new Set([1, 2, 3]), Arr.replace(10, "a")))
+    })
+
+    it("modify", () => {
+      assertSome(pipe([1, 2, 3], Arr.modify(1, double)), [1, 4, 3])
+      // out of bound
+      assertNone(pipe([], Arr.modify(1, double)))
+      assertNone(pipe([1, 2, 3], Arr.modify(10, double)))
+
+      assertSome(pipe(new Set([1, 2, 3]), Arr.modify(1, double)), [1, 4, 3])
+      // out of bound
+      assertNone(pipe(new Set([]), Arr.modify(1, double)))
+      assertNone(pipe(new Set([1, 2, 3]), Arr.modify(10, double)))
+    })
+
+    it("remove", () => {
+      deepStrictEqual(pipe([1, 2, 3], Arr.remove(0)), [2, 3])
+      // out of bound
+      deepStrictEqual(pipe([], Arr.remove(0)), [])
+      deepStrictEqual(pipe([1, 2, 3], Arr.remove(-1)), [1, 2, 3])
+      deepStrictEqual(pipe([1, 2, 3], Arr.remove(10)), [1, 2, 3])
+
+      deepStrictEqual(pipe(new Set([1, 2, 3]), Arr.remove(0)), [2, 3])
+      // out of bound
+      deepStrictEqual(pipe(new Set([]), Arr.remove(0)), [])
+      deepStrictEqual(pipe(new Set([1, 2, 3]), Arr.remove(-1)), [1, 2, 3])
+      deepStrictEqual(pipe(new Set([1, 2, 3]), Arr.remove(10)), [1, 2, 3])
+    })
+
+    it("reverse", () => {
+      deepStrictEqual(Arr.reverse([]), [])
+      deepStrictEqual(Arr.reverse([1]), [1])
+      deepStrictEqual(Arr.reverse([1, 2, 3]), [3, 2, 1])
+
+      deepStrictEqual(Arr.reverse(new Set([])), [])
+      deepStrictEqual(Arr.reverse(new Set([1])), [1])
+      deepStrictEqual(Arr.reverse(new Set([1, 2, 3])), [3, 2, 1])
+    })
+
+    it("sort", () => {
+      deepStrictEqual(Arr.sort(Num.Order)([]), [])
+      deepStrictEqual(Arr.sort(Num.Order)([1, 3, 2]), [1, 2, 3])
+
+      deepStrictEqual(Arr.sort(Num.Order)(new Set<number>()), [])
+      deepStrictEqual(Arr.sort(Num.Order)(new Set([1, 3, 2])), [1, 2, 3])
+    })
+
+    it("zip", () => {
+      deepStrictEqual(pipe(new Set([]), Arr.zip(new Set(["a", "b", "c", "d"]))), [])
+      deepStrictEqual(pipe(new Set([1, 2, 3]), Arr.zip(new Set([]))), [])
+      deepStrictEqual(pipe(new Set([1, 2, 3]), Arr.zip(new Set(["a", "b", "c", "d"]))), [
+        [1, "a"],
+        [2, "b"],
+        [3, "c"]
+      ])
+      deepStrictEqual(pipe(new Set([1, 2, 3]), Arr.zip(new Set(["a", "b", "c", "d"]))), [
+        [1, "a"],
+        [2, "b"],
+        [3, "c"]
+      ])
+    })
+
+    it("zipWith", () => {
+      deepStrictEqual(
+        pipe(new Set([1, 2, 3]), Arr.zipWith(new Set([]), (n, s) => s + n)),
+        []
+      )
+      deepStrictEqual(
+        pipe(new Set([]), Arr.zipWith(new Set(["a", "b", "c", "d"]), (n, s) => s + n)),
+        []
+      )
+      deepStrictEqual(
+        pipe(new Set([]), Arr.zipWith(new Set([]), (n, s) => s + n)),
+        []
+      )
+      deepStrictEqual(
+        pipe(new Set([1, 2, 3]), Arr.zipWith(new Set(["a", "b", "c", "d"]), (n, s) => s + n)),
+        ["a1", "b2", "c3"]
+      )
+    })
+
+    it("unzip", () => {
+      deepStrictEqual(Arr.unzip(new Set([])), [[], []])
+      deepStrictEqual(
+        Arr.unzip(
+          new Set(
+            [
+              [1, "a"],
+              [2, "b"],
+              [3, "c"]
+            ] as const
+          )
+        ),
+        [
+          [1, 2, 3],
+          ["a", "b", "c"]
+        ]
+      )
+    })
+
+    it("intersperse", () => {
+      deepStrictEqual(pipe([], Arr.intersperse(0)), [])
+      deepStrictEqual(pipe([1], Arr.intersperse(0)), [1])
+      deepStrictEqual(pipe([1, 2, 3], Arr.intersperse(0)), [1, 0, 2, 0, 3])
+      deepStrictEqual(pipe([1, 2], Arr.intersperse(0)), [1, 0, 2])
+      deepStrictEqual(pipe([1, 2, 3, 4], Arr.intersperse(0)), [1, 0, 2, 0, 3, 0, 4])
+
+      deepStrictEqual(pipe(new Set([]), Arr.intersperse(0)), [])
+      deepStrictEqual(pipe(new Set([1]), Arr.intersperse(0)), [1])
+      deepStrictEqual(pipe(new Set([1, 2, 3]), Arr.intersperse(0)), [1, 0, 2, 0, 3])
+      deepStrictEqual(pipe(new Set([1, 2]), Arr.intersperse(0)), [1, 0, 2])
+      deepStrictEqual(pipe(new Set([1, 2, 3, 4]), Arr.intersperse(0)), [1, 0, 2, 0, 3, 0, 4])
+    })
+
+    it("rotate", () => {
+      deepStrictEqual(Arr.rotate(0)(Arr.empty()), Arr.empty())
+      deepStrictEqual(Arr.rotate(1)(Arr.empty()), Arr.empty())
+      deepStrictEqual(Arr.rotate(1)([1]), [1])
+      deepStrictEqual(Arr.rotate(2)([1]), [1])
+      deepStrictEqual(Arr.rotate(-1)([1]), [1])
+      deepStrictEqual(Arr.rotate(-2)([1]), [1])
+      deepStrictEqual(Arr.rotate(2)([1, 2]), [1, 2])
+      deepStrictEqual(Arr.rotate(0)([1, 2]), [1, 2])
+      deepStrictEqual(Arr.rotate(-2)([1, 2]), [1, 2])
+      deepStrictEqual(Arr.rotate(1)([1, 2]), [2, 1])
+      deepStrictEqual(Arr.rotate(1)(new Set([1, 2, 3, 4, 5])), [5, 1, 2, 3, 4])
+      deepStrictEqual(Arr.rotate(2)(new Set([1, 2, 3, 4, 5])), [4, 5, 1, 2, 3])
+      deepStrictEqual(Arr.rotate(-1)(new Set([1, 2, 3, 4, 5])), [2, 3, 4, 5, 1])
+      deepStrictEqual(Arr.rotate(-2)(new Set([1, 2, 3, 4, 5])), [3, 4, 5, 1, 2])
+      // out of bounds
+      deepStrictEqual(Arr.rotate(7)([1, 2, 3, 4, 5]), [4, 5, 1, 2, 3])
+      deepStrictEqual(Arr.rotate(-7)([1, 2, 3, 4, 5]), [3, 4, 5, 1, 2])
+      deepStrictEqual(Arr.rotate(2.2)([1, 2, 3, 4, 5]), [4, 5, 1, 2, 3])
+      deepStrictEqual(Arr.rotate(-2.2)([1, 2, 3, 4, 5]), [3, 4, 5, 1, 2])
+    })
+
+    it("containsWith", () => {
+      const contains = Arr.containsWith(Equivalence.strictEqual<number>())
+      deepStrictEqual(pipe([1, 2, 3], contains(2)), true)
+      deepStrictEqual(pipe([1, 2, 3], contains(0)), false)
+
+      deepStrictEqual(pipe(new Set([1, 2, 3]), contains(2)), true)
+      deepStrictEqual(pipe(new Set([1, 2, 3]), contains(0)), false)
+    })
+
+    it("contains", () => {
+      const contains = Arr.contains
+      deepStrictEqual(pipe([1, 2, 3], contains(2)), true)
+      deepStrictEqual(pipe([1, 2, 3], contains(0)), false)
+
+      deepStrictEqual(pipe(new Set([1, 2, 3]), contains(2)), true)
+      deepStrictEqual(pipe(new Set([1, 2, 3]), contains(0)), false)
+    })
+
+    it("dedupeWith", () => {
+      const dedupe = Arr.dedupeWith(Equivalence.strictEqual<number>())
+      deepStrictEqual(dedupe([]), [])
+      deepStrictEqual(dedupe([-0, -0]), [-0])
+      deepStrictEqual(dedupe([0, -0]), [0])
+      deepStrictEqual(dedupe([1]), [1])
+      deepStrictEqual(dedupe([2, 1, 2]), [2, 1])
+      deepStrictEqual(dedupe([1, 2, 1]), [1, 2])
+      deepStrictEqual(dedupe([1, 2, 3, 4, 5]), [1, 2, 3, 4, 5])
+      deepStrictEqual(dedupe([1, 1, 2, 2, 3, 3, 4, 4, 5, 5]), [1, 2, 3, 4, 5])
+      deepStrictEqual(dedupe([1, 2, 3, 4, 5, 1, 2, 3, 4, 5]), [1, 2, 3, 4, 5])
+    })
+
+    it("dedupeAdjacentWith", () => {
+      const dedupeAdjacent = Arr.dedupeAdjacentWith(Equivalence.strictEqual<number>())
+      deepStrictEqual(dedupeAdjacent([]), [])
+      deepStrictEqual(dedupeAdjacent([1, 2, 3]), [1, 2, 3])
+      deepStrictEqual(dedupeAdjacent([1, 2, 2, 3, 3]), [1, 2, 3])
+    })
+
+    it("splitAt", () => {
+      const assertSplitAt = (
+        input: ReadonlyArray<number>,
+        index: number,
+        expectedInit: ReadonlyArray<number>,
+        expectedRest: ReadonlyArray<number>
+      ) => {
+        const [init, rest] = Arr.splitAt(index)(input)
+        deepStrictEqual(init, expectedInit)
+        deepStrictEqual(rest, expectedRest)
+      }
+      deepStrictEqual(Arr.splitAt(1)([1, 2]), [[1], [2]])
+      assertSplitAt([1, 2], 2, [1, 2], [])
+      deepStrictEqual(Arr.splitAt(2)([1, 2, 3, 4, 5]), [
+        [1, 2],
+        [3, 4, 5]
+      ])
+      deepStrictEqual(Arr.splitAt(2)(new Set([1, 2, 3, 4, 5])), [
+        [1, 2],
+        [3, 4, 5]
+      ])
+      assertSplitAt([], 0, [], [])
+      assertSplitAt([1, 2], 0, [], [1, 2])
+
+      // out of bounds
+      assertSplitAt([], -1, [], [])
+      assertSplitAt([1, 2], -1, [], [1, 2])
+      assertSplitAt([1, 2], 3, [1, 2], [])
+      assertSplitAt([], 3, [], [])
+    })
+  })
+
+  it("splitAtNonEmpty", () => {
+    deepStrictEqual(pipe(Arr.make(1, 2, 3, 4), Arr.splitAtNonEmpty(2)), [[1, 2], [3, 4]])
+    deepStrictEqual(pipe(Arr.make(1, 2, 3, 4), Arr.splitAtNonEmpty(10)), [[1, 2, 3, 4], []])
+  })
+
+  describe("getUnsafe", () => {
+    it("should throw on index out of bound", () => {
+      throws(() => pipe([], Arr.getUnsafe(100)), new Error("Index out of bounds: 100"))
+    })
+  })
+
+  it("fromNullishOr", () => {
+    deepStrictEqual(Arr.fromNullishOr(undefined), [])
+    deepStrictEqual(Arr.fromNullishOr(null), [])
+    deepStrictEqual(Arr.fromNullishOr(1), [1])
+  })
+
+  it("liftNullishOr", () => {
+    const f = Arr.liftNullishOr((n: number) => (n > 0 ? n : null))
+    deepStrictEqual(f(1), [1])
+    deepStrictEqual(f(-1), [])
+  })
+
+  it("flatMapNullishOr", () => {
+    const f = Arr.flatMapNullishOr((n: number) => (n > 0 ? n : null))
+    deepStrictEqual(pipe([], f), [])
+    deepStrictEqual(pipe([1], f), [1])
+    deepStrictEqual(pipe([1, 2], f), [1, 2])
+    deepStrictEqual(pipe([-1], f), [])
+    deepStrictEqual(pipe([-1, 2], f), [2])
+  })
+
+  it("liftPredicate", () => {
+    const p = (n: number): boolean => n > 2
+    const f = Arr.liftPredicate(p)
+    deepStrictEqual(f(1), [])
+    deepStrictEqual(f(3), [3])
+  })
+
+  it("liftOption", () => {
+    const f = Arr.liftOption((n: number) => (n > 0 ? Option.some(n) : Option.none()))
+    deepStrictEqual(f(1), [1])
+    deepStrictEqual(f(-1), [])
+  })
+
+  it("unprepend", () => {
+    deepStrictEqual(Arr.unprepend([0]), [0, []])
+    deepStrictEqual(Arr.unprepend([1, 2, 3, 4]), [1, [2, 3, 4]])
+  })
+
+  it("unappend", () => {
+    deepStrictEqual(Arr.unappend([0]), [[], 0])
+    deepStrictEqual(Arr.unappend([1, 2, 3, 4]), [
+      Arr.make(1, 2, 3),
+      4
+    ])
+    deepStrictEqual(Arr.unappend([0]), [[], 0])
+    deepStrictEqual(Arr.unappend([1, 2, 3, 4]), [
+      Arr.make(1, 2, 3),
+      4
+    ])
+  })
+
+  it("modifyHeadNonEmpty", () => {
+    const f = (s: string) => s + "!"
+    deepStrictEqual(pipe(["a"], Arr.modifyHeadNonEmpty(f)), ["a!"])
+    deepStrictEqual(pipe(["a", "b"], Arr.modifyHeadNonEmpty(f)), ["a!", "b"])
+    deepStrictEqual(pipe(["a", "b", "c"], Arr.modifyHeadNonEmpty(f)), ["a!", "b", "c"])
+  })
+
+  it("modifyLastNonEmpty", () => {
+    const f = (s: string) => s + "!"
+    deepStrictEqual(pipe(["a"], Arr.modifyLastNonEmpty(f)), ["a!"])
+    deepStrictEqual(pipe(["a", "b"], Arr.modifyLastNonEmpty(f)), ["a", "b!"])
+    deepStrictEqual(pipe(["a", "b", "c"], Arr.modifyLastNonEmpty(f)), ["a", "b", "c!"])
+  })
+
+  it("setHeadNonEmpty", () => {
+    deepStrictEqual(pipe(Arr.make("a"), Arr.setHeadNonEmpty("d")), ["d"])
+    deepStrictEqual(pipe(Arr.make("a", "b"), Arr.setHeadNonEmpty("d")), ["d", "b"])
+    deepStrictEqual(pipe(Arr.make("a", "b", "c"), Arr.setHeadNonEmpty("d")), ["d", "b", "c"])
+  })
+
+  it("setLastNonEmpty", () => {
+    deepStrictEqual(pipe(Arr.make("a"), Arr.setLastNonEmpty("d")), ["d"])
+    deepStrictEqual(pipe(Arr.make("a", "b"), Arr.setLastNonEmpty("d")), ["a", "d"])
+    deepStrictEqual(pipe(Arr.make("a", "b", "c"), Arr.setLastNonEmpty("d")), ["a", "b", "d"])
+  })
+
+  it("liftResult", () => {
+    const f = Arr.liftResult((s: string) => s.length > 2 ? Result.succeed(s.length) : Result.fail("e"))
+    deepStrictEqual(f("a"), [])
+    deepStrictEqual(f("aaa"), [3])
+  })
+
+  it("headNonEmpty", () => {
+    deepStrictEqual(Arr.headNonEmpty(Arr.make(1, 2)), 1)
+  })
+
+  it("tailNonEmpty", () => {
+    deepStrictEqual(Arr.tailNonEmpty(Arr.make(1, 2)), [2])
+  })
+
+  it("lastNonEmpty", () => {
+    deepStrictEqual(Arr.lastNonEmpty(Arr.make(1, 2, 3)), 3)
+    deepStrictEqual(Arr.lastNonEmpty([1]), 1)
+  })
+
+  it("initNonEmpty", () => {
+    deepStrictEqual(
+      Arr.initNonEmpty(Arr.make(1, 2, 3)),
+      Arr.make(1, 2)
+    )
+    deepStrictEqual(Arr.initNonEmpty([1]), [])
+  })
+
+  it("get", () => {
+    assertSome(pipe([1, 2, 3], Arr.get(0)), 1)
+    assertNone(pipe([1, 2, 3], Arr.get(3)))
+  })
+
+  it("unfold", () => {
+    const as = Arr.unfold(5, (n) => (n > 0 ? Option.some([n, n - 1]) : Option.none()))
+    deepStrictEqual(as, [5, 4, 3, 2, 1])
+  })
+
+  it("map", () => {
+    deepStrictEqual(
+      pipe([1, 2, 3], Arr.map((n) => n * 2)),
+      [2, 4, 6]
+    )
+    deepStrictEqual(
+      pipe(["a", "b"], Arr.map((s, i) => s + i)),
+      ["a0", "b1"]
+    )
+  })
+
+  it("flatMap", () => {
+    deepStrictEqual(
+      pipe([1, 2, 3], Arr.flatMap((n) => [n, n + 1])),
+      [1, 2, 2, 3, 3, 4]
+    )
+    const f = Arr.flatMap((n: number, i) => [n + i])
+    deepStrictEqual(pipe([], f), [])
+    deepStrictEqual(pipe([1, 2, 3], f), [1, 3, 5])
+  })
+
+  it("extend", () => {
+    deepStrictEqual(pipe([1, 2, 3, 4], Arr.extend(Num.sumAll)), [10, 9, 7, 4])
+    deepStrictEqual(pipe([1, 2, 3, 4], Arr.extend(identity)), [
+      [1, 2, 3, 4],
+      [2, 3, 4],
+      [3, 4],
+      [4]
+    ])
+  })
+
+  it("compact", () => {
+    deepStrictEqual(Arr.getSomes([]), [])
+    deepStrictEqual(Arr.getSomes([Option.some(1), Option.some(2), Option.some(3)]), [
+      1,
+      2,
+      3
+    ])
+    deepStrictEqual(Arr.getSomes([Option.some(1), Option.none(), Option.some(3)]), [
+      1,
+      3
+    ])
+  })
+
+  it("separate", () => {
+    deepStrictEqual(Arr.separate([]), [[], []])
+    deepStrictEqual(Arr.separate([Result.succeed(1), Result.fail("e"), Result.fail(2), Result.succeed(2)]), [
+      ["e", 2],
+      [1, 2]
+    ])
+  })
+
+  it("filter", () => {
+    deepStrictEqual(Arr.filter([1, 2, 3], (n) => n % 2 === 1), [1, 3])
+    deepStrictEqual(Arr.filter([Option.some(3), Option.some(2), Option.some(1)], Option.isSome), [
+      Option.some(3),
+      Option.some(2),
+      Option.some(1)
+    ])
+    deepStrictEqual(Arr.filter([Option.some(3), Option.none(), Option.some(1)], Option.isSome), [
+      Option.some(3),
+      Option.some(1)
+    ])
+    deepStrictEqual(Arr.filter(["a", "b", "c"], (_, i) => i % 2 === 0), ["a", "c"])
+  })
+
+  it("filterMap", () => {
+    const f: (n: number, i: number) => Result.Result<number, string> = (n, i) =>
+      n + i < 4 ? Result.succeed(n * 2) : Result.fail(`skip: ${n}`)
+
+    deepStrictEqual(Arr.filterMap([], f), [])
+    deepStrictEqual(Arr.filterMap([1, 2, 3], f), [2, 4])
+    deepStrictEqual(pipe([1, 2, 3], Arr.filterMap(f)), [2, 4])
+    deepStrictEqual(pipe(new Set([1, 2, 3]), Arr.filterMap(f)), [2, 4])
+    deepStrictEqual(pipe([1, 2, 3][Symbol.iterator](), Arr.filterMap(f)), [2, 4])
+  })
+
+  it("partition (identity)", () => {
+    deepStrictEqual(Arr.partition([], identity), [[], []])
+    deepStrictEqual(Arr.partition([Result.succeed(1), Result.fail("a"), Result.succeed(2)], identity), [["a"], [1, 2]])
+  })
+
+  it("partition - transformed outputs", () => {
+    deepStrictEqual(Arr.partition([], (n) => n > 2 ? Result.succeed(n) : Result.fail(n)), [[], []])
+    deepStrictEqual(Arr.partition([1, 3], (n) => n > 2 ? Result.succeed(n) : Result.fail(n)), [[1], [3]])
+
+    deepStrictEqual(Arr.partition([], (n, i) => n + i > 2 ? Result.succeed(n) : Result.fail(n)), [[], []])
+    deepStrictEqual(Arr.partition([1, 2], (n, i) => n + i > 2 ? Result.succeed(n) : Result.fail(n)), [[1], [2]])
+  })
+
+  it("reduce", () => {
+    deepStrictEqual(pipe(["a", "b", "c"], Arr.reduce("", (b, a) => b + a)), "abc")
+    deepStrictEqual(
+      pipe(
+        ["a", "b"],
+        Arr.reduce("", (b, a, i) => b + i + a)
+      ),
+      "0a1b"
+    )
+  })
+
+  it("reduceRight", () => {
+    const f = (b: string, a: string) => b + a
+    deepStrictEqual(pipe(["a", "b", "c"], Arr.reduceRight("", f)), "cba")
+    deepStrictEqual(pipe([], Arr.reduceRight("", f)), "")
+    deepStrictEqual(
+      pipe(
+        ["a", "b"],
+        Arr.reduceRight("", (b, a, i) => b + i + a)
+      ),
+      "1b0a"
+    )
+  })
+
+  it("makeOrder", () => {
+    const O = Arr.makeOrder(Str.Order)
+    deepStrictEqual(O([], []), 0)
+    deepStrictEqual(O(["a"], ["a"]), 0)
+
+    deepStrictEqual(O(["a"], ["b"]), -1)
+    deepStrictEqual(O(["b"], ["a"]), 1)
+
+    deepStrictEqual(O([], ["a"]), -1)
+    deepStrictEqual(O(["a"], []), 1)
+    deepStrictEqual(O(["a"], ["a", "a"]), -1)
+    deepStrictEqual(O(["b"], ["a", "a"]), 1)
+
+    deepStrictEqual(O(["a", "a"], ["a", "a"]), 0)
+    deepStrictEqual(O(["a", "b"], ["a", "b"]), 0)
+
+    deepStrictEqual(O(["a", "b"], ["a", "a"]), 1)
+    deepStrictEqual(O(["a", "a"], ["a", "b"]), -1)
+
+    deepStrictEqual(O(["b", "a"], ["a", "b"]), 1)
+    deepStrictEqual(O(["a", "a"], ["b", "a"]), -1)
+    deepStrictEqual(O(["a", "b"], ["b", "a"]), -1)
+    deepStrictEqual(O(["b", "a"], ["b", "b"]), -1)
+    deepStrictEqual(O(["b", "b"], ["b", "a"]), 1)
+  })
+
+  it("isReadonlyArrayEmpty", () => {
+    deepStrictEqual(Arr.isReadonlyArrayEmpty([1, 2, 3]), false)
+    deepStrictEqual(Arr.isReadonlyArrayEmpty([]), true)
+  })
+
+  it("isArrayEmpty", () => {
+    deepStrictEqual(Arr.isArrayEmpty([1, 2, 3]), false)
+    deepStrictEqual(Arr.isArrayEmpty([]), true)
+  })
+
+  it("isReadonlyArrayNonEmpty", () => {
+    deepStrictEqual(Arr.isReadonlyArrayNonEmpty([1, 2, 3]), true)
+    deepStrictEqual(Arr.isReadonlyArrayNonEmpty([]), false)
+  })
+
+  it("isArrayNonEmpty", () => {
+    deepStrictEqual(Arr.isArrayNonEmpty([1, 2, 3]), true)
+    deepStrictEqual(Arr.isArrayNonEmpty([]), false)
+  })
+
+  it("head", () => {
+    const as: ReadonlyArray<number> = [1, 2, 3]
+    assertSome(Arr.head(as), 1)
+    assertNone(Arr.head([]))
+  })
+
+  it("last", () => {
+    const as: ReadonlyArray<number> = [1, 2, 3]
+    assertSome(Arr.last(as), 3)
+    assertNone(Arr.last([]))
+  })
+
+  it("chunksOf", () => {
+    deepStrictEqual(Arr.chunksOf(2)([1, 2, 3, 4, 5]), [
+      Arr.make(1, 2),
+      [3, 4],
+      [5]
+    ])
+    deepStrictEqual(Arr.chunksOf(2)([1, 2, 3, 4, 5, 6]), [
+      Arr.make(1, 2),
+      [3, 4],
+      [5, 6]
+    ])
+    deepStrictEqual(Arr.chunksOf(1)([1, 2, 3, 4, 5]), [[1], [2], [3], [4], [5]])
+    deepStrictEqual(Arr.chunksOf(5)([1, 2, 3, 4, 5]), [[1, 2, 3, 4, 5]])
+    // out of bounds
+    deepStrictEqual(Arr.chunksOf(0)([1, 2, 3, 4, 5]), [[1], [2], [3], [4], [5]])
+    deepStrictEqual(Arr.chunksOf(-1)([1, 2, 3, 4, 5]), [[1], [2], [3], [4], [5]])
+
+    const assertSingleChunk = (
+      input: Arr.NonEmptyReadonlyArray<number>,
+      n: number
+    ) => {
+      const chunks = Arr.chunksOf(n)(input)
+      strictEqual(chunks.length, 1)
+      deepStrictEqual(Arr.headNonEmpty(chunks), input)
+    }
+    // n = length
+    assertSingleChunk(Arr.make(1, 2), 2)
+    // n out of bounds
+    assertSingleChunk(Arr.make(1, 2), 3)
+  })
+
+  it("window", () => {
+    deepStrictEqual(Arr.window([], 0), [])
+    deepStrictEqual(Arr.window([], 2), [])
+    deepStrictEqual(Arr.window([1, 2, 3, 4, 5], 2), [[1, 2], [2, 3], [3, 4], [4, 5]])
+    deepStrictEqual(Arr.window([1, 2, 3, 4, 5], 3), [[1, 2, 3], [2, 3, 4], [3, 4, 5]])
+
+    // n out of bounds
+    deepStrictEqual(Arr.window([1, 2, 3, 4, 5], 6), [])
+    deepStrictEqual(Arr.window([1, 2, 3, 4, 5], 0), [])
+    deepStrictEqual(Arr.window([1, 2, 3, 4, 5], -1), [])
+  })
+
+  it("min", () => {
+    deepStrictEqual(Arr.min(Num.Order)([2, 1, 3]), 1)
+    deepStrictEqual(Arr.min(Num.Order)([3]), 3)
+  })
+
+  it("max", () => {
+    deepStrictEqual(
+      Arr.max(Num.Order)(Arr.make(1, 2, 3)),
+      3
+    )
+    deepStrictEqual(Arr.max(Num.Order)([1]), 1)
+  })
+
+  it("flatten", () => {
+    deepStrictEqual(Arr.flatten([[1], [2], [3]]), [1, 2, 3])
+  })
+
+  it("groupWith", () => {
+    const groupWith = Arr.groupWith(Equivalence.strictEqual<number>())
+    deepStrictEqual(groupWith([1, 2, 1, 1]), [[1], [2], [1, 1]])
+    deepStrictEqual(groupWith([1, 2, 1, 1, 3]), [[1], [2], [1, 1], [3]])
+  })
+
+  it("groupBy", () => {
+    deepStrictEqual(Arr.groupBy((_) => "")([]), {})
+    deepStrictEqual(Arr.groupBy((a) => `${a}`)([1]), { "1": [1] })
+    deepStrictEqual(
+      Arr.groupBy((s: string) => `${s.length}`)(["foo", "bar", "foobar"]),
+      {
+        "3": ["foo", "bar"],
+        "6": ["foobar"]
+      }
+    )
+    deepStrictEqual(Arr.groupBy(["a", "b"], (s) => s === "a" ? symA : s === "b" ? symB : symC), {
+      [symA]: ["a"],
+      [symB]: ["b"]
+    })
+    deepStrictEqual(Arr.groupBy(["a", "b", "c", "d"], (s) => s === "a" ? symA : s === "b" ? symB : symC), {
+      [symA]: ["a"],
+      [symB]: ["b"],
+      [symC]: ["c", "d"]
+    })
+  })
+
+  it("match", () => {
+    const len: <A>(as: ReadonlyArray<A>) => number = Arr.match({
+      onEmpty: () => 0,
+      onNonEmpty: (as) => 1 + len(as.slice(1))
+    })
+    deepStrictEqual(len([1, 2, 3]), 3)
+  })
+
+  it("matchLeft", () => {
+    const len: <A>(as: ReadonlyArray<A>) => number = Arr.matchLeft({
+      onEmpty: () => 0,
+      onNonEmpty: (_, tail) => 1 + len(tail)
+    })
+    deepStrictEqual(len([1, 2, 3]), 3)
+  })
+
+  it("matchRight", () => {
+    const len: <A>(as: ReadonlyArray<A>) => number = Arr.matchRight({
+      onEmpty: () => 0,
+      onNonEmpty: (init, _) => 1 + len(init)
+    })
+    deepStrictEqual(len([1, 2, 3]), 3)
+  })
+
+  it("sortBy", () => {
+    interface X {
+      readonly a: string
+      readonly b: number
+      readonly c: boolean
+    }
+
+    const byName = pipe(
+      Str.Order,
+      Order.mapInput((p: { readonly a: string; readonly b: number }) => p.a)
+    )
+
+    const byAge = pipe(
+      Num.Order,
+      Order.mapInput((p: { readonly a: string; readonly b: number }) => p.b)
+    )
+
+    const sortByNameByAge = Arr.sortBy(byName, byAge)
+
+    const xs: Arr.NonEmptyArray<X> = [
+      { a: "a", b: 1, c: true },
+      { a: "b", b: 3, c: true },
+      { a: "c", b: 2, c: true },
+      { a: "b", b: 2, c: true }
+    ]
+
+    deepStrictEqual(Arr.sortBy()(xs), xs)
+    deepStrictEqual(sortByNameByAge([]), [])
+    deepStrictEqual(sortByNameByAge(xs), [
+      { a: "a", b: 1, c: true },
+      { a: "b", b: 2, c: true },
+      { a: "b", b: 3, c: true },
+      { a: "c", b: 2, c: true }
+    ])
+
+    deepStrictEqual(Arr.sortBy()(new Set(xs)), xs)
+    deepStrictEqual(sortByNameByAge(new Set([])), [])
+    deepStrictEqual(sortByNameByAge(new Set(xs)), [
+      { a: "a", b: 1, c: true },
+      { a: "b", b: 2, c: true },
+      { a: "b", b: 3, c: true },
+      { a: "c", b: 2, c: true }
+    ])
+
+    const sortByAgeByName = Arr.sortBy(byAge, byName)
+    deepStrictEqual(sortByAgeByName(xs), [
+      { a: "a", b: 1, c: true },
+      { a: "b", b: 2, c: true },
+      { a: "c", b: 2, c: true },
+      { a: "b", b: 3, c: true }
+    ])
+  })
+
+  it("copy", () => {
+    deepStrictEqual(pipe([], Arr.copy), [])
+    deepStrictEqual(pipe([1, 2, 3], Arr.copy), [1, 2, 3])
+  })
+
+  it("chop", () => {
+    deepStrictEqual(pipe([], Arr.chop((as) => [as[0] * 2, as.slice(1)])), [])
+    deepStrictEqual(pipe([1, 2, 3], Arr.chop((as) => [as[0] * 2, as.slice(1)])), [2, 4, 6])
+  })
+
+  it("pad", () => {
+    deepStrictEqual(pipe([], Arr.pad(0, 0)), [])
+    deepStrictEqual(pipe([1, 2, 3], Arr.pad(0, 0)), [])
+    deepStrictEqual(pipe([1, 2, 3], Arr.pad(2, 0)), [1, 2])
+    deepStrictEqual(pipe([1, 2, 3], Arr.pad(6, 0)), [1, 2, 3, 0, 0, 0])
+    deepStrictEqual(pipe([1, 2, 3], Arr.pad(-2, 0)), [])
+  })
+
+  describe("chunksOf", () => {
+    it("should split a `ReadonlyArray` into length-n pieces", () => {
+      deepStrictEqual(Arr.chunksOf(2)([1, 2, 3, 4, 5]), [[1, 2], [3, 4], [5]])
+      deepStrictEqual(Arr.chunksOf(2)([1, 2, 3, 4, 5, 6]), [
+        [1, 2],
+        [3, 4],
+        [5, 6]
+      ])
+      deepStrictEqual(Arr.chunksOf(1)([1, 2, 3, 4, 5]), [[1], [2], [3], [4], [5]])
+      deepStrictEqual(Arr.chunksOf(5)([1, 2, 3, 4, 5]), [[1, 2, 3, 4, 5]])
+      // out of bounds
+      deepStrictEqual(Arr.chunksOf(0)([1, 2, 3, 4, 5]), [[1], [2], [3], [4], [5]])
+      deepStrictEqual(Arr.chunksOf(-1)([1, 2, 3, 4, 5]), [[1], [2], [3], [4], [5]])
+
+      const assertSingleChunk = (input: ReadonlyArray<number>, n: number) => {
+        const chunks = Arr.chunksOf(n)(input)
+        deepStrictEqual(chunks.length, 1)
+        deepStrictEqual(chunks[0], input)
+      }
+      // n = length
+      assertSingleChunk([1, 2], 2)
+      // n out of bounds
+      assertSingleChunk([1, 2], 3)
+    })
+
+    it("returns an empty array if provided an empty array", () => {
+      const empty: ReadonlyArray<number> = []
+      deepStrictEqual(Arr.chunksOf(0)(empty), Arr.empty())
+      deepStrictEqual(Arr.chunksOf(0)(Arr.empty()), Arr.empty())
+      deepStrictEqual(Arr.chunksOf(1)(empty), Arr.empty())
+      deepStrictEqual(Arr.chunksOf(1)(Arr.empty()), Arr.empty())
+      deepStrictEqual(Arr.chunksOf(2)(empty), Arr.empty())
+      deepStrictEqual(Arr.chunksOf(2)(Arr.empty()), Arr.empty())
+    })
+
+    it("should respect the law: chunksOf(n)(xs).concat(chunksOf(n)(ys)) == chunksOf(n)(xs.concat(ys)))", () => {
+      const xs: ReadonlyArray<number> = []
+      const ys: ReadonlyArray<number> = [1, 2]
+      deepStrictEqual(
+        Arr.chunksOf(2)(xs).concat(Arr.chunksOf(2)(ys)),
+        Arr.chunksOf(2)(xs.concat(ys))
+      )
+      fc.assert(
+        fc.property(
+          fc.array(fc.integer()).filter((xs) => xs.length % 2 === 0), // Ensures `xs.length` is even
+          fc.array(fc.integer()),
+          fc.integer({ min: 1, max: 1 }).map((x) => x * 2), // Generates `n` to be even so that it evenly divides `xs`
+          (xs, ys, n) => {
+            const as = Arr.chunksOf(n)(xs).concat(Arr.chunksOf(n)(ys))
+            const bs = Arr.chunksOf(n)(xs.concat(ys))
+            deepStrictEqual(as, bs)
+          }
+        )
+      )
+    })
+  })
+
+  it("makeBy", () => {
+    deepStrictEqual(Arr.makeBy(5, (n) => n * 2), [0, 2, 4, 6, 8])
+    deepStrictEqual(Arr.makeBy((n) => n * 2)(5), [0, 2, 4, 6, 8])
+    deepStrictEqual(Arr.makeBy(2.2, (n) => n * 2), [0, 2])
+    deepStrictEqual(Arr.makeBy((n) => n * 2)(2.2), [0, 2])
+  })
+
+  it("replicate", () => {
+    deepStrictEqual(Arr.replicate("a", 0), ["a"])
+    deepStrictEqual(Arr.replicate("a", -1), ["a"])
+    deepStrictEqual(Arr.replicate("a", 3), ["a", "a", "a"])
+    deepStrictEqual(Arr.replicate("a", 2.2), ["a", "a"])
+  })
+
+  it("range", () => {
+    deepStrictEqual(Arr.range(0, 0), [0])
+    deepStrictEqual(Arr.range(0, 1), [0, 1])
+    deepStrictEqual(Arr.range(1, 5), [1, 2, 3, 4, 5])
+    deepStrictEqual(Arr.range(10, 15), [10, 11, 12, 13, 14, 15])
+    deepStrictEqual(Arr.range(-1, 0), [-1, 0])
+    deepStrictEqual(Arr.range(-5, -1), [-5, -4, -3, -2, -1])
+    // out of bound
+    deepStrictEqual(Arr.range(2, 1), [2])
+    deepStrictEqual(Arr.range(-1, -2), [-1])
+  })
+
+  it("unionWith", () => {
+    const two: ReadonlyArray<number> = [1, 2]
+    deepStrictEqual(pipe(two, Arr.unionWith([3, 4], Equivalence.strictEqual<number>())), [1, 2, 3, 4])
+    deepStrictEqual(pipe(two, Arr.unionWith([2, 3], Equivalence.strictEqual<number>())), [1, 2, 3])
+    deepStrictEqual(pipe(two, Arr.unionWith([1, 2], Equivalence.strictEqual<number>())), [1, 2])
+    deepStrictEqual(pipe(two, Arr.unionWith(Arr.empty(), Equivalence.strictEqual<number>())), two)
+    deepStrictEqual(pipe(Arr.empty(), Arr.unionWith(two, Equivalence.strictEqual<number>())), two)
+    deepStrictEqual(
+      pipe(Arr.empty(), Arr.unionWith(Arr.empty(), Equivalence.strictEqual<number>())),
+      Arr.empty()
+    )
+  })
+
+  it("intersectionWith", () => {
+    const intersectionWith = Arr.intersectionWith(Equivalence.strictEqual<number>())
+    deepStrictEqual(pipe([1, 2], intersectionWith([3, 4])), [])
+    deepStrictEqual(pipe([1, 2], intersectionWith([2, 3])), [2])
+    deepStrictEqual(pipe([1, 2], intersectionWith([1, 2])), [1, 2])
+    // iterator input
+    deepStrictEqual(pipe([1, 2], intersectionWith([3, 4][Symbol.iterator]())), [])
+    deepStrictEqual(pipe([1, 2], intersectionWith([2, 3][Symbol.iterator]())), [2])
+    deepStrictEqual(pipe([1, 2], intersectionWith([1, 2][Symbol.iterator]())), [1, 2])
+  })
+
+  it("differenceWith", () => {
+    const differenceWith = Arr.differenceWith(Equivalence.strictEqual<number>())
+    deepStrictEqual(pipe([1, 2], differenceWith([3, 4])), [1, 2])
+    deepStrictEqual(pipe([1, 2], differenceWith([2, 3])), [1])
+    deepStrictEqual(pipe([1, 2], differenceWith([1, 2])), [])
+    // iterator input
+    deepStrictEqual(pipe([1, 2], differenceWith([3, 4][Symbol.iterator]())), [1, 2])
+    deepStrictEqual(pipe([1, 2], differenceWith([2, 3][Symbol.iterator]())), [1])
+    deepStrictEqual(pipe([1, 2], differenceWith([1, 2][Symbol.iterator]())), [])
+  })
+
+  it("empty", () => {
+    deepStrictEqual(Arr.empty.length, 0)
+  })
+
+  it("every", () => {
+    const isPositive: Predicate.Predicate<number> = (n) => n > 0
+    deepStrictEqual(Arr.every([1, 2, 3], isPositive), true)
+    deepStrictEqual(Arr.every([1, 2, -3], isPositive), false)
+  })
+
+  it("some", () => {
+    const isPositive: Predicate.Predicate<number> = (n) => n > 0
+    deepStrictEqual(Arr.some([-1, -2, 3], isPositive), true)
+    deepStrictEqual(Arr.some([-1, -2, -3], isPositive), false)
+  })
+
+  it("length", () => {
+    deepStrictEqual(Arr.length(Arr.empty()), 0)
+    deepStrictEqual(Arr.length([]), 0)
+    deepStrictEqual(Arr.length(["a"]), 1)
+  })
+
+  it("fromOption", () => {
+    deepStrictEqual(Arr.fromOption(Option.some("hello")), ["hello"])
+    deepStrictEqual(Arr.fromOption(Option.none()), [])
+  })
+
+  it("forEach", () => {
+    const log: Array<string> = []
+    Arr.forEach(["a", "b", "c"], (a, i) => log.push(`${a}-${i}`))
+    deepStrictEqual(log, ["a-0", "b-1", "c-2"])
+  })
+
+  it("sortWith", () => {
+    type X = {
+      a: string
+      b: number
+    }
+    const arr: ReadonlyArray<X> = [{ a: "a", b: 2 }, { a: "b", b: 1 }]
+    deepStrictEqual(Arr.sortWith(arr, (x) => x.b, Order.Number), [{ a: "b", b: 1 }, { a: "a", b: 2 }])
+  })
+
+  it("countBy", () => {
+    deepStrictEqual(Arr.countBy([1, 2, 3, 4, 5], (n) => n % 2 === 0), 2)
+    deepStrictEqual(pipe([1, 2, 3, 4, 5], Arr.countBy((n) => n % 2 === 0)), 2)
+  })
+
+  it("isArray", () => {
+    strictEqual(Arr.isArray([]), true)
+    strictEqual(Arr.isArray([1, 2, 3]), true)
+    strictEqual(Arr.isArray("hello"), false)
+    strictEqual(Arr.isArray(123), false)
+    strictEqual(Arr.isArray(null), false)
+    strictEqual(Arr.isArray(undefined), false)
+    strictEqual(Arr.isArray({}), false)
+    strictEqual(Arr.isArray(new Set([1, 2])), false)
+  })
+
+  it("fromRecord", () => {
+    deepStrictEqual(Arr.fromRecord({}), [])
+    const entries = Arr.fromRecord({ a: 1, b: 2 })
+    deepStrictEqual(entries.length, 2)
+    deepStrictEqual(entries.sort(([a], [b]) => a.localeCompare(b)), [["a", 1], ["b", 2]])
+  })
+
+  it("join", () => {
+    deepStrictEqual(Arr.join([], ","), "")
+    deepStrictEqual(Arr.join(["a"], ","), "a")
+    deepStrictEqual(Arr.join(["a", "b", "c"], ", "), "a, b, c")
+    deepStrictEqual(Arr.join(["a", "b", "c"], ""), "abc")
+    deepStrictEqual(pipe(["x", "y"], Arr.join("-")), "x-y")
+  })
+
+  it("mapAccum", () => {
+    deepStrictEqual(Arr.mapAccum([1, 2, 3], 0, (acc, n) => [acc + n, acc + n]), [6, [1, 3, 6]])
+    deepStrictEqual(Arr.mapAccum([], 10, (acc, n: number) => [acc + n, n]), [10, []])
+    deepStrictEqual(
+      pipe([1, 2, 3], Arr.mapAccum(0, (acc, n) => [acc + n, n * 2])),
+      [6, [2, 4, 6]]
+    )
+    deepStrictEqual(
+      Arr.mapAccum(["a", "b", "c"], "", (acc, s, i) => [acc + s, `${s}${i}`]),
+      ["abc", ["a0", "b1", "c2"]]
+    )
+  })
+
+  it("partition", () => {
+    const f: (n: number, i: number) => Result.Result<number, string> = (n, i) =>
+      n > 0 ? Result.succeed(n + i) : Result.fail(`negative: ${n}:${i}`)
+    deepStrictEqual(Arr.partition([], f), [[], []])
+    deepStrictEqual(Arr.partition([1, -2, 3, -4], f), [["negative: -2:1", "negative: -4:3"], [1, 5]])
+    deepStrictEqual(pipe([5, 10], Arr.partition(f)), [[], [5, 11]])
+    deepStrictEqual(pipe([-1, -2], Arr.partition(f)), [["negative: -1:0", "negative: -2:1"], []])
+    deepStrictEqual(pipe(new Set([1, -2, 3, -4]), Arr.partition(f)), [["negative: -2:1", "negative: -4:3"], [
+      1,
+      5
+    ]])
+    deepStrictEqual(pipe([1, -2, 3][Symbol.iterator](), Arr.partition(f)), [["negative: -2:1"], [1, 5]])
+  })
+
+  it("partition with typed pass/fail outputs", () => {
+    const items: Array<string | number> = [1, "a", 2, "b"]
+    deepStrictEqual(
+      Arr.partition(items, (x) => typeof x === "number" ? Result.succeed(x) : Result.fail(x)),
+      [["a", "b"], [1, 2]]
+    )
+  })
+
+  it("getFailures", () => {
+    deepStrictEqual(Arr.getFailures([]), [])
+    deepStrictEqual(
+      Arr.getFailures([Result.succeed(1), Result.fail("err"), Result.succeed(2)]),
+      ["err"]
+    )
+    deepStrictEqual(
+      Arr.getFailures([Result.fail("a"), Result.fail("b")]),
+      ["a", "b"]
+    )
+    deepStrictEqual(
+      Arr.getFailures([Result.succeed(1), Result.succeed(2)]),
+      []
+    )
+  })
+
+  it("getSuccesses", () => {
+    deepStrictEqual(Arr.getSuccesses([]), [])
+    deepStrictEqual(
+      Arr.getSuccesses([Result.succeed(1), Result.fail("err"), Result.succeed(2)]),
+      [1, 2]
+    )
+    deepStrictEqual(
+      Arr.getSuccesses([Result.fail("a"), Result.fail("b")]),
+      []
+    )
+    deepStrictEqual(
+      Arr.getSuccesses([Result.succeed(1), Result.succeed(2)]),
+      [1, 2]
+    )
+  })
+
+  it("dedupe", () => {
+    deepStrictEqual(Arr.dedupe([]), [])
+    deepStrictEqual(Arr.dedupe([1, 2, 1, 3, 2, 4]), [1, 2, 3, 4])
+    deepStrictEqual(Arr.dedupe([1, 2, 3]), [1, 2, 3])
+    deepStrictEqual(Arr.dedupe([1, 1, 1]), [1])
+    deepStrictEqual(Arr.dedupe(["a", "b", "a"]), ["a", "b"])
+  })
+
+  it("dedupeAdjacent", () => {
+    deepStrictEqual(Arr.dedupeAdjacent([]), [])
+    deepStrictEqual(Arr.dedupeAdjacent([1, 2, 3]), [1, 2, 3])
+    deepStrictEqual(Arr.dedupeAdjacent([1, 1, 2, 2, 3, 3]), [1, 2, 3])
+    deepStrictEqual(Arr.dedupeAdjacent([1, 2, 1]), [1, 2, 1])
+    deepStrictEqual(Arr.dedupeAdjacent([1, 1, 1]), [1])
+  })
+
+  it("group", () => {
+    deepStrictEqual(Arr.group([1, 1, 2, 2, 2, 3, 1]), [[1, 1], [2, 2, 2], [3], [1]])
+    deepStrictEqual(Arr.group([1]), [[1]])
+    deepStrictEqual(Arr.group(["a", "a", "b"]), [["a", "a"], ["b"]])
+  })
+
+  it("union", () => {
+    deepStrictEqual(Arr.union([1, 2], [2, 3]), [1, 2, 3])
+    deepStrictEqual(Arr.union([], [1, 2]), [1, 2])
+    deepStrictEqual(Arr.union([1, 2], []), [1, 2])
+    deepStrictEqual(Arr.union([], []), [])
+    deepStrictEqual(Arr.union([1, 2], [1, 2]), [1, 2])
+    deepStrictEqual(pipe([1, 2], Arr.union([3, 4])), [1, 2, 3, 4])
+  })
+
+  it("intersection", () => {
+    deepStrictEqual(Arr.intersection([1, 2, 3], [3, 4, 1]), [1, 3])
+    deepStrictEqual(Arr.intersection([1, 2], [3, 4]), [])
+    deepStrictEqual(Arr.intersection([1, 2], [1, 2]), [1, 2])
+    deepStrictEqual(Arr.intersection([], [1, 2]), [])
+    deepStrictEqual(Arr.intersection([1, 2], []), [])
+    deepStrictEqual(pipe([1, 2, 3], Arr.intersection([2, 3, 4])), [2, 3])
+  })
+
+  it("difference", () => {
+    deepStrictEqual(Arr.difference([1, 2, 3], [2, 3, 4]), [1])
+    deepStrictEqual(Arr.difference([1, 2], [1, 2]), [])
+    deepStrictEqual(Arr.difference([1, 2], []), [1, 2])
+    deepStrictEqual(Arr.difference([], [1, 2]), [])
+    deepStrictEqual(pipe([1, 2, 3], Arr.difference([3])), [1, 2])
+  })
+
+  it("cartesianWith", () => {
+    deepStrictEqual(
+      Arr.cartesianWith([1, 2], ["a", "b"], (n, s) => `${n}-${s}`),
+      ["1-a", "1-b", "2-a", "2-b"]
+    )
+    deepStrictEqual(Arr.cartesianWith([], ["a", "b"], (n: number, s) => `${n}-${s}`), [])
+    deepStrictEqual(Arr.cartesianWith([1, 2], [], (n, s: string) => `${n}-${s}`), [])
+    deepStrictEqual(
+      pipe([1], Arr.cartesianWith(["x"], (n, s) => `${n}${s}`)),
+      ["1x"]
+    )
+  })
+
+  it("cartesian", () => {
+    deepStrictEqual(Arr.cartesian([1, 2], ["a", "b"]), [
+      [1, "a"],
+      [1, "b"],
+      [2, "a"],
+      [2, "b"]
+    ])
+    deepStrictEqual(Arr.cartesian([], ["a"]), [])
+    deepStrictEqual(Arr.cartesian([1], []), [])
+    deepStrictEqual(Arr.cartesian([1], ["a"]), [[1, "a"]])
+    deepStrictEqual(pipe([1, 2], Arr.cartesian(["x"])), [[1, "x"], [2, "x"]])
+  })
+
+  it("makeEquivalence", () => {
+    const eq = Arr.makeEquivalence(Equivalence.strictEqual<number>())
+    strictEqual(eq([], []), true)
+    strictEqual(eq([1, 2, 3], [1, 2, 3]), true)
+    strictEqual(eq([1, 2], [1, 2, 3]), false)
+    strictEqual(eq([1, 2, 3], [1, 2]), false)
+    strictEqual(eq([1, 2, 3], [1, 3, 2]), false)
+    strictEqual(eq([1], [2]), false)
+  })
+
+  it("getReadonlyReducerConcat", () => {
+    const reducer = Arr.getReadonlyReducerConcat<number>()
+    deepStrictEqual(reducer.combine([1, 2], [3, 4]), [1, 2, 3, 4])
+    deepStrictEqual(reducer.combine([], [1, 2]), [1, 2])
+    deepStrictEqual(reducer.combine([1, 2], []), [1, 2])
+    deepStrictEqual(reducer.initialValue, [])
+  })
+
+  it("makeReducerConcat", () => {
+    const reducer = Arr.makeReducerConcat<string>()
+    deepStrictEqual(reducer.combine(["a"], ["b"]), ["a", "b"])
+    deepStrictEqual(reducer.initialValue, [])
+  })
+
+  it("allocate", () => {
+    deepStrictEqual(Arr.allocate(0).length, 0)
+    deepStrictEqual(Arr.allocate(3).length, 3)
+  })
+
+  describe("every - edge cases", () => {
+    it("returns true for empty array", () => {
+      strictEqual(Arr.every([], (_n: number) => false), true)
+    })
+    it("with index", () => {
+      strictEqual(Arr.every([0, 1, 2], (n, i) => n === i), true)
+      strictEqual(Arr.every([0, 1, 3], (n, i) => n === i), false)
+    })
+  })
+
+  describe("some - edge cases", () => {
+    it("returns false for empty array", () => {
+      strictEqual(Arr.some([], (_n: number) => true), false)
+    })
+    it("with index", () => {
+      strictEqual(Arr.some([10, 20, 2], (n, i) => n === i), true)
+      strictEqual(Arr.some([10, 20, 30], (n, i) => n === i), false)
+    })
+  })
+
+  describe("copy - edge cases", () => {
+    it("returns a new reference", () => {
+      const original = [1, 2, 3]
+      const copied = Arr.copy(original)
+      deepStrictEqual(copied, original)
+      strictEqual(copied !== original, true)
+    })
+  })
+
+  describe("unfold - edge cases", () => {
+    it("returns empty when seed produces Option.none", () => {
+      deepStrictEqual(Arr.unfold(0, () => Option.none()), [])
+    })
+  })
+
+  it("bindTo", () => {
+    deepStrictEqual(pipe([1, 2, 3], Arr.bindTo("a")), [{ a: 1 }, { a: 2 }, { a: 3 }])
+    deepStrictEqual(pipe([], Arr.bindTo("a")), [])
+    deepStrictEqual(Arr.bindTo([1], "x"), [{ x: 1 }])
+  })
+
+  it("Do notation", () => {
+    const _do = Arr.Do
+    deepStrictEqual(_do, Arr.of({}))
+
+    const doA = Arr.bind(_do, "a", () => ["a"])
+    deepStrictEqual(doA, Arr.of({ a: "a" }))
+
+    const doAB = Arr.bind(doA, "b", (x) => ["b", x.a + "b"])
+    deepStrictEqual(doAB, [
+      { a: "a", b: "b" },
+      { a: "a", b: "ab" }
+    ])
+    const doABC = Arr.let(doAB, "c", (x) => [x.a, x.b, x.a + x.b])
+    deepStrictEqual(doABC, [
+      { a: "a", b: "b", c: ["a", "b", "ab"] },
+      { a: "a", b: "ab", c: ["a", "ab", "aab"] }
+    ])
+
+    const doABCD = Arr.bind(doABC, "d", () => Arr.empty())
+    deepStrictEqual(doABCD, [])
+
+    const doAB__proto__C = pipe(
+      Arr.let(doAB, "__proto__", (x) => [x.a, x.b, x.a + x.b]),
+      Arr.let("c", (x) => [x.a, x.b, x.a + x.b])
+    )
+    deepStrictEqual(doAB__proto__C, [
+      { a: "a", b: "b", c: ["a", "b", "ab"], ["__proto__"]: ["a", "b", "ab"] },
+      { a: "a", b: "ab", c: ["a", "ab", "aab"], ["__proto__"]: ["a", "ab", "aab"] }
+    ])
+  })
+})