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

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?

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 un genérico, por ejemplo:

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

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; }

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

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

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

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})
               });
           };

Esto funciona para mi

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

mientras que la respuesta popular con extends {}funciona y es mejor que extends any, obliga Ta ser un objeto

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

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

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

Para usar este tipo de declaración:

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

Permite definir accesorios adicionales para su función si alguna vez lo necesita y, en algunos casos, ayuda a mantener el cuerpo de la función más limpio de la definición genérica.

Si no necesita accesorios adicionales (tipo de espacio de nombres), puede simplificarse para:

const identity: <T>(arg: T) => T = (arg) => arg;

tan tarde, pero con ES6 no es necesario extenderlo todavía funciona para mí ... :)

let getArray = <T>(items: T[]): T[] => {
    return new Array<T>().concat(items)
}

let myNumArr = getArray<number>([100, 200, 300]);
let myStrArr = getArray<string>(["Hello", "World"]);
myNumArr.push(1)
console.log(myNumArr)