Qual é a sintaxe das funções de seta Typescript com genéricos?

O manual de texto datilografado atualmente não possui nada sobre funções de seta. Funções normais podem ser digitadas genericamente com esta sintaxe: exemplo:

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

Qual é a sintaxe para as funções de seta?

O exemplo completo que explica a sintaxe mencionada por Robin ... trouxe para casa:

Funções genéricas

Algo como o seguinte funciona bem:

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

No entanto, o uso de uma função genérica de seta não:

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

Solução alternativa: use extends no parâmetro genérico para sugerir ao compilador que é um genérico, por exemplo:

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

Achei o exemplo acima confuso. Estou usando React e JSX, então acho que complicou o cenário.

Eu recebi esclarecimentos do TypeScript Deep Dive , que afirma para os genéricos de seta:

Solução alternativa: o uso estende-se no parâmetro genérico para sugerir ao compilador que ele é genérico; isso veio de um exemplo mais simples que me ajudou.

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

Se você está em um .tsxarquivo, não pode simplesmente escrever <T>, mas isso funciona:

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

Ao contrário do extends {}hack, esse hack preserva pelo menos a intenção.

A especificação da linguagem diz na p.64f

Uma construção do formato <T> (...) => {...} pode ser analisada como uma expressão de função de seta com um parâmetro de tipo ou uma declaração de tipo aplicada a uma função de seta sem parâmetro de tipo. É resolvido como o antigo [..]

exemplo:

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

Isso funciona para mim

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

enquanto a resposta popular com extends {}obras e é melhor do que extends any, força o Tser um objeto

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

para evitar isso e preservar a segurança-tipo, você pode usar extends unknownem vez

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

Eu para usar este tipo de declaração:

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

Ele permite definir adereços adicionais para sua função, se você precisar e, em alguns casos, ajuda a manter o corpo da função mais limpo da definição genérica.

Se você não precisar de objetos adicionais (tipo de espaço para nome), ele poderá ser simplificado para:

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

tão tarde, mas com o ES6 não há necessidade, ele ainda funciona para mim .... :)

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)