错误累积

顺序组合器如 Effect.zip、Effect.all 和 Effect.forEach 在错误管理方面采用”快速失败”策略。这意味着它们在遇到第一个错误时会立即停止并返回。

以下是使用 Effect.zip 的示例，它在第一次失败时停止并只显示第一个错误：

示例（使用 Effect.zip 快速失败）

import { Effect, Console } from "effect"

const task1 = Console.log("task1").pipe(Effect.as(1))
const task2 = Effect.fail("Oh uh!").pipe(Effect.as(2))
const task3 = Console.log("task2").pipe(Effect.as(3))
const task4 = Effect.fail("Oh no!").pipe(Effect.as(4))

const program = task1.pipe(
  Effect.zip(task2),
  Effect.zip(task3),
  Effect.zip(task4)
)

Effect.runPromise(program).then(console.log, console.error)
/*
Output:
task1
(FiberFailure) Error: Oh uh!
*/

Effect.forEach 函数的行为类似。它对集合中的每个元素应用有效操作，但在遇到第一个错误时会停止：

示例（使用 Effect.forEach 快速失败）

import { Effect, Console } from "effect"

const program = Effect.forEach([1, 2, 3, 4, 5], (n) => {
  if (n < 4) {
    return Console.log(`item ${n}`).pipe(Effect.as(n))
  } else {
    return Effect.fail(`${n} is not less that 4`)
  }
})

Effect.runPromise(program).then(console.log, console.error)
/*
Output:
item 1
item 2
item 3
(FiberFailure) Error: 4 is not less that 4
*/

但是，在某些情况下，您可能希望收集所有错误而不是快速失败。在这些情况下，您可以使用累积成功和错误的函数。

validate

Effect.validate 函数类似于 Effect.zip，但它在遇到错误后继续组合 Effect，累积成功和失败。

示例（验证和收集错误）

import { Effect, Console } from "effect"

const task1 = Console.log("task1").pipe(Effect.as(1))
const task2 = Effect.fail("Oh uh!").pipe(Effect.as(2))
const task3 = Console.log("task2").pipe(Effect.as(3))
const task4 = Effect.fail("Oh no!").pipe(Effect.as(4))

const program = task1.pipe(
  Effect.validate(task2),
  Effect.validate(task3),
  Effect.validate(task4)
)

Effect.runPromiseExit(program).then(console.log)
/*
Output:
task1
task2
{
  _id: 'Exit',
  _tag: 'Failure',
  cause: {
    _id: 'Cause',
    _tag: 'Sequential',
    left: { _id: 'Cause', _tag: 'Fail', failure: 'Oh uh!' },
    right: { _id: 'Cause', _tag: 'Fail', failure: 'Oh no!' }
  }
}
*/

validateAll

Effect.validateAll 函数类似于 Effect.forEach 函数。它使用提供的有效操作转换集合的所有元素，但它在错误通道中收集所有错误，以及在成功通道中收集成功值。

import { Effect, Console } from "effect"

//      ┌─── Effect<number[], string[], never>
//      ▼
const program = Effect.validateAll([1, 2, 3, 4, 5], (n) => {
  if (n < 4) {
    return Console.log(`item ${n}`).pipe(Effect.as(n))
  } else {
    return Effect.fail(`${n} is not less that 4`)
  }
})

Effect.runPromiseExit(program).then(console.log)
/*
Output:
item 1
item 2
item 3
{
  _id: 'Exit',
  _tag: 'Failure',
  cause: {
    _id: 'Cause',
    _tag: 'Fail',
    failure: [ '4 is not less that 4', '5 is not less that 4' ]
  }
}
*/

成功值的丢失

请注意，此函数是有损的，这意味着如果有任何错误，所有成功值都将丢失。如果您需要保留成功和失败，请考虑使用 Effect.partition。

validateFirst

Effect.validateFirst 函数类似于 Effect.validateAll，但它返回第一个成功的结果，或者如果没有成功则返回所有错误。

示例（返回第一个成功）

import { Effect, Console } from "effect"

//      ┌─── Effect<number, string[], never>
//      ▼
const program = Effect.validateFirst([1, 2, 3, 4, 5], (n) => {
  if (n < 4) {
    return Effect.fail(`${n} is not less that 4`)
  } else {
    return Console.log(`item ${n}`).pipe(Effect.as(n))
  }
})

Effect.runPromise(program).then(console.log, console.error)
/*
Output:
item 4
4
*/

请注意，Effect.validateFirst 返回单个 number 作为成功类型，而不是像 Effect.validateAll 那样返回结果数组。

partition

Effect.partition 函数处理可迭代对象并对每个元素应用有效函数。它返回一个元组，其中第一部分包含所有失败，第二部分包含所有成功。

示例（分区成功和失败）

import { Effect } from "effect"

//      ┌─── Effect<[string[], number[]], never, never>
//      ▼
const program = Effect.partition([0, 1, 2, 3, 4], (n) => {
  if (n % 2 === 0) {
    return Effect.succeed(n)
  } else {
    return Effect.fail(`${n} is not even`)
  }
})

Effect.runPromise(program).then(console.log, console.error)
/*
Output:
[ [ '1 is not even', '3 is not even' ], [ 0, 2, 4 ] ]
*/

此操作符是一个无异常的 Effect，意味着错误通道类型是 never。失败被收集而不停止 Effect，因此整个操作完成并返回错误和成功。