Effect-TS Functional Patterns

# Effect-TS Functional Patterns for Google Antigravity

Effect-TS provides powerful abstractions for type-safe, composable code. This guide covers patterns for Google Antigravity IDE and Gemini 3.

## Basic Effect Usage

```typescript
// src/services/userService.ts
import { Effect, pipe, Context, Layer } from 'effect';

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

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

// Define service interface
interface UserRepository {
  readonly findById: (id: string) => Effect.Effect<User, UserNotFoundError | DatabaseError>;
  readonly findAll: () => Effect.Effect<User[], DatabaseError>;
  readonly create: (data: CreateUserInput) => Effect.Effect<User, DatabaseError>;
  readonly update: (id: string, data: UpdateUserInput) => Effect.Effect<User, UserNotFoundError | DatabaseError>;
  readonly delete: (id: string) => Effect.Effect<void, UserNotFoundError | DatabaseError>;
}

// Create service tag
const UserRepository = Context.GenericTag<UserRepository>('UserRepository');

// Service implementation
const UserRepositoryLive = Layer.succeed(
  UserRepository,
  UserRepository.of({
    findById: (id) =>
      Effect.tryPromise({
        try: () => db.user.findUnique({ where: { id } }),
        catch: (error) => new DatabaseError(error),
      }).pipe(
        Effect.flatMap((user) =>
          user ? Effect.succeed(user) : Effect.fail(new UserNotFoundError(id))
        )
      ),
    findAll: () =>
      Effect.tryPromise({
        try: () => db.user.findMany(),
        catch: (error) => new DatabaseError(error),
      }),
    create: (data) =>
      Effect.tryPromise({
        try: () => db.user.create({ data }),
        catch: (error) => new DatabaseError(error),
      }),
    update: (id, data) =>
      pipe(
        Effect.tryPromise({
          try: () => db.user.update({ where: { id }, data }),
          catch: (error) => new DatabaseError(error),
        }),
        Effect.catchTag('DatabaseError', (e) => {
          if (isNotFoundError(e.cause)) return Effect.fail(new UserNotFoundError(id));
          return Effect.fail(e);
        })
      ),
    delete: (id) =>
      Effect.tryPromise({
        try: () => db.user.delete({ where: { id } }).then(() => undefined),
        catch: (error) => new DatabaseError(error),
      }),
  })
);
```

## Composing Effects

```typescript
// src/workflows/orderWorkflow.ts
import { Effect, pipe } from 'effect';

const createOrder = (input: OrderInput) =>
  pipe(
    // Validate input
    validateOrderInput(input),
    // Check inventory
    Effect.flatMap((validated) =>
      pipe(
        checkInventory(validated.items),
        Effect.mapError(() => new InsufficientInventoryError())
      )
    ),
    // Process payment
    Effect.flatMap((items) =>
      pipe(
        processPayment(input.paymentMethod, calculateTotal(items)),
        Effect.mapError((e) => new PaymentFailedError(e.message))
      )
    ),
    // Create order record
    Effect.flatMap((paymentResult) =>
      createOrderRecord({
        ...input,
        paymentId: paymentResult.id,
        status: 'confirmed',
      })
    ),
    // Send confirmation email
    Effect.tap((order) =>
      pipe(
        sendOrderConfirmation(order),
        Effect.catchAll(() => Effect.succeed(undefined)) // Email failure is non-critical
      )
    )
  );

// Run the effect
const program = pipe(
  createOrder(orderInput),
  Effect.provide(OrderServiceLive),
  Effect.provide(PaymentServiceLive),
  Effect.provide(EmailServiceLive)
);

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

## Resource Management

```typescript
// src/resources/database.ts
import { Effect, Scope, pipe } from 'effect';

const acquireConnection = Effect.tryPromise(() => pool.connect());
const releaseConnection = (conn: PoolClient) => Effect.sync(() => conn.release());

const withConnection = <A, E>(
  use: (conn: PoolClient) => Effect.Effect<A, E>
): Effect.Effect<A, E, Scope.Scope> =>
  Effect.acquireRelease(acquireConnection, releaseConnection).pipe(Effect.flatMap(use));

// Usage with automatic cleanup
const getUsersWithConnection = pipe(
  withConnection((conn) =>
    Effect.tryPromise(() => conn.query('SELECT * FROM users'))
  ),
  Effect.scoped // Ensures connection is released
);
```

## Schema Validation

```typescript
// src/schemas/user.ts
import { Schema } from '@effect/schema';

const UserSchema = Schema.Struct({
  id: Schema.UUID,
  email: Schema.String.pipe(Schema.pattern(/^[^s@]+@[^s@]+.[^s@]+$/)),
  name: Schema.String.pipe(Schema.minLength(2), Schema.maxLength(100)),
  role: Schema.Literal('user', 'admin'),
  createdAt: Schema.Date,
});

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

const parseUser = Schema.decodeUnknown(UserSchema);

// Usage
const result = parseUser({ id: '...', email: 'user@example.com', name: 'John', role: 'user', createdAt: new Date() });
```

## Best Practices

1. **Tagged Errors**: Use discriminated unions for errors
2. **Service Pattern**: Define services with Context
3. **Layers**: Compose dependencies with Layer
4. **Resource Safety**: Use acquireRelease for cleanup
5. **Pipelines**: Compose effects with pipe
6. **Schema Validation**: Type-safe parsing

Google Antigravity's Gemini 3 understands Effect-TS patterns for robust applications.