Unexpected error/bad inference for generic composed function inside `pipe`

[OliverJAsh]

TypeScript Version: 2.9.2

Search Terms: index signature pipe generic lost dictionary

Code

declare function pipe<V0, T1, T2, T3>(
    fn0: (x: V0) => T1,
    fn1: (x: T1) => T2,
    fn2: (x: T2) => T3,
): (x: V0) => T3;

declare function getStringDict(): { [index: string]: string };

declare function stringDictIdentity<T>(stringDict: {
    [index: string]: T;
}): { [index: string]: T };

/*
Without strict enabled:
Expected type (x: {}) => { [index: string]: string; }
Actual type (x: {}) => { [index: string]: {}; }

With strict enabled, unexpected type error:
Argument of type '<T>(stringDict: { [index: string]: T; }) => { [index: string]: T; }' is not assignable to parameter of type '(x: {}) => { [index: string]: {}; }'.
  Types of parameters 'stringDict' and 'x' are incompatible.
    Type '{}' is not assignable to type '{ [index: string]: {}; }'.
      Index signature is missing in type '{}'.
 */
const fn = pipe(
    getStringDict,
    x => x,
    stringDictIdentity,
);

//
// Workarounds
//

declare function identity<T>(a: T): T;
const fn2 = pipe(
    getStringDict,
    identity,
    stringDictIdentity,
);

const fn3 = pipe(
    getStringDict,
    x => x,
    x => stringDictIdentity(x),
);

[OliverJAsh]

Revisiting this. I believe the issue can be narrowed down to:

{
    declare const pipe: {
        <A, B, C, D>(ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): (a: A) => D;
    };

    declare const getArray: () => string[];
    declare const first: <T>(ts: T[]) => T;

    /*
    Without `strictFunctionTypes` enabled:
    Expected type: `(a: {}) => string`
    Actual type: `(a: {}) => {}`
    */
    const fn = pipe(
        getArray,
        x => x,
        /*
        With `strictFunctionTypes` enabled, unexpected type error:
        Argument of type '<T>(ts: T[]) => T' is not assignable to parameter of type '(c: {}) => {}'.
            Types of parameters 'ts' and 'c' are incompatible.
                Type '{}' is missing the following properties from type '{}[]': length, pop, push, concat, and 25 more.
        */
        first,
    );

    // Workaround 1: use `identity` function
    declare const identity: <T>(value: T) => T;
    const fn2 = pipe(
        getArray,
        identity,
        first,
    );

    // Workaround 2: wrap last function
    const fn3 = pipe(
        getArray,
        x => x,
        x => first(x),
    );
}

Any ideas @mhegazy @weswigham? Does this help?