Haskell Language
Infix-operators

Opmerkingen

voorspel

Logisch

&& is logisch EN, || is logisch OF.

== is gelijkheid, /= niet-gelijkheid, < / <= kleiner en > / >= grotere operatoren.

Rekenkundige operatoren

De numerieke operatoren + , - en / gedragen zich grotendeels zoals u zou verwachten. (Verdeling werkt alleen op fractionele getallen om afrondingsproblemen te voorkomen - gehele getallen moeten met quot of div worden gedaan). Meer ongebruikelijk zijn de drie exponentiatie-exploitanten van Haskell:

• ^ neemt een basis van elk type naar een niet-negatieve, integrale macht. Dit werkt eenvoudig door ( snelle ) herhaalde vermenigvuldiging. Eg

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

• ^^ doet hetzelfde in het positieve geval, maar werkt ook voor negatieve exponenten. Eg

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

  In tegenstelling tot ^ vereist dit een fractioneel basistype (dwz 4^^5 :: Int werkt niet, alleen 4^5 :: Int of 4^^5 :: Rational ).

• ** implementeert real-nummer exponentiatie. Dit werkt voor zeer algemene argumenten, maar is computically duurder dan ^ of ^^ , en maakt over het algemeen kleine drijvende-kommafouten op.

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

lijsten

Er zijn twee aaneenschakelaars:

• : (uitgesproken nadelen ) plaatst een enkel argument voor een lijst. Deze operator is eigenlijk een constructor en kan dus ook worden gebruikt om een lijst te matchen ("inverse construct").

• ++ voegt volledige lijsten samen.

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

!! is een indexeringsoperator.

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

Merk op dat indexeringslijsten inefficiënt zijn (complexiteit O ( n ) in plaats van O (1) voor arrays of O (log n ) voor kaarten ); het heeft in Haskell over het algemeen de voorkeur om lijsten te deconstrueren door ot patroonovereenkomst te vouwen in plaats van te indexeren.

Controle stroom

• $ is een functie-applicatie-operator.

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

  Deze operator wordt meestal gebruikt om haakjes te vermijden. Het heeft ook een strikte versie $! , waardoor het argument moet worden geëvalueerd voordat de functie wordt toegepast.

• . stelt functies samen.

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

• >> sequenties monadische acties. Bijvoorbeeld writeFile "foo.txt" "bla" >> putStrLn "Done." zal eerst naar een bestand schrijven en vervolgens een bericht naar het scherm afdrukken.

• >>= doet hetzelfde, maar accepteert ook een argument dat moet worden doorgegeven van de eerste actie naar de volgende. readLn >>= \x -> print (x^2) wacht totdat de gebruiker een nummer readLn >>= \x -> print (x^2) vervolgens het kwadraat van dat nummer uit naar het scherm.

Aangepaste operatoren

In Haskell kunt u elke gewenste infix-operator definiëren. Ik zou bijvoorbeeld de operator voor lijstomhullende kunnen definiëren als

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

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

U moet dergelijke operatoren altijd een fixiteitsverklaring geven , zoals

infixr 5 >+<

(wat zou betekenen dat >+< zo strak bindt als ++ en : do).

Informatie zoeken over infix-operators

Omdat infixen zo vaak voorkomen in Haskell, moet je regelmatig hun handtekening enz. Opzoeken. Gelukkig is dit net zo eenvoudig als voor elke andere functie:

• De Haskell-zoekmachines Hayoo en Hoogle kunnen worden gebruikt voor infix-operators, zoals voor al het andere dat in sommige bibliotheken is gedefinieerd.

• In GHCi of IHaskell kunt u de richtlijnen :i en :t ( i nfo en t ype) gebruiken om de basiseigenschappen van een operator te leren. Bijvoorbeeld,

  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 ^^
  

  Dit vertelt me dat ^^ bindt dan + , beide nemen numerieke typen als hun elementen, maar ^^ vereist dat de exponent integraal is en de basis fractioneel.
  Hoe minder uitgebreid :t vereist de operator tussen haakjes, zoals

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