Exponentiation à Haskell

Quelqu'un peut-il me dire pourquoi le Haskell Prelude définit deux fonctions distinctes pour l'exponentiation (c'est ^-à- dire et **)? Je pensais que le système de typage était censé éliminer ce genre de duplication.

Prelude> 2^2
4
Prelude> 4**0.5
2.0

Il y a en fait trois opérateurs de exponentiation: (^), (^^)et (**). ^est une exponentiation intégrale non négative, une exponentiation ^^entière et une exponentiation à **virgule flottante:

(^) :: (Num a, Integral b) => a -> b -> a
(^^) :: (Fractional a, Integral b) => a -> b -> a
(**) :: Floating a => a -> a -> a

La raison est la sécurité de type: les résultats des opérations numériques ont généralement le même type que le ou les arguments d'entrée. Mais vous ne pouvez pas élever an Intà une puissance à virgule flottante et obtenir un résultat de type Int. Et donc le système de type vous empêche de faire cela: (1::Int) ** 0.5produit une erreur de type. Il en va de même (1::Int) ^^ (-1).

Une autre façon de dire ceci: les Numtypes sont fermés sous ^(ils ne sont pas obligés d'avoir un inverse multiplicatif), les Fractionaltypes sont fermés sous ^^, les Floatingtypes sont fermés sous **. Puisqu'il n'y a pas d' Fractionalexemple pour Int, vous ne pouvez pas l'élever à une puissance négative.

Idéalement, le deuxième argument de ^serait statiquement contraint à être non négatif (actuellement, 1 ^ (-2)lève une exception d'exécution). Mais il n'y a pas de type pour les nombres naturels dans le Prelude.

Le système de types de Haskell n'est pas assez puissant pour exprimer les trois opérateurs d'exponentiation comme un seul. Ce que vous voudriez vraiment, c'est quelque chose comme ceci:

class Exp a b where (^) :: a -> b -> a
instance (Num a,        Integral b) => Exp a b where ... -- current ^
instance (Fractional a, Integral b) => Exp a b where ... -- current ^^
instance (Floating a,   Floating b) => Exp a b where ... -- current **

Cela ne fonctionne pas vraiment même si vous activez l'extension de classe de type multi-paramètres, car la sélection d'instances doit être plus intelligente que ce que permet actuellement Haskell.

Il ne définit pas deux opérateurs - il en définit trois! À partir du rapport:

Il existe trois opérations d'exponentiation à deux arguments: ( ^) élève n'importe quel nombre à une puissance entière non négative, ( ^^) élève un nombre fractionnaire à n'importe quelle puissance entière et ( **) prend deux arguments à virgule flottante. La valeur de x^0ou x^^0est 1 pour tout x, y compris zéro; 0**yn'est pas défini.

Cela signifie qu'il existe trois algorithmes différents, dont deux donnent des résultats exacts ( ^et ^^), tandis que **des résultats approximatifs. En choisissant l'opérateur à utiliser, vous choisissez l'algorithme à invoquer.

^exige que son deuxième argument soit un Integral. Si je ne me trompe pas, l'implémentation peut être plus efficace si vous savez que vous travaillez avec un exposant intégral. De plus, si vous voulez quelque chose comme 2 ^ (1.234), même si votre base est une intégrale, 2, votre résultat sera évidemment fractionnaire. Vous disposez de plus d'options pour pouvoir contrôler plus étroitement quels types entrent et sortent de votre fonction d'exponentiation.

Le système de types de Haskell n'a pas le même objectif que les autres systèmes de types, tels que C, Python ou Lisp. Le typage du canard est (presque) l'opposé de l'état d'esprit Haskell.