Typescript: Tipo de arreglo que depende del elemento anterior del arreglo

¿Es posible en TypeScript implementar un Array infinito (no una Tupla) con un tipo que dependa del elemento anterior del array?

Aquí hay un código pseudo-typescript para dar un ejemplo:

class B<T, U> {}

function foo<X, Y>(...args: [B<X, Z0>, B<Z0, Z1>, B<Z1, Z2>, ..., B<ZN, Y>]) {}

foo<string, number>(new B<string, number>, new B<number, boolean>, new B<boolean, number>); // Correct
foo<string, number>(new B<string, number, new B<number, boolean>); // Incorrect
foo<string, number>(new B<string, number>, new B<boolean, number>); // Incorrect

¿Con qué debería reemplazar el "[B<X, Z0>, B<Z0, Z1>, B<Z1, Z2>, ..., B<ZN, Y>]" para que esto funcione? ¿Es esto siquiera posible?

¡Gracias!

Respuesta #1

Recientemente me encontré con un problema similar. Mi problema consistía en crear un largo conducto de flujos. La salida del flujo i tenía que ser la entrada del flujo i+1, etc. Lo resolví así:

type OmitFirst<T extends any[]> = T extends [any, ...infer R] ? R : never
type GetValueOrDefault<Thing, Key, Default = never> = Key extends keyof Thing ? Thing[Key] : Default
type Pipe<Start, Finish, Inputs extends [Start, ...any[]], Outputs extends any[] = OmitFirst<Inputs>> = {
    [I in keyof Inputs]: DuplexConstructor<Inputs[I], GetValueOrDefault<Outputs, I, Finish>>
}

export function pipe<F, L, P extends [F, ...any[]]>(
    ...streams: [ReadableConstructor<F>, ...Pipe<F, L, P>, WritableConstructor<L>]
): Writable {
    const source = streams[0]
    const duplexes = streams.slice(1, -1) as Pipe<F, L, P>
    const sink = streams[streams.length - 1] as WritableConstructor<L>

    let tail = readable(source)
    duplexes.forEach((dp) => (tail = tail.pipe(duplex(dp))))
    return tail.pipe(writable(sink))
}