Haskell Language
Infix-Operatoren

Bemerkungen

Auftakt

Logisch

&& ist logisch UND, || ist logisch ODER.

== ist Gleichheit, /= Nichtgleichheit, < / <= weniger und > / >= größere Operatoren.

Rechenzeichen

Die numerischen Operatoren + , - und / verhalten sich weitgehend wie erwartet. (Division arbeitet nur mit gebrochenen Zahlen, um Rundungsprobleme zu vermeiden - Ganzzahlige Division muss mit quot oder div ) Ungewöhnlicher sind die drei Potenzierungsoperatoren von Haskell:

• ^ nimmt eine Basis eines beliebigen Zahlentyps an eine nicht negative, integrale Potenz an. Dies funktioniert einfach durch ( schnelle ) iterierte Multiplikation. Z.B

  4^5  ≡  (4*4)*(4*4)*4
  

• ^^ tut dasselbe im positiven Fall, funktioniert aber auch für negative Exponenten. Z.B

  3^^(-2)  ≡  1 / (2*2)
  

  Im Gegensatz zu ^ erfordert dies einen gebrochenen Basistyp (dh 4^^5 :: Int funktioniert nicht, nur 4^5 :: Int oder 4^^5 :: Rational ).

• ** implementiert eine Exponentiation mit reellen Zahlen. Dies funktioniert für sehr allgemeine Argumente, ist jedoch rechenintensiver als ^ oder ^^ und führt im Allgemeinen zu kleinen Gleitkommafehlern.

  2**pi  ≡  exp (pi * log 2)
  

Listen

Es gibt zwei Verkettungsoperatoren:

• : (ausgesprochene Nachteile ) fügt ein einzelnes Argument vor einer Liste ein. Dieser Operator ist eigentlich ein Konstruktor und kann daher auch dazu verwendet werden, eine Liste mit einem Muster abzustimmen ("inverses Konstrukt").

• ++ verkettet ganze Listen.

  [1,2] ++ [3,4]  ≡  1 : 2 : [3,4]  ≡  1 : [2,3,4]  ≡  [1,2,3,4]
  

!! ist ein Indexierungsoperator.

[0, 10, 20, 30, 40] !! 3  ≡  30

Beachten Sie, dass die Indizierung von Listen ineffizient ist (Komplexität O ( n ) anstelle von O (1) für Arrays oder O (log n ) für Karten ). In Haskell wird es im Allgemeinen bevorzugt, Listen zu dekonstruieren, indem der Mustervergleich statt der Indexierung gefaltet wird.

Kontrollfluss

• $ ist ein Funktionsanwendungsoperator.

  f $ x  ≡  f x
         ≡  f(x)  -- disapproved style
  

  Dieser Operator wird meistens verwendet, um Klammern zu vermeiden. Es hat auch eine strikte Version $! , wodurch das Argument vor der Anwendung der Funktion ausgewertet werden muss.

• . komponiert Funktionen.

  (f . g) x  ≡  f (g x)  ≡  f $ g x
  

• >> monadische Aktionen aus. ZB writeFile "foo.txt" "bla" >> putStrLn "Done." schreibt zuerst in eine Datei und druckt dann eine Nachricht auf den Bildschirm.

• >>= tut dasselbe, akzeptiert aber auch ein Argument, das von der ersten Aktion an die folgende übergeben wird. readLn >>= \x -> print (x^2) wartet darauf, dass der Benutzer eine Zahl readLn >>= \x -> print (x^2) , und gibt dann das Quadrat dieser Zahl auf dem Bildschirm aus.

Benutzerdefinierte Operatoren

In Haskell können Sie einen beliebigen Infix-Operator definieren. Zum Beispiel könnte ich den Operator für das Einschließen von Listen als definieren

(>+<) :: [a] -> [a] -> [a]
env >+< l = env ++ l ++ env

GHCi> "**">+<"emphasis"
"**emphasis**"

Sie sollten solchen Operatoren immer eine Festigkeitserklärung geben, z

infixr 5 >+<

(was >+< bedeuten würde, bindet so eng wie ++ und : do).

Informationen zu Infix-Operatoren suchen

Da Infixes in Haskell so häufig sind, müssen Sie regelmäßig ihre Signatur usw. nachschlagen. Glücklicherweise ist dies genauso einfach wie für jede andere Funktion:

• Die Haskell-Suchmaschinen Hayoo und Hoogle können für Infix-Operatoren verwendet werden, wie für alles andere, was in einer Bibliothek definiert ist.

• In GHCi oder IHaskell, können Sie verwenden , um die :i und :t (i nfo und t yp) Richtlinien , die grundlegenden Eigenschaften eines Bedieners zu lernen. Zum Beispiel,

  Prelude> :i +
  class Num a where
    (+) :: a -> a -> a
    ...
        -- Defined in ‘GHC.Num’
  infixl 6 +
  Prelude> :i ^^
  (^^) :: (Fractional a, Integral b) => a -> b -> a
        -- Defined in ‘GHC.Real’
  infixr 8 ^^
  

  Dies sagt mir, dass ^^ fester bindet als + , beide nehmen numerische Typen als ihre Elemente an, aber ^^ erfordert, dass der Exponent ganzzahlig ist und die Basis gebrochen ist.
  Die weniger ausführlichen :t erfordert den Operator in Klammern, wie

  Prelude> :t (==)
  (==) :: Eq a => a -> a -> Bool