Add Tuple.map (#3658)

Co-authored-by: maksim.khramtsov <[email protected]>

.changeset/strong-pans-flash.md

@@ -0,0 +1,19 @@
+---
+"effect": minor
+---
+
+`Tuple.map` transforms each element of tuple using the given function, treating tuple homomorphically
+
+```ts
+import { pipe, Tuple } from "effect"
+
+const result = pipe(
+  //  ^? [string, string, string]
+  ["a", 1, false] as const,
+  T.map((el) => {
+    //^? "a" | 1 | false
+    return el.toString().toUppercase()
+  })
+)
+assert.deepStrictEqual(result, ["A", "1", "FALSE"])
+```

packages/effect/dtslint/Tuple.ts

@@ -60,3 +60,25 @@ pipe(hole<Array<number>>(), T.at(1))
 
 // $ExpectType number
 pipe(hole<Array<number>>(), T.at(-1))
+
+// -------------------------------------------------------------------------------------
+// map
+// -------------------------------------------------------------------------------------
+
+// $ExpectType [false, false, false]
+pipe(
+  T.make("a", 1),
+  T.appendElement(true),
+  T.map((x) => {
+    // $ExpectType string | number | boolean
+    x
+    return false as const
+  })
+)
+
+// $ExpectType [false, false, false]
+T.map(["a", 1, false], (x) => {
+  // $ExpectType string | number | boolean
+  x
+  return false as const
+})

packages/effect/src/Tuple.ts

@@ -7,6 +7,7 @@ import * as Equivalence from "./Equivalence.js"
 import { dual } from "./Function.js"
 import type { TypeLambda } from "./HKT.js"
 import * as order from "./Order.js"
+import type { TupleOf } from "./Types.js"
 
 /**
  * @category type lambdas
@@ -61,6 +62,40 @@ export const getFirst = <L, R>(self: readonly [L, R]): L => self[0]
  */
 export const getSecond = <L, R>(self: readonly [L, R]): R => self[1]
 
+/**
+ * Transforms each element of tuple using the given function, treating tuple homomorphically
+ *
+ * @param self - A tuple.
+ * @param f - The function to transform elements of the tuple.
+ *
+ * @example
+ * import { pipe, Tuple } from "effect"
+ *
+ * const result = pipe(
+ *   ["a", 1, false] as const,
+ *   Tuple.map((el) => el.toString().toUpperCase())
+ * )
+ * assert.deepStrictEqual(result, ['A', '1', 'FALSE'])
+ *
+ * @category mapping
+ * @since 3.9.0
+ */
+export const map: {
+  <T extends ReadonlyArray<any> | [], B>(
+    fn: (element: T[number]) => B
+  ): (self: T) => TupleOf<T["length"], B>
+  <B, T extends ReadonlyArray<any> | []>(
+    self: T,
+    fn: (element: T[number]) => B
+  ): TupleOf<T["length"], B>
+} = dual(
+  2,
+  <N extends number, A, B>(
+    self: TupleOf<N, A>,
+    fn: (element: A) => B
+  ): TupleOf<N, B> => self.map((element) => fn(element)) as TupleOf<N, B>
+)
+
 /**
  * Transforms both elements of a tuple using the given functions.
  *

packages/effect/test/Tuple.test.ts

@@ -31,6 +31,10 @@ describe("Tuple", () => {
     })).toEqual(["a!", 2])
   })
 
+  it("map", () => {
+    expect(T.map(["a", 1, false], (x) => x.toString().toUpperCase())).toEqual(["A", "1", "FALSE"])
+  })
+
   it("swap", () => {
     expect(T.swap(T.make("a", 1))).toEqual([1, "a"])
   })