type Declare pour une variable qui contient une référence à une fonction générique

Question

En Essense, au lieu d'écrire

function test<T>(param: T): T { 
    return param; 
} 

test<string>("xxx"); 

Je veux avoir une déclaration de type qui peut être appliqué à une valeur de fonction de flèche affectée à une variable.

type X<T> = (param: T) => T; 
const test: X<T> = (param) => param; // <- ???? 
test<string>("XXX") 

Est-il possible dans TS 2.5 d'une manière non hacky? .... ou au moins d'une manière hacky?

Contexte: J'essaie de migrer le code ES6 existant vers Typescript. La mise en œuvre de la fonction dans ES6 ressemble à ceci:

import * as React from "react"; 
import * as recompose from "recompose" 

const formEnhancer = recompose.withContext(
    { form: React.PropTypes.any }, 
    function getChildContext(props) { 
    const { value, errors, onChange } = props; 
    return { form: { value, errors, onChange }}; 
    } 
); 

value a le type V, errors a IErrors<V> type et onChange a le type ChangeHandler<V>.

Le type attendu de la fonction est

export type FormEnhancer<V> = 
    recompose.InferableComponentEnhancerWithProps<{}, Props<V>>; 

qui est une interface de fonction:

export interface InferableComponentEnhancerWithProps<TInjectedProps, TNeedsProps> { 
    <P extends TInjectedProps>(component: Component<P>): 
    React.ComponentType<Omit<P, keyof TInjectedProps> & TNeedsProps> 
} 

La partie délicate est que je ne peux pas trouver en fait un moyen d'ajouter cette déclaration de type à la variable.

écrire quelque chose comme

const formDecorator: FormEnhancer<V> = ... 

conduit à un échec immédiat, comme V n'est pas défini.

La meilleure version que j'était en mesure d'obtenir enveloppait recompose.withContext dans ma propre fonction explicite

function formEnhancer<V>(target: React.ComponentType) { 
    return recompose.withContext<IContextProps<V>, Props<V>>(
    { form: React.PropTypes.any }, 
    function getChildContext(props) { 
     const { value, errors, onChange } = props; 
     return { form: { value, errors, onChange }}; 
    } 
)(target); 
} 

qui ne résout pas tout à fait le problème que je suis encore capable d'écrire

const raw = ({ foo }) => <input type="text" />; 
const Wrapped = formEnhancer(raw); 

ce qui signifie que TS n'a pas pu déduire le type d'accessoires pour la cible. Etre capable d'écrire quelque chose comme

function formEnhancer<V>(target: React.ComponentType<P extends Props<V>>) { 

serait utile.

Answer 1

Cela fonctionne pour moi:

const test = (<T>(param: T) => param); 

Cela passerait la définition de X<T> qui est une fonction qui renvoie le même type que le premier argument.