Je voulais penser avoir compris les types personnalisés d'Elm en Java

C'est un mémo auquel Oncle Java a pensé en Java pour comprendre les types personnalisés d'Elm. Je ne connais pas le chokwagata.

Prenez Result comme exemple d'un type personnalisé:

Définition du résultat Elm

type Result error value
    = Ok value
    | Err error

Un exemple de représentation Java du Résultat ci-dessus:

Result.java

interface Result {
    class Ok<V> implements Result {
        final V value;
        Ok(V value) { this.value = value; }
    }

    class Err<E> implements Result {
        final E error;
        Err(E error) { this.error = error; }
    }
}

• La zone autour du modificateur d'accès a été ignorée.
• Je ne fais pas de mon mieux car le but n'est pas de ** reproduire ** des types personnalisés en Java. «J'ai vraiment fait de mon mieux (j'ai donné Result ʻE et V`), mais j'ai arrêté parce que c'était beaucoup de problèmes.

Exemple d'utilisation réelle du type Result de la version Java:

Main.java

class Main {
    public static void main(String[] args) {
        show(validate("100"));     // -> Ok: 100
        show(validate("200hoge")); // -> Err:Veuillez saisir un nombre
    }

    /**
     *Vérifiez que le texte est une chaîne composée uniquement de chiffres.
     * @param text La chaîne de caractères à vérifier.
     * @Entier si le texte renvoyé est composé uniquement de nombres.parseInt(text)Le résultat de
     *Ensemble de résultats dans le champ de valeur.Ok 。<br>
     *Si le texte contient autre chose que des chiffres"Veuillez saisir un nombre"À
     *Ensemble de résultats dans le champ d'erreur.Err 。
     */
    static Result validate(String text) { //"Elm compris des bases" P.91 fonctions de validation sont le matériau source
        try {
            var n = Integer.parseInt(text);
            return new Result.Ok<>(n);
        } catch (NumberFormatException e) {
            return new Result.Err<>("Veuillez saisir un nombre");
        }
    }

    /**
     *Sortir le contenu du résultat vers la sortie standard.
     * @param result La valeur à afficher.
     */
    static void show(Result result) {
        if (result instanceof Result.Ok) {
            var ok = (Result.Ok<Integer>) result;
            System.out.println("Ok: " + ok.value);
        } else if (result instanceof Result.Err) {
            var err = (Result.Err<String>) result;
            System.out.println("Err: " + err.error);
        } else {
            throw new RuntimeException("Le type de mystère est spécifié");
        }
    }
}

C'est un code qui n'a pas l'air cool car il dépend fortement de ʻIntegeret deString spécifiés dans le paramètre type, et il se branche sur ʻinsutanceof. Je suppose que je n'ai pas fait de mon mieux. ~~ Dans une telle atmosphère. ~~

La perception actuelle est que les types personnalisés d'Elm ressemblent à ceci en Java. À l'origine, vous devriez apprendre correctement les types de données algébriques, mais pour le moment, ma compréhension a avancé (je pense), alors Yoshi! Je suis.