Effect-TS Functional Patterns

# Effect-TS Functional Patterns for Google Antigravity IDE

Build robust, type-safe applications with Effect-TS using Google Antigravity IDE. This comprehensive guide covers functional effects, error handling, dependency injection, and concurrent programming patterns that eliminate runtime exceptions.

## Core Effect Patterns

```typescript
// src/services/user-service.ts
import { Effect, Context, Layer, pipe, Schedule, Duration } from "effect";
import { Schema } from "@effect/schema";

// Define typed errors
class UserNotFoundError {
  readonly _tag = "UserNotFoundError";
  constructor(readonly userId: string) {}
}

class DatabaseError {
  readonly _tag = "DatabaseError";
  constructor(readonly cause: unknown) {}
}

class ValidationError {
  readonly _tag = "ValidationError";
  constructor(readonly message: string) {}
}

// Schema for validation
const UserSchema = Schema.Struct({
  id: Schema.String,
  email: Schema.String.pipe(Schema.pattern(/^[^@]+@[^@]+$/)),
  name: Schema.String.pipe(Schema.minLength(2)),
  role: Schema.Literal("admin", "user", "guest"),
});

type User = Schema.Schema.Type<typeof UserSchema>;

// Service interface using Context
class UserRepository extends Context.Tag("UserRepository")<
  UserRepository,
  {
    readonly findById: (id: string) => Effect.Effect<User, UserNotFoundError | DatabaseError>;
    readonly save: (user: User) => Effect.Effect<void, DatabaseError>;
    readonly delete: (id: string) => Effect.Effect<void, UserNotFoundError | DatabaseError>;
  }
>() {}

// Service implementation
const UserRepositoryLive = Layer.succeed(
  UserRepository,
  UserRepository.of({
    findById: (id) =>
      pipe(
        Effect.tryPromise({
          try: () => db.users.findUnique({ where: { id } }),
          catch: (e) => new DatabaseError(e),
        }),
        Effect.flatMap((user) =>
          user
            ? Effect.succeed(user)
            : Effect.fail(new UserNotFoundError(id))
        )
      ),

    save: (user) =>
      Effect.tryPromise({
        try: () => db.users.upsert({
          where: { id: user.id },
          create: user,
          update: user,
        }),
        catch: (e) => new DatabaseError(e),
      }).pipe(Effect.asVoid),

    delete: (id) =>
      pipe(
        Effect.tryPromise({
          try: () => db.users.delete({ where: { id } }),
          catch: (e) => new DatabaseError(e),
        }),
        Effect.catchTag("DatabaseError", (e) => {
          if (isNotFoundError(e.cause)) {
            return Effect.fail(new UserNotFoundError(id));
          }
          return Effect.fail(e);
        }),
        Effect.asVoid
      ),
  })
);
```

## Composing Effects

```typescript
// src/services/user-workflow.ts
import { Effect, pipe, Either, Option } from "effect";

class EmailService extends Context.Tag("EmailService")<
  EmailService,
  {
    readonly send: (to: string, subject: string, body: string) => Effect.Effect<void, Error>;
  }
>() {}

// Compose multiple services
const createUser = (
  input: unknown
): Effect.Effect<
  User,
  ValidationError | DatabaseError,
  UserRepository | EmailService
> =>
  pipe(
    // Validate input
    Schema.decodeUnknown(UserSchema)(input),
    Effect.mapError((e) => new ValidationError(e.message)),
    
    // Save to database
    Effect.flatMap((user) =>
      pipe(
        UserRepository,
        Effect.flatMap((repo) => repo.save(user)),
        Effect.map(() => user)
      )
    ),
    
    // Send welcome email (don't fail if email fails)
    Effect.tap((user) =>
      pipe(
        EmailService,
        Effect.flatMap((email) =>
          email.send(
            user.email,
            "Welcome!",
            `Hello ${user.name}, welcome to our platform!`
          )
        ),
        Effect.catchAll(() => Effect.void) // Ignore email errors
      )
    )
  );

// Retry with exponential backoff
const resilientFetch = <A>(
  effect: Effect.Effect<A, Error>
): Effect.Effect<A, Error> =>
  pipe(
    effect,
    Effect.retry(
      Schedule.exponential(Duration.millis(100)).pipe(
        Schedule.compose(Schedule.recurs(3)),
        Schedule.union(Schedule.spaced(Duration.seconds(1)))
      )
    )
  );
```

## Running Effects

```typescript
// src/main.ts
import { Effect, Layer, Runtime } from "effect";

// Compose all layers
const MainLayer = Layer.mergeAll(
  UserRepositoryLive,
  EmailServiceLive,
  LoggerLive
);

// Create runtime
const runtime = Runtime.make(MainLayer);

// Run the program
const program = pipe(
  createUser({ id: "1", email: "user@example.com", name: "John", role: "user" }),
  Effect.tap((user) => Effect.log(`Created user: ${user.name}`))
);

Effect.runPromise(program.pipe(Effect.provide(MainLayer)))
  .then(console.log)
  .catch(console.error);
```

## Best Practices for Google Antigravity IDE

When using Effect-TS with Google Antigravity, define all errors as tagged classes for exhaustive handling. Use Schema for runtime validation with static types. Leverage Layers for dependency injection and testing. Implement retry policies for resilient operations. Use pipe for readable composition. Let Gemini 3 generate Effect-TS patterns from imperative code.

Google Antigravity's agent mode excels at refactoring try-catch code into type-safe Effect pipelines.