more type safe dual signature, closes Effect-TS#2967

.changeset/nice-laws-admire.md

@@ -0,0 +1,8 @@
+---
+"@effect/typeclass": minor
+"@effect/platform": minor
+"effect": minor
+"@effect/schema": minor
+---
+
+more type safe `Function.dual` signature

packages/effect/dtslint/Function.ts

@@ -0,0 +1,24 @@
+import * as Function from "effect/Function"
+
+// -------------------------------------------------------------------------------------
+// dual
+// -------------------------------------------------------------------------------------
+
+type f_data_first = (a: number, b: number) => number
+type f_data_last = (b: number) => (a: number) => number
+
+const f: f_data_first & f_data_last = Function.dual(2, (a: number, b: number) => a + b)
+// $ExpectType f_data_first & f_data_last
+f
+
+const f_explicit_types = Function.dual<f_data_last, f_data_first>(2, (a: number, b: number) => a + b)
+// $ExpectType f_data_first & f_data_last
+f_explicit_types
+
+const f_no_type = Function.dual(2, (a: number, b: number) => a + b)
+// $ExpectType (a: number, b: number) => number
+f_no_type
+
+// @ts-expect-error
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const f_wrong_impl: f_data_first & f_data_last = Function.dual(2, (a: string, b: string) => a + b)

packages/effect/src/Array.ts

@@ -994,9 +994,12 @@ export const findLast: {
   <A, B>(self: Iterable<A>, f: (a: A, i: number) => Option<B>): Option<B>
   <A, B extends A>(self: Iterable<A>, refinement: (a: A, i: number) => a is B): Option<B>
   <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Option<A>
-} = dual(
+} = dual<
+  typeof findLast,
+  <A>(self: Iterable<A>, f: ((a: A, i: number) => boolean) | ((a: A, i: number) => Option<A>)) => Option<A>
+>(
   2,
-  <A>(self: Iterable<A>, f: ((a: A, i: number) => boolean) | ((a: A, i: number) => Option<A>)): Option<A> => {
+  (self, f) => {
     const input = fromIterable(self)
     for (let i = input.length - 1; i >= 0; i--) {
       const a = input[i]
@@ -1680,7 +1683,7 @@ export const splitNonEmptyAt: {
 export const split: {
   (n: number): <A>(self: Iterable<A>) => Array<Array<A>>
   <A>(self: Iterable<A>, n: number): Array<Array<A>>
-} = dual(2, <A>(self: Iterable<A>, n: number) => {
+} = dual<typeof split, <A>(self: Iterable<A>, n: number) => Array<Array<A>>>(2, (self, n) => {
   const input = fromIterable(self)
   return chunksOf(input, Math.ceil(input.length / Math.floor(n)))
 })

packages/effect/src/Function.ts

@@ -69,14 +69,22 @@ export const isFunction = (input: unknown): input is Function => typeof input ==
  * @since 2.0.0
  */
 export const dual: {
-  <DataLast extends (...args: Array<any>) => any, DataFirst extends (...args: Array<any>) => any>(
-    arity: Parameters<DataFirst>["length"],
-    body: DataFirst
-  ): DataLast & DataFirst
-  <DataLast extends (...args: Array<any>) => any, DataFirst extends (...args: Array<any>) => any>(
+  <
+    Other extends (...args: ReadonlyArray<any>) => any,
+    Impl extends (...args: ReadonlyArray<any>) => any,
+    Signature extends Impl = Impl & ([Array<any>] extends [Parameters<Other>] ? unknown : Other)
+  >(
+    arity: Parameters<Impl>["length"],
+    body: Impl
+  ): Signature
+  <
+    Other extends (...args: ReadonlyArray<any>) => any,
+    Impl extends (...args: ReadonlyArray<any>) => any,
+    Signature extends Impl = Impl & ([Array<any>] extends [Parameters<Other>] ? unknown : Other)
+  >(
     isDataFirst: (args: IArguments) => boolean,
-    body: DataFirst
-  ): DataLast & DataFirst
+    body: Impl
+  ): Signature
 } = function(arity, body) {
   if (typeof arity === "function") {
     return function() {

packages/effect/src/Iterable.ts

@@ -376,9 +376,12 @@ export const findFirst: {
   <A, B>(self: Iterable<A>, f: (a: A, i: number) => Option<B>): Option<B>
   <A, B extends A>(self: Iterable<A>, refinement: (a: A, i: number) => a is B): Option<B>
   <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Option<A>
-} = dual(
+} = dual<
+  typeof findFirst,
+  <A>(self: Iterable<A>, f: ((a: A, i: number) => boolean) | ((a: A, i: number) => Option<A>)) => Option<A>
+>(
   2,
-  <A>(self: Iterable<A>, f: ((a: A, i: number) => boolean) | ((a: A, i: number) => Option<A>)): Option<A> => {
+  (self, f) => {
     let i = 0
     for (const a of self) {
       const o = f(a, i)
@@ -410,7 +413,10 @@ export const findLast: {
   <A, B>(self: Iterable<A>, f: (a: A, i: number) => Option<B>): Option<B>
   <A, B extends A>(self: Iterable<A>, refinement: (a: A, i: number) => a is B): Option<B>
   <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Option<A>
-} = dual(
+} = dual<
+  typeof findLast,
+  <A>(self: Iterable<A>, f: ((a: A, i: number) => boolean) | ((a: A, i: number) => Option<A>)) => Option<A>
+>(
   2,
   <A>(self: Iterable<A>, f: ((a: A, i: number) => boolean) | ((a: A, i: number) => Option<A>)): Option<A> => {
     let i = 0
@@ -795,7 +801,10 @@ export const filterMap: {
 export const filterMapWhile: {
   <A, B>(f: (a: A, i: number) => Option<B>): (self: Iterable<A>) => Iterable<B>
   <A, B>(self: Iterable<A>, f: (a: A, i: number) => Option<B>): Iterable<B>
-} = dual(2, <A, B>(self: Iterable<A>, f: (a: A, i: number) => Option<B>) => ({
+} = dual<
+  typeof filterMapWhile,
+  <A, B>(self: Iterable<A>, f: (a: A, i: number) => Option<B>) => Iterable<B>
+>(2, (self, f) => ({
   [Symbol.iterator]() {
     const iterator = self[Symbol.iterator]()
     let i = 0

packages/effect/src/Option.ts

@@ -614,7 +614,7 @@ export const map: {
  */
 export const as: {
   <B>(b: B): <X>(self: Option<X>) => Option<B>
-} = dual(2, <X, B>(self: Option<X>, b: B): Option<B> => map(self, () => b))
+} = dual<typeof as, <X, B>(self: Option<X>, b: B) => Option<B>>(2, (self, b) => map(self, () => b))
 
 /**
  * Maps the `Some` value of this `Option` to the `void` constant value.

packages/effect/src/internal/cause.ts

@@ -495,10 +495,12 @@ export const andThen: {
   <E2>(f: Cause.Cause<E2>): <E>(self: Cause.Cause<E>) => Cause.Cause<E2>
   <E, E2>(self: Cause.Cause<E>, f: (e: E) => Cause.Cause<E2>): Cause.Cause<E2>
   <E, E2>(self: Cause.Cause<E>, f: Cause.Cause<E2>): Cause.Cause<E2>
-} = dual(
+} = dual<
+  typeof andThen,
+  <E, E2>(self: Cause.Cause<E>, f: ((e: E) => Cause.Cause<E2>) | Cause.Cause<E2>) => Cause.Cause<E2>
+>(
   2,
-  <E, E2>(self: Cause.Cause<E>, f: ((e: E) => Cause.Cause<E2>) | Cause.Cause<E2>): Cause.Cause<E2> =>
-    isFunction(f) ? flatMap(self, f) : flatMap(self, () => f)
+  (self, f) => isFunction(f) ? flatMap(self, f) : flatMap(self, () => f)
 )
 
 // -----------------------------------------------------------------------------

packages/effect/src/internal/fiberRuntime.ts

@@ -1986,7 +1986,18 @@ export const forEach: {
       readonly discard: true
     }
   ): Effect.Effect<void, E, R>
-} = dual((args) => Predicate.isIterable(args[0]), <A, R, E, B>(
+} = dual<
+  typeof forEach,
+  <A, R, E, B>(
+    self: Iterable<A>,
+    f: (a: A, i: number) => Effect.Effect<B, E, R>,
+    options?: {
+      readonly concurrency?: Concurrency | undefined
+      readonly batching?: boolean | "inherit" | undefined
+      readonly discard?: boolean | undefined
+    }
+  ) => Effect.Effect<void, E, R> | Effect.Effect<RA.NonEmptyArray<B>, E, R> | Effect.Effect<Array<B>, E, R>
+>((args) => Predicate.isIterable(args[0]), <A, R, E, B>(
   self: Iterable<A>,
   f: (a: A, i: number) => Effect.Effect<B, E, R>,
   options?: {

packages/effect/src/internal/hashSet.ts

@@ -280,18 +280,21 @@ export const filter: {
   <A>(predicate: Predicate<NoInfer<A>>): (self: HS.HashSet<A>) => HS.HashSet<A>
   <A, B extends A>(self: HS.HashSet<A>, refinement: Refinement<A, B>): HS.HashSet<B>
   <A>(self: HS.HashSet<A>, predicate: Predicate<A>): HS.HashSet<A>
-} = dual(2, <A>(self: HS.HashSet<A>, f: Predicate<A>) => {
-  return mutate(empty(), (set) => {
-    const iterator = values(self)
-    let next: IteratorResult<A, any>
-    while (!(next = iterator.next()).done) {
-      const value = next.value
-      if (f(value)) {
-        add(set, value)
+} = dual<typeof filter, <A>(self: HS.HashSet<A>, f: Predicate<A>) => HS.HashSet<A>>(
+  2,
+  <A>(self: HS.HashSet<A>, f: Predicate<A>): HS.HashSet<A> => {
+    return mutate(empty(), (set) => {
+      const iterator = values(self)
+      let next: IteratorResult<A, any>
+      while (!(next = iterator.next()).done) {
+        const value = next.value
+        if (f(value)) {
+          add(set, value)
+        }
       }
-    }
-  })
-})
+    })
+  }
+)
 
 /** @internal */
 export const partition: {

packages/effect/src/internal/stm/tMap.ts

@@ -362,7 +362,16 @@ export const removeIf: {
       readonly discard: false
     }
   ): STM.STM<Array<[K, V]>>
-} = dual((args) => isTMap(args[0]), <K, V>(
+} = dual<
+  typeof removeIf,
+  <K, V>(
+    self: TMap.TMap<K, V>,
+    predicate: (key: K, value: V) => boolean,
+    options?: {
+      readonly discard: boolean
+    }
+  ) => STM.STM<Array<[K, V]> | void>
+>((args) => isTMap(args[0]), <K, V>(
   self: TMap.TMap<K, V>,
   predicate: (key: K, value: V) => boolean,
   options?: {

packages/effect/test/Function.test.ts

@@ -140,7 +140,7 @@ describe("Function", () => {
       deepStrictEqual(f(3, 2), 1)
       deepStrictEqual(Function.pipe(3, f(2)), 1)
       // should ignore excess arguments
-      deepStrictEqual(f.apply(null, [3, 2, 100] as any), 1)
+      deepStrictEqual((f as (self: number, that: number) => number).apply(null, [3, 2, 100] as any), 1)
     })
 
     it("arity: 0", () => {
@@ -169,7 +169,7 @@ describe("Function", () => {
       deepStrictEqual(f(3, 2), 1)
       deepStrictEqual(Function.pipe(3, f(2)), 1)
       // should ignore excess arguments
-      deepStrictEqual(f.apply(null, [3, 2, 100] as any), 1)
+      deepStrictEqual((f as (self: number, that: number) => number).apply(null, [3, 2, 100] as any), 1)
     })
 
     it("arity: 5", () => {
@@ -180,7 +180,13 @@ describe("Function", () => {
       deepStrictEqual(f("_", "a", "b", "c", "d"), "_abcd")
       deepStrictEqual(Function.pipe("_", f("a", "b", "c", "d")), "_abcd")
       // should ignore excess arguments
-      deepStrictEqual(f.apply(null, ["_", "a", "b", "c", "d", "e"] as any), "_abcd")
+      deepStrictEqual(
+        (f as ((self: string, a: string, b: string, c: string, d: string) => string)).apply(
+          null,
+          ["_", "a", "b", "c", "d", "e"] as any
+        ),
+        "_abcd"
+      )
     })
 
     it("arity > 5", () => {
@@ -191,7 +197,13 @@ describe("Function", () => {
       deepStrictEqual(f("_", "a", "b", "c", "d", "e"), "_abcde")
       deepStrictEqual(Function.pipe("_", f("a", "b", "c", "d", "e")), "_abcde")
       // should ignore excess arguments
-      deepStrictEqual(f.apply(null, ["_", "a", "b", "c", "d", "e", "f"] as any), "_abcde")
+      deepStrictEqual(
+        (f as (self: string, a: string, b: string, c: string, d: string, e: string) => string).apply(
+          null,
+          ["_", "a", "b", "c", "d", "e", "f"] as any
+        ),
+        "_abcde"
+      )
     })
   })
 })

packages/platform/src/Transferable.ts

@@ -86,9 +86,15 @@ export const schema: {
     self: Schema.Schema<A, I, R>,
     f: (_: I) => Iterable<globalThis.Transferable>
   ): Schema.Schema<A, I, R>
-} = dual(2, <A, I, R>(
-  self: Schema.Schema<A, I, R>,
-  f: (_: I) => Iterable<globalThis.Transferable>
+} = dual<
+  typeof schema,
+  <A, I, R>(
+    self: Schema.Schema<A, I, R>,
+    f: (_: I) => Iterable<globalThis.Transferable>
+  ) => Schema.Schema<A, I, R>
+>(2, (
+  self,
+  f
 ) =>
   Schema.transformOrFail(
     Schema.encodedSchema(self),

packages/schema/src/Schema.ts

@@ -2244,12 +2244,15 @@ export const optional: {
     self: Schema.All extends S ? "you can't apply optional implicitly, use optional() instead" : S,
     options?: Options
   ): [undefined] extends [Options] ? optional<S> : optionalWithOptions<S, Options>
-} = dual((args) => isSchema(args[0]), (from, options) => {
+} = (dual((args) => isSchema(args[0]), (
+  from,
+  options
+) => {
   // Note: `Schema.All extends S ? "you can't...` is used to prevent the case where `optional` is implicitly applied.
   // For example: `S.String.pipe(S.optional)` would result in `S.String` being inferred as `Schema.All`,
   // which is not the intended behavior. This is mostly an aesthetic consideration, so if it causes issues, we can remove it.
   return new PropertySignatureWithFromImpl(optionalPropertySignatureAST(from, options), from)
-})
+})) as unknown as typeof optional
 
 /**
  * @since 0.67.0
@@ -3060,9 +3063,12 @@ export interface extend<Self extends Schema.Any, That extends Schema.Any> extend
 export const extend: {
   <That extends Schema.Any>(that: That): <Self extends Schema.Any>(self: Self) => extend<Self, That>
   <Self extends Schema.Any, That extends Schema.Any>(self: Self, that: That): extend<Self, That>
-} = dual(
+} = dual<
+  typeof extend,
+  <Self extends Schema.Any, That extends Schema.Any>(self: Self, that: That) => extend<Self, That>
+>(
   2,
-  <Self extends Schema.Any, That extends Schema.Any>(self: Self, that: That) => make(extendAST(self.ast, that.ast, []))
+  (self, that) => make(extendAST(self.ast, that.ast, []))
 )
 
 /**

packages/typeclass/src/Filterable.ts

@@ -103,7 +103,10 @@ export const filter: <F extends TypeLambda>(
     predicate: (a: A) => boolean
   ): Kind<F, R, O, E, B>
 } = <F extends TypeLambda>(Filterable: Filterable<F>) =>
-  dual(
+  dual<
+    ReturnType<typeof filter<F>>,
+    <R, O, E, A>(self: Kind<F, R, O, E, A>, predicate: (a: A) => boolean) => Kind<F, R, O, E, A>
+  >(
     2,
     <R, O, E, A>(self: Kind<F, R, O, E, A>, predicate: (a: A) => boolean): Kind<F, R, O, E, A> =>
       Filterable.filterMap(self, (b) => (predicate(b) ? Option.some(b) : Option.none()))