L'inférence de type moteur de Haskell est beaucoup plus puissant que Scalas. En Haskell, j'ai rarement à écrire explicitement les types alors qu'en Scala, les types ne peut être déduite dans les expressions, mais pas dans les définitions de méthode.
Voir, par exemple, suite à Haskell extrait de code:
size xs = loop xs 0
where
loop [] acc = acc
loop (_ : xs) acc = loop xs (acc+1)
Il retourne la taille d'une Liste. Le compilateur Haskell peut reconnaître ce que les types sont utilisés et que la définition de la fonction est. L'équivalent de la Scala de code:
def size[A]: List[A] => Int = xs => {
def loop: (List[A], Int) => Int = {
case (Nil, acc) => acc
case (_ :: xs, acc) => loop(xs, acc+1)
}
loop(xs, 0)
}
Ou avec les définitions de méthode:
def size[A](xs: List[A]) = {
def loop(xs: List[A], acc: Int): Int = xs match {
case Nil => acc
case _ :: xs => loop(xs, acc+1)
}
loop(xs, 0)
}
Ma question est: Pourquoi ne puis-je pas écrire comme suit?
def size = xs => {
def loop = {
case (Nil, acc) => acc
case (_ :: xs, acc) => loop(xs, acc+1)
}
loop(xs, 0)
}
Une fois de plus avec les définitions de méthode:
def size(xs) = {
def loop(xs, acc) = xs match {
case Nil => acc
case _ :: xs => loop(xs, acc+1)
}
loop(xs, 0)
}
Est-ce parce que personne n'a encore mise en oeuvre? Est le type de système de Scala pas aussi puissant que nécessaire pour ce cas? Ou existe-il d'autres raisons?
