Personal tools

De/Flussrichtung

From HaskellWiki

Revision as of 14:08, 19 March 2007 by Lemming (Talk | contribs)

(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to: navigation, search

Wenn man sich mal genauer umschaut, gibt es in Haskell beide Varianten gleich haeufig. Wir haben die Schreibweisen:

 links nach rechts:
    Funktionsdefinition    f x =3D x*x  (links Eingabe, rechts Ausgabe)
    Lambda                 \ x -> x*x
    do-notation            do f; g
    monadische Verkettung  f >>=3D g
 rechts nach links:
    Funktionsanwendung     f x
                           f $ x
    Verkettung             g . f
    Ergebnisse von Monaden do x <- f
    monadische Verkettung  g =3D<< f

Lambda-Ausdruecke saehen viel natuerlicher aus, wenn die Verkettung von links nach rechts gehen wuerde, also statt

  transform3 . (\x -> transform2 x x)  . transform1
 besser
  transform1 . (\x -> x x transform2)  . transform3

Auch

 do f -> x; g x

wre schon viel nher an der darunterliegenden Implementierung

 f >>=3D \x -> g x


Allerdings sehe ich noch zwei Unschoenheiten/Gewoehnungsbeduerftigkeiten:

Eines tritt beim Lesen von links-nach-rechts-Ausdruecken auf: Man sieht bei der Verwendung von Funktionen hoeherer Ordnung nicht sofort, wo die Argumente eines Funktionsaufrufes aufhoeren. Mein Lieblingsbeispiel - der Differentialoperator 'derive':

derive :: (a -> a) -> (a -> a)

Wenn man den Ausdruck 'x f derive' nur bis 'f' liest, denkt man, es handelt sich um die Anwendung von f auf x und danach kommt noch irgendwas. Aber nein, durch 'derive' wird alles umgekrempelt. Man muss also einen Ausdruck erst bis zum naechsten Absatz (schliessende Klammer, Infixoperator) lesen, bis man weiss, um welchen Funktionsaufruf es sich eigentlich handelt.

Die zweite Sache ist die Verbindung von Typsignatur und Funktionsanwendung. Wir schreiben

derive :: (a -> a) -> (a -> a)
derive f :: a -> a
derive f x :: a
 Wir koennen gewissermassen die Argumente von der Typseite auf die

Werteseite umschichten. Die Argumentreihenfolge ist daher in Typsignatur und Funktionsanwendung gleich. Bei der konsequenten links-nach-rechts-Notation ist das nicht mehr der Fall:

    derive :: (a -> a) -> (a -> a)
  f derive :: a -> a
x f derive :: a
 Die Notation hat natuerlich den unbestreitbaren Vorteil, dass man sich

'::' wie ein Gleichheitszeichen vorstellen kann, wo man auf beiden Seiten der Gleichung die Ausdruecke immer von links manipuliert.