Fix signatures related to predicates, closes #1916 (#1958)

.changeset/fresh-tigers-tie.md

@@ -0,0 +1,5 @@
+---
+"effect": patch
+---
+
+Fix signatures related to predicates, closes #1916

packages/effect/dtslint/Cause.ts

@@ -1,8 +1,12 @@
 import * as Cause from "effect/Cause"
+import { pipe } from "effect/Function"
+import type * as Predicate from "effect/Predicate"
 
 declare const err1: Cause.Cause<"err-1">
 declare const err2: Cause.Cause<"err-2">
 
+declare const predicateString: Predicate.Predicate<Cause.Cause<string>>
+
 // -------------------------------------------------------------------------------------
 // andThen
 // -------------------------------------------------------------------------------------
@@ -18,3 +22,10 @@ err1.pipe(Cause.andThen(err2))
 
 // $ExpectType Cause<"err-2">
 err1.pipe(Cause.andThen(() => err2))
+
+// -------------------------------------------------------------------------------------
+// filter
+// -------------------------------------------------------------------------------------
+
+// $ExpectType Cause<"err-1">
+pipe(err1, Cause.filter(predicateString))

packages/effect/dtslint/Chunk.ts

@@ -63,8 +63,8 @@ pipe(
 // $ExpectType [excluded: Chunk<string | number>, satisfying: Chunk<string | number>]
 Chunk.partition(numbersOrStrings, predicateNumbersOrStrings)
 
-// $ExpectType [excluded: Chunk<string | number>, satisfying: Chunk<string | number>]
-pipe(numbersOrStrings, Chunk.partition(predicateNumbersOrStrings))
+// $ExpectType [excluded: Chunk<number>, satisfying: Chunk<number>]
+pipe(numbers, Chunk.partition(predicateNumbersOrStrings))
 
 // $ExpectType [excluded: Chunk<string>, satisfying: Chunk<number>]
 Chunk.partition(numbersOrStrings, Predicate.isNumber)
@@ -134,13 +134,22 @@ Chunk.filter(numbersOrStrings, (
   _item // $ExpectType string | number
 ) => true)
 
+// $ExpectType Chunk<string | number>
 pipe(
   numbersOrStrings,
   Chunk.filter((
     _item // $ExpectType string | number
   ) => true)
 )
 
+// $ExpectType Chunk<number>
+pipe(
+  numbers,
+  Chunk.filter((
+    item: string | number
+  ): item is string | number => true)
+)
+
 // $ExpectType Chunk<string | number>
 Chunk.filter(numbersOrStrings, predicateNumbersOrStrings)
 

packages/effect/dtslint/Effect.ts

@@ -587,13 +587,22 @@ Effect.dropWhile(numbersArray, (
   _item // $ExpectType number
 ) => Effect.succeed(true))
 
+// $ExpectType Effect<never, never, number[]>
 pipe(
   numbersArray,
   Effect.dropWhile((
     _item // $ExpectType number
   ) => Effect.succeed(true))
 )
 
+// $ExpectType Effect<never, never, number[]>
+pipe(
+  numbersArray,
+  Effect.dropWhile((
+    _item: number | string
+  ) => Effect.succeed(true))
+)
+
 // $ExpectType Effect<never, never, number[]>
 Effect.dropWhile(numbersArray, predicateNumbersOrStringsEffect)
 
@@ -608,13 +617,22 @@ Effect.dropUntil(numbersArray, (
   _item // $ExpectType number
 ) => Effect.succeed(true))
 
+// $ExpectType Effect<never, never, number[]>
 pipe(
   numbersArray,
   Effect.dropUntil((
     _item // $ExpectType number
   ) => Effect.succeed(true))
 )
 
+// $ExpectType Effect<never, never, number[]>
+pipe(
+  numbersArray,
+  Effect.dropUntil((
+    _item: string | number
+  ) => Effect.succeed(true))
+)
+
 // $ExpectType Effect<never, never, number[]>
 Effect.dropUntil(numbersArray, predicateNumbersOrStringsEffect)
 
@@ -629,13 +647,22 @@ Effect.takeUntil(numbersArray, (
   _item // $ExpectType number
 ) => Effect.succeed(true))
 
+// $ExpectType Effect<never, never, number[]>
 pipe(
   numbersArray,
   Effect.takeUntil((
     _item // $ExpectType number
   ) => Effect.succeed(true))
 )
 
+// $ExpectType Effect<never, never, number[]>
+pipe(
+  numbersArray,
+  Effect.takeUntil((
+    _item: number | string
+  ) => Effect.succeed(true))
+)
+
 // $ExpectType Effect<never, never, number[]>
 Effect.takeUntil(numbersArray, predicateNumbersOrStringsEffect)
 
@@ -646,17 +673,27 @@ pipe(numbersArray, Effect.takeUntil(predicateNumbersOrStringsEffect))
 // takeWhile
 // -------------------------------------------------------------------------------------
 
+// $ExpectType Effect<never, never, number[]>
 Effect.takeWhile(numbersArray, (
   _item // $ExpectType number
 ) => Effect.succeed(true))
 
+// $ExpectType Effect<never, never, number[]>
 pipe(
   numbersArray,
   Effect.takeWhile((
     _item // $ExpectType number
   ) => Effect.succeed(true))
 )
 
+// $ExpectType Effect<never, never, number[]>
+pipe(
+  numbersArray,
+  Effect.takeWhile((
+    _item: unknown
+  ) => Effect.succeed(true))
+)
+
 // $ExpectType Effect<never, never, number[]>
 Effect.takeWhile(numbersArray, predicateNumbersOrStringsEffect)
 

packages/effect/dtslint/Either.ts

@@ -1,17 +1,23 @@
 import * as Either from "effect/Either"
 import { pipe } from "effect/Function"
+import * as Predicate from "effect/Predicate"
+import * as ReadonlyArray from "effect/ReadonlyArray"
 
-declare const stringOrString: Either.Either<string, string>
-declare const stringOrNumber: Either.Either<string, number>
-declare const stringOrBoolean: Either.Either<string, boolean>
-declare const errorOrBoolean: Either.Either<Error, boolean>
+declare const string$string: Either.Either<string, string>
+declare const string$number: Either.Either<string, number>
+declare const string$boolean: Either.Either<string, boolean>
+declare const error$boolean: Either.Either<Error, boolean>
+
+declare const error$a: Either.Either<Error, "a">
+
+declare const predicateUnknown: Predicate.Predicate<unknown>
 
 // -------------------------------------------------------------------------------------
 // flip
 // -------------------------------------------------------------------------------------
 
 // $ExpectType Either<number, string>
-Either.flip(stringOrNumber)
+Either.flip(string$number)
 
 // -------------------------------------------------------------------------------------
 // try
@@ -31,19 +37,19 @@ Either.try({ try: () => 1, catch: () => new Error() })
 Either.all([])
 
 // $ExpectType Either<string, [number]>
-Either.all([stringOrNumber])
+Either.all([string$number])
 
 // $ExpectType Either<string, [number, boolean]>
-Either.all([stringOrNumber, stringOrBoolean])
+Either.all([string$number, string$boolean])
 
 // $ExpectType Either<string | Error, [number, boolean]>
-Either.all([stringOrNumber, errorOrBoolean])
+Either.all([string$number, error$boolean])
 
 // $ExpectType Either<string, [number, boolean]>
-pipe([stringOrNumber, stringOrBoolean] as const, Either.all)
+pipe([string$number, string$boolean] as const, Either.all)
 
 // $ExpectType Either<string | Error, [number, boolean]>
-pipe([stringOrNumber, errorOrBoolean] as const, Either.all)
+pipe([string$number, error$boolean] as const, Either.all)
 
 // -------------------------------------------------------------------------------------
 // all - struct
@@ -53,19 +59,19 @@ pipe([stringOrNumber, errorOrBoolean] as const, Either.all)
 Either.all({})
 
 // $ExpectType Either<string, { a: number; }>
-Either.all({ a: stringOrNumber })
+Either.all({ a: string$number })
 
 // $ExpectType Either<string, { a: number; b: boolean; }>
-Either.all({ a: stringOrNumber, b: stringOrBoolean })
+Either.all({ a: string$number, b: string$boolean })
 
 // $ExpectType Either<string | Error, { a: number; b: boolean; }>
-Either.all({ a: stringOrNumber, b: errorOrBoolean })
+Either.all({ a: string$number, b: error$boolean })
 
 // $ExpectType Either<string, { a: number; b: boolean; }>
-pipe({ a: stringOrNumber, b: stringOrBoolean }, Either.all)
+pipe({ a: string$number, b: string$boolean }, Either.all)
 
 // $ExpectType Either<string | Error, { a: number; b: boolean; }>
-pipe({ a: stringOrNumber, b: errorOrBoolean }, Either.all)
+pipe({ a: string$number, b: error$boolean }, Either.all)
 
 // -------------------------------------------------------------------------------------
 // all - array
@@ -93,13 +99,69 @@ Either.all(eitherRecord)
 // -------------------------------------------------------------------------------------
 
 // $ExpectType Either<string, number>
-Either.andThen(stringOrString, stringOrNumber)
+Either.andThen(string$string, string$number)
 
 // $ExpectType Either<string, number>
-Either.andThen(stringOrString, () => stringOrNumber)
+Either.andThen(string$string, () => string$number)
 
 // $ExpectType Either<string, number>
-stringOrString.pipe(Either.andThen(stringOrNumber))
+string$string.pipe(Either.andThen(string$number))
 
 // $ExpectType Either<string, number>
-stringOrString.pipe(Either.andThen(() => stringOrNumber))
+string$string.pipe(Either.andThen(() => string$number))
+
+// -------------------------------------------------------------------------------------
+// filterOrLeft
+// -------------------------------------------------------------------------------------
+
+declare const error$arrayOfStrings: Either.Either<Error, Array<string>>
+
+// $ExpectType Either<"b" | Error, [string, ...string[]]>
+pipe(
+  error$arrayOfStrings,
+  Either.filterOrLeft(ReadonlyArray.isNonEmptyArray, (
+    _s // $ExpectType string[]
+  ) => "b" as const)
+)
+
+declare const error$readonlyArrayOfStrings: Either.Either<Error, ReadonlyArray<string>>
+
+// $ExpectType Either<"b" | Error, readonly [string, ...string[]]>
+pipe(
+  error$readonlyArrayOfStrings,
+  Either.filterOrLeft(ReadonlyArray.isNonEmptyReadonlyArray, (
+    _s // $ExpectType readonly string[]
+  ) => "b" as const)
+)
+
+// $ExpectType Either<"b" | Error, "a">
+pipe(
+  error$a,
+  Either.filterOrLeft(Predicate.isString, (
+    _s // $ExpectType "a"
+  ) => "b" as const)
+)
+
+// $ExpectType Either<"b" | Error, "a">
+pipe(
+  error$a,
+  Either.filterOrLeft(Predicate.isString, (
+    _s: string
+  ) => "b" as const)
+)
+
+// $ExpectType Either<"b" | Error, "a">
+pipe(
+  error$a,
+  Either.filterOrLeft(predicateUnknown, (
+    _s // $ExpectType "a"
+  ) => "b" as const)
+)
+
+// $ExpectType Either<"b" | Error, "a">
+pipe(
+  error$a,
+  Either.filterOrLeft(predicateUnknown, (
+    _s: string
+  ) => "b" as const)
+)

packages/effect/dtslint/Exit.ts

@@ -17,6 +17,28 @@ if (Exit.exists(numberOrString, Predicate.isString)) {
   numberOrString // $ExpectType Exit<never, string>
 }
 
+if (
+  pipe(
+    number,
+    Exit.exists((
+      _n // $ExpectType number
+    ) => true)
+  )
+) {
+  number // $ExpectType Exit<string, number>
+}
+
+if (
+  pipe(
+    number,
+    Exit.exists((
+      _sn: string | number
+    ) => true)
+  )
+) {
+  number // $ExpectType Exit<string, number>
+}
+
 // $ExpectType boolean
 pipe(
   number,

packages/effect/dtslint/ReadonlyArray.ts

@@ -259,13 +259,26 @@ ReadonlyArray.filter(numbersOrStrings, (
   _item // $ExpectType string | number
 ) => true)
 
+// @ts-expect-error
+ReadonlyArray.filter(numbersOrStrings, (
+  _item: string
+) => true)
+
 pipe(
   numbersOrStrings,
   ReadonlyArray.filter((
     _item // $ExpectType string | number
   ) => true)
 )
 
+pipe(
+  numbersOrStrings,
+  // @ts-expect-error
+  ReadonlyArray.filter((
+    _item: string
+  ) => true)
+)
+
 // $ExpectType (string | number)[]
 ReadonlyArray.filter(numbersOrStrings, predicateNumbersOrStrings)
 

packages/effect/dtslint/Struct.ts

@@ -111,7 +111,7 @@ pipe(symbolStruct, S.pick(asym, bsym))
 // $ExpectType { [asym]: number | undefined; [bsym]: number | undefined; }
 pipe(symbolNumberRecord, S.pick(asym, bsym))
 
-// $ExpectType { 2: number; 1: string; }
+// $ExpectType { 1: string; 2: number; }
 pipe(numberStruct, S.pick(1, 2))
 
 // @ts-expect-error
@@ -123,7 +123,7 @@ S.pick(4)(numberStruct)
 // $ExpectType { [x: number]: unknown; }
 S.pick(4 as number)(numberStruct)
 
-// $ExpectType { 2: number | undefined; 1: number | undefined; }
+// $ExpectType { 1: number | undefined; 2: number | undefined; }
 pipe(numberNumberRecord, S.pick(1, 2))
 
 // $ExpectType { ab: number | undefined; aa: number | undefined; }