Generic Functions Type Error

[jkonowitch]

Example 1

  const minimalRepro = <A, E>(
    fn: () => AsyncResult<A, E>
  ): AsyncResult<A, E> => {
    return Result.gen(function* () {
      const r = yield* fn();
      return Result.ok(r);
    })
  }

Expected behavior

This should compile

Actual Behavior

Type 'AsyncResult<ExtractValue<Ok<A>>, E | InferError<Ok<A>>>' is not assignable to type 'AsyncResult<A, E>'.
Type 'ExtractValue<Ok<A>>' is not assignable to type 'A'.
'A' could be instantiated with an arbitrary type which could be unrelated to 'ExtractValue<Ok<A>>'. (ts 2322)

Example 2

  const minimalRepro2 = <A, E>(
    fn: () => AsyncResult<A, E>
  ): AsyncResult<A, E> => {
    return fn().map(a => a);
  }

Expected Behavior

This should compile

Actual Behavior

Type '[A] extends [never] ? AsyncResult<A, E> : [A] extends [Generator<unknown, any, any> | AsyncGenerator<unknown, any, any>] ? AsyncResult<...> : [...] extends [...] ? PValue extends A ? AsyncResult<...> : never : A extends A ? AsyncResult<...> : never' is not assignable to type 'AsyncResult<A, E>'.
Type 'AsyncResult<A, E> | ([A] extends [Generator<unknown, any, any> | AsyncGenerator<unknown, any, any>] ? AsyncResult<InferGeneratorReturn<A>, E | InferGeneratorError<...>> : [...] extends [...] ? PValue extends A ? AsyncResult<...> : never : A extends A ? AsyncResult<...> : never)' is not assignable to type 'AsyncResult<A, E>'.
Type '[A] extends [Generator<unknown, any, any> | AsyncGenerator<unknown, any, any>] ? AsyncResult<InferGeneratorReturn<A>, E | InferGeneratorError<...>> : [...] extends [...] ? PValue extends A ? AsyncResult<...> : never : A extends A ? AsyncResult<...> : never' is not assignable to type 'AsyncResult<A, E>'.
Type 'AsyncResult<InferGeneratorReturn<A>, E | InferGeneratorError<A>> | ([A] extends [Promise<infer PValue>] ? PValue extends A ? AsyncResult<...> : never : A extends A ? AsyncResult<...> : never)' is not assignable to type 'AsyncResult<A, E>'.
Type 'AsyncResult<InferGeneratorReturn<A>, E | InferGeneratorError<A>>' is not assignable to type 'AsyncResult<A, E>'.
Type 'E | InferGeneratorError<A>' is not assignable to type 'E'.
'E' could be instantiated with an arbitrary type which could be unrelated to 'E | InferGeneratorError<A>'. (ts 2322)

[everweij]

Hi @jkonowitch, thanks for reaching out!

I'm investigating whether and how I can make the signatures of the various methods more 'generic-friendly'.
Currently, I use a lot of conditional types, and while that is a totally valid approach, it has some downsides, especially in scenarios like the two examples you've provided. Due to the polymorphic nature of many methods, we heavily utilize conditional types; we must analyze what is provided by the user so we can return the next Result.
If we look at the error of your first example, the type that actually gets returned is AsyncResult<ExtractValue<Ok<A>>, E | InferError<Ok<A>>>. Utility types like ExtractValue and InferError make sure that whatever you pass (e.g. literal values, Promises, Result / AsyncResult instances, etc), something sensible will come out. We might know that AsyncResult<ExtractValue<Ok<A>>, E | InferError<Ok<A>>> evaluates to AsyncResult<A, E>, but currently, TS does not have a way to figure that out, even if we would constrain the A and E type parameters. When you declare a generic function, any conditional types involving its type parameters are left unresolved until the function is actually called. That means TypeScript won’t assume that ExtractValue<Ok<A>> is compatible with A at the declaration site, because for some instantiations of A that might not hold.

A solution would be to rely more on overloads instead of conditionals in the return type. That is the part I'm investigating at the moment. Do you have any specific ideas or use cases where you would like to use generics? Your repros are already helpful, but some real-world code example(s) would be of great help for fixing this issue.

A solution/work-arround for the current issue for now could be to remove the explicit return type or use a cast at your return statements.

[jkonowitch]

Hi @everweij - thanks for the response!

Yes, I saw the inferred type of AsyncResult<ExtractValue<Ok<A>>, E | InferError<Ok<A>>>, which does ultimately resolve to the correct A when you use the output of the function without an explicit return type. That is fine for many use cases.

But at the moment, it isn't possible to define a service interface (my main use case), such as

interface ThingRunner {
  run<A, E>(task: () => AsyncResult<A, E>): AsyncResult<A, E | SomeOtherErrorUniqueToThisService>
}

And then provide an implementation later on without resorting to casts, as you suggested.

I've often had better luck, per your suggestion, with overloads as opposed to conditional types simply because I find them more explicit and easier to reason about. But without knowing your type architecture in detail it's hard for me to propose a good solution. Depending on how you make out with this issue, if I am able to I can look through the source more closely and see if I have any useful suggestions.