typescript - usar - lambdas en javascript

¿Cuál es la sintaxis para las funciones de flecha de Typecript con genéricos?

Question

El manual mecanografiado actualmente no tiene nada sobre las funciones de flecha. Las funciones normales se pueden escribir genéricamente con esta sintaxis: ejemplo:

function identity<T>(arg: T): T {
    return arg;
}

¿Cuál es la sintaxis para las funciones de flecha?

Answer 1

El ejemplo anterior me pareció confuso. Estoy usando React y JSX, así que creo que complicó el escenario.

Recibí una aclaración de TypeScript Deep Dive , que establece los genéricos de flecha:

Solución alternativa: el uso se extiende en el parámetro genérico para insinuar al compilador que es genérico, esto vino de un ejemplo más simple que me ayudó.

const identity = < T extends {} >(arg: T): T => { return arg; }

Answer 2

El ejemplo completo que explica la sintaxis a la que hace referencia Robin ... me lo trajo a casa:

Funciones genéricas

Algo como lo siguiente funciona bien:

function foo<T>(x: T): T { return x; }

Sin embargo, el uso de una función genérica de flecha no:

const foo = <T>(x: T) => x; // ERROR : unclosed `T` tag

Solución alternativa: el uso se extiende en el parámetro genérico para indicar al compilador que es genérico, por ejemplo:

const foo = <T extends {}>(x: T) => x;

Answer 3

Esto funciona para mi

const foo = <T, >(x: T) => x;

Answer 4

La especificación del lenguaje dice en p.64f

Una construcción de la forma <T> (...) => {...} podría analizarse como una expresión de función de flecha con un parámetro de tipo o una aserción de tipo aplicada a una función de flecha sin parámetro de tipo. Se resuelve como el anterior [..]

ejemplo:

// helper function needed because Backbone-couchdb''s sync does not return a jqxhr
let fetched = <
           R extends Backbone.Collection<any> >(c:R) => {
               return new Promise(function (fulfill, reject) {
                   c.fetch({reset: true, success: fulfill, error: reject})
               });
           };

Answer 5

Si bien la respuesta popular con extends {} funciona y es mejor que extends any , obliga a la T a ser un objeto

const foo = <T extends {}>(x: T) => x;

para evitar esto y preservar la seguridad de tipos, puede usar extends unknown lugar

const foo = <T extends unknown>(x: T) => x;

Answer 6

Si está en un archivo .tsx , no puede simplemente escribir <T> , pero esto funciona:

const Generic = <T> (value: T) => {
    return value;
} 

A diferencia del hack extends {} , este hack conserva al menos la intención.