Qual è la sintassi per le funzioni freccia Typescript con generici?

Il manuale dattiloscritto attualmente non ha nulla sulle funzioni freccia. Le funzioni normali possono essere tipicamente digitate con questa sintassi: esempio:

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

Qual è la sintassi per le funzioni freccia?

L'esempio completo che spiega la sintassi a cui fa riferimento Robin ... me l'ha riportato a casa:

Funzioni generiche

Qualcosa di simile al seguente funziona bene:

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

Tuttavia, l'utilizzo di una funzione generica freccia non:

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

Soluzione alternativa: utilizzare extends sul parametro generico per indicare al compilatore che si tratta di un generico, ad esempio:

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

Ho trovato l'esempio sopra confuso. Sto usando React e JSX quindi penso che abbia complicato lo scenario.

Ho ricevuto chiarimenti da TypeScript Deep Dive , che afferma per i generici delle frecce:

Soluzione alternativa: utilizzare estende il parametro generico per suggerire al compilatore che si tratta di un generico, derivato da un esempio più semplice che mi ha aiutato.

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

Se sei in un .tsxfile non puoi semplicemente scrivere <T>, ma funziona:

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

A differenza extends {}dell'hack, questo hack almeno conserva l'intento.

La specifica della lingua dice a p.64f

Un costrutto della forma <T> (...) => {...} può essere analizzato come espressione di una funzione freccia con un parametro di tipo o un'asserzione di tipo applicata a una funzione di freccia senza parametro di tipo. Viene risolto come il precedente [..]

esempio:

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

Questo funziona per me

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

mentre la risposta popolare con extends {}funziona ed è meglio di extends any, costringe Ta essere un oggetto

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

per evitarlo e preservare la sicurezza del tipo, è possibile utilizzare extends unknowninvece

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

Devo usare questo tipo di dichiarazione:

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

Permette di definire ulteriori oggetti di scena per la tua funzione, se necessario, e in alcuni casi, aiuta a mantenere il corpo più pulito dalla definizione generica.

Se non hai bisogno di oggetti di scena aggiuntivi (specie di spazio dei nomi), può essere semplificato per:

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

così tardi, ma con ES6 non c'è bisogno di estenderlo funziona ancora per me .... :)

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)