Cannot preserve error types in nested function calls

[tatgean]

Hi, I'm trying to understand this behaviour of neverthrow:

import { err, ok } from "neverthrow";

class F1Error extends Error { }
function f1() {
  if (Math.random() > 0.5) {
    return err(new F1Error());
  }
  return ok(true);
}

class F2Error extends Error { }
function f2() {
  if (Math.random() > 0.5) {
    return err(new F2Error());
  }

  const f1Result = f1();
  if (f1Result.isErr()) {
    return f1Result;
  }

  return ok(true);
}

const finalResult = f2();

Now in vscode or typescript playground, when I hover on finalResult, it gives me Err<unknown, F1Error> | Ok<boolean, unknown>.
I think it should be Err<unknown, F1Error> | Err<unknown, F2Error> | Ok<boolean, unknown>? or is it an expected behaviour?

I'm new to both typescript and neverthrow, please correct me if I'm asking a stupid question.
Many thanks.

Here is the typescript playground with the code above

[ralacerda]

I believe this is one of those cases where Typescript collapses types because their definitions are the same (They are just Errors).
You can explicitly set the type:

function f2(): Result<true, F1Error | F2Error>{
  if (Math.random() > 0.5) {
    return err(new F2Error());
  }

  const f1Result = f1();
  if (f1Result.isErr()) {
    return f1Result;
  }

  return ok(true);
}

But the real problem here is that you cannot differentiate the errors at runtime.
One strategy is to include a readonly property on the class, something like:

class F1Error extends Error {
  readonly _tag = "F1Error"
}

class F2Error extends Error {
  readonly _tag = "F2Error"
 }

This fixes the problem with typescript trying to collapse the time, and you can also check the type of error during runtime by checking the _tag and deal with it.

Here it's in the playground

[janglad]

Yeah to add to this a pattern I basically always use with Neverthrow is

abstract class TaggedError extends Error {
    abstract readonly _tag: string;
}

class AuthError extends TaggedError{
    readonly _tag = "AuthError"
}

[rijenkii]

But the real problem here is that you cannot differentiate the errors at runtime.

Am I misunderstanding you or does instanceof do exactly what you're trying to achieve with the _tag (except for type collapsing):

class Error1 extends Error {}
class Error2 extends Error {}

const error1 = new Error1();
console.log(error1 instanceof Error1);
// true
console.log(error1 instanceof Error2);
// false

const error2 = new Error2();
console.log(error2 instanceof Error1);
// false
console.log(error2 instanceof Error2);
// true

[janglad]

But the real problem here is that you cannot differentiate the errors at runtime.

Am I misunderstanding you or does instanceof do exactly what you're trying to achieve with the _tag (except for type collapsing):

class Error1 extends Error {}
class Error2 extends Error {}

const error1 = new Error1();
console.log(error1 instanceof Error1);
// true
console.log(error1 instanceof Error2);
// false

const error2 = new Error2();
console.log(error2 instanceof Error1);
// false
console.log(error2 instanceof Error2);
// true

Basically yeah. Type collapsing is a pretty big deal though considering typed errors is the whole premise of this library. But instanceof also breaks across realms (which may or may not be an issue with what you're doing) and you can't use this across the network boundary. I always send errors as objects with everything but their _tag and an something like an optional public metadata field stripped