Haskell pattern-matching idiom

Question

Ich mache einen Taschenrechner auf abstrakte ganze Zahlen und ich mache eine Menge Mustervergleich. Ich kann

add Zero x = x 
add (P x) y = next $ add (prev $ P x) y 
add (N x) y = prev $ add (next $ N x) y 

oder

add Zero x = x 
add x y = case x of 
    P _ -> next $ add (prev x) y 
    _ -> prev $ add (next x) y 

Während der erste Weg ist kürzer, etwas in die zweite Möglichkeit spricht mich mehr schreiben.

Welches ist der bevorzugte Weg, dies zu tun?

Answer 1

Verwenden Sie as-patterns.

add Zero y = y 
add x@(P _) y = next $ add (prev x) y 
add x@(N _) y = prev $ add (next x) y 

ich auch unter Hinweis auf die gemeinsame Struktur Ihrer beiden rekursiven Zweige abstrahiert aus betrachten würde, dass Sie die Rollen der prev und next Funktionen tauschen nur davon abhängt, ob x positiv oder negativ ist:

add Zero x = x 
add x y = f $ add (g x) y 
    where (f, g) = case x of 
         P _ -> (next, prev) 
         N _ -> (prev, next) 

Answer 2

über diesen Stil:

add Zero x = x 
add x y = case x of 
    P _ -> next $ add (prev x) y 
    _ -> prev $ add (next x) y 

Auf der positiven Seite, vermeidet es einige Wiederholungen, das ist gut.

Auf der negativen Seite, die case scheint auf den ersten Blick nicht erschöpfend. In der Tat, um sich davon zu überzeugen, dass die Musterübereinstimmung wirklich erschöpfend ist, müssen wir über die möglichen Werte für die x in case x of diskutieren, und sehen, dass zur Laufzeit das Zero nicht sein kann, weil das oben behandelt wurde. Dies erfordert weit mehr geistige Anstrengung als das erste Snippet, das offensichtlich erschöpfend ist.

Schlimmer noch, beim Einschalten von Warnungen, wie wir es immer tun sollten, beschwert sich GHC, da es nicht davon überzeugt ist, dass die case erschöpfend ist.

Persönlich wünschte ich, die Designer von Haskell hätten nicht vollständige Spiele gänzlich verboten. Ich würde einen -Werror-on-non-exhaustive-matches verwenden, wenn es einen gab. Ich würde gerne gezwungen werden, z.B.

als die letzte Verzweigung, die vom Compiler für mich stillgelegt wird.

Answer 3

Betrachten wir die math-style definition of integers als Kongruenzklassen von Paaren von naturals unter der Äquivalenzbeziehung unter Verwendung von:

{((a,b), (c,d)) | b+c == d+a} 

Die Intuition ist, dass das Paar von naturals (a,b)b-a darstellt. Wie im Wikipedia-Artikel erwähnt, reduziert dies oft die Anzahl der Sonderfälle im Vergleich zur "0/positiv/negativ" -Definition. Insbesondere die Additionsoperation Sie über die Implementierung bitten wird zu einem Einzeiler:

-- both Int and Integer are taken 
data Int' = Int Nat Nat 

instance Num Int' where 
    -- b-a + d-c = (b+d)-(a+c) 
    Int a b + Int c d = Int (a + c) (b + d) 

Es ist eine Art Spaß durch die verschiedenen Operationen mit dieser Darstellung zu arbeiten.Zum Beispiel Eq kann mit der oben angegebenen Gleichung implementiert werden und Ord ist ähnlich:

instance Eq Int' where 
    -- b-a == d-c = b+c == d+a 
    Int a b == Int c d = b+c == d+a 

instance Ord Int' where 
    -- compare (b-a) (d-c) = compare (b+c) (d+a) 
    compare (Int a b) (Int c d) = compare (b+c) (d+a) 

Gelegentlich kann es nützlich sein, diese Dinge zu normalisieren. Genau wie Brüche durch Multiplizieren von Zähler und Nenner um die gleiche Zahl reduziert werden können, bis sie relativ prim sind, können diese Dinge reduziert werden, indem die gleiche Zahl zu beiden Teilen addiert oder subtrahiert wird, bis (wenigstens) einer von ihnen Null ist.

normalize (Int (S a) (S b)) = normalize (Int a b) 
normalize v = v