effect 4.0.0-beta.17 → 4.0.0-beta.19

package/src/Filter.ts

@@ -74,63 +74,6 @@ export interface FilterEffect<
   (input: Input, ...args: Args): Effect<Result.Result<Pass, Fail>, E, R>
 }
 
-// -------------------------------------------------------------------------------------
-// apply
-// -------------------------------------------------------------------------------------
-
-/**
- * @since 4.0.0
- * @category Apply
- */
-export type OrPredicate<A, R extends boolean | Result.Result<any, any>, Args extends ReadonlyArray<any> = []> = (
-  input: A,
-  ...args: Args
-) => R
-
-/**
- * @since 4.0.0
- * @category Apply
- */
-export type ResultOrBool<Out = any> = boolean | Result.Result<any, Out>
-
-/**
- * @since 4.0.0
- * @category Apply
- */
-export type Pass<A, R extends boolean | Result.Result<any, any>> = [R] extends [Result.Result<infer _P, infer _F>] ? _P
-  : A
-
-/**
- * @since 4.0.0
- * @category Apply
- */
-export type Fail<A, R extends boolean | Result.Result<any, any>> = [R] extends [Result.Result<infer _P, infer _F>] ? _F
-  : A
-
-/**
- * @since 4.0.0
- * @category Apply
- */
-export type ApplyResult<A, R extends boolean | Result.Result<any, any>> = Result.Result<Pass<A, R>, Fail<A, R>>
-
-/**
- * Applies a filter, predicate, or refinement to an input and returns a boxed
- * result. Extra arguments are forwarded to the function.
- *
- * @since 4.0.0
- * @category Apply
- */
-export const apply = <In, R extends ResultOrBool>(
-  filter: (input: In, ...args: Array<any>) => R,
-  input: In,
-  ...args: Array<any>
-): ApplyResult<In, R> => {
-  const result = filter(input, ...args)
-  if (result === true) return Result.succeed(input) as any
-  if (result === false) return Result.fail(input) as any
-  return result as any
-}
-
 // -------------------------------------------------------------------------------------
 // Constructors
 // -------------------------------------------------------------------------------------

package/src/HashMap.ts

@@ -3,6 +3,7 @@
  */
 
 import type { Equal } from "./Equal.ts"
+import type * as Filter from "./Filter.ts"
 import type { Inspectable } from "./Inspectable.ts"
 import * as internal from "./internal/hashMap.ts"
 import type { Option } from "./Option.ts"
@@ -2011,18 +2012,18 @@ export const filter: {
 export const compact: <K, A>(self: HashMap<K, Option<A>>) => HashMap<K, A> = internal.compact
 
 /**
- * Maps over the entries of the `HashMap` using the specified partial function
- * and filters out `None` values.
+ * Maps over the entries of the `HashMap` using the specified filter and keeps
+ * only successful results.
  *
  * @example
  * ```ts
  * import * as HashMap from "effect/HashMap"
- * import * as Option from "effect/Option"
+ * import * as Result from "effect/Result"
  *
  * const map1 = HashMap.make(["a", 1], ["b", 2], ["c", 3], ["d", 4])
  * const map2 = HashMap.filterMap(
  *   map1,
- *   (value) => value % 2 === 0 ? Option.some(value * 2) : Option.none()
+ *   (value) => value % 2 === 0 ? Result.succeed(value * 2) : Result.failVoid
  * )
  *
  * console.log(HashMap.size(map2)) // 2
@@ -2035,18 +2036,18 @@ export const compact: <K, A>(self: HashMap<K, Option<A>>) => HashMap<K, A> = int
  */
 export const filterMap: {
   /**
-   * Maps over the entries of the `HashMap` using the specified partial function
-   * and filters out `None` values.
+   * Maps over the entries of the `HashMap` using the specified filter and keeps
+   * only successful results.
    *
    * @example
    * ```ts
    * import * as HashMap from "effect/HashMap"
-   * import * as Option from "effect/Option"
+   * import * as Result from "effect/Result"
    *
    * const map1 = HashMap.make(["a", 1], ["b", 2], ["c", 3], ["d", 4])
    * const map2 = HashMap.filterMap(
    *   map1,
-   *   (value) => value % 2 === 0 ? Option.some(value * 2) : Option.none()
+   *   (value) => value % 2 === 0 ? Result.succeed(value * 2) : Result.failVoid
    * )
    *
    * console.log(HashMap.size(map2)) // 2
@@ -2057,20 +2058,20 @@ export const filterMap: {
    * @since 2.0.0
    * @category filtering
    */
-  <A, K, B>(f: (value: A, key: K) => Option<B>): (self: HashMap<K, A>) => HashMap<K, B>
+  <A, K, B, X>(f: Filter.Filter<A, B, X, [key: K]>): (self: HashMap<K, A>) => HashMap<K, B>
   /**
-   * Maps over the entries of the `HashMap` using the specified partial function
-   * and filters out `None` values.
+   * Maps over the entries of the `HashMap` using the specified filter and keeps
+   * only successful results.
    *
    * @example
    * ```ts
    * import * as HashMap from "effect/HashMap"
-   * import * as Option from "effect/Option"
+   * import * as Result from "effect/Result"
    *
    * const map1 = HashMap.make(["a", 1], ["b", 2], ["c", 3], ["d", 4])
    * const map2 = HashMap.filterMap(
    *   map1,
-   *   (value) => value % 2 === 0 ? Option.some(value * 2) : Option.none()
+   *   (value) => value % 2 === 0 ? Result.succeed(value * 2) : Result.failVoid
    * )
    *
    * console.log(HashMap.size(map2)) // 2
@@ -2081,7 +2082,7 @@ export const filterMap: {
    * @since 2.0.0
    * @category filtering
    */
-  <K, A, B>(self: HashMap<K, A>, f: (value: A, key: K) => Option<B>): HashMap<K, B>
+  <K, A, B, X>(self: HashMap<K, A>, f: Filter.Filter<A, B, X, [key: K]>): HashMap<K, B>
 } = internal.filterMap
 
 /**

package/src/Iterable.ts

@@ -32,7 +32,8 @@
 
 import type { NonEmptyArray } from "./Array.ts"
 import * as Equal from "./Equal.ts"
-import { dual, identity } from "./Function.ts"
+import type * as Filter from "./Filter.ts"
+import { dual } from "./Function.ts"
 import type { Option } from "./Option.ts"
 import * as O from "./Option.ts"
 import { isBoolean } from "./Predicate.ts"
@@ -3114,21 +3115,21 @@ export const flatten = <A>(self: Iterable<Iterable<A>>): Iterable<A> => ({
 })
 
 /**
- * Transforms elements of an iterable using a function that returns an Option, keeping only the Some values.
+ * Transforms elements of an iterable using a function that returns a `Result`, keeping only successful values.
  *
  * This combines mapping and filtering in a single operation - the function is applied to each element,
- * and only elements that result in Option.some are included in the result.
+ * and only elements that result in `Result.succeed` are included in the result.
  *
  * @example
  * ```ts
  * import { Iterable } from "effect"
- * import * as Option from "effect/Option"
+ * import * as Result from "effect/Result"
  *
  * // Parse strings to numbers, keeping only valid ones
  * const strings = ["1", "2", "invalid", "4", "not-a-number"]
  * const numbers = Iterable.filterMap(strings, (s) => {
  *   const num = parseInt(s)
- *   return isNaN(num) ? Option.none() : Option.some(num)
+ *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
  * })
  * console.log(Array.from(numbers)) // [1, 2, 4]
  *
@@ -3142,7 +3143,7 @@ export const flatten = <A>(self: Iterable<Iterable<A>>): Iterable<A> => ({
  * const adultEmails = Iterable.filterMap(
  *   users,
  *   (user) =>
- *     user.age >= 18 && user.email ? Option.some(user.email) : Option.none()
+ *     user.age >= 18 && user.email ? Result.succeed(user.email) : Result.failVoid
  * )
  * console.log(Array.from(adultEmails)) // ["alice@example.com", "charlie@example.com"]
  *
@@ -3150,7 +3151,7 @@ export const flatten = <A>(self: Iterable<Iterable<A>>): Iterable<A> => ({
  * const items = ["a", "b", "c", "d", "e"]
  * const evenIndexItems = Iterable.filterMap(
  *   items,
- *   (item, i) => i % 2 === 0 ? Option.some(`${i}: ${item}`) : Option.none()
+ *   (item, i) => i % 2 === 0 ? Result.succeed(`${i}: ${item}`) : Result.failVoid
  * )
  * console.log(Array.from(evenIndexItems)) // ["0: a", "2: c", "4: e"]
  * ```
@@ -3160,21 +3161,21 @@ export const flatten = <A>(self: Iterable<Iterable<A>>): Iterable<A> => ({
  */
 export const filterMap: {
   /**
-   * Transforms elements of an iterable using a function that returns an Option, keeping only the Some values.
+   * Transforms elements of an iterable using a function that returns a `Result`, keeping only successful values.
    *
    * This combines mapping and filtering in a single operation - the function is applied to each element,
-   * and only elements that result in Option.some are included in the result.
+   * and only elements that result in `Result.succeed` are included in the result.
    *
    * @example
    * ```ts
    * import { Iterable } from "effect"
-   * import * as Option from "effect/Option"
+   * import * as Result from "effect/Result"
    *
    * // Parse strings to numbers, keeping only valid ones
    * const strings = ["1", "2", "invalid", "4", "not-a-number"]
    * const numbers = Iterable.filterMap(strings, (s) => {
    *   const num = parseInt(s)
-   *   return isNaN(num) ? Option.none() : Option.some(num)
+   *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
    * })
    * console.log(Array.from(numbers)) // [1, 2, 4]
    *
@@ -3188,7 +3189,7 @@ export const filterMap: {
    * const adultEmails = Iterable.filterMap(
    *   users,
    *   (user) =>
-   *     user.age >= 18 && user.email ? Option.some(user.email) : Option.none()
+   *     user.age >= 18 && user.email ? Result.succeed(user.email) : Result.failVoid
    * )
    * console.log(Array.from(adultEmails)) // ["alice@example.com", "charlie@example.com"]
    *
@@ -3196,7 +3197,7 @@ export const filterMap: {
    * const items = ["a", "b", "c", "d", "e"]
    * const evenIndexItems = Iterable.filterMap(
    *   items,
-   *   (item, i) => i % 2 === 0 ? Option.some(`${i}: ${item}`) : Option.none()
+   *   (item, i) => i % 2 === 0 ? Result.succeed(`${i}: ${item}`) : Result.failVoid
    * )
    * console.log(Array.from(evenIndexItems)) // ["0: a", "2: c", "4: e"]
    * ```
@@ -3204,23 +3205,23 @@ export const filterMap: {
    * @category filtering
    * @since 2.0.0
    */
-  <A, B>(f: (a: A, i: number) => Option<B>): (self: Iterable<A>) => Iterable<B>
+  <A, B, X>(f: Filter.Filter<A, B, X, [i: number]>): (self: Iterable<A>) => Iterable<B>
   /**
-   * Transforms elements of an iterable using a function that returns an Option, keeping only the Some values.
+   * Transforms elements of an iterable using a function that returns a `Result`, keeping only successful values.
    *
    * This combines mapping and filtering in a single operation - the function is applied to each element,
-   * and only elements that result in Option.some are included in the result.
+   * and only elements that result in `Result.succeed` are included in the result.
    *
    * @example
    * ```ts
    * import { Iterable } from "effect"
-   * import * as Option from "effect/Option"
+   * import * as Result from "effect/Result"
    *
    * // Parse strings to numbers, keeping only valid ones
    * const strings = ["1", "2", "invalid", "4", "not-a-number"]
    * const numbers = Iterable.filterMap(strings, (s) => {
    *   const num = parseInt(s)
-   *   return isNaN(num) ? Option.none() : Option.some(num)
+   *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
    * })
    * console.log(Array.from(numbers)) // [1, 2, 4]
    *
@@ -3234,7 +3235,7 @@ export const filterMap: {
    * const adultEmails = Iterable.filterMap(
    *   users,
    *   (user) =>
-   *     user.age >= 18 && user.email ? Option.some(user.email) : Option.none()
+   *     user.age >= 18 && user.email ? Result.succeed(user.email) : Result.failVoid
    * )
    * console.log(Array.from(adultEmails)) // ["alice@example.com", "charlie@example.com"]
    *
@@ -3242,7 +3243,7 @@ export const filterMap: {
    * const items = ["a", "b", "c", "d", "e"]
    * const evenIndexItems = Iterable.filterMap(
    *   items,
-   *   (item, i) => i % 2 === 0 ? Option.some(`${i}: ${item}`) : Option.none()
+   *   (item, i) => i % 2 === 0 ? Result.succeed(`${i}: ${item}`) : Result.failVoid
    * )
    * console.log(Array.from(evenIndexItems)) // ["0: a", "2: c", "4: e"]
    * ```
@@ -3250,10 +3251,10 @@ export const filterMap: {
    * @category filtering
    * @since 2.0.0
    */
-  <A, B>(self: Iterable<A>, f: (a: A, i: number) => Option<B>): Iterable<B>
+  <A, B, X>(self: Iterable<A>, f: Filter.Filter<A, B, X, [i: number]>): Iterable<B>
 } = dual(
   2,
-  <A, B>(self: Iterable<A>, f: (a: A, i: number) => Option<B>): Iterable<B> => ({
+  <A, B, X>(self: Iterable<A>, f: Filter.Filter<A, B, X, [i: number]>): Iterable<B> => ({
     [Symbol.iterator]() {
       const iterator = self[Symbol.iterator]()
       let i = 0
@@ -3261,9 +3262,9 @@ export const filterMap: {
         next() {
           let result = iterator.next()
           while (!result.done) {
-            const b = f(result.value, i++)
-            if (O.isSome(b)) {
-              return { done: false, value: b.value }
+            const next = f(result.value, i++)
+            if (R.isSuccess(next)) {
+              return { done: false, value: next.success }
             }
             result = iterator.next()
           }
@@ -3275,18 +3276,18 @@ export const filterMap: {
 )
 
 /**
- * Transforms all elements of the `Iterable` for as long as the specified function returns some value
+ * Transforms all elements of the `Iterable` for as long as the specified function succeeds.
  *
  * @example
  * ```ts
  * import { Iterable } from "effect"
- * import * as Option from "effect/Option"
+ * import * as Result from "effect/Result"
  *
  * // Parse numbers until we hit an invalid one
  * const strings = ["1", "2", "3", "invalid", "4", "5"]
  * const numbers = Iterable.filterMapWhile(strings, (s) => {
  *   const num = parseInt(s)
- *   return isNaN(num) ? Option.none() : Option.some(num)
+ *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
  * })
  * console.log(Array.from(numbers)) // [1, 2, 3] (stops at "invalid")
  *
@@ -3294,7 +3295,7 @@ export const filterMap: {
  * const values = [2, 4, 6, 7, 8, 10]
  * const doubledEvens = Iterable.filterMapWhile(
  *   values,
- *   (n) => n % 2 === 0 ? Option.some(n * 2) : Option.none()
+ *   (n) => n % 2 === 0 ? Result.succeed(n * 2) : Result.failVoid
  * )
  * console.log(Array.from(doubledEvens)) // [4, 8, 12] (stops at 7)
  *
@@ -3302,7 +3303,7 @@ export const filterMap: {
  * const letters = ["a", "b", "c", "d", "e"]
  * const indexedUntilC = Iterable.filterMapWhile(
  *   letters,
- *   (letter, i) => letter !== "c" ? Option.some(`${i}: ${letter}`) : Option.none()
+ *   (letter, i) => letter !== "c" ? Result.succeed(`${i}: ${letter}`) : Result.failVoid
  * )
  * console.log(Array.from(indexedUntilC)) // ["0: a", "1: b"] (stops at "c")
  * ```
@@ -3312,18 +3313,18 @@ export const filterMap: {
  */
 export const filterMapWhile: {
   /**
-   * Transforms all elements of the `Iterable` for as long as the specified function returns some value
+   * Transforms all elements of the `Iterable` for as long as the specified function succeeds.
    *
    * @example
    * ```ts
    * import { Iterable } from "effect"
-   * import * as Option from "effect/Option"
+   * import * as Result from "effect/Result"
    *
    * // Parse numbers until we hit an invalid one
    * const strings = ["1", "2", "3", "invalid", "4", "5"]
    * const numbers = Iterable.filterMapWhile(strings, (s) => {
    *   const num = parseInt(s)
-   *   return isNaN(num) ? Option.none() : Option.some(num)
+   *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
    * })
    * console.log(Array.from(numbers)) // [1, 2, 3] (stops at "invalid")
    *
@@ -3331,7 +3332,7 @@ export const filterMapWhile: {
    * const values = [2, 4, 6, 7, 8, 10]
    * const doubledEvens = Iterable.filterMapWhile(
    *   values,
-   *   (n) => n % 2 === 0 ? Option.some(n * 2) : Option.none()
+   *   (n) => n % 2 === 0 ? Result.succeed(n * 2) : Result.failVoid
    * )
    * console.log(Array.from(doubledEvens)) // [4, 8, 12] (stops at 7)
    *
@@ -3339,7 +3340,7 @@ export const filterMapWhile: {
    * const letters = ["a", "b", "c", "d", "e"]
    * const indexedUntilC = Iterable.filterMapWhile(
    *   letters,
-   *   (letter, i) => letter !== "c" ? Option.some(`${i}: ${letter}`) : Option.none()
+   *   (letter, i) => letter !== "c" ? Result.succeed(`${i}: ${letter}`) : Result.failVoid
    * )
    * console.log(Array.from(indexedUntilC)) // ["0: a", "1: b"] (stops at "c")
    * ```
@@ -3347,20 +3348,20 @@ export const filterMapWhile: {
    * @category filtering
    * @since 2.0.0
    */
-  <A, B>(f: (a: A, i: number) => Option<B>): (self: Iterable<A>) => Iterable<B>
+  <A, B, X>(f: Filter.Filter<A, B, X, [i: number]>): (self: Iterable<A>) => Iterable<B>
   /**
-   * Transforms all elements of the `Iterable` for as long as the specified function returns some value
+   * Transforms all elements of the `Iterable` for as long as the specified function succeeds.
    *
    * @example
    * ```ts
    * import { Iterable } from "effect"
-   * import * as Option from "effect/Option"
+   * import * as Result from "effect/Result"
    *
    * // Parse numbers until we hit an invalid one
    * const strings = ["1", "2", "3", "invalid", "4", "5"]
    * const numbers = Iterable.filterMapWhile(strings, (s) => {
    *   const num = parseInt(s)
-   *   return isNaN(num) ? Option.none() : Option.some(num)
+   *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
    * })
    * console.log(Array.from(numbers)) // [1, 2, 3] (stops at "invalid")
    *
@@ -3368,7 +3369,7 @@ export const filterMapWhile: {
    * const values = [2, 4, 6, 7, 8, 10]
    * const doubledEvens = Iterable.filterMapWhile(
    *   values,
-   *   (n) => n % 2 === 0 ? Option.some(n * 2) : Option.none()
+   *   (n) => n % 2 === 0 ? Result.succeed(n * 2) : Result.failVoid
    * )
    * console.log(Array.from(doubledEvens)) // [4, 8, 12] (stops at 7)
    *
@@ -3376,7 +3377,7 @@ export const filterMapWhile: {
    * const letters = ["a", "b", "c", "d", "e"]
    * const indexedUntilC = Iterable.filterMapWhile(
    *   letters,
-   *   (letter, i) => letter !== "c" ? Option.some(`${i}: ${letter}`) : Option.none()
+   *   (letter, i) => letter !== "c" ? Result.succeed(`${i}: ${letter}`) : Result.failVoid
    * )
    * console.log(Array.from(indexedUntilC)) // ["0: a", "1: b"] (stops at "c")
    * ```
@@ -3384,8 +3385,8 @@ export const filterMapWhile: {
    * @category filtering
    * @since 2.0.0
    */
-  <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>) => ({
+  <A, B, X>(self: Iterable<A>, f: Filter.Filter<A, B, X, [i: number]>): Iterable<B>
+} = dual(2, <A, B, X>(self: Iterable<A>, f: Filter.Filter<A, B, X, [i: number]>) => ({
   [Symbol.iterator]() {
     const iterator = self[Symbol.iterator]()
     let i = 0
@@ -3395,9 +3396,9 @@ export const filterMapWhile: {
         if (result.done) {
           return { done: true, value: undefined }
         }
-        const b = f(result.value, i++)
-        if (O.isSome(b)) {
-          return { done: false, value: b.value }
+        const next = f(result.value, i++)
+        if (R.isSuccess(next)) {
+          return { done: false, value: next.success }
         }
         return { done: true, value: undefined }
       }
@@ -3425,7 +3426,25 @@ export const filterMapWhile: {
  * @category filtering
  * @since 2.0.0
  */
-export const getSomes: <A>(self: Iterable<Option<A>>) => Iterable<A> = filterMap(identity)
+export const getSomes = <A>(self: Iterable<Option<A>>): Iterable<A> => {
+  return {
+    [Symbol.iterator]() {
+      const iterator = self[Symbol.iterator]()
+      return {
+        next() {
+          let result = iterator.next()
+          while (!result.done) {
+            if (O.isSome(result.value)) {
+              return { done: false, value: result.value.value }
+            }
+            result = iterator.next()
+          }
+          return { done: true, value: undefined }
+        }
+      }
+    }
+  }
+}
 
 /**
  * Retrieves the `Err` values from an `Iterable` of `Result`s.
@@ -3451,7 +3470,25 @@ export const getSomes: <A>(self: Iterable<Option<A>>) => Iterable<A> = filterMap
  * @category filtering
  * @since 2.0.0
  */
-export const getFailures = <R, L>(self: Iterable<Result<R, L>>): Iterable<L> => filterMap(self, R.getFailure)
+export const getFailures = <R0, L>(self: Iterable<Result<R0, L>>): Iterable<L> => {
+  return {
+    [Symbol.iterator]() {
+      const iterator = self[Symbol.iterator]()
+      return {
+        next() {
+          let result = iterator.next()
+          while (!result.done) {
+            if (R.isFailure(result.value)) {
+              return { done: false, value: result.value.failure }
+            }
+            result = iterator.next()
+          }
+          return { done: true, value: undefined }
+        }
+      }
+    }
+  }
+}
 
 /**
  * Retrieves the `Ok` values from an `Iterable` of `Result`s.
@@ -3477,7 +3514,25 @@ export const getFailures = <R, L>(self: Iterable<Result<R, L>>): Iterable<L> =>
  * @category filtering
  * @since 2.0.0
  */
-export const getSuccesses = <R, L>(self: Iterable<Result<R, L>>): Iterable<R> => filterMap(self, R.getSuccess)
+export const getSuccesses = <R0, L>(self: Iterable<Result<R0, L>>): Iterable<R0> => {
+  return {
+    [Symbol.iterator]() {
+      const iterator = self[Symbol.iterator]()
+      return {
+        next() {
+          let result = iterator.next()
+          while (!result.done) {
+            if (R.isSuccess(result.value)) {
+              return { done: false, value: result.value.success }
+            }
+            result = iterator.next()
+          }
+          return { done: true, value: undefined }
+        }
+      }
+    }
+  }
+}
 
 /**
  * Filters an iterable to only include elements that match a predicate.
@@ -3855,7 +3910,7 @@ export const flatMapNullishOr: {
   <A, B>(self: Iterable<A>, f: (a: A) => B): Iterable<NonNullable<B>> =>
     filterMap(self, (a) => {
       const b = f(a)
-      return b == null ? O.none() : O.some(b)
+      return b == null ? R.failVoid : R.succeed(b)
     })
 )