Type de fonction qui a le même type en retour que celui de son unique paramètre

Le problème exposé dans ce sujet a été résolu.

Bonjour à tous !

J’essaie de faire en Typescript une fonction qui prend en paramètre une deuxième fonction où cette dernière peut utiliser n’importe quel type pour son paramètre mais la valeur de retour et le paramètre doivent être du même type

Un petit exemple : 

class Modifier {
    type: string;
    apply: <T>(data: T) => T;

    constructor(type: string, apply: (data: any) => any) {
        this.type = type;
        this.apply = apply;
    }
}

Donc ici je cherche à passer une fonction au constructeur pour apply qui peut être de n’importe quel type mais qui doit respecter la seule règle suivante : le type de retour doit être le même que celui du paramètre

Comme c’est écrit actuellement, ça fonctionne à moitié. Typescript me laisse bien passer n’importe quel type pour la fonction mais le type du paramètre et du retour peuvent être différents

Si je l’écrit de la manière suivante : 

class Modifier {
    type: string;
    apply: <T>(data: T) => T;

    constructor(type: string, apply: <T>(data: T) => T) {
        this.type = type;
        this.apply = apply;
    }
}

Alors je me retrouve avec des erreurs dès que je veux passer une fonction du type : (data: string[]) => string[] :

Type 'T' is not assignable to type 'string[]'

Est-ce que quelqu’un aurait une idée de comment réaliser ce genre de chose, si c’est même possible ?

Merci d’avance pour votre aide

+0 -0

Mon but est de transformer la donnée passée en paramètre à certains moments définis par Modifier.type. Pas au niveau du type mais seulement au niveau de la valeur, le type devant rester identique

Si on prend un tableau de chaînes de caractères comme dans l’exemple, ça serait ici d’ajouter/supprimer des éléments dans le tableau

Dans mon code, je parcours les Modifiers associés et si Modifier.type correspond aux Modifiers que l’on veut exécuter alors j’exécute apply

applyModifiers(type: string, data: any): any {
    this.modifiers.forEach((m) => {
        if (type === m.type) {
            data = m.apply(data);
        }
    });

    return data;
}
+0 -0

Je pense avoir une solution, qui implique de déclarer le type à chaque invocation de ta classe :

interface ModifierFunction<T> {
    (param: T): T;
}

class Modifier<T> {
    type: string;
    apply: ModifierFunction<T>;

    constructor(type: string, apply: ModifierFunction<T>) {
        this.type = type;
        this.apply = apply;
    }
}

const mod1 = new Modifier<string>('str', (d: string) => d );

En gros il faut créer une interface pour ta fonction afin d’indiquer que le paramètre et le retour doivent être du même type. Et communiquer ce type en amont, via l’instanciation de ta classe.

+0 -0
Connectez-vous pour pouvoir poster un message.
Connexion

Pas encore membre ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte