Intermediate

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

interface DatabasePool {
  readonly query: (sql: string) => Effect.Effect<string[], never, never>
  readonly close: () => Effect.Effect<void, never, never>
}

const DatabasePool = Context.GenericTag<DatabasePool>("DatabasePool")

// Layer.scoped: acquire a resource and release it when the scope closes
const DatabasePoolLayer = Layer.scoped(
  DatabasePool,
  Effect.gen(function* () {
    // => This Effect runs when the layer is initialized
    console.log("Opening database connection pool")
    // => Simulates opening a pool of connections

    const pool: DatabasePool = {
      query: (sql) => Effect.succeed([`result: ${sql}`]),
      close: () => Effect.sync(() => console.log("Pool closed")),
    }

    // Effect.addFinalizer: registers cleanup to run when scope closes
    yield* Effect.addFinalizer(() =>
      Effect.sync(() => console.log("Finalizer: closing database pool"))
      // => Runs automatically when the application exits or the scope is released
    )

    return pool
    // => Returns the initialized resource
  }),
)
// => Layer<DatabasePool, never, never> — scoped: lifecycle managed automatically

const program = Effect.gen(function* () {
  const db = yield* DatabasePool
  const rows = yield* db.query("SELECT * FROM users")
  console.log("rows:", rows)
})

// Effect.runPromise with provide handles the scope lifecycle
Effect.runPromise(program.pipe(Effect.provide(DatabasePoolLayer)))
// => Output:
// => Opening database connection pool
// => rows: [ 'result: SELECT * FROM users' ]
// => Finalizer: closing database pool
// => (pool closed automatically after runPromise completes)

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

interface Config { readonly apiKey: string }
interface Logger { readonly log: (msg: string) => void }
interface Cache { readonly get: (k: string) => string | null }
interface Api { readonly call: (endpoint: string) => string }

const Config = Context.GenericTag<Config>("Config")
const Logger = Context.GenericTag<Logger>("Logger")
const Cache = Context.GenericTag<Cache>("Cache")
const Api = Context.GenericTag<Api>("Api")

// Four independent layers — no inter-dependencies here
const ConfigLive = Layer.succeed(Config, { apiKey: "secret-key-123" })
// => Layer<Config, never, never>

const LoggerLive = Layer.succeed(Logger, {
  log: (msg) => console.log(`[LOG] ${msg}`),
})
// => Layer<Logger, never, never>

const CacheLive = Layer.succeed(Cache, {
  get: (k) => k === "user:1" ? "Alice" : null,
})
// => Layer<Cache, never, never>

const ApiLive = Layer.effect(
  Api,
  Effect.gen(function* () {
    const config = yield* Config
    // => Api depends on Config for the API key
    const logger = yield* Logger
    // => Api depends on Logger for request logging
    return {
      call: (endpoint) => {
        logger.log(`Calling ${endpoint} with key ${config.apiKey.slice(0, 3)}...`)
        return `response from ${endpoint}`
      },
    }
  }),
)
// => Layer<Api, never, Config | Logger>

// Layer.mergeAll: combine independent layers in parallel
const BaseLayer = Layer.mergeAll(ConfigLive, LoggerLive, CacheLive)
// => Layer<Config | Logger | Cache, never, never>
// => All three services available in one layer

// Layer.provideMerge: wire ApiLive's dependencies and keep them available
const FullLayer = ApiLive.pipe(Layer.provideMerge(BaseLayer))
// => Layer<Api | Config | Logger | Cache, never, never>
// => ApiLive gets Config and Logger from BaseLayer
// => ALL services remain available to the program

const program = Effect.gen(function* () {
  const api = yield* Api
  const cache = yield* Cache
  // => Both Api and Cache accessible because of provideMerge
  const cached = cache.get("user:1")
  // => cached is "Alice"
  if (!cached) return api.call("/users/1")
  return cached
})

Effect.runSync(program.pipe(Effect.provide(FullLayer)))
// => Returns: "Alice" (cache hit, no API call)

import { Effect, Duration } from "effect"

// Simulate a slow operation (e.g., a database or API call)
const slowOp = (id: number) =>
  Effect.gen(function* () {
    yield* Effect.sleep(Duration.millis(50))
    // => Simulates 50ms of latency
    return `result-${id}`
  })

const ids = [1, 2, 3, 4, 5]

// Sequential: effects run one after another — total time = 5 * 50ms = 250ms
const sequential = Effect.all(ids.map(slowOp))
// => Effect<string[], never, never>
// => Default: { concurrency: 1 }

// Unbounded parallel: all run at once — total time ≈ 50ms
const parallel = Effect.all(ids.map(slowOp), { concurrency: "unbounded" })
// => Launches all 5 effects simultaneously
// => Completes when the last one finishes

// Bounded parallel: at most N run at once — rate limits concurrency
const bounded = Effect.all(ids.map(slowOp), { concurrency: 2 })
// => At most 2 effects running at any given moment
// => Batch 1: ids 1, 2 (50ms)
// => Batch 2: ids 3, 4 (50ms)
// => Batch 3: id 5 (50ms)
// => Total time ≈ 150ms — 3x faster than sequential, controlled pressure

// discard: run effects for side effects, discard results
const withDiscard = Effect.all(ids.map(id =>
  Effect.sync(() => console.log(`processing ${id}`))
), { concurrency: "unbounded", discard: true })
// => Effect<void, never, never> — results discarded, only side effects matter

Effect.runPromise(parallel).then(results => {
  console.log("parallel results:", results)
  // => Output: parallel results: ['result-1', 'result-2', 'result-3', 'result-4', 'result-5']
})

import { Effect, Fiber, Duration } from "effect"

// Effect.fork: starts an effect in a new fiber, returns immediately
// The forked fiber runs concurrently with the current fiber

const task = (name: string, ms: number) =>
  Effect.gen(function* () {
    yield* Effect.sleep(Duration.millis(ms))
    // => Simulates work taking ms milliseconds
    console.log(`${name} completed after ${ms}ms`)
    return `result-${name}`
  })

const program = Effect.gen(function* () {
  console.log("Starting concurrent tasks")

  // Fork two tasks to run concurrently
  const fiber1 = yield* Effect.fork(task("task-A", 100))
  // => fiber1 is Fiber<string, never> — task-A is now running
  // => This line returns immediately — does not wait for task-A

  const fiber2 = yield* Effect.fork(task("task-B", 50))
  // => fiber2 is Fiber<string, never> — task-B is now running
  // => Both task-A and task-B are running concurrently

  console.log("Both tasks forked, doing other work...")
  yield* Effect.sleep(Duration.millis(10))
  // => Simulates doing other work while tasks run concurrently

  // Fiber.join: wait for a fiber to complete and get its result
  const result1 = yield* Fiber.join(fiber1)
  // => result1 is "result-task-A"
  // => Waits for task-A to finish (may already be done)

  const result2 = yield* Fiber.join(fiber2)
  // => result2 is "result-task-B"
  // => task-B finishes first (50ms < 100ms), but we join in order

  console.log("Results:", result1, result2)
  return [result1, result2]
})

Effect.runPromise(program).then(results => console.log("Final:", results))
// => Output:
// => Starting concurrent tasks
// => Both tasks forked, doing other work...
// => task-B completed after 50ms
// => task-A completed after 100ms
// => Results: result-task-A result-task-B
// => Final: ['result-task-A', 'result-task-B']

import { Effect, Fiber, Duration } from "effect"

// A long-running task that cleans up on interruption
const longTask = Effect.gen(function* () {
  yield* Effect.addFinalizer(() =>
    Effect.sync(() => console.log("longTask: cleaning up after interruption"))
    // => Runs when the fiber is interrupted — guaranteed cleanup
  )
  console.log("longTask: started")
  yield* Effect.sleep(Duration.millis(10000))
  // => Sleeps for 10 seconds (will be interrupted before this completes)
  console.log("longTask: completed")
  // => This line never runs because we interrupt the fiber
  return "completed"
})

const program = Effect.gen(function* () {
  const fiber = yield* Effect.fork(longTask)
  // => fiber is running longTask concurrently

  yield* Effect.sleep(Duration.millis(100))
  // => Wait 100ms, then interrupt

  console.log("interrupting fiber...")
  yield* Fiber.interrupt(fiber)
  // => Sends interruption signal to the fiber
  // => fiber's addFinalizer callbacks run before interruption completes
  // => Fiber.interrupt returns Exit.interrupt — the fiber's outcome

  console.log("fiber interrupted")
})

Effect.runPromise(program)
// => Output:
// => longTask: started
// => interrupting fiber...
// => longTask: cleaning up after interruption
// => fiber interrupted

// Structured concurrency: forkScoped ties fiber lifecycle to its scope
const structuredProgram = Effect.scoped(
  Effect.gen(function* () {
    const fiber = yield* Effect.forkScoped(longTask)
    // => fiber is tied to the current scope
    // => When the scope closes, fiber is automatically interrupted
    yield* Effect.sleep(Duration.millis(100))
    // => Scope closes here — fiber interrupted automatically
    return "scope done"
  }),
)

import { Schedule, Duration, Effect } from "effect"

// Schedule.recurs(n): run n additional times after the first attempt
const threeRetries = Schedule.recurs(3)
// => Allows 3 retries (4 total attempts)

// Schedule.spaced(duration): wait duration between each retry
const every500ms = Schedule.spaced(Duration.millis(500))
// => Retries with 500ms gap between each attempt
// => No limit on retries unless composed with recurs

// Schedule.exponential(base): double the delay each time
const backoff = Schedule.exponential(Duration.millis(100))
// => 100ms, 200ms, 400ms, 800ms, 1600ms, ...

// Schedule.fixed(duration): retry at fixed intervals (wall clock)
const everySecond = Schedule.fixed(Duration.seconds(1))
// => Retries at t=0, t=1, t=2, ... seconds (regardless of execution time)

// Compose schedules with pipe
const boundedBackoff = backoff.pipe(
  Schedule.compose(Schedule.recurs(4)),
  // => Exponential backoff, but stop after 4 retries
  // => Delays: 100ms, 200ms, 400ms, 800ms (then stop)
)

// Adding jitter: randomize delays to prevent thundering herd
const jitteredBackoff = Schedule.exponential(Duration.millis(100)).pipe(
  Schedule.jittered,
  // => Applies random jitter to each delay
  // => Prevents all clients retrying at exactly the same moment
  Schedule.compose(Schedule.recurs(5)),
  // => Max 5 retries
)

// Using a schedule with Effect.retry
let count = 0
const flaky = Effect.tryPromise({
  try: async () => {
    count++
    if (count < 3) throw new Error(`attempt ${count} failed`)
    return "success"
  },
  catch: (e) => new Error(`${e}`),
})

Effect.runPromise(
  flaky.pipe(Effect.retry(Schedule.recurs(5)))
).then(r => console.log("result:", r))
// => Output: result: success (after 2 failed attempts)

import { Effect, Schedule, Duration } from "effect"

// Effect.repeat: run the effect repeatedly, collecting results
let iteration = 0
const heartbeat = Effect.sync(() => {
  iteration++
  console.log(`heartbeat ${iteration} at ${Date.now()}`)
  return iteration
})

// repeat with recurs(2): run the effect 3 times total (1 + 2 repeats)
const threeHeartbeats = heartbeat.pipe(
  Effect.repeat(Schedule.recurs(2)),
  // => Runs heartbeat once, then repeats 2 more times
  // => Returns the LAST value emitted by the schedule
)

Effect.runSync(threeHeartbeats)
// => Output:
// => heartbeat 1 at ...
// => heartbeat 2 at ...
// => heartbeat 3 at ...
// => Returns: 2 (the 0-indexed repeat count from Schedule.recurs)

// repeat with spaced: run every N milliseconds (like setInterval)
const pollingTask = Effect.gen(function* () {
  const status = yield* Effect.succeed("healthy")
  // => Simulates checking a service status
  console.log(`status check: ${status}`)
  return status
})

// Poll every 1 second, 5 times total
const polling = pollingTask.pipe(
  Effect.repeat(
    Schedule.spaced(Duration.millis(100)).pipe(
      Schedule.compose(Schedule.recurs(4)),
      // => Wait 100ms between polls, max 4 repeats (5 total)
    )
  ),
)

// Schedule.forever: repeat indefinitely (until interrupted)
const forever = heartbeat.pipe(
  Effect.repeat(Schedule.spaced(Duration.seconds(60))),
  // => Runs every 60 seconds until the fiber is interrupted
  // => Return type: Effect<number, never, never> — runs until interrupted
)

// In practice, repeat with forever is used in long-running services
// The fiber is interrupted when the application shuts down

import { Effect, Ref } from "effect"

// Create a Ref with an initial value
const program = Effect.gen(function* () {
  const counter = yield* Ref.make(0)
  // => counter is Ref<number>, initialized to 0
  // => Ref.make returns Effect<Ref<number>, never, never>

  // Ref.get: read the current value
  const initial = yield* Ref.get(counter)
  console.log("initial:", initial)
  // => Output: initial: 0

  // Ref.set: replace the value
  yield* Ref.set(counter, 42)
  // => Sets counter to 42

  const afterSet = yield* Ref.get(counter)
  console.log("after set:", afterSet)
  // => Output: after set: 42

  // Ref.update: apply a function to the current value atomically
  yield* Ref.update(counter, n => n + 1)
  // => Reads 42, applies (42 + 1), writes 43
  // => The read-modify-write happens atomically

  const afterUpdate = yield* Ref.get(counter)
  console.log("after update:", afterUpdate)
  // => Output: after update: 43

  // Ref.updateAndGet: update and return the new value
  const newValue = yield* Ref.updateAndGet(counter, n => n * 2)
  // => Reads 43, applies (43 * 2), writes 86, returns 86
  console.log("after updateAndGet:", newValue)
  // => Output: after updateAndGet: 86

  // Ref.modify: update and return both old and new values
  const [old, updated] = yield* Ref.modify(counter, n => [n, n + 100])
  // => Returns [current value, new value] — [86, 186]
  console.log("old:", old, "new:", updated)
  // => Output: old: 86 new: 186
})

Effect.runSync(program)

import { Effect, Queue, Fiber, Duration } from "effect"

const program = Effect.gen(function* () {
  // Create a bounded queue with capacity 5
  const queue = yield* Queue.bounded<string>(5)
  // => queue is Queue<string> with max capacity 5
  // => Offering to a full queue suspends the fiber until space is available

  // Producer fiber: offers items to the queue
  const producer = yield* Effect.fork(
    Effect.gen(function* () {
      for (let i = 1; i <= 3; i++) {
        yield* Queue.offer(queue, `item-${i}`)
        // => Offers "item-1", "item-2", "item-3" to the queue
        console.log(`produced: item-${i}`)
        yield* Effect.sleep(Duration.millis(10))
        // => Small delay between productions
      }
      yield* Queue.shutdown(queue)
      // => Signals that no more items will be offered
    })
  )

  // Consumer: takes items from the queue
  // Queue.takeAll: take all available items (non-blocking)
  yield* Effect.sleep(Duration.millis(50))
  // => Wait for producer to add items

  const items = yield* Queue.takeAll(queue)
  // => Takes all currently available items
  console.log("consumed:", Array.from(items))
  // => Output: consumed: ['item-1', 'item-2', 'item-3']

  yield* Fiber.join(producer)
  // => Wait for producer to finish
})

Effect.runPromise(program)
// => Output:
// => produced: item-1
// => produced: item-2
// => produced: item-3
// => consumed: ['item-1', 'item-2', 'item-3']

// Queue.unbounded: no capacity limit — offering never suspends
const unboundedQueue = Queue.unbounded<number>()

// Queue.dropping: drops new items when full (producer never suspends)
const droppingQueue = Queue.dropping<number>(100)
// => At capacity 100, new offers are silently dropped

// Queue.sliding: drops oldest items when full
const slidingQueue = Queue.sliding<number>(100)
// => At capacity 100, oldest item is removed to make room for new one

import { Effect, PubSub, Fiber, Duration } from "effect"

type AppEvent = { type: string; payload: unknown }

const program = Effect.gen(function* () {
  // Create a bounded PubSub
  const pubsub = yield* PubSub.bounded<AppEvent>(16)
  // => PubSub with capacity 16
  // => Each published message is delivered to ALL subscribers

  // Subscribe creates a Queue that receives all published messages
  // Subscriptions must be created before publishing to receive messages
  const sub1Fiber = yield* Effect.fork(
    PubSub.subscribe(pubsub).pipe(
      // => PubSub.subscribe returns a scoped Queue
      Effect.flatMap(sub1 =>
        Effect.gen(function* () {
          const event = yield* Queue.take(sub1)
          // => Waits for the first event
          console.log("subscriber 1 received:", event.type)
        })
      ),
      Effect.scoped,
      // => Scope closes the subscription when done
    )
  )

  const sub2Fiber = yield* Effect.fork(
    PubSub.subscribe(pubsub).pipe(
      Effect.flatMap(sub2 =>
        Effect.gen(function* () {
          const event = yield* Queue.take(sub2)
          console.log("subscriber 2 received:", event.type)
        })
      ),
      Effect.scoped,
    )
  )

  // Give subscribers time to set up
  yield* Effect.sleep(Duration.millis(10))

  // Publish broadcasts to ALL subscribers
  yield* PubSub.publish(pubsub, { type: "UserCreated", payload: { id: "u1" } })
  // => Both sub1 and sub2 receive this event

  yield* Fiber.join(sub1Fiber)
  yield* Fiber.join(sub2Fiber)
})

// Import Queue for take operation
import { Queue } from "effect"

Effect.runPromise(program)
// => Output:
// => subscriber 1 received: UserCreated
// => subscriber 2 received: UserCreated

import { Schema, Effect } from "effect"

// Define a schema for a User
const UserSchema = Schema.Struct({
  id: Schema.String,
  // => id must be a string
  name: Schema.String,
  // => name must be a string
  age: Schema.Number,
  // => age must be a number
  email: Schema.optional(Schema.String),
  // => email is optional — may be absent
})

// Schema.decodeUnknown: parse unknown data and return Effect
const decodeUser = Schema.decodeUnknown(UserSchema)
// => decodeUser: (input: unknown) => Effect<User, ParseError, never>
// => ParseError is thrown when input doesn't match schema

const validInput = { id: "1", name: "Alice", age: 30, email: "alice@example.com" }
const invalidInput = { id: 123, name: "Alice" }
// => id is number instead of string, age is missing

// Decoding valid data succeeds
Effect.runPromise(decodeUser(validInput)).then(user => {
  console.log("decoded:", user)
  // => Output: decoded: { id: '1', name: 'Alice', age: 30, email: 'alice@example.com' }
  // => TypeScript type is { id: string; name: string; age: number; email?: string }
})

// Decoding invalid data fails with ParseError
Effect.runPromise(decodeUser(invalidInput)).catch(e => {
  console.log("decode failed:", e.message)
  // => Output: decode failed: (Encoded side)...Expected string, got number...
  // => ParseError includes detailed path and reason information
})

// Schema.is: type predicate for runtime checks
const isUser = Schema.is(UserSchema)
// => isUser: (input: unknown) => input is User

console.log(isUser(validInput))
// => Output: true

console.log(isUser({ name: 123 }))
// => Output: false

import { Schema, Effect } from "effect"

// Schema.filter adds a custom validation predicate
const PositiveNumber = Schema.Number.pipe(
  Schema.filter(n => n > 0, {
    message: () => "must be a positive number",
    // => Custom error message when the filter fails
  }),
)
// => Schema<number, number, never> — only positive numbers pass

// Schema.transform: convert between encoded and decoded types
// Useful for parsing Date from string, parsing enum from string, etc.
const DateFromString = Schema.transform(
  Schema.String,       // => Encoded type: string (what comes from JSON)
  Schema.DateFromSelf, // => Decoded type: Date (what your code uses)
  {
    decode: (s) => new Date(s),
    // => Converts string -> Date when decoding (parsing input)
    encode: (d) => d.toISOString(),
    // => Converts Date -> string when encoding (serializing output)
  },
)
// => Schema<Date, string, never>
// => decodeUnknown("2026-03-19") -> Date
// => encode(new Date()) -> "2026-03-19T..."

const EventSchema = Schema.Struct({
  id: Schema.String,
  name: Schema.String,
  capacity: PositiveNumber,
  // => Only positive numbers accepted for capacity
  startsAt: DateFromString,
  // => startsAt parsed from string, used as Date in code
})

type Event = typeof EventSchema.Type
// => { id: string; name: string; capacity: number; startsAt: Date }

const input = { id: "e1", name: "Conference", capacity: 500, startsAt: "2026-06-01T09:00:00Z" }

Effect.runPromise(Schema.decodeUnknown(EventSchema)(input)).then(event => {
  console.log("event:", event)
  // => event.startsAt is a Date object
  // => event.capacity is 500 (number, validated > 0)
  console.log("startsAt type:", event.startsAt instanceof Date)
  // => Output: startsAt type: true
})

// Encoding: converts typed data back to serializable form
const encodeEvent = Schema.encode(EventSchema)
const toSerialize: Event = { id: "e1", name: "Conference", capacity: 500, startsAt: new Date("2026-06-01") }

Effect.runPromise(encodeEvent(toSerialize)).then(encoded => {
  console.log("encoded:", encoded)
  // => encoded.startsAt is a string (ISO format), not a Date
  // => Safe to JSON.stringify
})

import { Effect, TestClock, Duration, Ref } from "effect"

// A time-dependent operation: waits 5 seconds then runs
const delayedTask = Effect.gen(function* () {
  yield* Effect.sleep(Duration.seconds(5))
  // => In production: sleeps 5 real seconds
  // => In tests with TestClock: sleeps until clock is advanced past 5 seconds
  return "task completed after 5 seconds"
})

// Test: use TestClock to control time
const test = Effect.gen(function* () {
  // Fork the delayed task — it's suspended waiting for the clock
  const fiber = yield* Effect.fork(delayedTask)
  // => delayedTask is now waiting for 5 seconds to elapse (on the test clock)

  // Advance the test clock by 5 seconds — releases the sleeping effect
  yield* TestClock.adjust(Duration.seconds(5))
  // => All effects sleeping for <= 5 seconds are woken up

  // Now the fiber can complete
  const result = yield* Fiber.join(fiber)
  // => fiber completed because clock was advanced
  console.log("test result:", result)
  // => Output: test result: task completed after 5 seconds
  // => This ran instantly in real time — no actual 5 second wait
})

// Import Fiber
import { Fiber } from "effect"

// Run the test — completes immediately despite the 5 second sleep
Effect.runPromise(test)
// => Completes in milliseconds, not seconds

// TestClock also works for scheduled retries
const retryTest = Effect.gen(function* () {
  let attempts = 0
  const flaky = Effect.gen(function* () {
    attempts++
    if (attempts < 3) {
      return yield* Effect.fail("not ready")
    }
    return "success"
  })

  const fiber = yield* Effect.fork(
    flaky.pipe(
      Effect.retry(
        Schedule.exponential(Duration.seconds(1)).pipe(
          Schedule.compose(Schedule.recurs(5))
        )
      ),
    )
  )

  // Advance clock to trigger retries
  yield* TestClock.adjust(Duration.seconds(10))
  // => Triggers all pending retries up to 10 seconds

  const result = yield* Fiber.join(fiber)
  console.log("result:", result, "attempts:", attempts)
  // => Output: result: success attempts: 3
})

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

// Production service interface and Tag
interface EmailService {
  readonly send: (to: string, subject: string, body: string) => Effect.Effect<void, Error, never>
}

const EmailService = Context.GenericTag<EmailService>("EmailService")

// Production Layer: actually sends emails
const LiveEmailLayer = Layer.succeed(EmailService, {
  send: (to, subject, body) =>
    Effect.tryPromise({
      try: () => fetch("https://api.sendgrid.com/...", { method: "POST" }),
      catch: (e) => new Error(`email send failed: ${e}`),
    }).pipe(Effect.map(() => undefined)),
})

// Test Layer: records sent emails without making network calls
const makeTestEmailLayer = Effect.gen(function* () {
  const sentEmails = yield* Ref.make<Array<{ to: string; subject: string }>>([])
  // => In-memory store for sent emails

  const layer = Layer.succeed(EmailService, {
    send: (to, subject, _body) =>
      Ref.update(sentEmails, emails => [...emails, { to, subject }]),
      // => Records the email in the Ref instead of sending it
  })

  return { layer, sentEmails }
  // => Returns both the layer and a reference to inspect sent emails
})

// Application code using EmailService
const welcomeUser = (userEmail: string) =>
  Effect.gen(function* () {
    const email = yield* EmailService
    yield* email.send(userEmail, "Welcome!", "Welcome to our app")
    console.log(`welcome email queued for ${userEmail}`)
  })

// Test using the test layer
const test = Effect.gen(function* () {
  const { layer, sentEmails } = yield* makeTestEmailLayer

  yield* welcomeUser("alice@example.com").pipe(Effect.provide(layer))
  // => Runs the production function with the test email service

  const emails = yield* Ref.get(sentEmails)
  // => emails contains everything "sent" during the test
  console.log("emails sent:", emails)
  // => Output: emails sent: [{ to: 'alice@example.com', subject: 'Welcome!' }]
  console.log("test passed:", emails.length === 1)
  // => Output: test passed: true
})

Effect.runSync(test)

import { Effect, Layer } from "effect"
import { HttpClient, HttpClientRequest, HttpClientResponse } from "@effect/platform"
import { NodeHttpClient } from "@effect/platform-node"

// Define a type for the API response
interface Post {
  id: number
  title: string
  body: string
  userId: number
}

// Make an HTTP GET request
const fetchPost = (id: number): Effect.Effect<Post, HttpClient.HttpClientError, HttpClient.HttpClient> =>
  HttpClientRequest.get(`https://jsonplaceholder.typicode.com/posts/${id}`).pipe(
    // => Creates a GET request to the JSONPlaceholder API
    HttpClient.execute,
    // => Executes the request using the HttpClient service
    Effect.flatMap(HttpClientResponse.schemaBodyJson(
      // => Parse the JSON response body
      // Schema for the response:
      {
        parse: (u): u is Post => typeof u === "object" && u !== null && "id" in u,
        // => Basic type guard for the post shape
      } as any
    )),
    Effect.scoped,
    // => Scoped: response body stream is cleaned up after use
  )

// Alternative: use HttpClient directly
const fetchWithClient = Effect.gen(function* () {
  const client = yield* HttpClient.HttpClient
  // => Accesses the HttpClient service from context

  const response = yield* client.get("https://jsonplaceholder.typicode.com/posts/1")
  // => Makes the GET request — returns HttpClientResponse

  const body = yield* HttpClientResponse.json(response)
  // => Reads and parses the JSON body

  return body as Post
})
// => Effect<Post, HttpClientError, HttpClient.HttpClient>

// Provide the Node.js HTTP client implementation
const program = fetchWithClient.pipe(
  Effect.provide(NodeHttpClient.layer),
  // => Provides the Node.js implementation of HttpClient
)

Effect.runPromise(program).then(post => {
  console.log("post title:", (post as Post).title)
  // => Output: post title: sunt aut facere repellat provident...
})

import { Effect, Config } from "effect"

// Config primitives: string, number, boolean, secret
const databaseUrl = Config.string("DATABASE_URL")
// => Config<string> — reads DATABASE_URL from environment

const port = Config.number("PORT").pipe(
  Config.withDefault(3000),
  // => Defaults to 3000 if PORT is not set
)
// => Config<number>

const debugMode = Config.boolean("DEBUG").pipe(
  Config.withDefault(false),
  // => Defaults to false if DEBUG is not set
)
// => Config<boolean>

// Config.secret: reads sensitive values — value is redacted in logs
const apiKey = Config.secret("API_KEY")
// => Config<Secret<string>> — Secret prevents accidental logging

// Combine multiple configs into a struct
const AppConfig = Config.all({
  databaseUrl,
  port,
  debugMode,
})
// => Config<{ databaseUrl: string; port: number; debugMode: boolean }>

// Use Config in an Effect program
const program = Effect.gen(function* () {
  const config = yield* AppConfig
  // => config is { databaseUrl: string; port: number; debugMode: boolean }
  // => If DATABASE_URL is missing, Effect fails with ConfigError

  console.log(`Starting server on port ${config.port}`)
  console.log(`Database: ${config.databaseUrl}`)
  console.log(`Debug mode: ${config.debugMode}`)

  if (config.debugMode) {
    yield* Effect.log("Debug logging enabled")
    // => Only logs when debug mode is true
  }
})

// Config.map: transform a config value
const portConfig = Config.number("PORT").pipe(
  Config.withDefault(8080),
  Config.map(p => ({ port: p, host: "0.0.0.0" })),
  // => Transforms number to an address object
)

// Running in a test environment without real env vars
const testConfig = program.pipe(
  Effect.provide(
    Config.mapInputContext(
      () => Effect.succeed({ DATABASE_URL: "postgresql://localhost/test", PORT: "4000", DEBUG: "true" })
    ) as any
  )
)

import { Chunk, Effect } from "effect"

// Creating Chunks
const fromArray = Chunk.fromIterable([1, 2, 3, 4, 5])
// => Chunk<number> containing [1, 2, 3, 4, 5]

const single = Chunk.of("hello")
// => Chunk<string> containing ["hello"]

const empty = Chunk.empty<number>()
// => Chunk<number> — empty chunk

// Appending elements (efficient — O(1) amortized)
const appended = Chunk.append(fromArray, 6)
// => Chunk<number> containing [1, 2, 3, 4, 5, 6]

const prepended = Chunk.prepend(fromArray, 0)
// => Chunk<number> containing [0, 1, 2, 3, 4, 5]

// Concatenating chunks (efficient — O(1))
const concat = Chunk.appendAll(fromArray, Chunk.fromIterable([6, 7, 8]))
// => Chunk<number> containing [1, 2, 3, 4, 5, 6, 7, 8]

// Common collection operations
const doubled = Chunk.map(fromArray, n => n * 2)
// => Chunk<number> containing [2, 4, 6, 8, 10]

const evens = Chunk.filter(fromArray, n => n % 2 === 0)
// => Chunk<number> containing [2, 4]

const first = Chunk.head(fromArray)
// => Option<number> = Option.some(1)

const rest = Chunk.tail(fromArray)
// => Option<Chunk<number>> = Option.some(Chunk[2, 3, 4, 5])

// Converting back to array when needed
const asArray = Chunk.toArray(fromArray)
// => number[] = [1, 2, 3, 4, 5]

// Chunk size
console.log(Chunk.size(fromArray))
// => Output: 5

// Chunk is used internally by Stream for efficient bulk data processing
// When processing large datasets with Stream, results come as Chunks
console.log(Chunk.toArray(doubled))
// => Output: [2, 4, 6, 8, 10]

import { Stream, Effect } from "effect"

// Stream.make: create a finite stream from values
const finite = Stream.make(1, 2, 3, 4, 5)
// => Stream<number, never, never>
// => When run: emits 1, 2, 3, 4, 5, then ends

// Stream.fromIterable: create a stream from any iterable
const fromArray = Stream.fromIterable([10, 20, 30])
// => Stream<number, never, never>

// Stream.range: create a stream of numbers in a range
const range = Stream.range(1, 10)
// => Stream<number, never, never> emitting 1 through 9

// Stream.fromEffect: lift a single Effect into a Stream
const fromEffect = Stream.fromEffect(Effect.succeed(42))
// => Stream<number, never, never> emitting 42 once

// Collecting stream elements into an array
const collected = Stream.runCollect(finite)
// => Effect<Chunk<number>, never, never>
// => When run: returns Chunk[1, 2, 3, 4, 5]

Effect.runPromise(collected).then(chunk => {
  console.log("collected:", Array.from(chunk))
  // => Output: collected: [1, 2, 3, 4, 5]
})

// Stream.runForEach: consume stream elements one by one
const consumed = Stream.runForEach(finite, n =>
  Effect.sync(() => console.log(`processing: ${n}`))
  // => Effect run for each element
)
// => Effect<void, never, never>

Effect.runSync(consumed)
// => Output:
// => processing: 1
// => processing: 2
// => processing: 3
// => processing: 4
// => processing: 5

// Stream.runSum: reduce stream to a sum
const sum = Stream.runSum(range)
Effect.runSync(sum).then
console.log(Effect.runSync(sum))
// => Output: 45 (1+2+...+9)

import { Stream, Effect } from "effect"

// Stream.map: transform each element
const numbers = Stream.range(1, 6)
// => Emits 1, 2, 3, 4, 5

const doubled = numbers.pipe(Stream.map(n => n * 2))
// => Emits 2, 4, 6, 8, 10

// Stream.filter: keep only matching elements
const evens = numbers.pipe(Stream.filter(n => n % 2 === 0))
// => Emits 2, 4

// Chaining transformations
const pipeline = Stream.range(1, 11).pipe(
  Stream.filter(n => n % 2 === 0),
  // => Keep only even numbers: 2, 4, 6, 8, 10
  Stream.map(n => n * n),
  // => Square each: 4, 16, 36, 64, 100
  Stream.take(3),
  // => Take only the first 3: 4, 16, 36
)

Effect.runPromise(Stream.runCollect(pipeline)).then(chunk => {
  console.log("pipeline result:", Array.from(chunk))
  // => Output: pipeline result: [4, 16, 36]
})

// Stream.flatMap: each element becomes a sub-stream
const sentences = Stream.make("hello world", "foo bar baz")
const words = sentences.pipe(
  Stream.flatMap(sentence =>
    Stream.fromIterable(sentence.split(" "))
    // => Each sentence becomes a stream of words
  ),
)
// => Emits "hello", "world", "foo", "bar", "baz"

Effect.runPromise(Stream.runCollect(words)).then(chunk => {
  console.log("words:", Array.from(chunk))
  // => Output: words: ['hello', 'world', 'foo', 'bar', 'baz']
})

// Stream.mapEffect: run an Effect for each element
const processedItems = Stream.make("a", "b", "c").pipe(
  Stream.mapEffect(item =>
    Effect.sync(() => {
      console.log(`processing: ${item}`)
      return item.toUpperCase()
      // => Each element is processed with an Effect
    })
  ),
)

Effect.runSync(Stream.runCollect(processedItems))
// => Output:
// => processing: a
// => processing: b
// => processing: c

import { Stream, Effect, Duration } from "effect"

// Stream.merge: interleave two streams (emit elements as they arrive)
const slow = Stream.make("slow-1", "slow-2").pipe(
  Stream.mapEffect(s => Effect.sleep(Duration.millis(100)).pipe(Effect.as(s)))
  // => Each element takes 100ms to produce
)

const fast = Stream.make("fast-1", "fast-2", "fast-3").pipe(
  Stream.mapEffect(s => Effect.sleep(Duration.millis(30)).pipe(Effect.as(s)))
  // => Each element takes 30ms to produce
)

const merged = Stream.merge(fast, slow)
// => Elements from both streams, in arrival order
// => fast-1, fast-2, fast-3 arrive before slow-1, slow-2 due to timing

Effect.runPromise(Stream.runCollect(merged)).then(chunk => {
  console.log("merged:", Array.from(chunk))
  // => Output (order may vary by timing):
  // => merged: ['fast-1', 'fast-2', 'fast-3', 'slow-1', 'slow-2']
})

// Stream.zip: combine two streams element by element into tuples
const names = Stream.make("Alice", "Bob", "Carol")
const scores = Stream.make(95, 87, 92)

const paired = Stream.zip(names, scores)
// => Stream<[string, number], never, never>
// => Emits ["Alice", 95], ["Bob", 87], ["Carol", 92]
// => Stops when the shorter stream ends

Effect.runPromise(Stream.runCollect(paired)).then(chunk => {
  Array.from(chunk).forEach(([name, score]) => {
    console.log(`${name}: ${score}`)
    // => Output:
    // => Alice: 95
    // => Bob: 87
    // => Carol: 92
  })
})

// Stream.zipWith: zip and transform the pairs simultaneously
const combined = Stream.zipWith(names, scores, (name, score) => ({ name, score }))
// => Stream<{ name: string; score: number }, never, never>

import { Effect, Data } from "effect"

class HttpError extends Data.TaggedError("HttpError")<{
  readonly status: number
  readonly message: string
}> {}

const fetchResource = (url: string): Effect.Effect<string, HttpError, never> => {
  if (url.includes("404")) {
    return Effect.fail(new HttpError({ status: 404, message: "not found" }))
  }
  if (url.includes("500")) {
    return Effect.fail(new HttpError({ status: 500, message: "server error" }))
  }
  return Effect.succeed(`content from ${url}`)
}

// catchIf: catch errors matching a predicate
const with404Fallback = fetchResource("http://example.com/404").pipe(
  Effect.catchIf(
    (e) => e.status === 404,
    // => Predicate: only catch 404 errors
    (_e) => Effect.succeed("default content for missing resource"),
    // => Fallback when predicate matches
  ),
)
// => 404 errors produce "default content"
// => 500 errors still propagate — not caught

Effect.runSync(with404Fallback).toString
console.log(Effect.runSync(with404Fallback))
// => Output: default content for missing resource

// orElse: provide a complete alternative Effect when the original fails
const primary = fetchResource("http://primary.com/500")
const fallback = fetchResource("http://fallback.com/data")
// => Simulates a fallback to a secondary service

const withFallback = primary.pipe(
  Effect.orElse(() => fallback),
  // => If primary fails for any reason, run fallback
  // => fallback runs only when primary fails
)
// => Effect<string, HttpError, never>

Effect.runSync(withFallback)
// => primary fails (500), fallback succeeds
// => Returns: "content from http://fallback.com/data"

// orElseSucceed: replace any failure with a success value
const withDefault = fetchResource("http://broken.com/500").pipe(
  Effect.orElseSucceed(() => "fallback data"),
  // => Any failure becomes this success value
)
// => Effect<string, never, never> — cannot fail after orElseSucceed

import { Effect, Either } from "effect"

// validateAll: run effects over a list, collecting ALL errors
const validateAge = (age: number): Effect.Effect<number, string, never> => {
  if (age < 0) return Effect.fail(`age ${age} is negative`)
  if (age > 150) return Effect.fail(`age ${age} is unrealistically large`)
  return Effect.succeed(age)
}

const ages = [25, -1, 30, 200, 45]
// => Mix of valid and invalid ages

const validated = Effect.validateAll(ages, validateAge)
// => Effect<number[], string[], never>
// => If ANY fail: fails with an ARRAY of all errors (not just the first)
// => Unlike Effect.all (fails on first error), validateAll collects all errors

Effect.runSyncExit(validated).pipe
const exit = Effect.runSyncExit(validated)
if (exit._tag === "Failure") {
  console.log("validation errors:", exit.cause)
  // => Contains all errors: ["-1 is negative", "200 is unrealistically large"]
}

// partition: split successes and failures, always succeeds
const partitioned = Effect.partition(ages, validateAge)
// => Effect<[errors: string[], successes: number[]], never, never>
// => NEVER fails — always returns both lists

Effect.runPromise(partitioned).then(([errors, successes]) => {
  console.log("errors:", errors)
  // => Output: errors: ['age -1 is negative', 'age 200 is unrealistically large']
  console.log("successes:", successes)
  // => Output: successes: [25, 30, 45]
  // => Valid ages are processed; invalid ages are reported; both are available
})

// Collecting Either: convert each failure to Either without failing the whole Effect
const asEithers = Effect.all(ages.map(age =>
  validateAge(age).pipe(Effect.either)
  // => Effect.either: converts Effect<A, E> to Effect<Either<A, E>, never>
  // => Never fails — wraps the result
))

Effect.runPromise(asEithers).then(eithers => {
  const valid = eithers.filter(Either.isRight).map(e => e.right)
  const invalid = eithers.filter(Either.isLeft).map(e => e.left)
  console.log("valid:", valid, "invalid:", invalid)
  // => Output: valid: [25, 30, 45] invalid: ['age -1 is negative', 'age 200 is unrealistically large']
})