Was die Klammern bedeuten in (x:xs) beim pattern matching?

wenn Sie split eine Liste mit x:xs syntax warum ist es verpackt in einer Runden Klammern? was ist die Bedeutung der Klammern? warum nicht [x:xs] oder einfach x:xs?

  • Haben Sie ein Beispiel, wo es gewickelt ist, in ()? x:xs verwendet werden können zur Beschreibung einer Liste mit der Liste das erste element. [x:xs] wäre eine Liste mit der Liste x:xs in es.
  • Er sagt über pattern-matching, nicht über den Bau Liste.
InformationsquelleAutor Pradeep | 2010-02-03
  1. 45

    Die cons-Zelle muss nicht die eingeklammerte in jedem Kontext, aber in den meisten Kontexten ist es denn

    Funktion Anwendung bindet stärker als alle infix-operator.

    Brennen in Ihrem Gehirn, in Briefen des Feuers.

    Beispiel:

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

    Wenn Klammern weggelassen, würde der compiler denken, Sie hätten ein argument x gefolgt von einem schlecht platziert infix-operator, und würde es beklagen sich bitter. Auf der anderen Seite ist dies OK

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

    In diesem Fall weder x noch xs kann möglicherweise so ausgelegt werden, als Teil einer Funktion-Anwendung, so dass keine Klammern benötigt werden.

    Beachten Sie, dass die gleiche wunderbare Regel Funktion Anwendung bindet stärker als alle infix-operator ist, was uns erlaubt, uns zu schreiben length xs im 1 + length xs ohne Klammern. Der infix-Regel gibt und das infix Regel nimmt.

    • +1 für die Buchstaben von Feuer. Mein Haskell-code gestoppt sah aus wie Lisp, nachdem ich dies verinnerlicht Regel.
    • +1. Liebe den letzten Satz
    InformationsquelleAutor Norman Ramsey
  2. 14

    Du bist einfach mit dem cons-operator :, das hat niedrige Priorität. Klammern sind erforderlich, so dass die Dinge Recht zu bleiben.

    Und Sie nicht verwenden [x:xs], denn das wäre mit einer Liste, deren einziges element einer Liste mit Kopf x - und tail -xs.

    • Ich hatte nie versucht, die spezifischen [x:xs] Muster, aber natürlich hast du Recht; es entspricht einem singleton-Liste auf der obersten Ebene. Die desugared notation der Muster wäre: ((x:xs):[]).
    InformationsquelleAutor sykora
  3. 3

    Weiß ich nicht genau beantworten, aber ich denke, das ist wegen dem, was abgeglichen werden kann, in den mustern. Nur Konstruktoren abgestimmt werden können. Konstruktoren können einzelne Wörter oder zusammengesetzte. Blick auf die nächste code: 

    data Foo = Bar | Baz Int

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

    Einziges Wort Konstruktoren entsprechen, wie Sie ist. Aber composite-Konstruktoren müssen umgeben sein, die mit Klammern um, um Mehrdeutigkeiten zu vermeiden. Wenn wir überspringen parens es sieht aus wie matching-gegen zwei unabhängige Argumente: 

    f Baz x = x - 1

    So, als (:) composite-es muss in Klammern. Überspringen parens für Bar ist eine Art syntaktischer Zucker.

    UPDATE: ich erkannte, dass (wie sykora angegeben) es ist eine Folge von Operatoren. Es klärt meine Annahmen. Funktion Anwendung (das ist nur der Raum zwischen Funktion und argument) hat höchste Priorität. Andere, einschließlich (:) haben niedrigere Priorität. So f x:xs wird interpretiert als ((:) (f x)) xs das ist vermutlich nicht das, was wir brauchen. Während f (x:xs) wird interpretiert als f angewendet x:xs was wiederum (:) angewendet x und xs.

    InformationsquelleAutor Rorick
  4. 2

    Geht es um die Analyse.

    Erinnern,, der Doppelpunkt : ist nur ein Konstruktor, der geschrieben wird mit dem operator-syntax. So eine Funktion wie

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

    könnte auch geschrieben werden als

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

    Wenn Sie die drop-Klammern in der letzten Zeile, wird es sehr schwer zu analysieren!

    InformationsquelleAutor yatima2975
  5. 1

    : ist ein Daten-Konstruktor, wie bei jedem anderen Muster übereinstimmen, aber geschrieben infix. Die Klammern sind rein, weil infix Vorrang; Sie sind eigentlich nicht erforderlich und kann sicher ausgelassen werden, wenn die Vorrang-Regeln erlauben. Zum Beispiel:

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

    Interessant, dass scheint nicht zu funktionieren im Kopf eines lambda. Nicht sicher, warum.

    Wie immer, die "nebeneinander" - operator bindet stärker als alles andere, so dass mehr als oft nicht, sind die Trennzeichen notwendig, aber Sie sind nicht wirklich Teil des pattern-match--sonst wärst du ja nicht in der Lage, verwenden Sie Muster wie (x:y:zs) statt (x:(y:zs)).

    InformationsquelleAutor C. A. McCann
Schreibe einen Kommentar