What is the return type for a function that returns another function

I am working on developing Protractor tests using Typescript. It appears that the d.ts file available for protractor is very out of date. I am trying to update it to include the Expected Conditions protractor has added.

To summarize it, Expected Conditions are a set of functions within protractor that return a function that returns a promise of your value.

An example of usage:

protractor.ExpectedCondtions.visibilityOf(element(by.id('button1')))();

I am stumped on how to tell protractor that I am returning a function that will return a specific return type. Does anyone have any experience with this?

If I understood you correctly, your solution will depend on the type that the "second" function returns.

In a nutshell, there are at least 2 ways to do it:

1. Lambda syntax
2. Interfaces (normal and generic interfaces)

I've tried to explain all these in the code below, please, check it:

module main
{
    export class TestClass
    {
        // Use lamba syntax as an interface for a return function
        protected returnSpecificFunctionWhichReturnsNumber(): () => number
        {
            return this.specificFunctionWhichReturnsNumber;
        }

        protected specificFunctionWhichReturnsNumber(): number
        {
            return 0;
        }

        // Use an interface to describe a return function
        protected returnSpecificInterfaceFunction(): INumberFunction
        {
            return this.specificFunctionWhichReturnsNumber;
        }

        // Use a generic interface to describe a return function
        protected returnSpecificGenericInterfaceFunction(): IReturnFunction<number>
        {
            return this.specificFunctionWhichReturnsNumber;
        }
    }

    // An interface for a function, which returns a number
    export interface INumberFunction
    {
        (): number;
    }

    // A generic interface for a function, which returns something
    export interface IReturnFunction<ValueType>
    {
        (): ValueType;
    }
}

Since this question popped up first in Google for how to type return function for a function that returns a function, I will add the generic solution here for declaring these types.

So if you want to add type declaration to this curried add function:

const add = (a : number) => (b: number) => a + b;

You just duplicate what is after the = sign and make the return value the corresponding value:

export const add: (a : number) => (b: number) => number =
    (a : number) => (b: number) => a + b;

But at this point, you don't need the types for the actual function, so you can just type this, as if it was JS:

export const add: (a : number) => (b: number) => number =
    a => b => a + b;

Writing it more extensively:

const add: (a : number) => (b: number) => number =
    a => {
        console.log(a);
        return b => {
            console.log(b);
            return a + b;
        }
    };

With generics:

export const add: <A extends number, B extends number>(a : A) => (b: B) => number =
    a => b => a + b;