Effect TS

// TypeScript: manual mocking with jest/vitest
import { describe, it, expect, vi } from "vitest"

// You mock modules, not interfaces — fragile and implicit
vi.mock("./email-service", () => ({
  sendEmail: vi.fn().mockResolvedValue(true)
}))
// If the module path changes, the mock silently breaks.
// No type safety — mock can return wrong shape.

describe("notifications", () => {
  it("sends email", async () => {
    const { sendEmail } = await import("./email-service")
    await sendEmail("user@test.com", "Hello!")
    expect(sendEmail).toHaveBeenCalledWith("user@test.com", "Hello!")
  })

  // Time testing: fake timers are global and brittle
  it("schedules work", () => {
    vi.useFakeTimers()
    setTimeout(() => { /* ... */ }, 60_000)
    vi.advanceTimersByTime(60_000)
    vi.useRealTimers() // Don't forget to restore!
  })
})

import { Effect, Layer, TestClock, Fiber, TestContext } from "effect"
import { describe, it, expect } from "vitest"

// 1. Define a service interface
class EmailService extends Effect.Tag("EmailService")<
  EmailService,
  { readonly send: (to: string, body: string) => Effect.Effect<void> }
>() {}

// 2. Test layer — no emails actually sent
const TestEmailService = Layer.succeed(EmailService, {
  send: (_to, _body) => Effect.void
})

describe("notifications", () => {
  // 3. Test with mock deps — just provide the test layer
  it("sends email", async () => {
    const program = Effect.gen(function* () {
      const email = yield* EmailService
      yield* email.send("user@test.com", "Hello!")
      return "sent"
    }).pipe(Effect.provide(TestEmailService))

    const result = await Effect.runPromise(program)
    expect(result).toBe("sent")
  })

  // 4. TestClock: fork → adjust → join
  it("handles scheduled work", async () => {
    const program = Effect.gen(function* () {
      const fiber = yield* Effect.sleep("5 minutes").pipe(
        Effect.as("done"),
        Effect.fork
      )
      yield* TestClock.adjust("5 minutes")
      return yield* Fiber.join(fiber)
    }).pipe(Effect.provide(TestContext.TestContext))

    const result = await Effect.runPromise(program)
    expect(result).toBe("done")
  })
})

// TypeScript: discriminated unions are manual work
type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "rect"; width: number; height: number }

// You write the switch yourself — no exhaustiveness help
function area(s: Shape): number {
  switch (s.kind) {
    case "circle": return Math.PI * s.radius ** 2
    case "rect": return s.width * s.height
    // Forgot a case? TS won't warn you by default.
  }
}

// Branded types? You fake them with intersections:
type UserId = string & { readonly __brand: "UserId" }
// No constructor, no validation — just casting everywhere

import { Data, Brand, pipe, Effect } from "effect"

// --- Dual APIs ---
// Data-first (direct call):
const doubled = Effect.map(Effect.succeed(21), (n) => n * 2)
// Data-last (pipe-friendly):
const doubled2 = Effect.succeed(21).pipe(Effect.map((n) => n * 2))

// --- pipe() = Unix pipes for code ---
const result = pipe(
  "  hello world  ",
  (s) => s.trim(),
  (s) => s.toUpperCase(),
  (s) => s.split(" ")
) // ["HELLO", "WORLD"]

// --- Branded types ---
type UserId = string & Brand.Brand<"UserId">
const UserId = Brand.nominal<UserId>()
// UserId("abc") ✅   "abc" as UserId ❌ (bypasses constructor)

// --- TaggedEnum with $is and $match ---
type RemoteData = Data.TaggedEnum<{
  Loading: {}
  Success: { readonly data: string }
  Failure: { readonly reason: string }
}>
const { Loading, Success, Failure, $is, $match } =
  Data.taggedEnum<RemoteData>()

const isLoading = $is("Loading")
isLoading(Loading()) // true

const describe = $match({
  Loading: () => "Loading...",
  Success: ({ data }) => `Got: ${data}`,
  Failure: ({ reason }) => `Error: ${reason}`,
})
describe(Success({ data: "hello" })) // "Got: hello"