Style diagnostics

Diagnostics that enforce idiomatic Effect patterns, cleanup, and consistency across your codebase.

Style diagnostics suggest code improvements that make Effect code more idiomatic, concise, and consistent. Most include a quick fix (🔧) so the improvement is one keystroke away. All are suggestions or off by default — they never block compilation.

Rules marked 💡 are suggestions. Rules marked ➖ are off by default and must be enabled in diagnosticSeverity.

catchAllToMapError — 💡 suggestion + 🔧 quick fix

V3/V4: ✓ / ✓

Suggests using Effect.mapError instead of the pattern Effect.catchAll(e => Effect.fail(transform(e))). When you only need to transform the error type without recovering, mapError is the idiomatic choice.

import { Effect } from "effect"

// ❌ Before — verbose catch + fail pattern
const result = someEffect.pipe(
  Effect.catchAll((e) => Effect.fail(new WrappedError({ cause: e })))
)

// ✅ After (quick fix applied) — concise mapError
const result = someEffect.pipe(
  Effect.mapError((e) => new WrappedError({ cause: e }))
)

deterministicKeys — ➖ off by default + 🔧 quick fix

V3/V4: ✓ / ✓

Enforces deterministic, file-path-based naming for service identifiers, tag identifiers, and error tag strings. Consistent key naming prevents accidental collisions when the same identifier is used in different files. Configure the naming formula with keyPatterns in the plugin options.

import { Effect } from "effect"

// ❌ Violation (when enabled) — key does not follow the configured pattern
class Database extends Effect.Service<Database>()("DB", {
  effect: Effect.succeed({ query: () => Effect.void })
}) {}

// ✅ After quick fix — key matches the deterministic formula
class Database extends Effect.Service<Database>()("services/Database", {
  effect: Effect.succeed({ query: () => Effect.void })
}) {}

To enable:

{ "diagnosticSeverity": { "deterministicKeys": "warning" } }

effectFnOpportunity — 💡 suggestion + 🔧 quick fix

V3/V4: ✓ / ✓

Suggests wrapping functions that return an Effect with Effect.fn to get automatic tracing, span naming, and a cleaner call signature. Applies to function declarations and arrow functions at module scope.

import { Effect } from "effect"

// ❌ Before — plain function returning Effect
const getUser = (id: string) =>
  Effect.gen(function* () {
    const db = yield* Database
    return yield* db.findById(id)
  })

// ✅ After (quick fix applied) — wrapped with Effect.fn for tracing
const getUser = Effect.fn("getUser")((id: string) =>
  Effect.gen(function* () {
    const db = yield* Database
    return yield* db.findById(id)
  })
)

effectMapVoid — 💡 suggestion + 🔧 quick fix

V3/V4: ✓ / ✓

Suggests using Effect.asVoid instead of Effect.map(() => void 0), Effect.map(() => undefined), or Effect.map(() => {}). Effect.asVoid is the idiomatic way to discard a success value.

import { Effect } from "effect"

// ❌ Before — verbose map to void
const result = someEffect.pipe(
  Effect.map(() => void 0)
)

// ✅ After (quick fix applied)
const result = someEffect.pipe(
  Effect.asVoid
)

effectSucceedWithVoid — 💡 suggestion + 🔧 quick fix

V3/V4: ✓ / ✓

Suggests using Effect.void instead of Effect.succeed(undefined) or Effect.succeed(void 0). Effect.void is the canonical empty-success value.

import { Effect } from "effect"

// ❌ Before
const noop = Effect.succeed(undefined)

// ✅ After (quick fix applied)
const noop = Effect.void

missedPipeableOpportunity — ➖ off by default + 🔧 quick fix

V3/V4: ✓ / ✓

Suggests converting deeply nested function calls to .pipe() style for better readability. Triggers when at least pipeableMinArgCount (default: 2) contiguous pipeable transformations are nested.

import { Effect } from "effect"

// ❌ Before — nested calls, hard to read
const result = Effect.mapError(
  Effect.map(someEffect, (x) => x + 1),
  (e) => new WrappedError({ cause: e })
)

// ✅ After (quick fix applied) — pipe style
const result = someEffect.pipe(
  Effect.map((x) => x + 1),
  Effect.mapError((e) => new WrappedError({ cause: e }))
)

To enable:

{ "diagnosticSeverity": { "missedPipeableOpportunity": "suggestion" } }

missingEffectServiceDependency — ➖ off by default (V3 only)

V3 only  ·  V4: —

Checks that an Effect.Service class’s declared dependencies array satisfies all required layer inputs. If a service’s implementation requires another service but that service is not listed in dependencies, the layer will be incomplete.

import { Effect } from "effect"

class Config extends Effect.Service<Config>()("Config", {
  effect: Effect.succeed({ url: "http://localhost" })
}) {}

// ❌ Violation (when enabled) — Config is required but not in dependencies
class HttpClient extends Effect.Service<HttpClient>()("HttpClient", {
  effect: Effect.gen(function* () {
    const config = yield* Config
    return { get: () => Effect.void }
  }),
  // dependencies: [Config.Default] // missing!
}) {}

// ✅ Correct — Config.Default listed in dependencies
class HttpClient extends Effect.Service<HttpClient>()("HttpClient", {
  effect: Effect.gen(function* () {
    const config = yield* Config
    return { get: () => Effect.void }
  }),
  dependencies: [Config.Default]
}) {}

To enable:

{ "diagnosticSeverity": { "missingEffectServiceDependency": "warning" } }

redundantSchemaTagIdentifier — 💡 suggestion + 🔧 quick fix

V3/V4: ✓ / ✓

Suggests removing the redundant identifier argument from Schema.TaggedClass, Schema.TaggedError, and Schema.TaggedRequest when the identifier is the same as the class name. The class name is used by default, so passing it explicitly is noise.

import { Schema } from "effect"

// ❌ Before — identifier duplicates the class name
class UserNotFound extends Schema.TaggedError<UserNotFound>()("UserNotFound", {
  id: Schema.String
}) {}

// ✅ After (quick fix applied) — identifier removed
class UserNotFound extends Schema.TaggedError<UserNotFound>()({
  id: Schema.String
}) {}

schemaStructWithTag — 💡 suggestion + 🔧 quick fix

V3/V4: ✓ / ✓

Suggests replacing Schema.Struct with a _tag field with Schema.TaggedStruct. Schema.TaggedStruct makes the _tag field optional in the constructor (it defaults to the tag value), reducing boilerplate.

import { Schema } from "effect"

// ❌ Before — Schema.Struct with explicit _tag
const UserEvent = Schema.Struct({
  _tag: Schema.Literal("UserEvent"),
  userId: Schema.String,
})

// ✅ After (quick fix applied) — Schema.TaggedStruct
const UserEvent = Schema.TaggedStruct("UserEvent", {
  userId: Schema.String,
})

schemaUnionOfLiterals — ➖ off by default + 🔧 quick fix (V3 only)

V3 only  ·  V4: —

Suggests combining multiple Schema.Literal calls inside a Schema.Union into a single Schema.Literal call. A single Schema.Literal with multiple arguments is equivalent and more concise.

import { Schema } from "effect"

// ❌ Before — multiple Literal in Union
const Status = Schema.Union(
  Schema.Literal("active"),
  Schema.Literal("inactive"),
  Schema.Literal("pending")
)

// ✅ After (quick fix applied) — single Literal
const Status = Schema.Literal("active", "inactive", "pending")

To enable:

{ "diagnosticSeverity": { "schemaUnionOfLiterals": "suggestion" } }

serviceNotAsClass — ➖ off by default + 🔧 quick fix (V4 only)

V4 only  ·  V3: —

Warns when ServiceMap.Service is used as a variable expression instead of a class declaration. The class declaration form is the idiomatic V4 pattern and enables better type inference, tooling support, and accessor generation.

import { ServiceMap } from "effect"

// ❌ Violation (when enabled) — variable assignment form
const Database = ServiceMap.Service<Database>()("Database", {
  effect: Effect.succeed({ query: () => Effect.void })
})

// ✅ After quick fix — class declaration form
class Database extends ServiceMap.Service<Database>()("Database", {
  effect: Effect.succeed({ query: () => Effect.void })
}) {}

To enable:

{ "diagnosticSeverity": { "serviceNotAsClass": "warning" } }

strictBooleanExpressions — ➖ off by default

V3/V4: ✓ / ✓

Enforces that only strictly boolean values are used in conditional expressions. Disallows truthy/falsy coercion of strings, numbers, null, and undefined in conditions. Mirrors TypeScript’s strictNullChecks spirit for conditionals.

// ❌ Violation (when enabled) — number used in condition (truthy coercion)
const count = getCount()
if (count) { // count is number, not boolean
  processItems()
}

// ✅ Correct — explicit boolean comparison
const count = getCount()
if (count > 0) {
  processItems()
}

To enable:

{ "diagnosticSeverity": { "strictBooleanExpressions": "warning" } }

unnecessaryEffectGen — 💡 suggestion + 🔧 quick fix

V3/V4: ✓ / ✓

Suggests removing the Effect.gen wrapper when the generator body contains only a single return statement. A single-expression generator adds indentation and function* syntax with no benefit.

import { Effect } from "effect"

// ❌ Before — unnecessary Effect.gen for a single expression
const result = Effect.gen(function* () {
  return yield* Effect.succeed(42)
})

// ✅ After (quick fix applied) — direct expression
const result = Effect.succeed(42)

unnecessaryFailYieldableError — 💡 suggestion + 🔧 quick fix

V3/V4: ✓ / ✓

Suggests yielding yieldable error types (such as Data.TaggedError instances) directly with yield* instead of wrapping them in Effect.fail. Tagged errors implement the Yieldable interface, so they can be yielded directly for a more concise syntax.

import { Effect, Data } from "effect"

class NotFoundError extends Data.TaggedError("NotFoundError")<{}> {}

// ❌ Before — wrapping a yieldable error in Effect.fail
const program = Effect.gen(function* () {
  return yield* Effect.fail(new NotFoundError())
})

// ✅ After (quick fix applied) — yield* the error directly
const program = Effect.gen(function* () {
  return yield* new NotFoundError()
})

unnecessaryPipe — 💡 suggestion + 🔧 quick fix

V3/V4: ✓ / ✓

Removes pipe() calls that contain no arguments. An empty pipe() call is a no-op and should be removed.

import { pipe } from "effect"

// ❌ Before — pipe with no arguments
const result = pipe(someValue)

// ✅ After (quick fix applied)
const result = someValue

unnecessaryPipeChain — 💡 suggestion + 🔧 quick fix

V3/V4: ✓ / ✓

Simplifies chained pipe calls into a single pipe call. When multiple pipe(...) calls are chained, they can always be flattened into one, improving readability.

import { pipe, Effect } from "effect"

// ❌ Before — chained pipe calls
const result = pipe(
  pipe(
    someEffect,
    Effect.map((x) => x + 1)
  ),
  Effect.mapError((e) => new WrappedError({ cause: e }))
)

// ✅ After (quick fix applied) — single pipe call
const result = pipe(
  someEffect,
  Effect.map((x) => x + 1),
  Effect.mapError((e) => new WrappedError({ cause: e }))
)