Bonsoir, nous recevons des cours de scheme à la fac, mais j'ai quelques difficultés avec lambda...
 
Je sais que dans le cas suivant:
(define fonction
(lambda (f g) (* (f g))))
 
 
lambda sert à definir les arguments, mais là où je bloque, c'est dans le cas suivant:
 
(define fonction
(lambda (f g)
(lambda (x) (f (g x)))))
 
Je bute dans le sens où je ne sais pas ce que fait (f (g x)), ni d'où on sort ce x ou quelle valeur il a, puisqu'on appelle la fonction avec comme seuls arguments f et g...
 
 
Autre problème, dans l'exercice que nous a donné le prof, je suis incapable de répondre à la question "qu'est ce qui est retourné? :" avec pour code:
(define doubler1
(lambda (f)     ;okay, parametre de doubler1
(lambda(x)(f x x))))    ;que fait donc ce f x x, et d'où sort ce x??
 
(define doubler2
(lambda (f x)     ;bon, deux parametres
((doubler1 f) x)))    ;on appelle doubler1 sur f, et... que fait-on avec x???
 
(doubler2 doubler2 doubler2)   ; là je comprends pas... on ne file pas d'arguments, rien... a moins que ce soient ces "doubler2", mais je comprends vraiment pas...
 
 
Merci d'avance!!!

Salut,

Ca sent le currying, non? Est-ce qu'il vous a parlé de ce terme ou d'applications partielles?
Je connais pas scheme, mais ça y ressemble fortement...

Euuuuuh, disons que je n'étais pas énormément en cours (honte à moi, je sais, mais boulot oblige), mais il ne me semble pas qu'il en ait parlé.

C'est ballot; ca te fait 3 mots clés pour chercher donc..

Ca commence bien... premier échec critique, (lambda) sert à définir une fonction anonyme, absolument pas à "définir les arguments", qui n'a de toute façon aucun sens

 
T'as pas eu l'idée 30 secondes de regarder ce que ça faisait dans un interpréteur scheme?

Et accessoirement, tu devrais penser à indenter, parce qu'indenté ça donne:

(define fonction
    (lambda (f g)
        (lambda (x)
            (f (g x)))))

Donc on a

(lambda (f g) ...), qui définit une fonction anonyme prenant deux paramètres "f" et "g".
(lambda (x) ...), qui définit une autre fonction anonyme, prenant ici un seul paramètre "x". Cette fonction anonyme est renvoyée par la fonction créée par (lambda (f g) ...)
(f (g x)), est une application de fonction tout ce qu'il y a de plus classique en scheme on applique "g" à "x", puis on applique "f" à son résultat

Donc c'est juste de la composition: en mathématique, c'est équivalent à écrire

On renvoie une fonction résultant de la composition des fonctions f et g.

Je suggère que tu ailles lire tes cours, ou l'un des très bon tuto Scheme qu'on peut trouver sur le net.

Nope, c'est de la composition de fonctions (enfin la première partie), ça correspond à l'opérateur (.) de Haskell ( http://haskell.org/ghc/docs/latest [...] ml#v%3A%2e )

La 2e est une HoF sans grand intérêt visible (elle permet simplement d'appliquer une fonction à deux arguments identiques en ne spécifiant qu'une seule fois l'argument). La seconde est équivalente à la première, sauf que l'intégralité de l'opération se fait en un seul appel de fonction (alors que pour la première il en faut 2 de suite, donc plus de parenthèses)

Par contre pour autant que je puisse en juger l'appel à la fin du truc va pêter (et mon scheme48 semble confirmer): si on déroule l'opération on se retrouve avec

(double2 double2 double2)
;; on applique double2 à double2 et double2, ce qui correspond donc à
(double2 double2 double2)
;; On se retrouve avec exactement la même expression \o/

donc ça va tourner en boucle à l'infini et ne jamais se terminer.

Merci, j'aurais jamais fait le lien avec ça (et j'ai du mal à le saisir pour l'instant, ça va m'occuper pour l'aprés-midi)

C'est relativement sympas, mais:
 

• Dispo uniquement dans les langages avec first-class functions
• Un peu long à utiliser quand on a pas un opérateur pour (à la haskell), on a souvent aussi vite fait de composer les fonctions à la main dans une fonction explicite, au coup par coup
• Rarement utilisé dans les langages où c'est pas natif. Dans du code haskell on trouve ça en permanence, dans les autres langages je le vois rarement.

Etant toujours en train d'apprendre Haskell, je l'utilise déjà pas mal (pour l'instant, uniquement quand ça rend le code plus lisible, ce qui n'est peut-être pas le meilleur argument ).
Mais à voir la tronche des fonctions données, en particulier celle-là:

(define fonction
         (lambda (f g)
             (lambda (x)
                 (f (g x)))))

Je l'ai compris de travers en fait; à y réfléchir à avec ton message, cette fonction et sa signature dans ghci, je comprends un peu mieux le fonctionnement de (.)  
 
Désolé strayyy2 pour les mauvaises pistes données initialement

C'est très utilisé en pointfree, (le pointfree ayant, comme son nom ne l'indique pas, plus de points \o/)

Là où (.) est très chiant, par contre, c'est qu'il ne permet que des fonctions à un seul argument, donc quand on veut composer des fonctions à arguments multiples, faut jouer avec curry et uncurry
(ou alors passer par les trucs dans Control.Arrow, mais pour l'instant je comprend pas grand chose aux arrows)
(j'ai pas trop joué avec, d'un autre côté)

Hum, j'imagine que tu dois avoir de bonnes raisons pour l'utiliser, mais quel serait le problème en mettant des parenthéses pour préparer les fonctions? Genre:

((+2) . (*20)) 2

(Et les arrows je verrais ça  plus tard, pour l'instant, j'en suis encore aux monades )

((+2) . (*20)) 2

Je parlais pas de ça, là tu utilises les 2 trucs avec un seul argument puisque tu composes (+2) :: (Num a) => a -> a et (*20) :: (Num a) => a -> a

Je parlais de composer des fonctions à 2 arguments, genre de composer un truc avec map :: (a -> b) -> [a] -> [b]

Imaginons que je veuille composer filter odd :: (Integral a) => [a] -> [a] avec map, dans la mesure où map prend deux arguments il faut que j'écrive:

curry (filter odd . uncurry map)

qui est de type

curry (filter odd . uncurry map) :: (Integral b) => (a -> b) -> [a] -> [b]

(note, le code même n'a pas grand intérêt, c'est juste pour l'exemple )

Ah oui, c'est pas la même souplesse. Merci beaucoup