No todas las funciones aritméticas en la biblioteca base de Haskell son operadores; la mayoría no lo son. Se cuenta con las siguientes funciones.

Para cualquier número:

negate le cambia el signo al número.

Prelude> negate 7
-7
Prelude> negate (-7)
7
Prelude> negate.negate $ 7
7

abs es valor absoluto:

Prelude> abs 7
7
Prelude> abs (-7)
7

signum produce un 1 "multiplicable" con el signo del argumento.

Prelude> signum 4
1
Prelude> signum (-4)
-1

Para enteros:

quot, rem son división entera y residuo, respectivamente.

Prelude> quot 17 7
2
Prelude> rem 17 7
3

div es también división entera, pero aproxima hacia menos infinito, mientras que quot aproxima hacia cero:

Prelude> div (-17) 7
-3
Prelude> quot (-17) 7
-2

De la misma forma que se pueden emplear paréntesis para darle a un operador sintaxis de función, se pueden usar comillas simples para convertir una función que toma dos argumentos en operador:

Prelude> 17 `div` 7
2

mod es el operador de módulo. Es similar a rem, pero no es simétrico alrededor del cero.

Prelude> 17 `mod` 7
3
Prelude> (-17) `mod` 7
4
Prelude> 17 `rem` 7
3
Prelude> (-17) `rem` 7
-3

quotRem y divMod hacen dos cosas de una vez, y devuelven el resultado en un par (quot x y, rem x y) o (div x y, mod x y) respectivamente, para argumentos x, y.

Prelude> quotRem 17 (-7)
(-2,3)
Prelude> divMod 17 (-7)
(-3,-4)

Para extraer datos del par, fst regresa el primer elemento, y snd el segundo:

Prelude> fst $ quotRem 17 (-7)
-2
Prelude> snd $ quotRem 17 (-7)
3

gcd y lcm calculan, respectivamente, el máximo común divisor y el mínimo común múltiplo de dos enteros.

Prelude> gcd 30 12
6
Prelude> lcm 30 12
60

Para fraccionales:

recip produce la inversa multiplicativa del argumento.

Prelude> recip 3/4
8.333333333333333e-2
Prelude> recip $ 3/4
1.3333333333333333

El primer caso (sin el operador de aplicación) no produce el resultado esperado, porque primero calcula el recíproco de 3 y después lo divide por 4.

Para flotantes:

pi, exp, sqrt, sin, cos, tan, asin, acos, atan, sinh, cosh, tanh, asinh, acosh y atanh hacen exactamente lo esperado. Las funciones trigonométricas operan en radianes:

Prelude> sin $ pi / 2
1.0

log es logaritmo natural; logBase tomo como primer argumento la base.

Prelude> log 2.718281828459045
1.0
Prelude> logBase 2 64
6.0

Para fraccionales reales:

truncate, round, ceiling, floor convierten un fraccional real a entero. truncate elimina la parte fraccionaria. round aproxima hacia el valor más cercano. ceiling aproxima hacia arriba, floor hacia abajo.

Prelude> truncate 3.14
3
Prelude> round 3.14
3
Prelude> round 3.84
4
Prelude> round 0.5
0
Prelude> round 0.5000000001
1
Prelude> floor 3.8
3
Prelude> ceiling 3.8
4
Prelude> floor (-3.8)
-4
Prelude> ceiling (-3.8)
-3

properFraction divide el argumento x en un par (e,f) tal que e es la parte entera de x, y f es su parte fraccionaria. e y f tienen el mismo signo que x.

Prelude> properFraction $ 25/4
(6,0.25)
Prelude> properFraction 6.25
(6,0.25)

Para flotantes reales:

floatRadix, floatDigits, floatRange, decodeFloat, encodeFloat, exponent, significand, scaleFloat, isDenormalized, isIEEE, isNegativeZero son funciones que solamente tienen significado dentro de la definición IEEE 754 de punto flotante, y probablemente no son interesantes para hacer cálculos, a menos que se esté calculando el error de un análisis numérico o algo así.

isNaN dice si su argumento es "no un número"; isInfinite dice si el argumento representa "infinito". Estas pueden ser más útiles, aunque, tal vez, no muy elegantes.

Prelude> isNaN (0/0)
True
Prelude> isInfinite (1/0)
True

atan2 es más interesante: dados los argumentos x, y, calcula el ángulo en radiantes, entre -pi y pi, del vector que va del origen a (x, y).

Prelude> atan2 (1/2) (sqrt (3/4))
0.5235987755982989
Prelude> pi / it 
5.999999999999999

Aquí it se refiere al resultado inmediatamente anterior.