¿Son posibles las funciones fuertemente tipadas como parámetros en TypeScript?

En TypeScript, puedo declarar un parámetro de una función como un tipo Función. ¿Hay una forma "segura de escribir" de hacer esto que me falta? Por ejemplo, considere esto:

class Foo {
    save(callback: Function) : void {
        //Do the save
        var result : number = 42; //We get a number from the save operation
        //Can I at compile-time ensure the callback accepts a single parameter of type number somehow?
        callback(result);
    }
}

var foo = new Foo();
var callback = (result: string) : void => {
    alert(result);
}
foo.save(callback);

La devolución de llamada de guardar no es de tipo seguro, le estoy dando una función de devolución de llamada donde el parámetro de la función es una cadena pero le estoy pasando un número y se compila sin errores. ¿Puedo hacer que el parámetro de resultado guarde una función de tipo seguro?

TL; Versión DR: ¿hay un equivalente de un delegado .NET en TypeScript?

Por supuesto. El tipo de una función consiste en los tipos de su argumento y su tipo de retorno. Aquí especificamos que el callbacktipo de parámetro debe ser "función que acepta un número y devuelve tipo any":

class Foo {
    save(callback: (n: number) => any) : void {
        callback(42);
    }
}
var foo = new Foo();

var strCallback = (result: string) : void => {
    alert(result);
}
var numCallback = (result: number) : void => {
    alert(result.toString());
}

foo.save(strCallback); // not OK
foo.save(numCallback); // OK

Si lo desea, puede definir un alias de tipo para encapsular esto:

type NumberCallback = (n: number) => any;

class Foo {
    // Equivalent
    save(callback: NumberCallback) : void {
        callback(42);
    }
}

Aquí hay equivalentes de TypeScript de algunos delegados comunes de .NET:

interface Action<T>
{
    (item: T): void;
}

interface Func<T,TResult>
{
    (item: T): TResult;
}

Me doy cuenta de que esta publicación es antigua, pero hay un enfoque más compacto que es ligeramente diferente de lo que se pidió, pero puede ser una alternativa muy útil. Se puede declarar esencialmente la función en línea al llamar al método ( Foo's save()en este caso). Se vería algo así:

class Foo {
    save(callback: (n: number) => any) : void {
        callback(42)
    }

    multipleCallbacks(firstCallback: (s: string) => void, secondCallback: (b: boolean) => boolean): void {
        firstCallback("hello world")

        let result: boolean = secondCallback(true)
        console.log("Resulting boolean: " + result)
    }
}

var foo = new Foo()

// Single callback example.
// Just like with @RyanCavanaugh's approach, ensure the parameter(s) and return
// types match the declared types above in the `save()` method definition.
foo.save((newNumber: number) => {
    console.log("Some number: " + newNumber)

    // This is optional, since "any" is the declared return type.
    return newNumber
})

// Multiple callbacks example.
// Each call is on a separate line for clarity.
// Note that `firstCallback()` has a void return type, while the second is boolean.
foo.multipleCallbacks(
    (s: string) => {
         console.log("Some string: " + s)
    },
    (b: boolean) => {
        console.log("Some boolean: " + b)
        let result = b && false

        return result
    }
)

El multipleCallback()enfoque es muy útil para cosas como llamadas de red que pueden tener éxito o fallar. Una vez más, suponiendo un ejemplo de llamada de red, cuando multipleCallbacks()se llama, el comportamiento tanto para el éxito como para el fracaso se puede definir en un solo lugar, lo que se presta a una mayor claridad para futuros lectores de códigos.

En general, en mi experiencia, este enfoque se presta a ser más conciso, menos desorden y mayor claridad en general.

¡Buena suerte a todos!

type FunctionName = (n: inputType) => any;

class ClassName {
    save(callback: FunctionName) : void {
        callback(data);
    }
}

Esto seguramente se alinea con el paradigma de programación funcional.

En TS podemos escribir funciones de la siguiente manera:

Tipos de funciones / firmas

Esto se usa para implementaciones reales de funciones / métodos, tiene la siguiente sintaxis:

(arg1: Arg1type, arg2: Arg2type) : ReturnType

Ejemplo:

function add(x: number, y: number): number {
    return x + y;
}

class Date {
  setTime(time: number): number {
   // ...
  }

}

Tipo de función Literales

Los literales de tipo de función son otra forma de declarar el tipo de una función. Por lo general, se aplican en la firma de la función de una función de orden superior. Una función de orden superior es una función que acepta funciones como parámetros o que devuelve una función. Tiene la siguiente sintaxis:

(arg1: Arg1type, arg2: Arg2type) => ReturnType

Ejemplo:

type FunctionType1 = (x: string, y: number) => number;

class Foo {
    save(callback: (str: string) => void) {
       // ...
    }

    doStuff(callback: FunctionType1) {
       // ...
    }

}

Si define el tipo de función primero, se vería así

type Callback = (n: number) => void;

class Foo {
    save(callback: Callback) : void {        
        callback(42);
    }
}

var foo = new Foo();
var stringCallback = (result: string) : void => {
    console.log(result);
}

var numberCallback = (result: number) : void => {
    console.log(result);
}

foo.save(stringCallback); //--will be showing error
foo.save(numberCallback);

Sin el tipo de función utilizando la sintaxis de propiedad simple, sería:

class Foo {
    save(callback: (n: number) => void) : void {        
        callback(42);
    }
}

var foo = new Foo();
var stringCallback = (result: string) : void => {
    console.log(result);
}

var numberCallback = (result: number) : void => {
    console.log(result);
}

foo.save(stringCallback); //--will be showing error
foo.save(numberCallback);

Si lo desea mediante el uso de una función de interfaz como delegados genéricos de C # sería:

interface CallBackFunc<T, U>
{
    (input:T): U;
};

class Foo {
    save(callback: CallBackFunc<number,void>) : void {        
        callback(42);
    }
}

var foo = new Foo();
var stringCallback = (result: string) : void => {
    console.log(result);
}

var numberCallback = (result: number) : void => {
    console.log(result);
}

let strCBObj:CallBackFunc<string,void> = stringCallback;
let numberCBObj:CallBackFunc<number,void> = numberCallback;

foo.save(strCBObj); //--will be showing error
foo.save(numberCBObj);

Además de lo que dijo otro, un problema común es declarar los tipos de la misma función que está sobrecargada. El caso típico es el método EventEmitter on () que aceptará múltiples tipos de oyentes. Puede ocurrir algo similar al trabajar con acciones redux, y allí usa el tipo de acción como literal para marcar la sobrecarga. En el caso de EventEmitters, usa el tipo de nombre de evento literal:

interface MyEmitter extends EventEmitter {
  on(name:'click', l: ClickListener):void
  on(name:'move', l: MoveListener):void
  on(name:'die', l: DieListener):void
  //and a generic one
  on(name:string, l:(...a:any[])=>any):void
}

type ClickListener = (e:ClickEvent)=>void
type MoveListener = (e:MoveEvent)=>void
... etc

// will type check the correct listener when writing something like:
myEmitter.on('click', e=>...<--- autocompletion