Stuck on an issue?

Lightrun Answers was designed to reduce the constant googling that comes with debugging 3rd party libraries. It collects links to all the places you might be looking at while hunting down a tough bug.

And, if you’re still stuck at the end, we’re happy to hop on a call to see how we can help out.

Unbounded lists of results without a type annotation don't have enough type information

See original GitHub issue

This is next proposition to solve problem with #224.

I feel I learned a lot about TypeScript in last week 😉 Today I tried again to provide proper types for Heterogeneous combine function.

First, I would like to provide my new proposition, implementation of combine types, based on our findings in #224 and my experimetns.

import { Result, Ok, Err } from 'neverthrow';

declare function combine<T extends readonly Result<unknown, unknown>[]>(
  results: [...T]
): Result<ExtractOkTypes<T>, ExtractErrTypes<T>[number]>;

// Given a list of Results, this extracts all the different `T` types from that list
type ExtractOkTypes<T extends readonly Result<unknown, unknown>[]> = {
  [Key in keyof T]: T[Key] extends Result<unknown, unknown>
    ? ExtractOkFromUnion<T[Key]>
    : never;
};

// Given a list of Results, this extracts all the different `E` types from that list
type ExtractErrTypes<T extends readonly Result<unknown, unknown>[]> = {
  [Key in keyof T]: T[Key] extends Result<unknown, unknown>
    ? ExtractErrFromUnion<T[Key]>
    : never;
};

// need to be separated generic type to run it for every element of union T separately
type ExtractOkFromUnion<T extends Result<unknown, unknown>> = T extends Ok<
  infer V,
  unknown
> // filter out "unknown" values
  ? V extends {}
    ? V
    : never
  : never;

// need to be separated generic type to run it for every element of union T separately
type ExtractErrFromUnion<T extends Result<unknown, unknown>> = T extends Err<
  unknown,
  infer E
> // filter out "unknown" values
  ? E extends {}
    ? E
    : never
  : never;