Haskell Language
Opérateurs Infix

Remarques

Prélude

Logique

&& est logique ET, || est logique OU.

== est égalité, /= non-égalité, < / <= moindre et > / >= opérateurs plus grands.

Opérateurs arithmétiques

Les opérateurs numériques + , - et / se comportent largement comme prévu. (Division ne fonctionne que sur des nombres fractionnaires pour éviter les problèmes d’arrondi - la division entière doit être effectuée avec quot ou div ). Les trois opérateurs d’exponentiation de Haskell sont plus inhabituels:

• ^ prend une base de n'importe quel type de nombre à une puissance intégrale non négative. Cela fonctionne simplement par une multiplication itérée ( rapide ). Par exemple

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

• ^^ fait de même dans le cas positif, mais fonctionne également pour les exposants négatifs. Par exemple

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

  Contrairement à ^ , ceci nécessite un type de base fractionnaire (c.-à-d. 4^^5 :: Int ne fonctionnera pas, seulement 4^5 :: Int ou 4^^5 :: Rational ).

• ** implémente une exponentiation en nombres réels. Cela fonctionne pour des arguments très généraux, mais est plus coûteux que ^ ou ^^ , et engendre généralement de petites erreurs en virgule flottante.

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

Des listes

Il y a deux opérateurs de concaténation:

• : (prononcé contre ) ajoute un seul argument avant une liste. Cet opérateur est en réalité un constructeur et peut donc aussi être utilisé pour créer une correspondance («construction inverse») dans une liste.

• ++ concatène des listes entières.

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

!! est un opérateur d'indexation.

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

Notez que les listes d'indexation sont inefficaces (complexité O ( n ) au lieu de O (1) pour les tableaux ou O (log n ) pour les cartes ); Il est généralement préférable dans Haskell de déconstruire les listes en repliant la correspondance de motifs au lieu de l'indexation.

Flux de contrôle

• $ est un opérateur d'application de fonction.

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

  Cet opérateur est principalement utilisé pour éviter les parenthèses. Il a aussi une version stricte $! , qui force l'évaluation de l'argument avant d'appliquer la fonction.

• . compose des fonctions.

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

• >> séquences d'actions monadiques. Par exemple, writeFile "foo.txt" "bla" >> putStrLn "Done." va d'abord écrire dans un fichier, puis imprimer un message à l'écran.

• >>= fait de même, tout en acceptant qu'un argument soit transmis de la première action à la suivante. readLn >>= \x -> print (x^2) attend que l'utilisateur saisisse un nombre, puis affiche le carré de ce numéro sur l'écran.

Opérateurs personnalisés

Dans Haskell, vous pouvez définir n'importe quel opérateur d'infixe que vous aimez. Par exemple, je pourrais définir l'opérateur d'enveloppes de liste comme

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

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

Vous devriez toujours donner à ces opérateurs une déclaration de fixité , comme

infixr 5 >+<

(ce qui voudrait dire >+< lie aussi étroitement que ++ et : do).

Recherche d'informations sur les opérateurs infixes

Comme les infixes sont si courants chez Haskell, vous devrez régulièrement rechercher leur signature, etc. Heureusement, c'est aussi simple que pour toute autre fonction:

• Les moteurs de recherche Haskell Hayoo et Hoogle peuvent être utilisés pour les opérateurs infixes, comme pour tout ce qui est défini dans une bibliothèque.

• Dans GHCi ou IHaskell, vous pouvez utiliser les directives :i et :t ( i nfo et t ype) pour apprendre les propriétés de base d'un opérateur. Par exemple,

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

  Cela me dit que ^^ se lie plus étroitement que + , les deux prennent des types numériques comme éléments, mais ^^ exige que l'exposant soit intégral et la base fractionnaire.
  Le moins verbeux :t nécessite l'opérateur entre parenthèses, comme

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