概念：Effect 是一个值

import { Effect } from "effect"

// Promise：构造的那一刻，函数体就运行了
const p = new Promise<number>((resolve) => {
  console.log("A: Promise 体立刻执行")
  resolve(42)
})

// Effect：只是一个描述。下面这行不会打印任何东西。
const program = Effect.sync(() => {
  console.log("B: 只有 run 时才执行")
  return 42
})

console.log("--- 到这里，只有 A 打印过，B 还没有 ---")

// 现在才执行 program
const result = Effect.runSync(program) // 此刻打印 "B: ..."
console.log("result =", result)        // 42

A: Promise 体立刻执行
--- 到这里，只有 A 打印过，B 还没有 ---
B: 只有 run 时才执行
result = 42

import { Effect } from "effect"

const a = Effect.succeed(42)
//    a: Effect<number, never, never>   成功 number；不会失败；无依赖

const b = Effect.fail(new Error("boom"))
//    b: Effect<never, Error, never>    永不成功；以 Error 失败；无依赖

// 只有 E=never 且 R=never 的 effect，才能用 runSync 直接同步求值
const value: number = Effect.runSync(a) // 42

import { Effect } from "effect"

Effect.succeed(42)                 // Effect<number>        已有的值
Effect.fail(new Error("boom"))     // Effect<never, Error>  已知的失败

Effect.sync(() => Date.now())      // 包裹"不会抛"的同步副作用
Effect.try(() => JSON.parse(raw))  // 包裹"可能抛"的同步调用，抛出进入 E 通道

// 包裹会 reject 的 Promise；catch 把 reject 转成类型化错误
Effect.tryPromise({
  try: () => fetch("https://api.example/ping"),
  catch: (cause) => new Error(`network: ${String(cause)}`),
})

import { Effect } from "effect"

const program = Effect.succeed(21).pipe(Effect.map((n) => n * 2))

Effect.runSync(program)            // 42      同步求值；effect 异步或会失败则抛
await Effect.runPromise(program)   // 42      → Promise<A>，失败则 reject
const fiber = Effect.runFork(program)        // 在后台 fiber 跑，返回 Fiber
const exit = await Effect.runPromiseExit(program)
//    exit: Exit<number, never>    成功/失败都不 reject，结果装在 Exit 里

import { Effect } from "effect"

// pipe 风格：数据从上往下流过一串算子
const withPipe = Effect.succeed(2).pipe(
  Effect.map((n) => n + 1),
  Effect.flatMap((n) => Effect.succeed(n * 10)),
)

// gen 风格：yield* 取出每一步的结果，像顺序代码
const withGen = Effect.gen(function* () {
  const n = yield* Effect.succeed(2)
  const m = yield* Effect.succeed(n + 1)
  return m * 10
})

// 两者等价：都是 Effect<number>，runSync 都得到 30
Effect.runSync(withPipe) // 30
Effect.runSync(withGen)  // 30

import { Effect, Data } from "effect"

// 定义一个带 _tag: "HttpError" 的标签错误
class HttpError extends Data.TaggedError("HttpError")<{
  readonly status: number
}> {}

const fetchUser = (id: number) =>
  Effect.gen(function* () {
    if (id < 0) {
      return yield* Effect.fail(new HttpError({ status: 400 }))
    }
    return { id, name: "Ada" }
  })
// fetchUser(id): Effect<{ id: number; name: string }, HttpError>

const safe = fetchUser(-1).pipe(
  Effect.catchTag("HttpError", (e) =>
    Effect.succeed({ id: 0, name: `fallback(${e.status})` }),
  ),
)
// safe: Effect<{ id; name }, never>  —— HttpError 被处理掉，E 变回 never

Effect.runSync(safe) // { id: 0, name: "fallback(400)" }

import { Effect, Context, Layer } from "effect"

// 1. 声明服务：类名同时是"类型"和"运行时的键"
class Clock extends Context.Tag("app/Clock")<
  Clock,
  { readonly now: Effect.Effect<number> }
>() {}

// 2. 业务代码 yield* 这个 Tag —— 依赖被记进 R 通道
const program = Effect.gen(function* () {
  const clock = yield* Clock        // 取出 Clock 的实现
  const t = yield* clock.now
  return `now = ${t}`
})
// program: Effect<string, never, Clock>   注意 R = Clock

// 3. 提供实现
const ClockLive = Layer.succeed(Clock, { now: Effect.succeed(1_717_000_000_000) })

// 4. provide 把 R 从 Clock 消成 never —— 之后才能 run
const runnable = program.pipe(Effect.provide(ClockLive))
// runnable: Effect<string, never, never>

Effect.runSync(runnable) // "now = 1717000000000"

import { Effect, Fiber } from "effect"

const slow = Effect.succeed("done").pipe(Effect.delay("1 second"))

const program = Effect.gen(function* () {
  const fiber = yield* Effect.fork(slow) // 派生 fiber，立即返回，不等待
  yield* Effect.log("fiber 已在后台运行")
  const result = yield* Fiber.join(fiber) // 需要结果时再等
  return result
})

Effect.runPromise(program) // 约 1 秒后得到 "done"