多个嵌套泛型的功能组合的打字稿等价物

Question

Sometimes I do a lot of operations on a type in order to create a new one, ie:

type Complex = Omit<Merge<Interface1, {modifiedField: false}>, 'omitted field'>

Is there any equivalent of a functional compose or pipe functions so that creating such a type would more readable, ie:

type Complex = Pipe<Interface1, 
   Merge<{modified: false}>,
   Omit<'omitted field'>
>

Answer 1

No, the language doesn't have higher-order type manipulation of the kind needed for this to work. The closest I can imagine is to drop from the type level to the value level, abuse the recent support for higher order function inference from generic functions , and then move back up to the type level. It's not pretty and you end up with a little useless runtime code to boot.

Here's what I mean. I'm assuming you have these definitions:

interface Interface1 {
    a: string;
    "omitted field": boolean;
}
type Merge<T, U> = T & U;
type ManualComplex = Omit<Merge<Interface1, { modifiedField: false }>, 'omitted field'>
/* type ManualComplex = {
    a: string;
    modifiedField: false;
} */

Then here's the hoop-jumping with values I'm talking about:

declare const CurriedOmit: <K extends PropertyKey>() => <T>(t: T) => Omit<T, K>;
declare const CurriedMerge: <U>() => <T>(t: T) => Merge<T, U>;
declare const Id: <T>() => T

I'm pretending that there's a curried Omit and Merge , as well as an Id . Then we can pretend that there's a pipe() function that applies these in order:

// there may be some variadic pipe but for now let's do this:
declare const pipe: {
    <A>(a: A): A;
    <A, B>(a: A, b: (a: A) => B): B;
    <A, B, C>(a: A, b: (a: A) => B, c: (b: B) => C): C;
    <A, B, C, D>(a: A, b: (a: A) => B, c: (b: B) => C, d: (c: C) => D): D;
}

Finally I write some actual runtime code that fools the compiler into evaluating the type you want, although at runtime the code will short-circuit to true (which is good because if it were to actually call the non-existent pipe() function you'd get some yucky runtime error):

const complex = (true as false) || pipe(
    Id<Interface1>(),
    CurriedMerge<{ modifiedField: false }>(),
    CurriedOmit<'omitted field'>()
);

Now that the compiler thinks it has a value complex , we can get Complex as typeof complex :

type Complex = typeof complex;
/* type Complex = {
    a: string;
    modifiedField: false;
} */

Yay, it's the same type as ManualComplex . 😺🌹 Is it worth it? No. 😿🥀 Oh well, best I can do. I'd definitely stick with the non-piped version you started with. Good luck!

Playground Link to code