Effect TS

grep -n "^export declare const retry:" node_modules/effect/dist/Effect.d.ts
grep -rn "Schedule.while" .agent-sources/effect/ai-docs/src

import { Effect, Schema } from "effect"

export class SomeError extends Schema.TaggedError<SomeError>()("SomeError", {
  message: Schema.String
}) {}

export const effectFunction = Effect.fn("effectFunction")(
  function*(n: number): Effect.fn.Return<string, SomeError> {
    yield* Effect.logInfo("Received number:", n)
    // Always `return yield*` when raising so TypeScript knows the function stops.
    return yield* new SomeError({ message: "Failed" })
  },
  // Extra arguments add combinators. Do not `.pipe` the result of Effect.fn.
  Effect.catch((error) => Effect.logError(`An error occurred: ${error}`)),
  Effect.annotateLogs({ method: "effectFunction" })
)

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

export class DatabaseError extends Schema.TaggedError<DatabaseError>()("DatabaseError", {
  cause: Schema.Defect()
}) {}

export class Database extends Context.Service<Database, {
  query(sql: string): Effect.Effect<Array<unknown>, DatabaseError>
}>()("myapp/db/Database") {
  static readonly layer = Layer.effect(
    Database,
    Effect.gen(function*() {
      const query = Effect.fn("Database.query")(function*(sql: string) {
        yield* Effect.log("Executing SQL query:", sql)
        return [{ id: 1, name: "Alice" }]
      })
      return Database.of({ query })
    })
  )
}

export type DatabaseService = Database["Service"]

import { Match, Schema } from "effect"

const UserId = Schema.String.pipe(Schema.brand("UserId"))
type UserId = typeof UserId.Type

export class User extends Schema.Class<User>("app/User")({
  id: UserId,
  name: Schema.NonEmptyString,
  role: Schema.Literals(["admin", "member"])
}) {
  get label() { return `${this.name} (${this.role})` }
}

class Success extends Schema.TaggedClass<Success>()("Success", { value: Schema.Number }) {}
class Failure extends Schema.TaggedClass<Failure>()("Failure", { error: Schema.String }) {}
const Result = Schema.Union([Success, Failure])
type Result = typeof Result.Type

const render = (r: Result) => Match.valueTags(r, {
  Success: ({ value }) => `Got: ${value}`,
  Failure: ({ error }) => `Error: ${error}`
})

export const decodeUser = Schema.decodeUnknownEffect(User)

import { Effect, Schema } from "effect"

export class ParseError extends Schema.TaggedError<ParseError>()("ParseError", {
  input: Schema.String
}) {}
export class ReservedPortError extends Schema.TaggedError<ReservedPortError>()("ReservedPortError", {
  port: Schema.Int
}) {}

declare const loadPort: (input: string) => Effect.Effect<number, ParseError | ReservedPortError>

export const recovered = loadPort("80").pipe(
  Effect.catchTag(["ParseError", "ReservedPortError"], () => Effect.succeed(3000))
)

export const fallback = loadPort("x").pipe(
  Effect.catchTag("ReservedPortError", () => Effect.succeed(3000)),
  Effect.catch(() => Effect.succeed(3000))
)

const appLayer = UserService.layer.pipe(
  Layer.provideMerge(Database.layer),
  Layer.provideMerge(Logger.layer)
)
Effect.runPromise(program.pipe(Effect.provide(appLayer)))

import { Effect, Schedule } from "effect"

// Capped exponential backoff with jitter, only while the error is retryable.
export const productionRetry = Schedule.min([
  Schedule.exponential("250 millis"),
  Schedule.spaced("10 seconds")
]).pipe(
  Schedule.jittered,
  Schedule.setInputType<HttpError>(),
  Schedule.while(({ input }) => input.retryable)
)

export const loadUser = fetchUserProfile("u1").pipe(
  Effect.retry(productionRetry),
  Effect.timeout("30 seconds")
)

// Or the options form: schedule + attempt cap + predicate in one place.
export const loadUser2 = fetchUserProfile("u1").pipe(
  Effect.retry({ schedule: Schedule.exponential("1 second"), times: 5, while: (e) => e.retryable })
)

// Attempt cap: Schedule.max continues only while all inputs continue.
export const sixAttempts = Schedule.max([Schedule.exponential("250 millis"), Schedule.recurs(6)])

// Polling: repeat a successful effect on a cadence.
export const poll = healthCheck.pipe(Effect.repeat(Schedule.spaced("1 second")))