Haskell correspondance de modèle de type

Est-il possible de faire quelque chose comme cela en haskell ?

data Fruits = Apple Int | Orange Int deriving (Eq, Show)

basket = [Apple 2, Orange 4]

from_basket t (x:basket) =
    case x of
        (t i) -> i
        _ -> from_basket t basket

Maintenant, je veux faire la "pomme" de la liste des fruits ( panier )

from_basket Apple basket

Sans motif explicite match

case x of
    Apple i -> ...
    Orange i -> ...
    _ ->
Semble être une presque copie exacte de stackoverflow.com/questions/4273702/type-comparison-in-haskell
Je ne pense pas que c'est presque exacte. Dans l'autre question que l'OP veut vérifier si une variable est d'un type (qui est décidé au moment de la compilation). Ici, la question est de savoir quel constructeur d'une constante de type a été invoquée (ce qui est décidé au moment de l'exécution).

OriginalL'auteur jgoday | 2011-04-29

  1. 11

    Un autre moyen serait de définir votre propre fonction d'assistance isApple et puis faire du filtrage:

    isApple (Apple _) = True
isApple _         = False

getApples = filter isApple

    Pattern matching est l'outil de votre choix, je ne sais pas si vous pouvez simplifier cette toute nouvelle. Mais en dehors de certains sales modèle de Haskell, je ne vois pas d'autre moyen.

    Cela renvoie [Fruits] bien, pas Int.
    de sorte que vous pouvez de la chaîne pour obtenir le Int: head . map (\Apple i -> i) . filter isApple
    Cela me semble légèrement plus propre que le Maybe approche dans ce cas, et en ayant accès à toutes les pommes dans le panier, ou [] si il n'en existe aucune, peut également être utile.

    OriginalL'auteur fuz

  2. 9

    Les autres réponses ont expliqué pourquoi il ne fonctionne pas comme il est, mais pour autant que des solutions de rechange, voulant faire quelque chose comme ça, c'est souvent un signe que vos types de données devrait ressembler à quelque chose comme ceci:

    data FruitName = Apple | Orange deriving (Eq, Show)
data Fruits = Fruits FruitName Int deriving (Eq, Show)

    ...auquel cas la fonction désirée devient trivial.

    Pouvez-vous développer pour ceux qui ne parviennent pas à voir la trivialité dans l'exemple?

    OriginalL'auteur C. A. McCann

  3. 4

    Vous pouvez accomplir quelque chose de semblable à cela, définissez le sélecteur de fonctions

    getApple :: Fruits -> Maybe Int
getApple (Apple x) = Just x
getApple _ = Nothing

getOrange :: Fruits -> Maybe Int
getOrange (Orange x) = Just x
getOrange _ = Nothing

fromBasket selector [] = Nothing
fromBasket selector (x:basket) =
    case selector x of
        Just x -> Just x
        Nothing -> fromBasket selector basket

    Maintenant vous pouvez le faire

    > fromBasket getApple basket
Just 2

> fromBasket getOrange basket
Just 4

    Cela suppose que vos constructeurs prennent tous des arguments similaires. Il renvoie également Nothing si le fruit désiré type n'était pas dans le panier.

    Vous utilisez déjà Maybe - pourquoi ne pas faire fromBasket :: [Fruits] -> Maybe Fruits trop et éviter le "mal" error? I. e. fromBasket selector [] = Nothing (et je pense que cela doit aller d'abord, trop).
    Oui, qui fait sens ici. J'ai mis à jour le code. La liste vide de cas n'ont pas à venir en premier ici, comme le (:) constructeur ne correspond pas à la [], cependant la passation de la liste vide de cas première est considérée comme la plus idiomatique. Merci 🙂

    OriginalL'auteur hammar