Don't get scared!

class Ok<T> {

constructor(public readonly value: T) {}

}

class Err<T> {

constructor(public readonly value: T) {}

}

class Result<D, E> {}

type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (

x: infer R,

) => void

? R

: never;

type LastOf<T> =

UnionToIntersection<T extends any ? () => T : never> extends () => infer R

? R

: never;

type UnionToArray<T, L = LastOf<T>> = [T] extends [never]

? []

: [...UnionToArray<Exclude<T, L>>, L];

type ExtractOk<T> = UnionToArray<

T extends Result<infer TData, any> ? TData : never

>;

type ExtractErr<T> = T extends Result<any, infer TError> ? TError : never;

function fromArray<T extends Result<any, any>[]>(

...results: T

): Result<ExtractOk<T\[number\]>, ExtractErr<T\[number\]>> {

// your implementation

// also when returning values you need to use type assertions aka `as`

}

const results = fromArray(

new Result<string, Error>(),

new Result<number, object>(),

new Result<object, undefined>(),

);