Ce qui ne les parenthèses signifient par (x:xs) lorsque le pattern matching?

lorsque vous divisez une liste à l'aide de x:xs syntaxe pourquoi est-il enveloppé dans un parenthèses? quelle est l'importance des parenthèses? pourquoi ne pas [x:xs] ou tout simplement x:xs?

  • Avez-vous un exemple de cas où il est enveloppé dans ()? x:xs peut être utilisé pour décrire une liste avec la liste du premier élément. [x:xs] serait une liste avec la liste x:xs pour elle.
  • Il a dit à propos de la correspondance de motif, pas sur la construction de liste.
InformationsquelleAutor Pradeep | 2010-02-03
  1. 45

    Les inconvénients de la cellule ne doit pas être mis entre parenthèses dans chaque contexte, mais dans la plupart des contextes, c'est parce que

    Fonction de l'application se lie plus serré que tout opérateur infixe.

    Graver ce dans votre cerveau en lettres de feu.

    Exemple:

    length [] = 0
length (x:xs) = 1 + length xs

    Si les parenthèses ont été omis, le compilateur crois que vous avez eu un argument x suivie par un mal placée opérateur infixe, et il allait se plaindre amèrement. D'un autre côté c'est OK

    length l = case l of [] -> 0
                     x:xs -> 1 + length xs

    Dans ce cas ni x ni xs peut éventuellement être interprété comme une partie de la fonction de demande donc pas de parenthèses sont nécessaires.

    Noter que le même merveilleux règle fonction de l'application se lie plus serré que tout opérateur infixe est ce qui nous permet d'écrire length xs dans 1 + length xs sans parenthèses. L'infixe règle donne, et l'infixe règle ôte.

    • +1 pour les lettres de feu. Mon code Haskell cessé de regarder comme Lisp après que j'ai assimilé cette règle.
    • +1. L'amour la dernière phrase
    InformationsquelleAutor Norman Ramsey
  2. 14

    Vous êtes tout simplement à l'aide de l'opérateur cons :, qui a une faible priorité. Les parenthèses sont nécessaires pour que les choses restent à droite.

    Et que vous n'utilisez pas [x:xs], parce que ce serait correspondent à une liste dont le seul élément est une liste avec tête x et la queue xs.

    • Je n'avais jamais essayé spécifiques [x:xs] modèle, mais bien sûr, vous avez raison; il correspond à un singleton sur la liste de haut niveau. Le délactosé notation du modèle serait: ((x:xs):[]).
    InformationsquelleAutor sykora
  3. 3

    Je ne sais pas de réponse exacte, mais je suppose que c'est en raison de ce qui peut être mis en correspondance des modèles. Seuls les constructeurs peuvent être appariés. Les constructeurs peuvent être d'un seul mot ou en composite. Regardez le code suivant: 

    data Foo = Bar | Baz Int

f :: Foo -> Int
f Bar     = 1
f (Baz x) = x - 1

    Seul mot constructeurs match est. Mais composite constructeurs doit être entouré de parenthèses pour éviter toute ambiguïté. Si nous sautons parens il ressemble à la correspondance contre deux indépendant arguments: 

    f Baz x = x - 1

    Donc, comme (:) est composite, il doit être dans les parenthèses. Sauter parens pour Bar est une sorte de sucre syntaxique.

    Mise à JOUR: j'ai réalisé que (comme sykora noté) c'est une conséquence de la priorité de l'opérateur. Il clarifie mes hypothèses. Fonction de l'application (qui est juste de l'espace entre la fonction et argument) a la plus haute priorité. D'autres, y compris (:) ont priorité inférieure. Donc f x:xs doit être interprété comme ((:) (f x)) xs qui n'est sans doute pas ce dont nous avons besoin. Alors que f (x:xs) est interprété comme f appliquée à x:xs qui est à son tour (:) appliquée à x et xs.

    InformationsquelleAutor Rorick
  4. 2

    C'est à faire avec l'analyse.

    Rappelez-vous, le côlon : est juste un constructeur qui est écrit à l'exploitant de la syntaxe. Donc une fonction comme

    foo [] = 0
foo (x:xs) = x + foo xs

    pourrait aussi être écrit comme

    foo [] = 0
foo ((:) x xs) = x + foo xs

    Si vous supprimez les parenthèses dans la dernière ligne, il devient très difficile à analyser!

    InformationsquelleAutor yatima2975
  5. 1

    : est une des données constructeur, comme pour tout autre motif, mais écrit infix. Les parenthèses sont purement là parce que de infix priorité; ils ne sont pas vraiment nécessaires et peuvent être en toute sécurité omis lorsque les règles de priorité permettent. Par exemple:

    > let (_, a:_) = (1, [2, 3, 4]) in a
2
> let a:_ = "xyzzy"
'x'
> case [1, 2, 3] of; a:b -> a; otherwise -> 0;
1

    Il est intéressant de noter, qui ne semble pas fonctionner dans la tête d'un lambda. Je ne sais pas pourquoi.

    Comme toujours, la "juxtaposition" de l'opérateur se lie plus serré qu'autre chose, donc le plus souvent pas les délimiteurs sont nécessaires, mais elles ne sont pas réellement partie de la correspondance de modèle--sinon vous ne seriez pas en mesure d'utiliser des modèles comme (x:y:zs) au lieu de (x:(y:zs)).

    InformationsquelleAutor C. A. McCann