Send error as json to client?

[piscopancer]

see the output below - left is weird. I expected it to be { _tag: "UnluckError", rolled: <num> }

import { Console, Data, Effect, pipe, Schema } from "effect"

// json serialization

class UnluckError extends Data.TaggedError("UnluckError")<{
  readonly rolled: number
}> {}

Effect.runPromise(
  pipe(
    Effect.sync(() => Math.random()),
    Effect.flatMap((rolled) =>
      rolled > 0.5
        ? Effect.succeed(123)
        : Effect.fail(new UnluckError({ rolled })),
    ),
    Effect.either,
    Effect.map(
      Schema.encodeSync(
        Schema.Either({
          left: Schema.instanceOf(UnluckError),
          right: Schema.Number,
        }),
      ),
    ),
    Effect.tap(Console.log),
    Effect.tapError(Console.error),
  ),
)

/*
{
  _tag: "Left",
  left: UnluckError: An error has occurred
    at <anonymous> ...1.test.ts:22:27),
}
*/

I found out this works... But Jesus Christ why would i do so much typing and do not follow DRY? I swear it can be simplified somehow...

// left: Schema.instanceOf(UnluckError),
// ✔️
left: Schema.Struct({
  _tag: Schema.String,
  rolled: Schema.Number.pipe(),
}),

[harshagarwalnyu]

The issue is Schema.instanceOf(UnluckError) — instanceOf checks the class instance but doesn't know how to encode it as a plain object. It passes the class instance through as-is, which serializes to {} (class instances have non-enumerable prototype methods).

Fix: use Schema.TaggedError instead of Data.TaggedError + instanceOf:

import { Console, Effect, pipe, Schema } from "effect";

// Define the error WITH a schema (not just Data.TaggedError)
class UnluckError extends Schema.TaggedError<UnluckError>()("UnluckError", {
  rolled: Schema.Number,
}) {}

Effect.runPromise(
  pipe(
    Effect.sync(() => Math.random()),
    Effect.flatMap((rolled) =>
      rolled > 0.5
        ? Effect.succeed(123)
        : Effect.fail(new UnluckError({ rolled })),
    ),
    Effect.either,
    Effect.map(
      Schema.encodeSync(
        Schema.Either({
          left: UnluckError,  // use the class directly — it IS a schema
          right: Schema.Number,
        }),
      ),
    ),
    Effect.tap(Console.log),
    Effect.runSync,
  ),
);

Output: { _tag: "Left", left: { _tag: "UnluckError", rolled: 0.3 } }

Why Schema.TaggedError works:

Schema.TaggedError extends both Data.TaggedError (for runtime behavior) AND defines an Effect schema on the class itself. So UnluckError can be used directly as a schema in Schema.Either({ left: UnluckError }).

Data.TaggedError + instanceOf fails because:

• Data.TaggedError = runtime class with correct _tag + equality
• Schema.instanceOf = "value must be an instance of this class" — it's for INPUT validation, not encoding
• Encoding an instance doesn't know which fields to serialize

Alternatively, keep Data.TaggedError and define a separate encode schema:

const UnluckErrorSchema = Schema.Struct({
  _tag: Schema.Literal("UnluckError"),
  rolled: Schema.Number,
});

// Use UnluckErrorSchema in your Either — transform the class to plain object manually

But Schema.TaggedError is the idiomatic Effect solution.

[piscopancer]

thanks