Effect TS

// --- The question: could a user cause this error? ---

// YES → Effect.fail (expected, in the type)
const findUser = (id: string) =>
  id === "0"
    ? Effect.fail(new UserNotFound({ id }))
    : Effect.succeed({ id, name: "Alice" })
// Type: Effect<User, UserNotFound, never>
// A missing user is normal — the caller should handle it

// NO → Effect.die (defect, NOT in the type)
// A switch that should be exhaustive hitting default:
type Status = "active" | "inactive"
const label = (s: Status) => {
  switch (s) {
    case "active": return Effect.succeed("Active")
    case "inactive": return Effect.succeed("Inactive")
    default: return Effect.die(`Unhandled status: ${s}`)
    // If this runs, a developer forgot to add a case.
    // No user action or retry can fix this.
  }
}
// Type: Effect<string, never, never>

// More defect examples:
// - Required env var missing at startup → die (deployment is broken)
// - JSON.parse fails on data YOU generated → die (your code is wrong)
// - Array access after you just checked length → die (logic bug)

// More expected error examples:
// - API returns 404 → fail (normal, show "not found" to user)
// - User submits invalid email → fail (validate and show message)
// - Network timeout → fail (retry or show error to user)

// --- Setup: tagged error classes + a function that can fail ---
class NotFound { readonly _tag = "NotFound" as const; constructor(readonly id: string) {} }
class Forbidden { readonly _tag = "Forbidden" as const }

const getResource = (id: string) => {
  if (id === "missing") return Effect.fail(new NotFound(id))
  if (id === "secret") return Effect.fail(new Forbidden())
  return Effect.succeed({ id, name: "Resource" })
}
// Type: Effect<Resource, NotFound | Forbidden, never>

// --- catchTag: handle ONE specific error ---
const withFallback = getResource("missing").pipe(
  Effect.catchTag("NotFound", ({ id }) =>
    Effect.succeed({ id, name: "Default" })
  )
)
// Type: Effect<Resource, Forbidden, never>
// NotFound is gone from the type! Forbidden still needs handling.

// --- catchTags: handle MULTIPLE errors at once ---
const withAllHandled = getResource("missing").pipe(
  Effect.catchTags({
    NotFound: ({ id }) => Effect.succeed({ id, name: "Default" }),
    Forbidden: () => Effect.succeed({ id: "0", name: "Guest" }),
  })
)
// Type: Effect<Resource, never, never>
// All errors handled — no E left.

// --- catchAll: handle ALL expected errors (any tag) ---
const withCatchAll = getResource("missing").pipe(
  Effect.catchAll((error) =>
    Effect.succeed({ id: "0", name: `Fallback (${error._tag})` })
  )
)
// Type: Effect<Resource, never, never>

// --- mapError: transform without handling ---
class AppError { readonly _tag = "AppError" as const; constructor(readonly cause: unknown) {} }

const withWrapped = getResource("missing").pipe(
  Effect.mapError((e) => new AppError(e))
)
// Type: Effect<Resource, AppError, never>
// Error is still there, just wrapped. Caller still must handle it.

// --- orElse: swap to a completely different Effect ---
const withOrElse = getResource("missing").pipe(
  Effect.orElse(() => Effect.succeed({ id: "0", name: "Fallback" }))
)
// Type: Effect<Resource, never, never>

async function fetchWithRetry(url: string) {
  for (let i = 0; i < 3; i++) {
    try {
      const controller = new AbortController()
      const id = setTimeout(() => controller.abort(), 5000)
      const res = await fetch(url, { signal: controller.signal })
      clearTimeout(id)
      return await res.json()
    } catch (e) {
      if (i === 2) throw e
      await new Promise((r) => setTimeout(r, 1000 * 2 ** i))
    }
  }
}
// 15 lines. Manual loop, manual backoff, manual abort.
// Want to change the strategy? Rewrite the whole function.

// --- Effect.retry: retry on failure ---
// Simplest: retry up to 3 times
const retried = fetchData.pipe(
  Effect.retry({ times: 3 })
)

// With a Schedule: exponential backoff, max 3 attempts
const withBackoff = fetchData.pipe(
  Effect.retry(
    Schedule.exponential("1 second").pipe(
      Schedule.compose(Schedule.recurs(3))
    )
  )
)
// Waits 1s, 2s, 4s between retries

// Fixed delay between retries
const withFixed = fetchData.pipe(
  Effect.retry(Schedule.fixed("500 millis"))
)

// --- Effect.timeout: fail if too slow ---
const withTimeout = fetchData.pipe(
  Effect.timeout("5 seconds")
)
// Type adds TimeoutException to the E channel automatically

// --- Effect.timeoutFail: custom error on timeout ---
class MyTimeout { readonly _tag = "MyTimeout" as const }

const withCustomTimeout = fetchData.pipe(
  Effect.timeoutFail({
    duration: "5 seconds",
    onTimeout: () => new MyTimeout()
  })
)
// Type: Effect<Data, OriginalError | MyTimeout, never>

// --- Composing them together ---
const resilient = fetchData.pipe(
  Effect.timeout("5 seconds"),
  Effect.retry({ times: 3 }),
  Effect.catchTag("TimeoutException", () =>
    Effect.succeed(cachedData)
  )
)
// timeout each attempt, retry up to 3 times, fallback on timeout

class NotFound extends Data.TaggedError("NotFound")<{
  readonly id: string
}> {}

const getUser = (id: string) => Effect.gen(function* () {
  const user = yield* findUser(id)
  if (!user) yield* new NotFound({ id }) // type-safe "throw"
  return user
})
// Type: Effect<User, NotFound, Database>