Typescript generic function where parameters compose into the return type

I have a set of type guard functions with the signature:

type Validator<T> = (doc: any) => doc is T;

I want to be able to compose these validators. For example:

export const union = <T>(validators: Validator<>[]): ValidatorFn<T> => {
  return (doc: any): doc is T => {
     for (const validator of validators) {
       if (validator(doc)) return true;
     }
     return false;
  }
}

export const intersection = <T>(validators: Validator<>[]): ValidatorFn<T> => {
  return (doc: any): doc is T => {
     for (const validator of validators) {
       if (!validator(doc)) return false;
     }
     return true;
  }
}

However, i don't really know how to type the validators param such that whatever is in there is either 'in' T or 'sums up' to T. For example, the following should hopefully work:

interface FooOne {
  a: string;
}

interface FooTwo {
  b: string;
}

interface FooThree {
  c: string
}

type Bar = FooOne | FooTwo
type Baz = FooOne & FooTwo

const oneValidator = validator<FooOne>()
const twoValidator = validator<FooTwo>()
const threeValidator = validator<FooThree>()


const barValidator = union<Bar>([oneValidator, twoValidator])  // should succeed
const barValidator = union<Bar>([oneValidator])  // should succeed because FooOne is sufficient to validate Bar
const barValidator = union<Bar>([oneValidator, twoValidator, threeValidator])  // should fail because FooThree is not in Bar

const bazValidator = intersection<Baz>([oneValidator, twoValidator]) // should succeed
const bazValidator = intersection<Baz>([oneValidator]) // should fail because validating FooOne is insufficient to validate Baz
const bazValidator = intersection<Baz>([oneValidator, twoValidator, threeValidator]) // should fail because FooThree is not in Baz

How can I set up the types so that the typescript compiler is smart enough to evaluate these compositions?

My inclination here would be to make union and intersection generic in the tuple type T corresponding to the type each validators is guarding. For example, if you have validators vx of type Validator<X>, vy of type Validator<Y>, and vz of type Validator<Z>, then when you call union([vx, vy, vz]) we want T to be [X, Y, Z].

Then we can represent the validators input as a straightforward mapped type on the tuple, like {[I in keyof T]: Validator<T[I]>}. And in order to give a hint that we want T to be a tuple and not an unordered array type, we can write it as a variadic tuple type, [...{ I in keyof T]: Validator<T[I]> }]. Because the mapped type is homomorphic (see https://stackoverflow.com/q/59790508/2887218 ), the compiler is able to infer T from a value of that mapped type.

That means all we need to worry about is the return types of union and intersection.

For union, the question is: "given a tuple type T, how do we write a type which is the union of all its element types"? That is relatively easy to write; all we need to do is index into the type with number, since tuple types already have a number index signature with the union of element types. (Hopefully that makes sense; if you have a value a of type [string, number, boolean] and index into it with a number i that isn't out of bounds, then the type of a[i] will be string | number | boolean):

const union = <T extends any[]>(
    validators: [...{ [I in keyof T]: Validator<T[I]> }]
): Validator<T[number]> => {
    return (doc: any): doc is T[number] => {
        for (const validator of validators) {
            if (validator(doc)) return true;
        }
        return false;
    }
}

And let's test it:

declare const oneValidator: Validator<FooOne>;
declare const twoValidator: Validator<FooTwo>;
declare const threeValidator: Validator<FooThree>;

const uv1 = union([oneValidator]);
// const uv1: Validator<FooOne>
const uv12 = union([oneValidator, twoValidator]);
// const uv12: Validator<FooOne | FooTwo>
const uv123 = union([oneValidator, twoValidator, threeValidator]);
// const uv123: Validator<FooOne | FooTwo | FooThree>

Looks good.

For intersection, the question is: "given a tuple type T, how do we write a type which is the intersection of all its element types"? That is more involved. There is no simple way to get this... the indexed access types correspond to what you get when you read properties, not write them.

In order to turn a tuple into the intersection of all its element types, we need to write our own utility type that maps the tuple to a version with the elements in a contravariant type position (see https://stackoverflow.com/q/66410115/2887218) and then use conditional type inference via infer to infer a single type for those, which will become the intersection, as documented.

It looks like this:

type TupleToIntersection<T extends any[]> = {
    [I in keyof T]: (x: T[I]) => void
}[number] extends (x: infer R) => void ? R : never;

which you can verify works as intended:

type Test = TupleToIntersection<[{ a: string }, { b: number }, { c: boolean }]>
// type Test = { a: string; } & { b: number; } & { c: boolean; }

And thus intersection looks like

const intersection = <T extends any[]>(
    validators: [...{ [I in keyof T]: Validator<T[I]> }]
): Validator<TupleToIntersection<T>> => {
    return ((doc: any): doc is TupleToIntersection<T> => {
        for (const validator of validators) {
            if (!validator(doc)) return false;
        }
        return true;
    });
}

And let's test it:

const iv1 = intersection([oneValidator]);
// const iv1: Validator<FooOne>
const iv12 = intersection([oneValidator, twoValidator]);
// const iv12: Validator<FooOne & FooTwo>
const iv123 = intersection([oneValidator, twoValidator, threeValidator]);
// const iv123: Validator<FooOne & FooTwo & FooThree>

Also looks good.

Playground link to code