Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/Effect-TS/tsgo/llms.txt

Use this file to discover all available pages before exploring further.

The Effect Language Service augments TypeScript’s built-in completion list with Effect-aware snippets. These completions fire in specific syntactic positions — typically inside extends clauses, after a . accessor, or inside a comment — and insert ready-to-use boilerplate with tab stops.
All completions work in both Effect V3 and V4 unless noted otherwise.

​
Class extends completions

These completions trigger when your cursor is inside the extends clause of a class declaration. They insert the full parent-class call, including the self-referencing type parameter and deterministic tag key.

​
contextSelfInClasses

Inserts a Context.Tag("key")<ClassName, Shape>(){} snippet when you dot-access Context in an extends clause. Support: V3 ✓ · V4 ✗ 
// Typing: class MyService extends Context.|
class MyService extends Context.Tag("MyService")<MyService, { port: number }>()
{}

​
effectSelfInClasses

Inserts an Effect.Service<ClassName>()("key", { ... }){} or Effect.Tag("key")<ClassName, Shape>(){} snippet when you dot-access Effect in an extends clause. Support: V3 ✓ · V4 ✗ 
// Typing: class Database extends Effect.|
class Database extends Effect.Service<Database>()("Database", {
  effect: Effect.gen(function* () {
    return { query: (sql: string) => Effect.succeed([]) }
  })
}) {}

​
serviceMapSelfInClasses

Inserts a ServiceMap.Service<ClassName, {}>()( "key"){} or factory-based ServiceMap.Service<ClassName>()( "key", { make }){} snippet when you dot-access ServiceMap in an extends clause. Support: V3 ✓ · V4 ✓ 
// Typing: class Database extends ServiceMap.|

// Option 1 — inline shape
class Database extends ServiceMap.Service<Database, { query: (sql: string) => Effect.Effect<Row[]> }>()("Database") {}

// Option 2 — factory
class Database extends ServiceMap.Service<Database>()("Database", {
  make: Effect.gen(function* () {
    return { query: (sql: string) => Effect.succeed([]) }
  })
}) {}

​
effectDataClasses

Inserts a Data.TaggedError("ClassName")<{}>{} or Data.TaggedClass("ClassName")<{}>{} snippet when you dot-access Data in an extends clause. Support: V3 ✓ · V4 ✓ 
// Typing: class DatabaseError extends Data.|

// TaggedError
class DatabaseError extends Data.TaggedError("DatabaseError")<{
  message: string
}> {}

// TaggedClass
class Row extends Data.TaggedClass("Row")<{
  id: number
  name: string
}> {}

​
effectSchemaSelfInClasses

Inserts schema class constructor snippets when you dot-access Schema (or Model in V4) in an extends clause. The available variants depend on your Effect version. Support: V3 ✓ · V4 ✓ 
class User extends Schema.Class<User>("User")({ name: Schema.String }) {}

class UserError extends Schema.TaggedError<UserError>()("UserError", {
  message: Schema.String
}) {}

class UserEvent extends Schema.TaggedClass<UserEvent>()("UserEvent", {
  id: Schema.Number
}) {}

class GetUser extends Schema.TaggedRequest<GetUser>()("GetUser", {
  id: Schema.Number
}) {}

​
rpcMakeClasses

Inserts an Rpc.make("ClassName", { ... }){} snippet when you dot-access Rpc from @effect/rpc in an extends clause. Support: V3 ✓ · V4 ✗ 
// Typing: class GetUser extends Rpc.|
class GetUser extends Rpc.make("GetUser", {
  payload: Schema.Struct({ id: Schema.Number }),
  success: Schema.Struct({ name: Schema.String })
}) {}

​
Dot-access completions

​
genFunctionStar

Inserts a gen(function*(){}) snippet when you type .gen after any object that has a callable gen property — for example Effect, Micro, or any custom object with a compatible gen method. Support: V3 ✓ · V4 ✓ 
// Typing: Effect.|
Effect.gen(function* () {
  // cursor placed here
})

​
schemaBrand

Inserts a brand("varName") snippet when you dot-access Schema inside a variable declaration initializer. The variable name is automatically inferred from the enclosing declaration. Support: V3 ✓ · V4 ✗ 
// Typing: const UserId = Schema.String.pipe(Schema.|
// Variable name "UserId" is inferred automatically
const UserId = Schema.String.pipe(Schema.brand("UserId"))

​
Comment directive completions

​
effectDiagnosticsComment

Inserts an @effect-diagnostics ruleName:severity or @effect-diagnostics-next-line ruleName:severity directive snippet when you type @ inside a //, /*, or /** comment. All diagnostic rule names and severity levels are offered as choices. Support: V3 ✓ · V4 ✓ 
// Typing: // @|

// @effect-diagnostics floatingEffect:off
const abandoned = Effect.succeed(1)

// @effect-diagnostics-next-line missingEffectError:off
const risky: Effect.Effect<void> = doSomethingRisky()

​
effectCodegensComment

Inserts an @effect-codegens codegenName directive snippet when you type @ inside a comment. All available codegen names are offered as tab-stop choices. Support: V3 ✓ · V4 ✓ 
// Typing: // @|

// @effect-codegens accessors
class MyService extends Effect.Service<MyService>()("MyService", {
  // ...
}) {}

​
Codegens

Codegens are comment-directive-driven code generators. You annotate a declaration with an @effect-codegens comment and the language service inserts boilerplate into the file. All three codegens are planned but not yet implemented.
Codegens are not yet available. The completion for @effect-codegens (above) inserts the directive, but no code is generated from it in the current release.
CodegenDescriptionStatus
accessorsGenerate Service accessor methods from an @effect-codegens accessors comment directiveNot yet implemented
annotateGenerate type annotations from an @effect-codegens annotate comment directiveNot yet implemented
typeToSchemaGenerate a Schema from a type alias via an @effect-codegens typeToSchema comment directiveNot yet implemented
When implemented, usage will look like this: 
// @effect-codegens accessors
class Logger extends Effect.Service<Logger>()("Logger", {
  accessors: true,
  effect: Effect.gen(function* () {
    return { log: (msg: string) => Console.log(msg) }
  })
}) {}
// ↑ The language service will insert accessor methods below this class

​
Rename extensions

​
keyStrings

Extends TypeScript’s rename operation to also update key string literals inside Effect class declarations (e.g., the tag key string "MyService" when you rename the class MyService). This feature is planned but not yet implemented.
keyStrings rename extension is not yet available in the current release.
// Renaming "Database" would also update the string literal "Database"
class Database extends Effect.Service<Database>()("Database", {
  //                                                ^^^^^^^^^^  also renamed
  effect: Effect.succeed({ query: () => Effect.succeed([]) })
}) {}

Build docs developers (and LLMs) love

Get started for freeTalk to us