Haskell Language
Operadores de infijo

Observaciones

Preludio

Lógico

&& es lógico AND, || es lógico o.

== es igualdad, /= no igualdad, < / <= menor y > / >= operadores mayores.

Operadores aritméticos

Los operadores numéricos + , - y / comportan en gran medida como cabría esperar. (División funciona sólo en los números fraccionarios para evitar problemas de redondeo - división entera debe hacerse con quot o div ). Más inusuales son los tres operadores de exponenciación de Haskell:

• ^ toma una base de cualquier tipo de número a una potencia integral no negativa. Esto funciona simplemente por multiplicación iterada ( rápida ). P.ej

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

• ^^ hace lo mismo en el caso positivo, pero también funciona para exponentes negativos. P.ej

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

  A diferencia de ^ , esto requiere un tipo de base fraccional (es decir, 4^^5 :: Int no funcionará, solo 4^5 :: Int o 4^^5 :: Rational ).

• ** Implementa exponenciación de números reales. Esto funciona para argumentos muy generales, pero es mucho más caro que ^ o ^^ , y generalmente incurre en pequeños errores de punto flotante.

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

Liza

Hay dos operadores de concatenación:

• : (se pronuncia contras ) antepone un solo argumento antes de una lista. Este operador es en realidad un constructor y, por lo tanto, también puede usarse para hacer un patrón de coincidencia ("construcción inversa") de una lista.

• ++ concatena listas enteras.

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

!! Es un operador de indexación.

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

Tenga en cuenta que las listas de indexación son ineficientes (complejidad O ( n ) en lugar de O (1) para matrices o O (log n ) para mapas ); en Haskell generalmente se prefiere deconstruir las listas doblando la coincidencia de patrones en lugar de indexar.

Flujo de control

• $ es un operador de aplicación de función.

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

  Este operador se utiliza principalmente para evitar paréntesis. ¡También tiene una versión estricta $! , lo que obliga a evaluar el argumento antes de aplicar la función.

• . compone funciones

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

• >> secuencias monádicas de acciones. Por ejemplo, writeFile "foo.txt" "bla" >> putStrLn "Done." primero escribirá en un archivo, luego imprimirá un mensaje en la pantalla.

• >>= hace lo mismo, mientras que también acepta un argumento para pasar de la primera acción a la siguiente. readLn >>= \x -> print (x^2) esperará a que el usuario ingrese un número y luego envíe el cuadrado de ese número a la pantalla.

Operadores personalizados

En Haskell, puedes definir cualquier operador de infijo que te guste. Por ejemplo, podría definir el operador que envuelve la lista como

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

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

Siempre debe dar a dichos operadores una declaración de fijeza , como

infixr 5 >+<

(lo que significaría que >+< enlaza tan fuertemente como ++ y : do).

Encontrar información sobre operadores de infijo.

Debido a que los infijos son tan comunes en Haskell, regularmente deberá buscar su firma, etc. Afortunadamente, esto es tan fácil como para cualquier otra función:

• Los motores de búsqueda de Haskell Hayoo y Hoogle se pueden usar para operadores de infijo, como para cualquier otra cosa que esté definida en alguna biblioteca.

• En GHCi o IHaskell, puede usar las directivas :i y :t ( i nfo y t ype) para conocer las propiedades básicas de un operador. Por ejemplo,

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

  Esto me dice que ^^ une más fuertemente que + , ambos toman tipos numéricos como sus elementos, pero ^^ requiere que el exponente sea integral y la base sea fraccionaria.
  El menos detallado :t requiere el operador entre paréntesis, como

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