Add Array.removeOption and Chunk.removeOption (#4861)

Co-authored-by: Tim <hello@timsmart.co>

Author: 2 people

.changeset/six-pumpkins-yell.md

@@ -0,0 +1,5 @@
+---
+"effect": minor
+---
+
+Add Array.removeOption and Chunk.removeOption

packages/effect/src/Array.ts

@@ -1257,8 +1257,15 @@ export const modify: {
   ): ReadonlyArray.With<S, ReadonlyArray.Infer<S> | B>
 } = dual(
   3,
-  <A, B>(self: Iterable<A>, i: number, f: (a: A) => B): Array<A | B> =>
-    Option.getOrElse(modifyOption(self, i, f), () => Array.from(self))
+  <A, B>(self: Iterable<A>, i: number, f: (a: A) => B): Array<A | B> => {
+    const out: Array<A | B> = Array.from(self)
+    if (isOutOfBounds(i, out)) {
+      return out
+    }
+    const b = f(out[i] as A)
+    out[i] = b
+    return out
+  }
 )
 
 /**
@@ -1291,11 +1298,11 @@ export const modifyOption: {
     f: (a: ReadonlyArray.Infer<S>) => B
   ): Option.Option<ReadonlyArray.With<S, ReadonlyArray.Infer<S> | B>>
 } = dual(3, <A, B>(self: Iterable<A>, i: number, f: (a: A) => B): Option.Option<Array<A | B>> => {
-  const arr = Array.from(self)
+  const arr = fromIterable(self)
   if (isOutOfBounds(i, arr)) {
     return Option.none()
   }
-  const out: Array<A | B> = arr
+  const out: Array<A | B> = Array.isArray(self) ? self.slice() : arr
   const b = f(arr[i])
   out[i] = b
   return Option.some(out)
@@ -1332,6 +1339,38 @@ export const remove: {
   return out
 })
 
+/**
+ * Delete the element at the specified index, creating a new `Array`,
+ * or return `None` if the index is out of bounds.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Array, Option } from "effect"
+ *
+ * const numbers = [1, 2, 3, 4]
+ * const result = Array.removeOption(numbers, 2)
+ * assert.deepStrictEqual(result, Option.some([1, 2, 4]))
+ *
+ * const outOfBoundsResult = Array.removeOption(numbers, 5)
+ * assert.deepStrictEqual(outOfBoundsResult, Option.none())
+ * ```
+ *
+ * @since 3.16.0
+ */
+export const removeOption: {
+  (i: number): <A>(self: Iterable<A>) => Option.Option<Array<A>>
+  <A>(self: Iterable<A>, i: number): Option.Option<Array<A>>
+} = dual(2, <A>(self: Iterable<A>, i: number): Option.Option<Array<A>> => {
+  const arr = fromIterable(self)
+  if (isOutOfBounds(i, arr)) {
+    return Option.none()
+  }
+  const out = Array.isArray(self) ? self.slice() : arr
+  out.splice(i, 1)
+  return Option.some(out)
+})
+
 /**
  * Reverse an `Iterable`, creating a new `Array`.
  *

packages/effect/src/Chunk.ts

@@ -1238,7 +1238,24 @@ export const remove: {
   <A>(self: Chunk<A>, i: number): Chunk<A>
 } = dual(
   2,
-  <A>(self: Chunk<A>, i: number): Chunk<A> => unsafeFromArray(RA.remove(toReadonlyArray(self), i))
+  <A>(self: Chunk<A>, i: number): Chunk<A> => {
+    if (i < 0 || i >= self.length) return self
+    return unsafeFromArray(RA.remove(toReadonlyArray(self), i))
+  }
+)
+
+/**
+ * @since 3.16.0
+ */
+export const removeOption: {
+  (i: number): <A>(self: Chunk<A>) => Option<Chunk<A>>
+  <A>(self: Chunk<A>, i: number): Option<Chunk<A>>
+} = dual(
+  2,
+  <A>(self: Chunk<A>, i: number): Option<Chunk<A>> => {
+    if (i < 0 || i >= self.length) return O.none()
+    return O.some(unsafeFromArray(RA.remove(toReadonlyArray(self), i)))
+  }
 )
 
 /**
@@ -1249,8 +1266,10 @@ export const modifyOption: {
   <A, B>(self: Chunk<A>, i: number, f: (a: A) => B): Option<Chunk<A | B>>
 } = dual(
   3,
-  <A, B>(self: Chunk<A>, i: number, f: (a: A) => B): Option<Chunk<A | B>> =>
-    O.map(RA.modifyOption(toReadonlyArray(self), i, f), unsafeFromArray)
+  <A, B>(self: Chunk<A>, i: number, f: (a: A) => B): Option<Chunk<A | B>> => {
+    if (i < 0 || i >= self.length) return O.none()
+    return O.some(unsafeFromArray(RA.modify(toReadonlyArray(self), i, f)))
+  }
 )
 
 /**

packages/effect/test/Array.test.ts

@@ -452,6 +452,20 @@ describe("Array", () => {
       deepStrictEqual(pipe(new Set([1, 2, 3]), Arr.remove(10)), [1, 2, 3])
     })
 
+    it("removeOption", () => {
+      assertSome(pipe([1, 2, 3], Arr.removeOption(0)), [2, 3])
+      // out of bound
+      assertNone(pipe([], Arr.removeOption(0)))
+      assertNone(pipe([1, 2, 3], Arr.removeOption(-1)))
+      assertNone(pipe([1, 2, 3], Arr.removeOption(10)))
+
+      assertSome(pipe(new Set([1, 2, 3]), Arr.removeOption(0)), [2, 3])
+      // out of bound
+      assertNone(pipe(new Set([]), Arr.removeOption(0)))
+      assertNone(pipe(new Set([1, 2, 3]), Arr.removeOption(-1)))
+      assertNone(pipe(new Set([1, 2, 3]), Arr.removeOption(10)))
+    })
+
     it("reverse", () => {
       deepStrictEqual(Arr.reverse([]), [])
       deepStrictEqual(Arr.reverse([1]), [1])

packages/effect/test/Chunk.test.ts

@@ -116,6 +116,11 @@ describe("Chunk", () => {
     assertEquals(pipe(Chunk.make(1, 2, 3), Chunk.remove(0)), Chunk.make(2, 3))
   })
 
+  it("removeOption", () => {
+    assertNone(pipe(Chunk.empty(), Chunk.removeOption(0)))
+    assertSome(pipe(Chunk.make(1, 2, 3), Chunk.removeOption(0)), Chunk.make(2, 3))
+  })
+
   it("chunksOf", () => {
     assertEquals(pipe(Chunk.empty(), Chunk.chunksOf(2)), Chunk.empty())
     assertEquals(