@dojocho/effect-ts 0.0.1

package/katas/008-error-patterns/solution.ts

@@ -0,0 +1,38 @@
+import { Data, Effect } from "effect";
+
+export class NetworkError extends Data.TaggedError("NetworkError")<{
+  readonly url: string;
+}> {}
+
+export class TimeoutError extends Data.TaggedError("TimeoutError")<{
+  readonly ms: number;
+}> {}
+
+export class AuthError extends Data.TaggedError("AuthError")<{
+  readonly reason: string;
+}> {}
+
+/** Use Effect.catchTags to handle each error type differently:
+ * NetworkError → "network error: {url}"
+ * TimeoutError → "timeout after {ms}ms"
+ * AuthError → "auth failed: {reason}" */
+export const handleAllErrors = (
+  effect: Effect.Effect<string, NetworkError | TimeoutError | AuthError>,
+): Effect.Effect<string> => {
+  throw new Error("Not implemented");
+};
+
+/** Use Effect.orElse to try the primary effect, and if it fails, run the fallback */
+export const withFallback = (
+  primary: Effect.Effect<string, string>,
+  fallback: Effect.Effect<string, string>,
+): Effect.Effect<string, string> => {
+  throw new Error("Not implemented");
+};
+
+/** Use Effect.match to return "ok: {value}" on success or "err: {error}" on failure */
+export const toResult = (
+  effect: Effect.Effect<string, string>,
+): Effect.Effect<string> => {
+  throw new Error("Not implemented");
+};

package/katas/009-option-type/SENSEI.md

@@ -0,0 +1,96 @@
+# SENSEI — 009 Option Type
+
+## Briefing
+
+### Goal
+
+Work with the Option type to safely represent values that may or may not exist.
+
+### Tasks
+
+1. Implement `fromNullable` — convert a nullable value to an Option
+2. Implement `describe` — use `Option.match` to return "Found: {value}" or "Nothing"
+3. Implement `doubleOption` — use `Option.map` to double the number inside an Option
+4. Implement `safeDivide` — use `Option.flatMap` to divide safely (None if divisor is 0)
+5. Implement `getOrDefault` — use `Option.getOrElse` to extract value or return a default
+
+### Hints
+
+```ts
+import { Option } from "effect";
+
+// Create Options
+const some = Option.some(42);
+const none = Option.none();
+
+// fromNullable
+const opt = Option.fromNullable(null); // None
+const opt2 = Option.fromNullable(42); // Some(42)
+
+// match
+const result = Option.match(opt, {
+  onNone: () => "nothing",
+  onSome: (v) => `found: ${v}`,
+});
+
+// map and flatMap
+const doubled = Option.map(some, (n) => n * 2);
+const chained = Option.flatMap(some, (n) =>
+  n > 0 ? Option.some(n) : Option.none()
+);
+
+// getOrElse
+const value = Option.getOrElse(none, () => 0);
+```
+
+## Prerequisites
+
+- **001-005 Basics** — `Effect.succeed`, `Effect.map`, `pipe`, `Effect.gen`, `Effect.flatMap`
+- **006-008 Error Handling** — `Effect.fail`, `catchAll`, `catchTag`, `catchTags`, `match`
+
+## Skills
+
+Invoke `effect-patterns-value-handling` before teaching this kata.
+
+## Test Map
+
+| Test | Concept | Verifies |
+|------|---------|----------|
+| `fromNullable converts value to Some` | `Option.fromNullable` | Non-null value wrapped in Some |
+| `fromNullable converts null to None` | `Option.fromNullable` | Null becomes None |
+| `fromNullable converts undefined to None` | `Option.fromNullable` | Undefined becomes None |
+| `describe returns 'Found: hello' for Some` | `Option.match` | Pattern matching on Some |
+| `describe returns 'Nothing' for None` | `Option.match` | Pattern matching on None |
+| `doubleOption doubles Some(5) to Some(10)` | `Option.map` | Transform inside Some |
+| `doubleOption returns None for None` | `Option.map` | None passes through unchanged |
+| `safeDivide(10, 2) returns Some(5)` | `Option.some` + `Option.flatMap` | Division succeeds — Some result |
+| `safeDivide(10, 0) returns None` | `Option.none` | Division by zero — None result |
+| `getOrDefault extracts Some value` | `Option.getOrElse` | Unwrap when value exists |
+| `getOrDefault returns default for None` | `Option.getOrElse` | Fallback when value is absent |
+
+## Teaching Approach
+
+### Socratic prompts
+
+- "What's the difference between `null` and `Option.none()`? Why bother wrapping it?"
+- "You used `Effect.map` to transform Effects. `Option.map` works the same way. What does it do when the Option is None?"
+- "How is `Option.flatMap` different from `Option.map`? When would your callback need to return an Option?"
+- "In `safeDivide`, the result is `Option<number>`, not `Effect<number, DivisionByZero>`. When would you choose Option over Effect with an error?"
+
+### Common pitfalls
+
+1. **Confusing Option.flatMap with Effect.flatMap** — they work the same way but on different types. Option.flatMap takes `A => Option<B>`, Effect.flatMap takes `A => Effect<B, E, R>`. Ask: "Are you working with an Option or an Effect here?"
+2. **Using if/else instead of Option.match** — students may extract the value manually. Nudge: "Option.match handles both cases in one expression — what does it look like?"
+3. **fromNullable with falsy values** — `Option.fromNullable(0)` returns `Some(0)`, not `None`. Only `null` and `undefined` produce None. Ask: "Is `0` the same as `null`?"
+4. **Returning raw values from map** — `Option.map(opt, (n) => n * 2)` is correct. Students sometimes try to wrap the result in `Option.some` inside the callback. Ask: "What does `map` do with your callback's return value?"
+5. **Start with `fromNullable`** — just pass the value to `Option.fromNullable` and return the result; it's the simplest function here.
+
+## On Completion
+
+### Insight
+
+Option is for "might not exist" — different from errors. Use Option when absence is a normal case (e.g., looking up a key in a map), not an error condition. Notice how Option has the same vocabulary as Effect: `map`, `flatMap`, `match`. This isn't a coincidence — Effect's design reuses these patterns across types so that once you learn them, they transfer everywhere.
+
+### Bridge
+
+Option handles missing values. Kata 010 introduces `Either` for pure validation results (no effects needed) and `Exit` for inspecting effect outcomes after execution. `Effect.either` bridges the two worlds — converting an Effect's error channel into an Either value.

package/katas/009-option-type/solution.test.ts

@@ -0,0 +1,49 @@
+import { Option } from "effect";
+import { describe, expect, it } from "vitest";
+import { fromNullable, describeOption, doubleOption, safeDivide, getOrDefault } from "@/katas/009-option-type/solution.js";
+
+describe("009 — Option Type", () => {
+  it("fromNullable converts value to Some", () => {
+    expect(fromNullable(42)).toEqual(Option.some(42));
+  });
+
+  it("fromNullable converts null to None", () => {
+    expect(fromNullable(null)).toEqual(Option.none());
+  });
+
+  it("fromNullable converts undefined to None", () => {
+    expect(fromNullable(undefined)).toEqual(Option.none());
+  });
+
+  it("describe returns 'Found: hello' for Some", () => {
+    expect(describeOption(Option.some("hello"))).toBe("Found: hello");
+  });
+
+  it("describe returns 'Nothing' for None", () => {
+    expect(describeOption(Option.none())).toBe("Nothing");
+  });
+
+  it("doubleOption doubles Some(5) to Some(10)", () => {
+    expect(doubleOption(Option.some(5))).toEqual(Option.some(10));
+  });
+
+  it("doubleOption returns None for None", () => {
+    expect(doubleOption(Option.none())).toEqual(Option.none());
+  });
+
+  it("safeDivide(10, 2) returns Some(5)", () => {
+    expect(safeDivide(10, 2)).toEqual(Option.some(5));
+  });
+
+  it("safeDivide(10, 0) returns None", () => {
+    expect(safeDivide(10, 0)).toEqual(Option.none());
+  });
+
+  it("getOrDefault extracts Some value", () => {
+    expect(getOrDefault(Option.some(42), 0)).toBe(42);
+  });
+
+  it("getOrDefault returns default for None", () => {
+    expect(getOrDefault(Option.none(), 0)).toBe(0);
+  });
+});

package/katas/009-option-type/solution.ts

@@ -0,0 +1,26 @@
+import { Option } from "effect";
+
+/** Convert a nullable value to an Option */
+export const fromNullable = <A>(value: A | null | undefined): Option.Option<A> => {
+  throw new Error("Not implemented");
+};
+
+/** Use Option.match to return "Found: {value}" for Some, "Nothing" for None */
+export const describeOption = (opt: Option.Option<string>): string => {
+  throw new Error("Not implemented");
+};
+
+/** Use Option.map to double the number inside the Option */
+export const doubleOption = (opt: Option.Option<number>): Option.Option<number> => {
+  throw new Error("Not implemented");
+};
+
+/** Use Option.flatMap to safely divide a by b (return None if b is 0) */
+export const safeDivide = (a: number, b: number): Option.Option<number> => {
+  throw new Error("Not implemented");
+};
+
+/** Use Option.getOrElse to extract value or return a default */
+export const getOrDefault = (opt: Option.Option<number>, defaultValue: number): number => {
+  throw new Error("Not implemented");
+};

package/katas/010-either-and-exit/SENSEI.md

@@ -0,0 +1,86 @@
+# SENSEI — 010 Either and Exit
+
+## Briefing
+
+### Goal
+
+Use Either for pure validation and Exit to inspect effect results without throwing.
+
+### Tasks
+
+1. Implement `safeRun` — use `Effect.either` and `Either.match` to return "ok: {value}" or "err: {error}"
+2. Implement `validatePositive` — return `Either.right(n)` if n > 0, `Either.left("not positive")` otherwise
+3. Implement `inspectExit` — use `Effect.runSyncExit` and `Exit.match` to return "success: {value}" or "failure"
+
+### Hints
+
+```ts
+import { Effect, Either, Exit } from "effect";
+
+// Effect.either converts error channel to Either
+const safe = effect.pipe(
+  Effect.either,
+  Effect.map(
+    Either.match({
+      onLeft: (e) => `err: ${e}`,
+      onRight: (a) => `ok: ${a}`,
+    })
+  )
+);
+
+// Either for pure validation
+const validated = n > 0 ? Either.right(n) : Either.left("invalid");
+
+// Exit inspection
+const exit = Effect.runSyncExit(effect);
+const result = Exit.match(exit, {
+  onFailure: () => "failed",
+  onSuccess: (a) => `success: ${a}`,
+});
+```
+
+## Prerequisites
+
+- **009 Option Type** — `Option`, `some`, `none`, `match`, `map`, `flatMap`
+
+> **Note**: Unlike previous katas, the user DOES write `Effect.runSyncExit` and `Exit.match` in `inspectExit`. This is intentional — inspecting an Exit is the lesson.
+
+## Test Map
+
+| Test | Concept | Verifies |
+|------|---------|----------|
+| `safeRun wraps success` | `Effect.either` + `Either.match` | Success becomes Right, matched to string |
+| `safeRun wraps failure` | `Effect.either` + `Either.match` | Failure becomes Left, matched to string |
+| `validatePositive returns Right for positive` | `Either.right` | Pure validation — valid input |
+| `validatePositive returns Left for zero` | `Either.left` | Pure validation — zero rejected |
+| `validatePositive returns Left for negative` | `Either.left` | Pure validation — negative rejected |
+| `inspectExit returns success string` | `Effect.runSyncExit` + `Exit.match` | Execute and inspect successful exit |
+| `inspectExit returns failure string` | `Effect.runSyncExit` + `Exit.match` | Execute and inspect failed exit |
+
+## Teaching Approach
+
+### Socratic prompts
+
+- "You've used `Effect.catchAll` to recover from errors. What if instead of recovering, you just want to see whether it succeeded or failed — without losing the information?"
+- "`Effect.either` turns `Effect<A, E>` into `Effect<Either<A, E>, never>`. The error channel becomes `never`. Where did the error go?"
+- "Either doesn't need an Effect to be useful. `validatePositive` is a pure function. When would you use Either without Effect?"
+- "Exit looks a lot like Either. What's the difference? When do you encounter an Exit?"
+
+### Common pitfalls
+
+1. **Confusing Either and Effect** — Either is a pure data structure (Left or Right), not an Effect. `Either.right(5)` is a value, not a computation. Ask: "Does `Either.right(5)` need to be run?"
+2. **Either.match argument order** — `Either.match` takes `{ onLeft, onRight }`. Students may mix up which handler is for success vs failure. Ask: "In Either, which side is the success — Left or Right?"
+3. **Exit vs Either** — Exit is what you get after running an Effect. It's similar to Either but lives in the "execution" world, not the "pure data" world. Ask: "When do you get an Exit? Before or after running an Effect?"
+4. **Forgetting Effect.either in safeRun** — students may try to use try/catch or Effect.catchAll. Nudge: "`Effect.either` gives you the Either directly — no catching needed."
+5. **inspectExit uses runSyncExit** — this is the one place in the kata series where the user writes runtime execution code. It's intentional. Ask: "Why would you want to inspect the Exit rather than just running the Effect normally?"
+6. **Start with `validatePositive`** — it's pure, no Effects: if `n` is positive, return `Either.right(n)`, otherwise return `Either.left` with an error message.
+
+## On Completion
+
+### Insight
+
+Either is for pure validation (no effects needed). Exit is for inspecting effect outcomes after execution. `Effect.either` bridges the two worlds — converting an Effect's error channel into an Either value. Notice the pattern: Option (might not exist), Either (might be wrong), Exit (might have failed at runtime). Each represents a different kind of "two outcomes" at a different level of abstraction.
+
+### Bridge
+
+Value Handling is now complete. You can model missing values (Option), validation results (Either), and execution outcomes (Exit). Next up is **Dependency Injection** — kata 011 introduces `Context.Tag` and `provideService`, giving your Effects access to external services without hardcoding them.

package/katas/010-either-and-exit/solution.test.ts

@@ -0,0 +1,33 @@
+import { Effect, Either } from "effect";
+import { describe, expect, it } from "vitest";
+import { safeRun, validatePositive, inspectExit } from "@/katas/010-either-and-exit/solution.js";
+
+describe("010 — Either and Exit", () => {
+  it("safeRun wraps success", () => {
+    expect(Effect.runSync(safeRun(Effect.succeed("hello")))).toBe("ok: hello");
+  });
+
+  it("safeRun wraps failure", () => {
+    expect(Effect.runSync(safeRun(Effect.fail("boom")))).toBe("err: boom");
+  });
+
+  it("validatePositive returns Right for positive", () => {
+    expect(validatePositive(5)).toEqual(Either.right(5));
+  });
+
+  it("validatePositive returns Left for zero", () => {
+    expect(Either.isLeft(validatePositive(0))).toBe(true);
+  });
+
+  it("validatePositive returns Left for negative", () => {
+    expect(Either.isLeft(validatePositive(-3))).toBe(true);
+  });
+
+  it("inspectExit returns success string", () => {
+    expect(inspectExit(Effect.succeed("data"))).toBe("success: data");
+  });
+
+  it("inspectExit returns failure string", () => {
+    expect(inspectExit(Effect.fail("oops"))).toBe("failure");
+  });
+});

package/katas/010-either-and-exit/solution.ts

@@ -0,0 +1,17 @@
+import { Effect, Either, Exit } from "effect";
+
+/** Use Effect.either to convert an Effect<A, E> into Effect<Either<A, E>>
+ * then use Either.match to return "ok: {value}" or "err: {error}" */
+export const safeRun = (effect: Effect.Effect<string, string>): Effect.Effect<string> => {
+  throw new Error("Not implemented");
+};
+
+/** Use Either.right and Either.left to validate: return Right(n) if n > 0, Left("not positive") otherwise */
+export const validatePositive = (n: number): Either.Either<number, string> => {
+  throw new Error("Not implemented");
+};
+
+/** Use Effect.runSyncExit and Exit.match to return "success: {value}" or "failure" */
+export const inspectExit = (effect: Effect.Effect<string, string>): string => {
+  throw new Error("Not implemented");
+};

package/katas/011-services-and-context/SENSEI.md

@@ -0,0 +1,82 @@
+# SENSEI — 011 Services and Context
+
+## Briefing
+
+### Goal
+
+Learn how Effect manages dependencies through the R (Requirements) channel.
+
+### Tasks
+
+1. Implement `getRandomNumber` — access the `Random` service and return its `next` value
+2. Implement `rollDice` — access the `Random` service and return `"Roll: {n}"` where `n` is the random value
+
+### Hints
+
+```ts
+import { Context, Effect } from "effect";
+
+// Declare a service with Context.Tag
+class MyService extends Context.Tag("MyService")<
+  MyService,
+  { readonly getValue: Effect.Effect<number> }
+>() {}
+
+// Access the service inside Effect.gen
+const program = Effect.gen(function* () {
+  const svc = yield* MyService;
+  const value = yield* svc.getValue;
+  return value;
+});
+
+// Provide a concrete implementation
+const result = Effect.runSync(
+  Effect.provideService(program, MyService, {
+    getValue: Effect.succeed(42),
+  }),
+);
+```
+
+## Prerequisites
+
+- **001-005 Basics** — `Effect.succeed`, `Effect.sync`, `Effect.map`, `pipe`, `Effect.gen`, `yield*`, `Effect.flatMap`
+- **006-008 Error Handling** — `Effect.fail`, `catchAll`, `catchTag`, `Data.TaggedError`
+- **009-010 Value Handling** — `Option`, `Either`, `Exit`
+
+## Skills
+
+Invoke `effect-patterns-core-concepts` before teaching this kata. This is the first kata in the Dependency Injection area.
+
+> **Note**: `Effect.runSync` and `Effect.provideService` appear only in tests. The student does NOT write them. Never attribute them to their learning.
+
+## Test Map
+
+| Test | Concept | Verifies |
+|------|---------|----------|
+| `getRandomNumber returns the service value` | `yield* Random` + `yield* svc.next` | Accessing a service and calling its method |
+| `rollDice formats the result` | `yield* Random` + `yield* svc.next` + string formatting | Service access plus value transformation |
+
+## Teaching Approach
+
+### Socratic prompts
+
+- "You've used `yield*` to unwrap Effects. What happens if you `yield*` a Context.Tag like `Random`?"
+- "After you get the service with `yield* Random`, you have an object with a `next` property. What is `next` — a value or an Effect? How do you get the value out?"
+- "Look at the type of `getRandomNumber` — what does the `R` channel (the third type parameter) tell you?"
+
+### Common pitfalls
+
+1. **Calling Random directly** — `Random.next` doesn't exist. `Random` is a tag, not an instance. You need `yield* Random` first to get the service implementation, THEN access `.next` on it. Ask: "What does `Random` represent — the service itself, or a key to look it up?"
+2. **Forgetting the second yield*** — `yield* Random` gives you the service object, but `svc.next` is still an Effect. You need a second `yield*` to unwrap it. Ask: "What's the type of `svc.next`? Is it a number or an Effect?"
+3. **String formatting in rollDice** — students may return the number instead of the formatted string. The test expects `"Roll: 4"`. Nudge: "Check the test — what exact string format does `rollDice` need to produce?"
+4. **Two-step yield pattern** — inside `Effect.gen`, first `yield*` the `Random` tag to get the service, then `yield*` its `next` method to get the number. The Briefing hints show this pattern.
+
+## On Completion
+
+### Insight
+
+`yield* Random` doesn't call anything — it asks Effect's runtime to provide the Random service. The `R` type parameter tracks what's needed. This is dependency injection at the type level: your program declares its dependencies in its type signature, and the runtime satisfies them. Notice how the tests provide a `TestRandom` with a predictable value — your code never knew or cared where the implementation came from.
+
+### Bridge
+
+You've seen how to USE services, but the tests had to manually wire them with `provideService`. Kata 012 introduces **Layers** — reusable recipes for building services. Layers decouple "how a service is built" from "how it's used", making large programs composable.

package/katas/011-services-and-context/solution.test.ts

@@ -0,0 +1,23 @@
+import { Effect } from "effect";
+import { describe, expect, it } from "vitest";
+import { Random, getRandomNumber, rollDice } from "@/katas/011-services-and-context/solution.js";
+
+const TestRandom = {
+  next: Effect.succeed(4),
+};
+
+describe("011 — Services and Context", () => {
+  it("getRandomNumber returns the service value", () => {
+    const result = Effect.runSync(
+      Effect.provideService(getRandomNumber, Random, TestRandom),
+    );
+    expect(result).toBe(4);
+  });
+
+  it("rollDice formats the result", () => {
+    const result = Effect.runSync(
+      Effect.provideService(rollDice, Random, TestRandom),
+    );
+    expect(result).toBe("Roll: 4");
+  });
+});

package/katas/011-services-and-context/solution.ts

@@ -0,0 +1,17 @@
+import { Context, Effect } from "effect";
+
+// A simple "Random" service that produces random numbers
+export class Random extends Context.Tag("Random")<
+  Random,
+  { readonly next: Effect.Effect<number> }
+>() {}
+
+/** Use Effect.flatMap or Effect.gen to access the Random service and return its next value */
+export const getRandomNumber = Effect.gen(function* () {
+  throw new Error("Not implemented");
+});
+
+/** Access Random service and return "Roll: {n}" where n is the random value */
+export const rollDice = Effect.gen(function* () {
+  throw new Error("Not implemented");
+});

package/katas/012-layers/SENSEI.md

@@ -0,0 +1,73 @@
+# SENSEI — 012 Layers
+
+## Briefing
+
+### Goal
+
+Learn how to compose service implementations using Layers.
+
+### Tasks
+
+1. Implement `ConfigLive` — a Layer that provides `Config` with `baseUrl` set to `"https://api.example.com"`
+2. Implement `LoggerLive` — a Layer that provides `Logger` with a `log` function that uses `Effect.log`
+3. Implement `getEndpoint` — read `Config.baseUrl` and `Logger.log` to return `"{baseUrl}/users"`
+
+### Hints
+
+```ts
+import { Context, Effect, Layer } from "effect";
+
+// Create a Layer from a value
+const MyLayer = Layer.succeed(MyService, { value: 42 });
+
+// Create a Layer from an effect
+const MyEffectLayer = Layer.effect(
+  MyService,
+  Effect.succeed({ value: 42 }),
+);
+
+// Merge layers
+const Combined = Layer.merge(LayerA, LayerB);
+
+// Provide a layer to a program
+const result = Effect.runSync(Effect.provide(program, Combined));
+```
+
+## Prerequisites
+
+- **011 Services and Context** — `Context.Tag`, `yield*` on a tag, `yield*` on a service method
+
+> **Note**: `Effect.runSync`, `Effect.provide`, `Layer.merge`, and `Layer.succeed` (in tests) appear only in tests. Never attribute them to the user's learning.
+
+## Test Map
+
+| Test | Concept | Verifies |
+|------|---------|----------|
+| `ConfigLive provides baseUrl` | `Layer.succeed` | Creating a Layer with a static service value |
+| `getEndpoint returns full URL` | `yield* Config` + `yield* Logger` + format | Multi-service program using two services |
+
+## Teaching Approach
+
+### Socratic prompts
+
+- "In kata 011, the tests used `provideService` to wire one service at a time. What if you have TWO services? How would you provide both?"
+- "What's the difference between `Layer.succeed(Config, { baseUrl: '...' })` and directly providing the service? When would the Layer approach be better?"
+- "For `getEndpoint`, you need both Config and Logger. Does the order you `yield*` them matter?"
+
+### Common pitfalls
+
+1. **Confusing `Layer.succeed` and `Layer.effect`** — `Layer.succeed(Tag, value)` is for static values. `Layer.effect(Tag, someEffect)` is when building the service requires running an Effect. For `ConfigLive`, a static config object works. Ask: "Is the config value known upfront, or does it need computation?"
+2. **Forgetting to call Logger.log** — `getEndpoint` needs to use the Logger service. Students may skip the logging step. Check the test to see if logging is required for the test to pass.
+3. **Layer type annotation** — the stub uses a type cast. Students need to replace the entire implementation with a proper `Layer.succeed(Config, { ... })` call. Nudge: "Delete the placeholder and write a fresh `Layer.succeed` call."
+4. **String concatenation in getEndpoint** — the test expects `"https://test.com/users"`. Make sure to include the `/` between baseUrl and `"users"`.
+5. **Start with `Layer.succeed`** — the simplest form is `Layer.succeed(Config, { baseUrl: 'https://api.example.com' })`. Use that pattern for both `ConfigLive` and `LoggerLive`.
+
+## On Completion
+
+### Insight
+
+Layers decouple "how a service is built" from "how it's used". The program says WHAT it needs (via the R channel), the Layer says HOW to provide it. This separation is what makes Effect programs composable and testable. Notice how the test swapped in a completely different Config and a no-op Logger — your `getEndpoint` code didn't change at all.
+
+### Bridge
+
+You've built services and wired them with Layers. But the real power shows up in testing. Kata 013 makes this explicit: you'll write programs against a service interface, and the tests will provide different implementations — no mocking frameworks needed.

package/katas/012-layers/solution.test.ts

@@ -0,0 +1,23 @@
+import { Effect, Layer } from "effect";
+import { describe, expect, it } from "vitest";
+import { Config, Logger, ConfigLive, LoggerLive, getEndpoint } from "@/katas/012-layers/solution.js";
+
+describe("012 — Layers", () => {
+  it("ConfigLive provides baseUrl", () => {
+    const program = Effect.gen(function* () {
+      const config = yield* Config;
+      return config.baseUrl;
+    });
+    const result = Effect.runSync(Effect.provide(program, ConfigLive));
+    expect(result).toBe("https://api.example.com");
+  });
+
+  it("getEndpoint returns full URL", () => {
+    const TestLayer = Layer.merge(
+      Layer.succeed(Config, { baseUrl: "https://test.com" }),
+      Layer.succeed(Logger, { log: () => Effect.void }),
+    );
+    const result = Effect.runSync(Effect.provide(getEndpoint, TestLayer));
+    expect(result).toBe("https://test.com/users");
+  });
+});

package/katas/012-layers/solution.ts

@@ -0,0 +1,26 @@
+import { Context, Effect, Layer } from "effect";
+
+export class Config extends Context.Tag("Config")<
+  Config,
+  { readonly baseUrl: string }
+>() {}
+
+export class Logger extends Context.Tag("Logger")<
+  Logger,
+  { readonly log: (msg: string) => Effect.Effect<void> }
+>() {}
+
+/** Create a Layer that provides Config with baseUrl "https://api.example.com" */
+export const ConfigLive: Layer.Layer<Config> = Layer.effectDiscard(
+  Effect.die("Not implemented"),
+) as unknown as Layer.Layer<Config>;
+
+/** Create a Layer that provides Logger with a log function that uses Effect.log */
+export const LoggerLive: Layer.Layer<Logger> = Layer.effectDiscard(
+  Effect.die("Not implemented"),
+) as unknown as Layer.Layer<Logger>;
+
+/** Create a program that reads Config.baseUrl and Logger.log to return "{baseUrl}/users" */
+export const getEndpoint = Effect.gen(function* () {
+  throw new Error("Not implemented");
+});