OCaml : trouver une valeur de type spécifique

Question

J'ai la liste de certaines valeurs où je dois trouver quel type de valeur est le premier :

type my_types =
    | MAlpha
    | MBeta of int list
    | MGamma of string * int

let find_first where what =
    List.iter ( fun m ->
        | MAlpha ->
            (* iterate frough "what" to find if it was asked to look and return it if it was *)
        | (* do the same for all other types *)
    ) where;
;;

let main =
    let where_to_find = [MGamma, MAlpha, MBeta] in
    let what_to_find = [MAlpha, MBeta] in
    (match (first_found where_to_find what_to_find) with
    | MAlpha ->
        (* should return this *)
    )
;;

Existe-t-il un moyen de le faire sans toucher à tous les types de MonType en trouver_premier - est-il possible de comparer les types de deux valeurs ? Merci.

Answer 1

Le code que vous avez posté ne compile pas, mais je pense que vous recherchez l'information suivante :

1. Il est possible d'écrire des modèles dits "ou", comme dans, par exemple, (function MAlpha | MBeta _ -> ...) .

2. Mais les modèles ne sont pas des citoyens de première classe. Vous ne pouvez pas construire un motif à partir d'une liste (et d'ailleurs, [MGamma, MAlpha, MBeta] est l'une des choses qui ne compile pas dans votre question), et vous ne pouvez pas non plus passer un motif comme argument à une fonction.

3. Cependant, vous pouvez construire et transmettre une fonction qui correspond à un motif, donc si vous êtes prêt à modifier votre fonction find_first pour prendre une fonction au lieu d'une liste pour what il sera plus pratique à utiliser.

Answer 2

Une autre façon de voir les choses est que vous avez une relation d'équivalence pour votre type, c'est-à-dire que vous avez des endroits où vous voulez traiter tous les types de données. MAlpha est le même, tous les MBeta est le même, et tous les MGamma est le même. Une manipulation standard pour les relations d'équivalence consiste à choisir un élément représentatif qui représente l'ensemble des valeurs équivalentes (la classe d'équivalence).

Dans votre cas, vous pourriez utiliser MAlpha pour représenter tous les MAlpha (mais il n'y en a qu'un seul), MBeta [] pour représenter tous les MBeta et MGamma ("", 0) pour représenter tous les MGamma s. Vous auriez une fonction pour calculer la valeur représentative à partir d'une valeur donnée :

let malpha = MAlpha
let mbeta = MBeta []
let mgamma = MGamma ("", 0)

let canonicalize =
    function
    | MAlpha -> malpha
    | MBeta _ -> mbeta
    | MGamma _ -> mgamma

let find_first where what =
    canonicalize (List.find (fun x -> List.mem (canonicalize x) what) where)

let main () =
    let where_to_find = [MGamma ("a", 3); MAlpha; MBeta [3; 4]] in
    let what_to_find = [malpha; mbeta] in
    try
        let found = find_first where_to_find what_to_find
        in
            if found = malpha then (* what to do *)
            else if found = mbeta then (* what to do *)
            else (* what to do *)
    with Not_found -> (* nothing was there *)

J'ai déjà écrit du code comme ça et ça n'est pas si mal. Dans votre cas, cela vous permet de spécifier le what paramètre un peu naturellement. Un inconvénient, cependant, c'est que vous ne pouvez pas faire de correspondance de motif avec malpha , mbeta y mgamma . Vous devez faire des comparaisons d'égalité avec eux.

Il se peut que vous vouliez trouver la valeur spécifique dans la liste, plutôt que la valeur canonisée. Je pense que les changements pour ce cas devraient être assez clairs.

Cela répond également à la deuxième partie de votre question. Le site List.find s'arrêtera dès qu'elle aura trouvé ce qu'elle cherche.

OCaml définit une relation d'ordre pour tous les types qui ne contiennent pas de valeurs fonctionnelles. Si cet ordre intégré (polymorphe) ne fait pas ce que vous voulez, vous devez définir le vôtre. Vous auriez certainement besoin de le faire pour comparer des valeurs de deux types différents, mais ce n'est pas ce que vous faites ici.

Si aucun élément de la liste ne ressemble à ce que vous avez dit que vous vouliez, cette version de la fonction find_first soulèvera l'exception Not_found . C'est une autre chose à laquelle il faut penser.