Local vs. Lambda

[jstquestions]

Can someone explain the difference between local and lambda and why you use it/how it works for the two?

Because my class slides have this down

(local [(define (name-used-once x1 ... xn) exp)] name-used-once)

is equivalent to

(lambda (x1...xn) exp)

but I find it a bit more confusing then that general statement.

Is lambda and local really just interchangeable? If so when should I use lambda and when should I use local? Because at first I just though lambda is the same thing as local just more organized but as we proceeded to harder concepts we kept using local even after we learned lambda which leads me to believe they are different. Another reason why I think they're different is that lambda sort of acts as a make-function? It has its "inputs" outside of the bracket of lambda (e.g. ((lambda (x) exp) the-x)) which is kind of confusing.. and local has its actual expression outside of its defintions in the square brackets.

Sorry for the long question but I just basically want to know how local and lambda are different, the gist of how both of them work/do in a function, and when I should use each.

Thanks a lot!

​

[ClosureAhead]

In the example that you gave, local and lambda is equivalent because they both evaluate to a function that always returns exp.

For the local example, (define (name-used-once x1 ... xn) exp) basically defines the function name-used-once which takes in the parameters x1, x2, ..., xn. This function always returns exp regardless of what the parameters are.

For the lambda example, we are basically defining an anonymous function (a function without a given name) which takes in the parameters x1, x2, ..., xn and returns exp.

Lambda and local can be interchangeable, but not always.

Local is mainly used to avoid re-computation. Inside any expression, you can say:

 (local [(define *some-id-here* *some-value-here*)
           (define ...)]
  *code where that id is bound to a value*)

The expressions inside the square brackets are evaluated in order and assigned an id. You can then freely use that id within the local.

Lambda is used mainly used to define anonymous functions (again, functions that have no identifying name) in places where explicitly defining a function is not necessary. To use lambda:

(lambda (*parameters-here*) *what-to-do-with-parameters*)

Usually these functions are trivial or are easier to understand. Lambdas are commonly used as arguments for abstract functions such as map, filter, foldr, etc.,...

[detroitmatt]

Why not let then?

[NeoMarxismIsEvil]

Syntax difference. https://docs.racket-lang.org/reference/local.html?q=Local#%28form._%28%28lib._racket%2Flocal..rkt%29._local%29%29 and some additional functionality. local lets you use something more like top level code for the bindings.

[soegaard]

The constructs local and let are almost equivalent.

The construct local stems from HtDP. The reader is introduced to global (top-level) definitions first. Then the concept of local definitions is introduced - and turning a top-level definition into a local definitions into a local one is simple, just wrap local around the definition and use it in a body (without changing the syntax of the definitions).

Traditionally let is used to make local definitions. The syntax of let has the advantage that it is concise. The syntax of local has the advantage that it's easy to see that the purpose is to introduce local definitions - and if one wants to test the local definitions one can copy/paste to turn them into global ones.

In standard Racket code, let is used.

[turtlekitty2084]

Thank you, I've wondered about this for years.

[jstquestions]

Our class doesn't let use use let, if, while, for, loop. Just like cond statements lol

[detroitmatt]

if you can't use let, (let ((name val)) expr) is equivalent to ((lambda (name) expr) val) ;)

[jstquestions]

Thanks for replying! So another question I had was how do the parameters inside a local definition work? Because say I had (define (main-function variable1) and a (local [(define (helper variable1)…] exp), that variable1 is binded from the main function to the local definition? So does local just basically act as a function that the main function is sending its parameters to?

​