Infer output array type from type argument of input items

Question

I'm currently writing typings for a function that takes in an array of Clazz<U> objects, and returns an array of U. U isn't always identical between all the arguments.

Is it possible to set the return type to an array of all the values of U?

I've tried a variety of things including various usages of keyof and typeof, but simply doing so within the typings doesn't seem to give any results. The U-typed value of each Clazz item is accessed via a call to (instanceof Clazz).value.

Example function: (actual code in context on GitHub)

function example(input: Array<Clazz<U>>): Array<U> {
    const out = [];
    
    for(const item of input) {
        out.push(item.value); // where item.value instanceof U === true
    }
    
    return out;
}

Ideal outcomes:

// if this is possible it would be fantastic!
example([new Clazz('this is a string'), new Clazz(500)]); // output type: [string, number]

// a union is acceptable!
example([new Clazz('this is a string'), new Clazz(500)]); // output type: Array<string | number>

So T is a class? That's a weird class name (usually T is used as a type parameter). This isn't quite a minimal reproducible example without a definition of T (external links don't count) but I guess it's just something with a value property. — jcalz
– jcalz, Commented Aug 26, 2020 at 0:52
@jcalz I've updated the question to clarify this for any future readers :) Thanks for pointing that out, I didn't consider that when writing — maxichrome
– maxichrome, Commented Aug 26, 2020 at 23:08

jcalz · Accepted Answer · 2020-08-31 13:11:36Z

I'm going to use this implementation for T... and I'm not going to call it T because that name is usually used for generic type parameters. I'll call it, uh, Tee instead:

class Tee<U> {
    constructor(public value: U) { }
}

Here's how I'd write example():

function example<X extends Array<Tee<any>>>(input: X | []) {
    const out = [] as any as { [K in keyof X]: X[K] extends Tee<infer U> ? U : never };

    for (const item of input) {
        out.push(item.value); 
    }

    return out;
}

There are a few things going on there. One is that example is a generic function, whose generic type parameter X is constrained to be an array of some Tee-like thing (Tee<any>). Let's imagine that the input parameter is of type X (I'll explain X | [] below). Then the output type is what we've asserted out to be:

{ [K in keyof X]: X[K] extends Tee<infer U> ? U : never }

That is mapping the array type X to another array type, where we unwrap Tee<U> to U for each element, using conditional type inferences. That's the type manipulation you're looking for.

There's not really any chance the compiler would be able to figure out that you're doing that type manipulation just by examining the implementation of example(), which is why I had to use a type assertion to tell it that's what out will be.

The last bit to explain is the | [] in the input type. This is just a hint so that the compiler will try to interpret an array literal passed in for input as a tuple type instead of as an unordered array, as explained in this comment of microsoft/TypeScript#27179, a GitHub issue asking for a way to prefer tuples over unordered arrays. Without the | [] you'd tend to get an unordered array (which I guess you're fine with, but is not necessary).

Enough explanation, let's test it:

example([new Tee('this is a string'), new Tee(500)]); // [string, number]

Looks good! Okay, hope that helps; good luck!

Playground link to code

Collectives™ on Stack Overflow

Infer output array type from type argument of input items

1 Answer 1

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

Comments

Your Answer

Sign up or log in

Post as a guest

Related