@dojocho/effect-ts 0.0.1

package/katas/033-pattern-matching/SENSEI.md

@@ -0,0 +1,86 @@
+# SENSEI — 033 Pattern Matching
+
+## Briefing
+
+### Goal
+
+Use Effect's `Match` module and `Data.taggedEnum` to perform exhaustive, type-safe pattern matching on tagged unions and plain values.
+
+### Tasks
+
+1. Define the `Shape` tagged enum (already provided) and implement `area(shape)` — compute the area using `Match.type` with `Match.tag` for each variant
+2. Implement `describeShape(shape)` — return a formatted string for each shape variant
+3. Implement `classifyNumber(n)` — match on a plain number using `Match.value` and `Match.when` predicates
+
+### Hints
+
+```ts
+import { Match, Data } from "effect";
+
+// Tagged enum definition
+type Animal =
+  | Data.TaggedEnum.Member<"Dog", { readonly name: string }>
+  | Data.TaggedEnum.Member<"Cat", { readonly lives: number }>;
+const Animal = Data.taggedEnum<Animal>();
+
+// Match on a tagged type
+const describe = Match.type<Animal>().pipe(
+  Match.tag("Dog", (dog) => `Dog: ${dog.name}`),
+  Match.tag("Cat", (cat) => `Cat: ${cat.lives} lives`),
+  Match.exhaustive,
+);
+// describe is a function: (input: Animal) => string
+
+// Match on a plain value
+const classify = (n: number) =>
+  Match.value(n).pipe(
+    Match.when((x) => x < 0, () => "negative"),
+    Match.when((x) => x === 0, () => "zero"),
+    Match.orElse(() => "positive"),
+  );
+```
+
+## Prerequisites
+
+- **009 Option Type** — Working with `Option` and discriminated unions
+- **010 Either and Exit** — Pattern matching on `Either` variants
+- **015 Domain Modeling** — `Data.TaggedEnum` and `Schema`
+
+## Test Map
+
+> **Note**: `Shape.Circle(...)` etc. are constructors from `Data.taggedEnum`. Tests use them to create instances.
+
+| Test | Concept | Verifies |
+|------|---------|----------|
+| `area of Circle` | `Match.tag` + geometry | Matching `Circle` and computing `pi * r^2` |
+| `area of Rectangle` | `Match.tag` + geometry | Matching `Rectangle` and computing `w * h` |
+| `area of Triangle` | `Match.tag` + geometry | Matching `Triangle` and computing `0.5 * b * h` |
+| `describeShape for Circle` | `Match.tag` + string formatting | Producing formatted string per variant |
+| `describeShape for Rectangle` | `Match.tag` + string formatting | Producing formatted string per variant |
+| `classifyNumber negative` | `Match.when` with predicate | Matching plain values with conditions |
+| `classifyNumber zero` | `Match.when` with predicate | Exact value matching |
+| `classifyNumber positive` | `Match.orElse` or `Match.when` | Catch-all / else branch |
+
+## Teaching Approach
+
+### Socratic prompts
+
+- "`Match.exhaustive` makes the matcher into a callable function, but it also does something at the type level. What happens if you forget to handle one of the shape variants?"
+- "How does `Match.tag` know which field to match on? What convention does `Data.taggedEnum` follow?"
+- "Compare `Match.when` with a plain `if/else` chain. What does Match give you that conditionals don't?"
+
+### Common pitfalls
+
+1. **Forgetting `Match.exhaustive` at the end of the pipe** — Without it, you get a `Matcher` object, not a callable function. The result of `Match.type<Shape>().pipe(Match.tag(...), Match.exhaustive)` is what you can call with a shape. Ask: "What does `Match.exhaustive` return — a matcher or a function?"
+2. **Using `Match.when` for tagged types instead of `Match.tag`** — For tagged unions, `Match.tag("Circle", ...)` is more idiomatic and gives better type narrowing than `Match.when`. Save `Match.when` for predicate-based matching on plain values. Ask: "What is the difference between matching on a tag versus matching with a predicate?"
+3. **Getting the `Match.value` vs `Match.type` distinction wrong** — `Match.type<T>()` creates a reusable matcher (returns a function). `Match.value(x)` matches a specific value (returns the result directly). For `classifyNumber`, you receive `n` as a parameter and want to match it immediately. Ask: "Do you need a reusable function or a one-shot match here?"
+
+## On Completion
+
+### Insight
+
+Pattern matching with `Match` brings the exhaustiveness guarantees of languages like Rust or Haskell to TypeScript. When you use `Match.exhaustive`, the compiler ensures every variant is handled — adding a new shape variant will cause a type error at every unhandled match site. Combined with `Data.taggedEnum`, this creates a workflow where the type system guides you: define your domain as tagged unions, match exhaustively, and let the compiler tell you what you missed. This is far more reliable than `switch` statements, which silently fall through on unhandled cases.
+
+### Bridge
+
+Pattern matching helps you handle every case in your data. But what about coordinating between concurrent computations that need to wait for each other? Kata 034 introduces `Deferred`, Effect's primitive for one-shot synchronization between fibers.

package/katas/033-pattern-matching/solution.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+import { Shape, area, describeShape, classifyNumber } from "@/katas/033-pattern-matching/solution.js";
+
+describe("033 — Pattern Matching", () => {
+  it("area of Circle", () => {
+    expect(area(Shape.Circle({ radius: 5 }))).toBeCloseTo(Math.PI * 25);
+  });
+
+  it("area of Rectangle", () => {
+    expect(area(Shape.Rectangle({ width: 4, height: 6 }))).toBe(24);
+  });
+
+  it("area of Triangle", () => {
+    expect(area(Shape.Triangle({ base: 10, height: 5 }))).toBe(25);
+  });
+
+  it("describeShape for Circle", () => {
+    expect(describeShape(Shape.Circle({ radius: 3 }))).toBe("Circle with radius 3");
+  });
+
+  it("describeShape for Rectangle", () => {
+    expect(describeShape(Shape.Rectangle({ width: 4, height: 6 }))).toBe("Rectangle 4x6");
+  });
+
+  it("classifyNumber negative", () => {
+    expect(classifyNumber(-5)).toBe("negative");
+  });
+
+  it("classifyNumber zero", () => {
+    expect(classifyNumber(0)).toBe("zero");
+  });
+
+  it("classifyNumber positive", () => {
+    expect(classifyNumber(7)).toBe("positive");
+  });
+});

package/katas/033-pattern-matching/solution.ts

@@ -0,0 +1,28 @@
+import { Data, Match } from "effect";
+
+type ShapeDefinition = {
+  readonly Circle: { readonly radius: number };
+  readonly Rectangle: { readonly width: number; readonly height: number };
+  readonly Triangle: { readonly base: number; readonly height: number };
+};
+
+type Shape = Data.TaggedEnum<ShapeDefinition>;
+
+export const Shape = Data.taggedEnum<ShapeDefinition>();
+
+/** Compute the area of a shape using pattern matching
+ * Circle: π * r², Rectangle: w * h, Triangle: (b * h) / 2 */
+export const area = (shape: Shape): number => {
+  throw new Error("Not implemented");
+};
+
+/** Describe a shape as a string using pattern matching
+ * "Circle with radius {r}", "Rectangle {w}x{h}", "Triangle {b}x{h}" */
+export const describeShape = (shape: Shape): string => {
+  throw new Error("Not implemented");
+};
+
+/** Classify a number as "negative", "zero", or "positive" using Match.when */
+export const classifyNumber = (n: number): string => {
+  throw new Error("Not implemented");
+};

package/katas/034-deferred-and-coordination/SENSEI.md

@@ -0,0 +1,85 @@
+# SENSEI — 034 Deferred and Coordination
+
+## Briefing
+
+### Goal
+
+Use `Deferred` to coordinate between fibers, implementing one-shot signaling patterns for synchronization.
+
+### Tasks
+
+1. Implement `completeAndAwait(value)` — create a `Deferred`, immediately complete it with the given value, then await it
+2. Implement `forkThenComplete(value)` — create a `Deferred`, fork a fiber that awaits it, complete the deferred from the main fiber, then join the forked fiber to get the result
+3. Implement `gatedExecution(a, b)` — create a `Deferred` as a "gate", fork two fibers that each await the gate and then return their respective value, open the gate, join both fibers, return the results as a tuple
+
+### Hints
+
+```ts
+import { Deferred, Effect, Fiber } from "effect";
+
+// Create and use a Deferred
+const program = Effect.gen(function* () {
+  const deferred = yield* Deferred.make<string>();
+  yield* Deferred.succeed(deferred, "hello");
+  const value = yield* Deferred.await(deferred);
+  return value; // "hello"
+});
+
+// Fork a waiter, then signal it
+const coordination = Effect.gen(function* () {
+  const gate = yield* Deferred.make<void>();
+  const fiber = yield* Effect.fork(
+    Effect.gen(function* () {
+      yield* Deferred.await(gate);
+      return "started!";
+    }),
+  );
+  yield* Deferred.succeed(gate, undefined);
+  return yield* Fiber.join(fiber);
+});
+```
+
+## Prerequisites
+
+- **020 Fibers** — `Effect.fork`, `Fiber.join`, fiber lifecycle
+- **017 Parallel Effects** — `Effect.all`, concurrency
+- **019 Ref and State** — Shared mutable state between fibers
+
+## Skills
+
+Invoke `effect-patterns-concurrency-getting-started` before teaching this kata.
+
+## Test Map
+
+> **Note**: `Effect.runPromise` appears only in tests. Never attribute it to the user's learning.
+
+| Test | Concept | Verifies |
+|------|---------|----------|
+| `completeAndAwait resolves with the value` | `Deferred.make` + `succeed` + `await` | Basic deferred lifecycle with a number |
+| `completeAndAwait works with strings` | `Deferred.make` + `succeed` + `await` | Deferred is generic over the value type |
+| `forkThenComplete coordinates via deferred` | `Effect.fork` + `Deferred.await` + `Deferred.succeed` | Cross-fiber signaling |
+| `gatedExecution both fibers run after gate opens` | Multiple fibers + shared `Deferred` | Gate pattern — multiple waiters, single signal |
+
+## Teaching Approach
+
+### Socratic prompts
+
+- "A `Deferred` can only be completed once. What happens if you try to `Deferred.succeed` a second time? Why is this one-shot design useful for coordination?"
+- "In `forkThenComplete`, the forked fiber calls `Deferred.await` — what does that fiber do while waiting? How is this different from a busy loop or polling?"
+- "The gate pattern uses a single `Deferred` to unblock multiple fibers. Could you achieve the same thing with a `Ref`? What would be different?"
+
+### Common pitfalls
+
+1. **Completing the deferred after awaiting it (deadlock)** — If you `await` a deferred in the same fiber that needs to `succeed` it, you'll block forever. The completion must happen from a different fiber or before the await. Ask: "Which fiber completes the deferred, and which one waits? Can the same fiber do both sequentially?"
+2. **Forgetting to join forked fibers** — Forking a fiber starts it, but you must `Fiber.join` to get the result. Without joining, the fiber's result is discarded and the test won't get the expected value. Ask: "After forking a fiber, how do you get its result back into the main fiber?"
+3. **Not specifying the type parameter on `Deferred.make`** — `Deferred.make<A>()` needs a type parameter so TypeScript knows what the deferred will hold. If you omit it, type inference might not work as expected. Ask: "What type should the deferred hold for each function?"
+
+## On Completion
+
+### Insight
+
+`Deferred` is Effect's primitive for one-shot synchronization. Unlike `Ref` (which can be updated many times), a `Deferred` transitions exactly once from "pending" to "completed." This makes it perfect for signaling: "the config is loaded," "the connection is ready," "all workers can start." Fibers that `await` a pending deferred are suspended without consuming CPU — the runtime resumes them when the deferred is completed. This is the building block for more sophisticated coordination patterns like barriers, latches, and rendezvous points.
+
+### Bridge
+
+`Deferred` coordinates fibers with a single signal. But what if fibers need to exchange a continuous stream of values? Kata 035 introduces `Queue` — Effect's bounded, backpressure-aware channel for producer-consumer communication.

package/katas/034-deferred-and-coordination/solution.test.ts

@@ -0,0 +1,25 @@
+import { Effect } from "effect";
+import { describe, expect, it } from "vitest";
+import { completeAndAwait, forkThenComplete, gatedExecution } from "@/katas/034-deferred-and-coordination/solution.js";
+
+describe("034 — Deferred and Coordination", () => {
+  it("completeAndAwait resolves with the value", async () => {
+    const result = await Effect.runPromise(completeAndAwait(42));
+    expect(result).toBe(42);
+  });
+
+  it("completeAndAwait works with strings", async () => {
+    const result = await Effect.runPromise(completeAndAwait("hello"));
+    expect(result).toBe("hello");
+  });
+
+  it("forkThenComplete coordinates via deferred", async () => {
+    const result = await Effect.runPromise(forkThenComplete("done"));
+    expect(result).toBe("done");
+  });
+
+  it("gatedExecution both fibers run after gate opens", async () => {
+    const result = await Effect.runPromise(gatedExecution("a", "b"));
+    expect(result).toEqual(["a", "b"]);
+  });
+});

package/katas/034-deferred-and-coordination/solution.ts

@@ -0,0 +1,24 @@
+import { Deferred, Effect, Fiber } from "effect";
+
+/** Create a Deferred, complete it with the value, and await the result */
+export const completeAndAwait = <A>(
+  value: A,
+): Effect.Effect<A> => {
+  throw new Error("Not implemented");
+};
+
+/** Create a Deferred, fork a fiber that completes it, await the result */
+export const forkThenComplete = <A>(
+  value: A,
+): Effect.Effect<A> => {
+  throw new Error("Not implemented");
+};
+
+/** Create a gate (Deferred<void>), fork two fibers that wait on it,
+ * open the gate, join both fibers and return [a, b] */
+export const gatedExecution = <A, B>(
+  a: A,
+  b: B,
+): Effect.Effect<[A, B]> => {
+  throw new Error("Not implemented");
+};

package/katas/035-queue-and-backpressure/SENSEI.md

@@ -0,0 +1,100 @@
+# SENSEI — 035 Queue and Backpressure
+
+## Briefing
+
+### Goal
+
+Use bounded `Queue` to implement producer-consumer patterns with automatic backpressure, coordinating data flow between fibers.
+
+### Tasks
+
+1. Implement `roundTrip(items)` — create a bounded queue with capacity equal to `items.length` (or 1 if empty), offer all items, then take them back in order
+2. Implement `backpressureDemo()` — create a bounded queue of capacity 2, fork a producer that offers `[1, 2, 3]`, take 3 items from the main fiber. The producer will block on the 3rd offer until a take frees space.
+3. Implement `producerConsumer(n)` — fork a producer that offers numbers `1..n` into a bounded queue, fork a consumer that takes `n` items and collects them, return the collected items
+
+### Hints
+
+```ts
+import { Effect, Queue, Fiber } from "effect";
+
+// Create a bounded queue
+const program = Effect.gen(function* () {
+  const queue = yield* Queue.bounded<number>(10);
+
+  // Offer items
+  yield* Queue.offer(queue, 1);
+  yield* Queue.offer(queue, 2);
+
+  // Take items (FIFO)
+  const a = yield* Queue.take(queue);
+  const b = yield* Queue.take(queue);
+
+  return [a, b]; // [1, 2]
+});
+
+// Backpressure: offer blocks when queue is full
+const backpressure = Effect.gen(function* () {
+  const queue = yield* Queue.bounded<number>(2);
+  // Fork producer — it will block on 3rd offer
+  const producer = yield* Effect.fork(
+    Effect.all([
+      Queue.offer(queue, 1),
+      Queue.offer(queue, 2),
+      Queue.offer(queue, 3), // blocks until space opens
+    ]),
+  );
+  // Consumer takes, freeing space
+  const items = yield* Effect.all([
+    Queue.take(queue),
+    Queue.take(queue),
+    Queue.take(queue),
+  ]);
+  yield* Fiber.join(producer);
+  return items;
+});
+```
+
+## Prerequisites
+
+- **020 Fibers** — `Effect.fork`, `Fiber.join`, fiber lifecycle
+- **034 Deferred and Coordination** — `Deferred`, one-shot synchronization
+- **017 Parallel Effects** — `Effect.all`, concurrency
+
+## Skills
+
+Invoke `effect-patterns-concurrency-getting-started` before teaching this kata.
+
+## Test Map
+
+> **Note**: `Effect.runPromise` appears only in tests. Never attribute it to the user's learning.
+
+| Test | Concept | Verifies |
+|------|---------|----------|
+| `roundTrip offers and takes items` | `Queue.bounded` + `offer` + `take` | Basic queue lifecycle with multiple items |
+| `roundTrip works with empty array` | Edge case handling | Queue creation and empty iteration |
+| `backpressureDemo collects all 3 items despite bounded queue` | Backpressure | Producer blocks when queue is full, consumer unblocks it |
+| `producerConsumer collects n items` | Fork + Queue coordination | Full producer-consumer pattern with separate fibers |
+
+## Teaching Approach
+
+### Socratic prompts
+
+- "What happens when a producer calls `Queue.offer` on a full bounded queue? Does it fail, drop the item, or do something else?"
+- "In `backpressureDemo`, the queue has capacity 2 but the producer offers 3 items. How does the system avoid losing the third item without the producer explicitly waiting?"
+- "Why use a bounded queue instead of an unbounded one? What problem does backpressure solve that an ever-growing buffer doesn't?"
+
+### Common pitfalls
+
+1. **Deadlocking by offering and taking in the wrong order** — If you offer more items than the queue capacity in the main fiber (without forking), the fiber blocks on `offer` and never reaches `take`. The producer must be in a separate fiber so the consumer can drain the queue. Ask: "If the queue is full and `offer` blocks, who will call `take` to free space?"
+2. **Forgetting to join the producer fiber** — If you don't join the producer, the test may complete before the producer finishes offering. Always join to ensure all items are produced. Ask: "What guarantees that the producer has finished all its offers before you inspect the results?"
+3. **Using `Queue.unbounded` instead of `Queue.bounded`** — Unbounded queues never block on offer, which means `backpressureDemo` won't demonstrate backpressure at all. The exercise specifically requires bounded queues. Ask: "What is the behavioral difference between `Queue.bounded(2)` and `Queue.unbounded`?"
+
+## On Completion
+
+### Insight
+
+Bounded queues implement backpressure automatically: when the queue is full, producers suspend until consumers make space. This is a fundamental pattern in concurrent systems — it prevents fast producers from overwhelming slow consumers, avoiding unbounded memory growth. The beauty of Effect's `Queue` is that this coordination happens transparently: the producer just calls `offer`, the consumer just calls `take`, and the runtime handles the suspension and resumption. Combined with fibers, queues let you build robust data pipelines where the flow rate self-regulates.
+
+### Bridge
+
+You have now covered Effect's core coordination primitives: `Deferred` for one-shot signals and `Queue` for streaming data between fibers. These are the building blocks for the more advanced concurrency patterns you will encounter in real-world Effect applications.

package/katas/035-queue-and-backpressure/solution.test.ts

@@ -0,0 +1,25 @@
+import { Effect } from "effect";
+import { describe, expect, it } from "vitest";
+import { roundTrip, backpressureDemo, producerConsumer } from "@/katas/035-queue-and-backpressure/solution.js";
+
+describe("035 — Queue and Backpressure", () => {
+  it("roundTrip offers and takes items", async () => {
+    const result = await Effect.runPromise(roundTrip([1, 2, 3]));
+    expect(result).toEqual([1, 2, 3]);
+  });
+
+  it("roundTrip works with empty array", async () => {
+    const result = await Effect.runPromise(roundTrip([]));
+    expect(result).toEqual([]);
+  });
+
+  it("backpressureDemo collects all 3 items despite bounded queue", async () => {
+    const result = await Effect.runPromise(backpressureDemo());
+    expect(result).toEqual([1, 2, 3]);
+  });
+
+  it("producerConsumer collects n items", async () => {
+    const result = await Effect.runPromise(producerConsumer(5));
+    expect(result.sort()).toEqual([1, 2, 3, 4, 5]);
+  });
+});

package/katas/035-queue-and-backpressure/solution.ts

@@ -0,0 +1,21 @@
+import { Effect, Queue, Fiber } from "effect";
+
+/** Create an unbounded queue, offer all items, take them back */
+export const roundTrip = <A>(
+  items: A[],
+): Effect.Effect<A[]> => {
+  throw new Error("Not implemented");
+};
+
+/** Create a bounded queue (capacity 2), fork a producer that offers 1, 2, 3,
+ * take 3 items from consumer side, return them */
+export const backpressureDemo = (): Effect.Effect<number[]> => {
+  throw new Error("Not implemented");
+};
+
+/** Producer offers 1..n into a bounded queue, consumer takes all n items */
+export const producerConsumer = (
+  n: number,
+): Effect.Effect<number[]> => {
+  throw new Error("Not implemented");
+};

package/katas/036-schema-advanced/SENSEI.md

@@ -0,0 +1,81 @@
+# SENSEI — 036 Schema Advanced
+
+## Briefing
+
+### Goal
+
+Learn to build refined, branded, and transformed schemas for robust domain modeling with Effect Schema.
+
+### Tasks
+
+1. Observe the `PositiveInt` branded type -- it is already implemented for you as a reference
+2. Implement `DateFromString` -- use `Schema.transform` to convert a `"YYYY-MM-DD"` string into a `Date` object
+3. Update `UserSchema` to use `PositiveInt` for `id` and `Schema.NonEmptyString` for `name`
+4. Verify that `decodeUser` and `encodeUser` work correctly with the refined schema
+
+### Hints
+
+```ts
+import { Schema } from "effect";
+
+// Schema.brand creates a nominal type wrapper on a schema
+const UserId = Schema.Number.pipe(
+  Schema.filter((n) => n > 0),
+  Schema.brand("UserId"),
+);
+
+// Schema.transform converts between two schemas
+const BoolFromString = Schema.transform(Schema.String, Schema.Boolean, {
+  decode: (s) => s === "true",
+  encode: (b) => (b ? "true" : "false"),
+});
+
+// Schema.NonEmptyString rejects empty strings
+const NameSchema = Schema.NonEmptyString;
+```
+
+## Prerequisites
+
+- **014 Schema Basics** -- `Schema.Struct`, `Schema.decodeUnknown`, `Schema.NonEmptyString`
+- **015 Domain Modeling** -- combining validation with typed errors
+
+## Skills
+
+Invoke `effect-patterns-domain-modeling` before teaching this kata.
+
+## Test Map
+> **Note**: `Effect.runSync`, `Effect.runSyncExit`, `Exit.isFailure`, and `Schema.decodeUnknown` appear only in tests. Never attribute them to the user's learning.
+
+| Test | Concept | Verifies |
+|------|---------|----------|
+| `PositiveInt accepts positive integers` | `Schema.int`, `Schema.positive` | Accepts valid values AND rejects non-integers |
+| `PositiveInt rejects negative numbers` | `Schema.filter` | Filter predicate rejects negatives |
+| `PositiveInt rejects non-integers` | `Schema.filter` | Filter predicate rejects floats |
+| `DateFromString transforms date string to Date` | `Schema.transform` | String-to-Date transformation via decode |
+| `decodeUser succeeds with valid data` | `Schema.Struct` with refined fields | Accepts valid input AND rejects invalid id |
+| `decodeUser fails with invalid id` | `PositiveInt` in struct | Branded field rejects invalid id |
+| `decodeUser fails with empty name` | `Schema.NonEmptyString` | Refined field rejects empty string |
+
+## Teaching Approach
+
+### Socratic prompts
+
+- "`PositiveInt` uses `Schema.brand`. What does branding add beyond the runtime filter? Think about what happens at the type level."
+- "`Schema.transform` takes a `decode` and `encode` function. Why does a transformation schema need both directions?"
+- "When you put `PositiveInt` inside a `Schema.Struct`, what happens to the overall struct's Type? Does the brand propagate?"
+
+### Common pitfalls
+
+1. **Schema.transform argument order** -- the first argument is the "from" (encoded) schema, the second is the "to" (type) schema. Students often reverse them. Nudge: "Which side is the raw input, and which side is the rich domain type?"
+2. **DateFromString decode must return a Date** -- `new Date("2024-01-15")` is enough for valid ISO strings, but the transform also needs an `encode` direction that converts back to string. Ask: "What does `.toISOString().slice(0, 10)` give you?"
+3. **Forgetting to update UserSchema** -- the stub uses `Schema.Number` and `Schema.String` as placeholders. Both need to be swapped for their refined versions. The tests for `decodeUser fails with invalid id` and `decodeUser fails with empty name` will guide you.
+
+## On Completion
+
+### Insight
+
+Branded schemas are one of Effect's most powerful domain modeling tools. A `PositiveInt` is not just a number that happens to be positive -- it is a distinct type that the compiler tracks. Once data passes through `Schema.decodeUnknown`, you get a branded value that carries proof of validation. `Schema.transform` extends this further by letting you work with rich domain types (like `Date`) while keeping a simple serialization format (like a string). Together, these tools let you build schemas that are both the validation layer and the type definition -- one source of truth for runtime checks and compile-time safety.
+
+### Bridge
+
+You have built refined and transformed schemas. Kata 037 introduces `Cache` -- a performance primitive that memoizes effectful lookups with TTL and capacity controls. Caching is where domain modeling meets real-world performance.

package/katas/036-schema-advanced/solution.test.ts

@@ -0,0 +1,55 @@
+import { Effect, Exit, Schema } from "effect";
+import { describe, expect, it } from "vitest";
+import {
+  PositiveInt,
+  DateFromString,
+  UserSchema,
+  decodeUser,
+  encodeUser,
+} from "@/katas/036-schema-advanced/solution.js";
+
+describe("036 — Schema Advanced", () => {
+  it("PositiveInt accepts positive integers", () => {
+    const result = Effect.runSync(Schema.decodeUnknown(PositiveInt)(5));
+    expect(result).toBe(5);
+    // Must reject non-integers (verifies int() filter is applied)
+    const exit = Effect.runSyncExit(Schema.decodeUnknown(PositiveInt)(1.5));
+    expect(Exit.isFailure(exit)).toBe(true);
+  });
+
+  it("PositiveInt rejects negative numbers", () => {
+    const exit = Effect.runSyncExit(Schema.decodeUnknown(PositiveInt)(-1));
+    expect(Exit.isFailure(exit)).toBe(true);
+  });
+
+  it("PositiveInt rejects non-integers", () => {
+    const exit = Effect.runSyncExit(Schema.decodeUnknown(PositiveInt)(1.5));
+    expect(Exit.isFailure(exit)).toBe(true);
+  });
+
+  it("DateFromString transforms date string to Date", () => {
+    const result = Effect.runSync(
+      Schema.decodeUnknown(DateFromString)("2024-01-15"),
+    );
+    expect(result).toBeInstanceOf(Date);
+    expect((result as Date).getFullYear()).toBe(2024);
+  });
+
+  it("decodeUser succeeds with valid data", () => {
+    const result = Effect.runSync(decodeUser({ id: 1, name: "Alice" }));
+    expect(result).toEqual({ id: 1, name: "Alice" });
+    // Must reject invalid id (verifies UserSchema uses PositiveInt)
+    const exit = Effect.runSyncExit(decodeUser({ id: -1, name: "Alice" }));
+    expect(Exit.isFailure(exit)).toBe(true);
+  });
+
+  it("decodeUser fails with invalid id", () => {
+    const exit = Effect.runSyncExit(decodeUser({ id: -1, name: "Alice" }));
+    expect(Exit.isFailure(exit)).toBe(true);
+  });
+
+  it("decodeUser fails with empty name", () => {
+    const exit = Effect.runSyncExit(decodeUser({ id: 1, name: "" }));
+    expect(Exit.isFailure(exit)).toBe(true);
+  });
+});

package/katas/036-schema-advanced/solution.ts

@@ -0,0 +1,19 @@
+import { Effect, Schema } from "effect";
+
+/** Define a schema for positive integers using Schema.Number with int() and positive() filters */
+export const PositiveInt: Schema.Schema<number> = Schema.Number as any;
+
+/** Define a schema that transforms a string to a Date */
+export const DateFromString: Schema.Schema<Date, string> = Schema.String as any;
+
+/** Define a User schema with id (PositiveInt) and name (NonEmptyString) */
+export const UserSchema = Schema.Struct({
+  id: Schema.Number,
+  name: Schema.String,
+});
+
+/** Create a decode function for UserSchema */
+export const decodeUser = Schema.decodeUnknown(UserSchema);
+
+/** Create an encode function for UserSchema */
+export const encodeUser = Schema.encode(UserSchema);