graph TD
    A[Effect-ts 設計思想] --> B[型安全性]
    A --> C[合成可能性]
    A --> D[観測可能性]
 
    B --> B1[エラー型の追跡]
    B --> B2[依存の追跡]
    B --> B3[リソースの安全性]
 
    C --> C1[パイプライン構築]
    C --> C2[Layer の合成]
    C --> C3[モジュラー設計]
 
    D --> D1[トレーシング]
    D --> D2[メトリクス]
    D --> D3[構造化ログ]

import { Effect } from "effect";
 
// コンパイル時にエラー型が追跡される
const program: Effect.Effect<number, DivisionByZeroError> =
  divide(10, 0);
 
// エラーを処理しないとコンパイルエラー
const safe: Effect.Effect<number, never> = program.pipe(
  Effect.catchAll(() => Effect.succeed(0))
);

const saveUser = (user: User) =>
  Effect.gen(function* () {
    yield* validateUser(user);    // Effect<void, ValidationError, Validator>
    yield* storeInDb(user);        // Effect<void, DbError, Database>
    yield* sendEmail(user.email);  // Effect<void, EmailError, EmailService>
    yield* logEvent("user.created"); // Effect<void, never, Logger>
  });
// 型: Effect<void, ValidationError | DbError | EmailError, Validator & Database & EmailService & Logger>

const program = fetchUser("123").pipe(
  Effect.withSpan("fetchUser", { attributes: { userId: "123" } }),
  Effect.tap((user) => Effect.log(`Fetched user: ${user.name}`)),
  Effect.tapErrorCause((cause) => Effect.logError("Fetch failed", cause))
);

import { Effect } from "effect";
 
// (1) 成功する Effect: Effect<A, never, never>
const succeed: Effect.Effect<number> = Effect.succeed(42);
//   型パラメータ: A=number, E=never (エラーなし), R=never (依存なし)
 
// (2) 失敗する Effect: Effect<never, E, never>
const fail: Effect.Effect<never, Error> = Effect.fail(new Error("boom"));
//   型パラメータ: A=never (成功しない), E=Error, R=never
 
// (3) 依存が必要な Effect: Effect<A, E, R>
interface Database {
  readonly query: (sql: string) => Promise<unknown>;
}
 
const queryDb: Effect.Effect<string, DbError, Database> =
  Effect.gen(function* () {
    const db = yield* Effect.context<Database>();
    // Database に依存している
    return "result";
  });

import { Effect } from "effect";
 
// 成功値
const a = Effect.succeed(42);
// Effect<number, never, never>
 
// 失敗値
const b = Effect.fail("error");
// Effect<never, string, never>
 
// 遅延評価
const c = Effect.sync(() => {
  console.log("evaluated!");
  return 100;
});
// Effect<number, never, never>
// 実行されるまで console.log は呼ばれない
 
// void (Unit)
const d = Effect.void;
// Effect<void, never, never>

import { Effect } from "effect";
 
// tryPromise: Promise<T> → Effect<T, UnknownException>
const e = Effect.tryPromise(() =>
  fetch("/api/data").then((r) => r.json())
);
// Effect<any, UnknownException, never>
 
// エラーを変換
class FetchError {
  readonly _tag = "FetchError";
  constructor(readonly cause: unknown) {}
}
 
const f = Effect.tryPromise({
  try: () => fetch("/api/data").then((r) => r.json()),
  catch: (error) => new FetchError(error),
});
// Effect<any, FetchError, never>

import { Effect } from "effect";
 
// try: 例外を投げる可能性がある関数
const g = Effect.try(() => {
  const data = JSON.parse('{"invalid"}'); // SyntaxError が投げられる
  return data;
});
// Effect<unknown, UnknownException, never>
 
// catch でエラーを変換
class ParseError {
  readonly _tag = "ParseError";
  constructor(readonly input: string, readonly cause: unknown) {}
}
 
const h = Effect.try({
  try: () => JSON.parse('{"invalid"}'),
  catch: (error) => new ParseError('{"invalid"}', error),
});
// Effect<unknown, ParseError, never>

import { Effect } from "effect";
 
const program = Effect.succeed(42);
 
// (1) runSync: 同期的に実行（エラーは例外として投げられる）
const result1 = Effect.runSync(program);
// 42
 
// (2) runPromise: Promise として実行
const result2 = await Effect.runPromise(program);
// 42
 
// (3) runPromiseExit: Exit 型で実行（エラーも安全に取得）
const exit = await Effect.runPromiseExit(program);
if (exit._tag === "Success") {
  console.log(exit.value); // 42
} else {
  console.error(exit.cause);
}
 
// (4) runFork: Fiber として実行（バックグラウンド）
const fiber = Effect.runFork(program);
const result3 = await fiber.await();

import { Effect, pipe } from "effect";
 
// pipe 関数を使ったパイプライン
const program = pipe(
  Effect.succeed(10),
  Effect.map((n) => n * 2),           // 20
  Effect.flatMap((n) =>
    n > 15
      ? Effect.succeed(`Large: ${n}`)
      : Effect.fail(new Error("Too small"))
  ),
  Effect.tap((value) =>
    Effect.log(`Result: ${value}`)
  )
);
 
// メソッドチェーンスタイル（同じ意味）
const program2 = Effect.succeed(10).pipe(
  Effect.map((n) => n * 2),
  Effect.flatMap((n) =>
    n > 15
      ? Effect.succeed(`Large: ${n}`)
      : Effect.fail(new Error("Too small"))
  ),
  Effect.tap((value) => Effect.log(`Result: ${value}`))
);
 
// 実行
const result = await Effect.runPromise(program);
// "Large: 20"

import { Effect } from "effect";
 
const program = Effect.succeed(42).pipe(
  Effect.map((n) => n * 2),
  Effect.map((n) => `Result: ${n}`)
);
// Effect<string, never, never>
// 実行結果: "Result: 84"

import { Effect } from "effect";
 
const divide = (a: number, b: number): Effect.Effect<number, string> =>
  b === 0
    ? Effect.fail("Division by zero")
    : Effect.succeed(a / b);
 
const program = Effect.succeed(10).pipe(
  Effect.flatMap((n) => divide(n, 2)),  // 5
  Effect.flatMap((n) => divide(n, 0))   // エラー
);
// Effect<number, string, never>

import { Effect } from "effect";
 
const program = Effect.succeed(42).pipe(
  Effect.tap((n) => Effect.log(`Value is ${n}`)), // ログを出すが値は変わらない
  Effect.map((n) => n * 2)
);
// Effect<number, never, never>
// 実行結果: 84 (ログ: "Value is 42")

import { Effect } from "effect";
 
const a = Effect.succeed(10);
const b = Effect.succeed(20);
 
const sum = Effect.zipWith(a, b, (x, y) => x + y);
// Effect<number, never, never>
// 実行結果: 30

import { Effect } from "effect";
 
const program = Effect.succeed(42).pipe(
  Effect.filterOrFail(
    (n) => n > 50,
    () => new Error("Value too small")
  )
);
// Effect<number, Error, never>
// 実行するとエラー

import { Effect } from "effect";
 
// pipe スタイル
const program1 = pipe(
  Effect.succeed(10),
  Effect.flatMap((a) =>
    pipe(
      Effect.succeed(20),
      Effect.map((b) => a + b)
    )
  )
);
 
// Effect.gen スタイル（同じ意味）
const program2 = Effect.gen(function* () {
  const a = yield* Effect.succeed(10);
  const b = yield* Effect.succeed(20);
  return a + b;
});

import { Effect, Data } from "effect";
 
class NotFoundError extends Data.TaggedError("NotFoundError")<{
  readonly id: string;
}> {}
 
class PermissionError extends Data.TaggedError("PermissionError")<{
  readonly action: string;
}> {}
 
interface User {
  id: string;
  name: string;
  role: "ADMIN" | "USER";
}
 
const findUser = (id: string): Effect.Effect<User, NotFoundError> =>
  id === "123"
    ? Effect.succeed({ id, name: "Alice", role: "ADMIN" })
    : Effect.fail(new NotFoundError({ id }));
 
const fetchPosts = (userId: string): Effect.Effect<string[]> =>
  Effect.succeed([`post1-${userId}`, `post2-${userId}`]);
 
const fetchComments = (userId: string): Effect.Effect<string[]> =>
  Effect.succeed([`comment1-${userId}`]);
 
// Effect.gen で同期的に書く
const program = Effect.gen(function* () {
  // yield* で Effect の値を取り出す
  const user = yield* findUser("123");
 
  // 通常の if 文が使える
  if (user.role !== "ADMIN") {
    yield* Effect.fail(
      new PermissionError({ action: "delete" })
    );
  }
 
  // 並列実行
  const [posts, comments] = yield* Effect.all(
    [fetchPosts(user.id), fetchComments(user.id)],
    { concurrency: 2 }
  );
 
  // ログ
  yield* Effect.log(`User ${user.name} has ${posts.length} posts`);
 
  return { user, posts, comments };
});

import { Data } from "effect";
 
// Data.TaggedError を使うと _tag フィールドが自動的に追加される
class NotFoundError extends Data.TaggedError("NotFoundError")<{
  readonly resource: string;
  readonly id: string;
}> {}
 
class ValidationError extends Data.TaggedError("ValidationError")<{
  readonly message: string;
  readonly fields: readonly string[];
}> {}
 
class DatabaseError extends Data.TaggedError("DatabaseError")<{
  readonly cause: unknown;
}> {}
 
class NetworkError extends Data.TaggedError("NetworkError")<{
  readonly url: string;
  readonly statusCode: number;
}> {}
 
// 使用例
const error1 = new NotFoundError({ resource: "User", id: "123" });
console.log(error1._tag); // "NotFoundError"
 
const error2 = new ValidationError({
  message: "Invalid email",
  fields: ["email"],
});
console.log(error2._tag); // "ValidationError"

import { Effect, pipe, Data } from "effect";
 
class NotFoundError extends Data.TaggedError("NotFoundError")<{
  readonly resource: string;
  readonly id: string;
}> {}
 
class DatabaseError extends Data.TaggedError("DatabaseError")<{
  readonly cause: unknown;
}> {}
 
interface User {
  id: string;
  name: string;
}
 
interface Database {
  findById: (id: string) => Promise<User | null>;
}
 
// エラーを返す Effect
function findUser(
  id: string
): Effect.Effect<User, NotFoundError | DatabaseError, Database> {
  return Effect.gen(function* () {
    const db = yield* Effect.context<Database>();
 
    // Promise を Effect に変換
    const user = yield* Effect.tryPromise({
      try: () => db.findById(id),
      catch: (cause) => new DatabaseError({ cause }),
    });
 
    // null の場合は NotFoundError
    if (user === null) {
      yield* Effect.fail(new NotFoundError({ resource: "User", id }));
    }
 
    return user;
  });
}
// 型: Effect<User, NotFoundError | DatabaseError, Database>

import { Effect } from "effect";
 
const program = findUser("123").pipe(
  Effect.catchAll((error) => {
    console.error("Error:", error);
    return Effect.succeed(null); // デフォルト値を返す
  })
);
// 型: Effect<User | null, never, Database>

import { Effect } from "effect";
 
const userOrDefault = findUser("123").pipe(
  Effect.catchTag("NotFoundError", (error) =>
    Effect.succeed({ id: error.id, name: "Guest" } as User)
  )
  // DatabaseError はそのまま伝播
);
// 型: Effect<User, DatabaseError, Database>

import { Effect } from "effect";
 
const resilient = findUser("123").pipe(
  Effect.catchTags({
    NotFoundError: (error) =>
      Effect.succeed({ id: error.id, name: "Guest" } as User),
    DatabaseError: (error) => {
      console.error("DB Error:", error.cause);
      return Effect.fail(new Error("Service unavailable"));
    },
  })
);
// 型: Effect<User, Error, Database>

import { Effect, Option } from "effect";
 
const program = findUser("123").pipe(
  Effect.catchSome((error) => {
    if (error._tag === "NotFoundError" && error.id === "123") {
      return Option.some(Effect.succeed({ id: "123", name: "Default" } as User));
    }
    return Option.none(); // エラーを伝播
  })
);

import { Effect } from "effect";
 
const program = findUser("123").pipe(
  Effect.orElse(() => findUser("456")), // 失敗したら別のユーザーを探す
  Effect.orElse(() => Effect.succeed({ id: "default", name: "Guest" } as User))
);

import { Effect, Context, Layer, Data } from "effect";
 
// エラー定義
class DatabaseError extends Data.TaggedError("DatabaseError")<{
  readonly cause: unknown;
}> {}
 
class EmailError extends Data.TaggedError("EmailError")<{
  readonly cause: unknown;
}> {}
 
interface User {
  id: string;
  name: string;
  email: string;
  createdAt: Date;
}
 
// サービスインターフェースの定義
class UserRepository extends Context.Tag("UserRepository")<
  UserRepository,
  {
    readonly findById: (id: string) => Effect.Effect<User | null, DatabaseError>;
    readonly save: (user: User) => Effect.Effect<void, DatabaseError>;
    readonly delete: (id: string) => Effect.Effect<void, DatabaseError>;
  }
>() {}
 
class EmailService extends Context.Tag("EmailService")<
  EmailService,
  {
    readonly send: (
      to: string,
      subject: string,
      body: string
    ) => Effect.Effect<void, EmailError>;
  }
>() {}
 
class Logger extends Context.Tag("Logger")<
  Logger,
  {
    readonly info: (message: string) => Effect.Effect<void>;
    readonly error: (message: string, cause?: unknown) => Effect.Effect<void>;
  }
>() {}

import { Effect } from "effect";
 
class ValidationError extends Data.TaggedError("ValidationError")<{
  readonly message: string;
}> {}
 
interface CreateUserDto {
  name: string;
  email: string;
}
 
// サービスを使う関数
function createUser(
  data: CreateUserDto
): Effect.Effect<
  User,
  ValidationError | DatabaseError | EmailError,
  UserRepository & EmailService & Logger
> {
  return Effect.gen(function* () {
    // サービスを取得
    const userRepo = yield* UserRepository;
    const emailService = yield* EmailService;
    const logger = yield* Logger;
 
    // バリデーション
    if (!data.email.includes("@")) {
      yield* Effect.fail(new ValidationError({ message: "Invalid email" }));
    }
 
    // ログ
    yield* logger.info(`Creating user: ${data.email}`);
 
    // ユーザー作成
    const user: User = {
      id: crypto.randomUUID(),
      name: data.name,
      email: data.email,
      createdAt: new Date(),
    };
 
    // DB に保存
    yield* userRepo.save(user);
 
    // メール送信
    yield* emailService.send(user.email, "Welcome!", `Hello ${user.name}`);
 
    // ログ
    yield* logger.info(`User created: ${user.id}`);
 
    return user;
  });
}

import { Effect, Layer } from "effect";
 
// (1) Logger の実装
const ConsoleLoggerLive = Layer.succeed(Logger, {
  info: (message) => Effect.log(`[INFO] ${message}`),
  error: (message, cause) =>
    Effect.logError(`[ERROR] ${message}`, cause),
});
 
// (2) EmailService の実装
const ConsoleEmailServiceLive = Layer.succeed(EmailService, {
  send: (to, subject, body) =>
    Effect.sync(() => {
      console.log(`Email to ${to}: ${subject}`);
      console.log(body);
    }),
});
 
// (3) UserRepository の実装（他のサービスに依存）
const InMemoryUserRepoLive = Layer.effect(
  UserRepository,
  Effect.gen(function* () {
    const logger = yield* Logger;
    const users = new Map<string, User>();
 
    return {
      findById: (id) =>
        Effect.sync(() => users.get(id) ?? null),
 
      save: (user) =>
        Effect.gen(function* () {
          users.set(user.id, user);
          yield* logger.info(`Saved user: ${user.id}`);
        }),
 
      delete: (id) =>
        Effect.gen(function* () {
          users.delete(id);
          yield* logger.info(`Deleted user: ${id}`);
        }),
    };
  })
);
 
// Layer の合成
const AppLayerLive = Layer.mergeAll(
  ConsoleLoggerLive,
  ConsoleEmailServiceLive,
  InMemoryUserRepoLive.pipe(
    Layer.provide(ConsoleLoggerLive) // UserRepo は Logger に依存
  )
);
 
// 実行
const program = createUser({ name: "Alice", email: "alice@example.com" });
const result = await Effect.runPromise(
  program.pipe(Effect.provide(AppLayerLive))
);

import { Layer } from "effect";
 
// テスト用の Mock Layer
const MockUserRepoLive = Layer.succeed(UserRepository, {
  findById: (id) =>
    Effect.succeed({
      id,
      name: "Test User",
      email: "test@example.com",
      createdAt: new Date(),
    }),
  save: () => Effect.void,
  delete: () => Effect.void,
});
 
const MockEmailServiceLive = Layer.succeed(EmailService, {
  send: () => Effect.void, // メール送信しない
});
 
const TestLayerLive = Layer.mergeAll(
  ConsoleLoggerLive,
  MockEmailServiceLive,
  MockUserRepoLive.pipe(Layer.provide(ConsoleLoggerLive))
);
 
// テストでは TestLayer を使用
const testResult = await Effect.runPromise(
  createUser({ name: "Bob", email: "bob@test.com" }).pipe(
    Effect.provide(TestLayerLive)
  )
);

graph TD
    A[AppLayer] --> B[Layer.mergeAll]
    B --> C[LoggerLayer]
    B --> D[EmailServiceLayer]
    B --> E[UserRepoLayer]
    E --> F[Layer.provide]
    F --> C
 
    style A fill:#90EE90
    style C fill:#FFB6C1
    style D fill:#FFB6C1
    style E fill:#87CEEB

import { Effect } from "effect";
 
const fetchUser = (id: string): Effect.Effect<User> =>
  Effect.succeed({ id, name: `User ${id}`, email: `${id}@example.com`, createdAt: new Date() });
 
// (1) 並列実行（制限なし）
const allUsers = Effect.all(
  [fetchUser("1"), fetchUser("2"), fetchUser("3")],
  { concurrency: "unbounded" }
);
// 型: Effect<[User, User, User], never, never>
 
// (2) 制限付き並列実行
const urls = ["url1", "url2", "url3", "url4", "url5"];
const limited = Effect.all(
  urls.map((url) => Effect.succeed(url)),
  { concurrency: 2 } // 最大2並列
);
 
// (3) 最初に成功した結果を使用
const fastest = Effect.raceAll([
  Effect.succeed("CDN1"),
  Effect.succeed("CDN2"),
  Effect.succeed("CDN3"),
]);
 
// (4) forEach: 配列の各要素に Effect を適用
const userIds = ["1", "2", "3", "4", "5"];
const results = Effect.forEach(
  userIds,
  (id) => fetchUser(id),
  { concurrency: 3 }
);

import { Effect, Fiber } from "effect";
 
// Fiber: 軽量スレッドのようなもの
const program = Effect.gen(function* () {
  // バックグラウンドで実行
  const fiber1 = yield* Effect.fork(
    Effect.gen(function* () {
      yield* Effect.sleep("1 second");
      return "Result 1";
    })
  );
 
  const fiber2 = yield* Effect.fork(
    Effect.gen(function* () {
      yield* Effect.sleep("500 millis");
      return "Result 2";
    })
  );
 
  // 他の処理
  yield* Effect.log("Doing other work...");
 
  // Fiber の結果を待つ
  const result1 = yield* Fiber.join(fiber1);
  const result2 = yield* Fiber.join(fiber2);
 
  return [result1, result2];
});

import { Effect, Fiber } from "effect";
 
const program = Effect.gen(function* () {
  const fiber = yield* Effect.fork(
    Effect.gen(function* () {
      yield* Effect.sleep("10 seconds");
      return "Long running task";
    })
  );
 
  // 500ms 待つ
  yield* Effect.sleep("500 millis");
 
  // Fiber を中断
  yield* Fiber.interrupt(fiber);
 
  // 中断されたかチェック
  const result = yield* Fiber.await(fiber);
  if (result._tag === "Failure") {
    yield* Effect.log("Fiber was interrupted");
  }
});

import { Effect, Ref } from "effect";
 
const program = Effect.gen(function* () {
  // Ref の作成
  const counter = yield* Ref.make(0);
 
  // 値を取得
  const value1 = yield* Ref.get(counter);
  console.log(value1); // 0
 
  // 値を設定
  yield* Ref.set(counter, 10);
 
  // 値を更新
  yield* Ref.update(counter, (n) => n + 5);
 
  // アトミックな更新と取得
  const oldValue = yield* Ref.getAndUpdate(counter, (n) => n * 2);
  console.log(oldValue); // 15
 
  const newValue = yield* Ref.get(counter);
  console.log(newValue); // 30
});

import { Effect, Queue } from "effect";
 
const program = Effect.gen(function* () {
  // キューの作成（容量100）
  const queue = yield* Queue.bounded<string>(100);
 
  // プロデューサー
  const producer = Effect.gen(function* () {
    for (let i = 0; i < 10; i++) {
      yield* Queue.offer(queue, `Item ${i}`);
      yield* Effect.sleep("100 millis");
    }
  });
 
  // コンシューマー
  const consumer = Effect.gen(function* () {
    for (let i = 0; i < 10; i++) {
      const item = yield* Queue.take(queue);
      yield* Effect.log(`Consumed: ${item}`);
    }
  });
 
  // 並列実行
  yield* Effect.all([producer, consumer], { concurrency: 2 });
});

import { Effect, Schedule } from "effect";
 
// (1) 固定間隔
const everySecond = Schedule.fixed("1 second");
 
// (2) 指数バックオフ
const exponential = Schedule.exponential("100 millis");
// 100ms, 200ms, 400ms, 800ms, ...
 
// (3) 回数制限
const maxRetries = Schedule.recurs(5); // 最大5回
 
// (4) 合成
const policy = Schedule.exponential("100 millis").pipe(
  Schedule.compose(Schedule.recurs(5)),
  Schedule.jittered // ランダムなジッターを追加
);

import { Effect, Schedule } from "effect";
 
class NetworkError extends Data.TaggedError("NetworkError")<{
  readonly url: string;
}> {}
 
const fetchData = (url: string): Effect.Effect<string, NetworkError> =>
  Effect.fail(new NetworkError({ url })); // 常に失敗する例
 
// (1) 基本的なリトライ
const retried = fetchData("https://api.example.com").pipe(
  Effect.retry(Schedule.recurs(3)) // 最大3回リトライ
);
 
// (2) 指数バックオフでリトライ
const retryPolicy = Schedule.exponential("100 millis").pipe(
  Schedule.compose(Schedule.recurs(5)),
  Schedule.jittered
);
 
const resilient = fetchData("https://api.example.com").pipe(
  Effect.retry(retryPolicy)
);
 
// (3) タイムアウト付き
const withTimeout = fetchData("https://api.example.com").pipe(
  Effect.timeout("5 seconds")
);
 
// (4) リトライ + タイムアウト
const robust = fetchData("https://api.example.com").pipe(
  Effect.timeout("3 seconds"),
  Effect.retry(
    Schedule.exponential("200 millis").pipe(
      Schedule.compose(Schedule.recurs(3))
    )
  )
);

import { Effect, Schedule } from "effect";
 
class TransientError extends Data.TaggedError("TransientError")<{
  readonly cause: unknown;
}> {}
 
class PermanentError extends Data.TaggedError("PermanentError")<{
  readonly cause: unknown;
}> {}
 
const task: Effect.Effect<string, TransientError | PermanentError> =
  Effect.fail(new TransientError({ cause: "Network issue" }));
 
// TransientError のみリトライ
const selective = task.pipe(
  Effect.retry({
    schedule: Schedule.recurs(3),
    while: (error) => error._tag === "TransientError",
  })
);

import { Effect, Schedule } from "effect";
 
// (1) 10回繰り返す
const repeated = Effect.log("Hello").pipe(
  Effect.repeat(Schedule.recurs(10))
);
 
// (2) 1秒ごとに無限に繰り返す
const polling = Effect.gen(function* () {
  const data = yield* fetchData("https://api.example.com/status");
  yield* Effect.log(`Status: ${data}`);
}).pipe(
  Effect.repeat(Schedule.fixed("1 second"))
);
 
// (3) 条件を満たすまで繰り返す
const untilCondition = Effect.sync(() => Math.random()).pipe(
  Effect.repeat({
    schedule: Schedule.spaced("100 millis"),
    until: (value) => value > 0.9, // 0.9 以上になるまで
  })
);

import { Schema } from "effect";
 
// (1) プリミティブ型
const StringSchema = Schema.String;
const NumberSchema = Schema.Number;
const BooleanSchema = Schema.Boolean;
 
// (2) リテラル型
const RoleSchema = Schema.Literal("ADMIN", "USER", "GUEST");
 
// (3) オブジェクト
const UserSchema = Schema.Struct({
  id: Schema.String,
  name: Schema.String,
  email: Schema.String,
  age: Schema.Number,
  role: RoleSchema,
});
 
// (4) 配列
const UsersSchema = Schema.Array(UserSchema);
 
// (5) オプショナル
const UserWithOptionalAgeSchema = Schema.Struct({
  id: Schema.String,
  name: Schema.String,
  email: Schema.String,
  age: Schema.optional(Schema.Number),
  role: RoleSchema,
});

import { Schema, Effect } from "effect";
 
const UserSchema = Schema.Struct({
  id: Schema.String,
  name: Schema.String,
  email: Schema.String.pipe(Schema.pattern(/^[^\s@]+@[^\s@]+\.[^\s@]+$/)),
  age: Schema.Number.pipe(Schema.greaterThanOrEqualTo(0)),
});
 
// unknown → User の変換
const parse = Schema.decodeUnknown(UserSchema);
 
const validData = {
  id: "123",
  name: "Alice",
  email: "alice@example.com",
  age: 25,
};
 
const program = Effect.gen(function* () {
  // バリデーション成功
  const user = yield* parse(validData);
  console.log(user); // { id: "123", name: "Alice", ... }
 
  // バリデーション失敗
  const invalidData = { id: "456", name: "Bob", email: "invalid", age: -5 };
  const result = yield* Effect.either(parse(invalidData));
 
  if (result._tag === "Left") {
    console.error("Validation failed:", result.left);
  }
});

import { Schema } from "effect";
 
// (1) カスタム制約
const PositiveNumber = Schema.Number.pipe(
  Schema.filter((n) => n > 0, { message: () => "Must be positive" })
);
 
// (2) Transform
const TrimmedString = Schema.String.pipe(
  Schema.transform(
    Schema.String,
    {
      decode: (s) => s.trim(),
      encode: (s) => s,
    }
  )
);
 
// (3) カスタム型
const EmailSchema = Schema.String.pipe(
  Schema.pattern(/^[^\s@]+@[^\s@]+\.[^\s@]+$/),
  Schema.brand("Email")
);
 
type Email = Schema.Schema.Type<typeof EmailSchema>;
 
// (4) 複雑なバリデーション
const PasswordSchema = Schema.String.pipe(
  Schema.minLength(8),
  Schema.filter(
    (s) => /[A-Z]/.test(s) && /[a-z]/.test(s) && /[0-9]/.test(s),
    { message: () => "Must contain uppercase, lowercase, and digit" }
  )
);

import { Schema, Effect, Data } from "effect";
 
class ValidationError extends Data.TaggedError("ValidationError")<{
  readonly errors: ReadonlyArray<string>;
}> {}
 
const CreateUserRequestSchema = Schema.Struct({
  name: Schema.String.pipe(Schema.minLength(1)),
  email: Schema.String.pipe(Schema.pattern(/^[^\s@]+@[^\s@]+\.[^\s@]+$/)),
  age: Schema.Number.pipe(
    Schema.greaterThanOrEqualTo(0),
    Schema.lessThanOrEqualTo(150)
  ),
});
 
type CreateUserRequest = Schema.Schema.Type<typeof CreateUserRequestSchema>;
 
const validateRequest = (
  data: unknown
): Effect.Effect<CreateUserRequest, ValidationError> => {
  const decode = Schema.decodeUnknown(CreateUserRequestSchema);
 
  return decode(data).pipe(
    Effect.mapError((error) =>
      new ValidationError({
        errors: [String(error)],
      })
    )
  );
};
 
// 使用例
const handleRequest = (body: unknown) =>
  Effect.gen(function* () {
    const request = yield* validateRequest(body);
 
    // request は型安全に使える
    const user = yield* createUser(request);
 
    return user;
  });

import { Stream, Effect } from "effect";
 
// (1) Stream の作成
const stream1 = Stream.make(1, 2, 3, 4, 5);
 
const stream2 = Stream.range(1, 10); // 1, 2, ..., 9
 
const stream3 = Stream.fromIterable([1, 2, 3]);
 
// (2) Stream の操作
const doubled = stream1.pipe(
  Stream.map((n) => n * 2)
);
 
const filtered = stream1.pipe(
  Stream.filter((n) => n % 2 === 0)
);
 
// (3) Stream の実行
const program = Stream.runCollect(doubled);
// Effect<Chunk<number>, never, never>
 
const result = await Effect.runPromise(program);
// Chunk([2, 4, 6, 8, 10])

import { Stream, Effect, Schedule } from "effect";
 
// (1) Effect から Stream を作成
const fetchStream = Stream.repeatEffect(
  Effect.gen(function* () {
    const response = yield* Effect.tryPromise({
      try: () => fetch("https://api.example.com/data"),
      catch: (error) => new Error(String(error)),
    });
    const data = yield* Effect.tryPromise({
      try: () => response.json(),
      catch: (error) => new Error(String(error)),
    });
    return data;
  })
);
 
// (2) 定期実行
const pollingStream = Stream.repeatEffectWithSchedule(
  Effect.sync(() => new Date().toISOString()),
  Schedule.fixed("1 second")
);
 
// (3) ファイルの行ごと処理
const fileStream = Stream.fromIterable(["line1", "line2", "line3"]);
 
const processed = fileStream.pipe(
  Stream.map((line) => line.toUpperCase()),
  Stream.filter((line) => line.length > 5)
);

import { Stream, Effect } from "effect";
 
const stream1 = Stream.make(1, 2, 3);
const stream2 = Stream.make(4, 5, 6);
 
// (1) 連結
const concatenated = Stream.concat(stream1, stream2);
// 1, 2, 3, 4, 5, 6
 
// (2) Merge
const merged = Stream.merge(stream1, stream2);
// 順序は保証されない
 
// (3) Zip
const zipped = Stream.zip(stream1, stream2);
// [1, 4], [2, 5], [3, 6]
 
// (4) flatMap
const flattened = stream1.pipe(
  Stream.flatMap((n) => Stream.make(n, n * 10))
);
// 1, 10, 2, 20, 3, 30

import { Stream, Sink, Effect } from "effect";
 
const stream = Stream.make(1, 2, 3, 4, 5);
 
// (1) 合計
const sum = Stream.run(stream, Sink.sum);
// Effect<number, never, never> → 15
 
// (2) 配列に収集
const collect = Stream.run(stream, Sink.collectAll());
// Effect<Chunk<number>, never, never>
 
// (3) 最初のn個
const takeFirst = Stream.run(stream, Sink.take(3));
// Effect<Chunk<number>, never, never> → [1, 2, 3]
 
// (4) カスタム Sink
const customSink = Sink.foldLeft(0, (acc, n: number) => acc + n * 2);
const result = Stream.run(stream, customSink);
// 2 + 4 + 6 + 8 + 10 = 30

import { Stream, Effect, pipe } from "effect";
 
interface LogEntry {
  timestamp: string;
  level: "INFO" | "WARN" | "ERROR";
  message: string;
}
 
const parseLogLine = (line: string): Effect.Effect<LogEntry, Error> =>
  Effect.try({
    try: () => {
      const [timestamp, level, message] = line.split(" | ");
      return {
        timestamp,
        level: level as "INFO" | "WARN" | "ERROR",
        message,
      };
    },
    catch: (error) => new Error(`Parse failed: ${error}`),
  });
 
const processLogFile = (lines: string[]) =>
  pipe(
    Stream.fromIterable(lines),
    Stream.mapEffect((line) => parseLogLine(line)),
    Stream.filter((entry) => entry.level === "ERROR"),
    Stream.take(100), // 最初の100件のエラーのみ
    Stream.runCollect
  );
 
// 使用例
const lines = [
  "2024-01-01T00:00:00Z | INFO | Server started",
  "2024-01-01T00:01:00Z | ERROR | Connection failed",
  "2024-01-01T00:02:00Z | WARN | High memory usage",
];
 
const program = processLogFile(lines);
const errors = await Effect.runPromise(program);

import { Effect, Layer, Context, Data } from "effect";
import { Schema } from "effect";
 
// エラー定義
class ValidationError extends Data.TaggedError("ValidationError")<{
  readonly errors: ReadonlyArray<string>;
}> {}
 
class DatabaseError extends Data.TaggedError("DatabaseError")<{
  readonly cause: unknown;
}> {}
 
class NotFoundError extends Data.TaggedError("NotFoundError")<{
  readonly resource: string;
  readonly id: string;
}> {}
 
// スキーマ定義
const UserSchema = Schema.Struct({
  id: Schema.String,
  name: Schema.String,
  email: Schema.String.pipe(Schema.pattern(/^[^\s@]+@[^\s@]+\.[^\s@]+$/)),
  createdAt: Schema.Date,
});
 
const CreateUserRequestSchema = Schema.Struct({
  name: Schema.String.pipe(Schema.minLength(1)),
  email: Schema.String.pipe(Schema.pattern(/^[^\s@]+@[^\s@]+\.[^\s@]+$/)),
});
 
type User = Schema.Schema.Type<typeof UserSchema>;
type CreateUserRequest = Schema.Schema.Type<typeof CreateUserRequestSchema>;
 
// サービス定義
class Database extends Context.Tag("Database")<
  Database,
  {
    readonly query: <A>(sql: string, params: unknown[]) => Effect.Effect<A, DatabaseError>;
  }
>() {}
 
class Logger extends Context.Tag("Logger")<
  Logger,
  {
    readonly info: (message: string) => Effect.Effect<void>;
    readonly error: (message: string, error: unknown) => Effect.Effect<void>;
  }
>() {}
 
// ビジネスロジック
const createUser = (
  request: CreateUserRequest
): Effect.Effect<User, ValidationError | DatabaseError, Database & Logger> =>
  Effect.gen(function* () {
    const db = yield* Database;
    const logger = yield* Logger;
 
    yield* logger.info(`Creating user: ${request.email}`);
 
    const user: User = {
      id: crypto.randomUUID(),
      name: request.name,
      email: request.email,
      createdAt: new Date(),
    };
 
    yield* db.query(
      "INSERT INTO users (id, name, email, created_at) VALUES ($1, $2, $3, $4)",
      [user.id, user.name, user.email, user.createdAt]
    );
 
    yield* logger.info(`User created: ${user.id}`);
 
    return user;
  });
 
const getUser = (
  id: string
): Effect.Effect<User, NotFoundError | DatabaseError, Database> =>
  Effect.gen(function* () {
    const db = yield* Database;
 
    const result = yield* db.query<User[]>(
      "SELECT * FROM users WHERE id = $1",
      [id]
    );
 
    if (result.length === 0) {
      yield* Effect.fail(new NotFoundError({ resource: "User", id }));
    }
 
    return result[0];
  });
 
// Layer 実装
const PostgresDatabaseLive = Layer.succeed(Database, {
  query: (sql, params) =>
    Effect.tryPromise({
      try: async () => {
        // 実際の PostgreSQL クライアントを使用
        // const result = await pool.query(sql, params);
        // return result.rows;
        return [] as any;
      },
      catch: (cause) => new DatabaseError({ cause }),
    }),
});
 
const ConsoleLoggerLive = Layer.succeed(Logger, {
  info: (message) => Effect.log(`[INFO] ${message}`),
  error: (message, error) => Effect.logError(`[ERROR] ${message}`, error),
});
 
const AppLayerLive = Layer.mergeAll(
  PostgresDatabaseLive,
  ConsoleLoggerLive
);
 
// Express との統合例
import express from "express";
 
const app = express();
app.use(express.json());
 
app.post("/users", async (req, res) => {
  const program = Effect.gen(function* () {
    // リクエストのバリデーション
    const request = yield* Schema.decodeUnknown(CreateUserRequestSchema)(req.body).pipe(
      Effect.mapError((error) => new ValidationError({ errors: [String(error)] }))
    );
 
    // ユーザー作成
    const user = yield* createUser(request);
 
    return user;
  }).pipe(
    Effect.provide(AppLayerLive)
  );
 
  const exit = await Effect.runPromiseExit(program);
 
  if (exit._tag === "Success") {
    res.status(201).json(exit.value);
  } else {
    const error = exit.cause;
    // エラーハンドリング
    if (error._tag === "Fail" && error.error._tag === "ValidationError") {
      res.status(400).json({ errors: error.error.errors });
    } else {
      res.status(500).json({ error: "Internal server error" });
    }
  }
});
 
app.get("/users/:id", async (req, res) => {
  const program = getUser(req.params.id).pipe(
    Effect.provide(AppLayerLive)
  );
 
  const exit = await Effect.runPromiseExit(program);
 
  if (exit._tag === "Success") {
    res.json(exit.value);
  } else {
    const error = exit.cause;
    if (error._tag === "Fail" && error.error._tag === "NotFoundError") {
      res.status(404).json({ error: "User not found" });
    } else {
      res.status(500).json({ error: "Internal server error" });
    }
  }
});