le comportement de "const"id

Question

Je suis en train de travailler sur la 99 Haskell questions et y voit une solution pour trouver le dernier élément d'une liste:

  myLast = foldr1 (const id)

le type d' const est a -> b -> a mais qui de la const id est b -> a -> a
alors, quelle est la magie?

Answer 1

Le type d' id est c->c; elle renvoie simplement la même chose, c'est donné.

Le type d' const est a->b->a. En const id, a devient c->c, de sorte que le type de const dans ce cas est:

(c->c) -> b -> (c->c)

Maintenant que vous avez appliqué ce const fonction, c'est à dire que vous avez passé de id à elle, alors vous êtes de gauche avec b -> (c->c).

PS: Le type d' const const id est a->b->a, et le type d' const const const id est b->a->a, et ainsi de suite!

Answer 2

Pas de magie. La définition de l' const est:

const :: a -> b -> a
const x y = x

Et la définition de l' id est:

id :: a -> a
id x = x

Donc, const id est juste \y -> id, une fonction qui renvoie toujours id. Et si id est juste \x -> x alors const id doit être le même que \y -> \x -> x. Ergo, elle est de type b -> (a -> a).

const id peut également être rédigé flip const.

Answer 3

Voici ma compréhension de la façon dont cela fonctionne.

C'est l'explication la plus simple que je pouvais penser, j'ai essayé (sur le but) pour éviter tout risque de porter à confusion des concepts ou des mots.

Un concept important de garder à l'esprit est l'application partielle.

La façon dont je comprends que c'est, qu'en Haskell, on peut "corriger" l'un des paramètres de la fonction pour une valeur connue, de sorte que maintenant la fonction accepte moins un paramètre.

Rappel: le type de const est:

const :: a -> b -> a

Comme un exemple simple, nous allons "fixer" le premier paramètre à (+)

let f = const (+)

Maintenant que nous avons résolu le premier paramètre de const, "f" est une fonction qui accepte un seul paramètre. Mais depuis const toujours le retour de son premier paramètre, qui est fixe, cela signifie que tout ce que nous passons à "f" sera ignoré, et il retournera toujours la fonction "+".

Comme un exemple, tout ce qui suit donnera 5, puisque f retournera toujours la fonction "+" peu importe ce qu'il a reçu dès le premier paramètre, et la fonction "+" fonctionne sur 2 et 3:

f "aaa"        2 3
f  904212      2 3
f  undefined   2 3

Le type de f est:

f :: b -> Integer -> Integer -> Integer

Notez que "b" peut être n'importe quoi, comme on peut le voir ci-dessus.

Maintenant, pour la fonction en question:

g = const id

Cela signifie que l'on "fixe" id que le premier paramètre, comme ci-dessus, "g" ignore son premier paramètre et renvoie la fonction "id". En Haskell, nous pouvons aller de l'avant et de fournir le paramètre supplémentaire à la "id" est, comme nous l'avons fait à (+) ci-dessus, ainsi, par exemple, l'ensemble de ces sera de retour 42:

g  "aaa"     42
g  undefined 42

Donc, "g" est la fonction d'accepter deux paramètres, revenant toujours la seconde, de sorte que son type est:

g = const id :: b -> a -> a

Mais attendez une minute, je viens de faire un bond de géant là. Ne pas le type de l'être:

b -> (a -> a) 

depuis, nous nous sommes dit que nous acceptons n'importe quoi et retour "id"?

Eh bien, oui, sauf qu'en Haskell ces parenthèses peuvent être omises.
Il a également un sens puisque vous pouvez communiquer immédiatement le "id" de la fonction avec le paramètre supplémentaire dont elle a besoin (comme dans le "const" ( + ) " exemple ci-dessus).