Incorrect overload is used for `pipe` when first function has optional parameter

[OliverJAsh]

TypeScript Version: 3.3.1

Search Terms:

Code

• when strictFunctionTypes is disabled
• when first composed function parameter is optional
• when first pipe overload is zero parameters for first function

declare const pipe: {
    // 0-argument first function
    // Workaround: disable this overload
    <A>(a: () => A): () => A;

    // 1-argument first function
    <A, B>(ab: (a: A) => B): (a: A) => B;
};

// Expected type: `(a: {} | undefined) => number`
// Actual type: `() => number`
const fn = pipe((_a?: {}) => 1);

Related Issues:
#29904

[RyanCavanaugh]

The first overload that matches is always chosen. The pipe overloads should be in the other order.

[OliverJAsh]

How come this behaviour only applies when strictFunctionTypes is disabled?

This is the order of overloads used by Lodash's flow (aka pipe) function. I have raised a PR to fix the overload order, as you suggested: DefinitelyTyped/DefinitelyTyped#33450.

[RyanCavanaugh]

strictFunctionTypes off means that parameter types are compared bivariantly, so the {} | undefined being assignable from the implicit no-argument undefined is acceptable.

[OliverJAsh]

The first overload that matches is always chosen. The pipe overloads should be in the other order.

If we do this, it fixes the example above, but it causes other issues:

{
    declare const pipe: {
        // 1-argument first function
        <A, B>(ab: (a: A) => B): (a: A) => B;

        // 0-argument first function
        // Workaround: disable this overload
        <A>(a: () => A): () => A;
    };

    // Expected and actual type: `(a: {} | undefined) => number`
    const fn1 = pipe((_a?: {}) => 1);

    // Expected type: () => number
    // Actual type: (a: unknown) => number
    const fn2 = pipe(() => 1);
}

Workaround: use generic rest parameters:

{
    declare const pipe: {
        <A extends any[], B>(ab: (...a: A) => B): (...a: A) => B;
    };

    // Expected and actual type: `(a: {} | undefined) => number`
    const fn1 = pipe((_a?: {}) => 1);

    // Expected and actual type: () => number
    const fn2 = pipe(() => 1);
}