Haskell Language
Infix-operatörer

Anmärkningar

Förspel

Logisk

&& är logiskt OCH, || är logiskt ELLER.

== är jämlikhet, /= icke-jämlikhet, < / <= mindre och > / >= större operatörer.

Aritmetiska operatörer

De numeriska operatörerna + , - och / uppför sig till stor del som du kan förvänta dig. (Division arbetar endast på bråknummer för att undvika avrundningsproblem - heltal måste delas med quot eller div ). Mer ovanligt är Haskells tre exponentieringsoperatörer:

• ^ tar en bas av vilken siffertyp som helst till en icke-negativ integral effekt. Detta fungerar helt enkelt genom ( snabb ) itererad multiplikation. T.ex

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

• ^^ gör samma sak i det positiva fallet, men fungerar också för negativa exponenter. T.ex

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

  Till skillnad från ^ kräver detta en fraktionerad bastyp (dvs 4^^5 :: Int fungerar inte, bara 4^5 :: Int eller 4^^5 :: Rational ).

• ** implementerar exponentiering av verkligt nummer. Detta fungerar för mycket generella argument, men är mer beräkningsbart dyrare än ^ eller ^^ , och genererar vanligtvis små flytande punktfel.

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

listor

Det finns två sammankopplingsoperatörer:

• : (uttalade nackdelar ) beror på ett enda argument före en lista. Den här operatören är faktiskt en konstruktör och kan därför också användas för att mönstra matchning (”invers konstruktion”) av en lista.

• ++ sammanlänker hela listor.

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

!! är en indexeringsoperatör.

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

Observera att indexeringslistor är ineffektiva (komplexitet O ( n ) istället för O (1) för matriser eller O (log n ) för kartor ); i Haskell är det vanligtvis att föredra att konstruera listor genom att fälla otmatchning i stället för att indexera.

Styrningsflöde

• $ är en funktionsapplikationsoperatör.

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

  Denna operatör används mest för att undvika parenteser. Den har också en strikt version $! , vilket tvingar argumentet att utvärderas innan funktionen tillämpas.

• . komponerar funktioner.

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

• >> sekvenser monadiska handlingar. writeFile "foo.txt" "bla" >> putStrLn "Done." skriver först till en fil, skriver sedan ut ett meddelande på skärmen.

• >>= gör samma sak, samtidigt som du accepterar ett argument som ska överföras från den första åtgärden till följande. readLn >>= \x -> print (x^2) väntar på att användaren ska mata in ett nummer och sedan mata ut kvadratet på det numret till skärmen.

Anpassade operatörer

I Haskell kan du definiera vilken infixoperatör du vill. Till exempel kan jag definiera operatören med listhöljen som

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

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

Du bör alltid ge sådana operatörer en fixitetsdeklaration , som

infixr 5 >+<

(vilket skulle betyda >+< binds lika tätt som ++ och : gör).

Hitta information om infixoperatörer

Eftersom infixer är så vanliga i Haskell, måste du regelbundet slå upp deras signatur osv. Lyckligtvis är detta lika enkelt som för någon annan funktion:

• Haskell-sökmotorerna Hayoo och Hoogle kan användas för infixoperatörer, som för allt annat som definieras i ett bibliotek.

• I GHCi eller IHaskell kan du använda :i och :t ( i nfo och t ype) -direktiven för att lära dig en operatørs grundläggande egenskaper. Till exempel,

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

  Detta säger till mig att ^^ binds tätare än + , båda tar numeriska typer som sina element, men ^^ kräver att exponenten är integrerad och basen är fraktionerad.
  Den mindre verbos :t kräver operatören inom parentes, som

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