Quel est le point de lambda dans le schéma?

Je suis d'apprentissage. Je sais comment utiliser les lambda et laissez expressions.

Cependant j'ai du mal à comprendre quel est l'intérêt de l'utilisation de lambda. Ne pouvez-vous pas tout faire avec laissez que vous pouvez avec lambda?

Il serait particulièrement utile pour voir un exemple d'une situation où une expression lambda est un meilleur choix que de laisser.

Une autre chose - sont il y a également des situations où les laissez est plus utile que lambda? Si donc un tel exemple serait agréable aussi bien.

Edit: je suis aussi intéressé par contraste de définir et de lambda, comme ils semblent effectuer des tâches similaires.

Mise à jour:

Merci pour l'aide tout le monde. J'ai fait un peu plus de la recherche en lambda/let/définir après la lecture de vos réponses, et maintenant le comprendre beaucoup mieux.

Je suis tombé sur un excellent exemple de cool lambda useage - de retour d'une fonction anonyme à partir de procédures. Par exemple, la procédure operateTwice ci-dessous retourne une fonction anonyme qui est basé sur les paramètres transmis à la procédure:

(define operateTwice
  (lambda (op1 op2)
    (lambda (x y)
      (op2 (op1 x y) y))))

((operateTwice * +) 2 3) ;equivalent to: (+ (* 2 3) 3), or in standard notation 2*3+3

De sortie:

InformationsquelleAutor Cam | 2010-05-31

44

Un let est un lambda.

E. g.
```
(let ((x 1))
  body)
```
peut être traduit en
```
((lambda (x) body) 1)
```
En outre, dans le Schéma de tous de contrôle et de l'environnement, les structures peuvent être représentés par des expressions lambda et les applications de lambdas.

Donc, lambda est strictement plus puissant que let et constitue la base de la plupart des constructions intéressantes trouvées dans le Schéma.

Concernant define et lambda, un haut niveau de define ajoute une liaison à haut-niveau de l'environnement.

Lorsque vous écrivez
```
(define (f x)
  body)
```
vous êtes en train de dire
```
(define f (lambda (x) body))
```
Imbriquée définit sont convertis en letrec, qui peut être réécrite en utilisant les lambdas ainsi.

Donc, encore une fois, beaucoup de Régime de constructions peut être traduit en quelque chose à l'aide lambda, et par conséquent, il est vraiment mériteraient que vous comprenez lambda bien.
- Génial tout à fait compréhensible, merci!
- Hey, vous pouvez même construire des nombres naturels et des arythmetic opérations avec rien de plus que les lambdas.
- Vous devez répondre à anonyme lambda fonctions (programmation fonctionnelle) sur CS site.
InformationsquelleAutor eljenso
13

Vous utilisez lambda si vous souhaitez créer une fonction pour l'utiliser comme un argument à une autre fonction (comme par exemple map), mais vous n'avez pas vraiment envie de le nom de la fonction.

Par exemple, si vous souhaitez ajouter 42 à chaque nombre dans une liste, vous pouvez le faire:
```
(define (add42 x) (+ x 42))
(map add42 (list 1 2 3 4))
```
Mais si vous ne voulez pas lui donner un nom à une fonction que vous utilisez seulement une fois, vous pourriez faire:
```
(map (lambda (x) (+ x 42)) (list 1 2 3 4))
```
- Merci. Pouvez-vous fournir des détails concernant la raison pour laquelle vous mgiht choisir un ou l'autre? Vous avez dit "si vous ne voulez pas lui donner un nom à une fonction ...". Mais, pourquoi pas vous?
- Dans le schéma et l'autre fonctionnel des programmes que vous utilisez des fonctions tellement que vous ne voulez pas polluer votre espace de noms par définition, même si vous utilisez seulement une fois. En outre fonctions très simples ne peuvent pas supporter la surcharge de les définir séparément, et il serait très fastidieux d'avoir à chercher leurs définitions dans un autre lieu que celui où vous en avez besoin. Il deviendra évident après quelques utilisation. Il est difficile de l'expliquer sans éprouver réellement.
- Pourquoi lui donner un nom quand vous en avez besoin seulement en une seule occasion? Au lieu de penser de certains, un nom à ne pas encombrer votre espace de noms, vous pouvez simplement transmettre une fonction anonyme.
- 1. Vous avez besoin de penser à un nom en premier. Si vous utilisez un tas de petites fonctions comme cela, cela peut devenir ennuyeux. 2. Le plus de fonctions, vous définissez la plus difficile, il va devenir à penser à un inutilisés nom de la fonction. 3. Il devient aussi plus difficile de se rappeler la fonction qui fait quoi, si vous définissez un tas de petites fonctions. 4. Comme vous pouvez le voir dans mon exemple, la version lambda est aussi un peu plus courte que celle à définir.
InformationsquelleAutor sepp2k
4

Laissez est en fait juste un raccourci pour une expression Lambda.
Les deux expressions suivantes sont équivalentes:
```
(let ((alpha 7)) (* 5 alpha))

((lambda (alpha) (* 5 alpha)) 7)
```
Lambda suit la philosophie de la langue que tout devrait ressembler à une fonction mathématique. Mais, dans la pratique, Laissez le rend plus facile de comprendre ce qui se passe si les variables sont trop nombreuses. Imaginez 10 variables qui ont leurs valeurs définies après le Lambda d'un bloc, et que vous essayez de faire correspondre chacun de ceux avec le nom de la variable, avec Laissez-les valeurs des variables sont placés l'un à côté de leurs noms, pratique pour le programmeur, mais moins conforme à la Programmation Fonctionnelle, la philosophie.

Lambda peut être utilisé pour le retour d'une fonction à partir d'un ordre supérieur de la fonction mais ne peut pas le faire. Par exemple:
```
(define (plus-list x)
  (cond ((number? x)
         (lambda (y) (+ (sum-n x) y)))
        ((list? x)
         (lambda (y) (+ (sum-list x) y)))
        (else (lambda (x) x))
        ))

> ((plus-list 3) 4)
10
> ((plus-list '(1 3 5)) 5)
14
> ((plus-list 'a) 5)
5
```
Lambda peut également être utilisé pour passer d'une fonction à une fonction:
```
>(map (lambda (x) (+ 1 x)) '(-1 2 -3))
(0 3 -2)
```
InformationsquelleAutor Ibrahim Muhammad
3

lambda crée de nouvelles fonctions anonymes, qui sont évalués à chaque fois que vous les utilisez.

laisser crée des noms temporaires de valeurs et sont fixés une fois pour une utilisation dans le cadre défini par la forme.

Ils sont vraiment très différents des bêtes.

quelques exemples :

(lambda (x) (* 5 x))

(let ([x 2]) (* 5 x))
10
(let ([f (lambda (x) (* 5 x))]) (f 2))
10

première forme crée une fonction pour multiplier par 5

deuxième forme affecter 2 à x et la multiplie par 5 pour un total de 10

tiers, nous utilisons la fonction de 1 (qui mutiplies par 5) et de l'appeler avec 2 comme paramètre, ce qui fait 10
- Je pense que cela a du sens. Mais alors pourquoi utiliser lambda au lieu de la définir?
- Vous n'avez pas toujours besoin d'un nom pour une fonction, donc vous n'avez pas toujours besoin de la définir.
- Droit obtenu à partir de sepp2k de réponse. Pourquoi voudriez-vous pas le nom d'une fonction si? (peut-être afin de répondre au mieux sous sepp2k de réponse afin de ne pas reproduire cette conversation). Merci!
- est une forme particulière et ne peut pas être une partie d'une expression, car il peut gâcher l'environnement local, car il ajoute ou remplace les noms de variables. Ce n'est pas acceptable. Les noms doivent déjà exister avant l'évaluation.
InformationsquelleAutor Peter Tillemans
3

Dans le Schéma d'une procédure (ou fonction) est une première classe de l'objet comme une liste, un nombre ou une chaîne. Pour créer une liste littérale vous utilisez la primitive appelée list:
```
> (define marks (list 33 40 56))
> marks
> (33 40 56)
```
Juste comme ça, pour créer une procédure, vous utilisez le lambda primitive (ou formulaire spécial):
```
> (define add-marks (lambda (m) (apply + m)))
> (add-marks marks)
> 129
```
Que les procédures sont la principale forme d'abstraction, plan prévoit un raccourci pour define pour le rendre facile de lier de nouvelles procédures:
```
> (define (add-marks m) (apply + m))
```
Autre que cela, les procédures sont juste comme tous les autres objets de première classe. Ils peuvent être passés comme arguments à d'autres procédures et une procédure peut évaluer à produire (ou le retour) d'une autre procédure.

InformationsquelleAutor Vijay Mathew
1

Vous pouvez le penser comme ça...
vous créez une fonction qui utilise une autre fonction
mais vous voulez rendre les choses plus modulaire, de sorte que vous avez à faire est d'appeler la deuxième fonction en tant qu'argument de la première, et qui vous laisse la possibilité de modifier le deuxième à chaque fois que vous vous sentez comme vous avez besoin d'une fonctionnalité...
l'espoir qui fait sens

InformationsquelleAutor rabidmachine9

Vous devez vous connecter pour publier un commentaire.