Question

I’d like to ask if you can help me with a programming exercise. I’m trying to make a lambda expression of this form:

λz.x(yz)

The way I understand this, is that y is a function, applied to the value z. Then x is a function applied to what comes out if the function y is applied to z. The whole expression then says this:

λz.x(yz) means: Do the following with the argument z:

1. Apply the function y to z.
2. Apply the function x to what comes out of the first procedure.

I’ve made this program to try to get Scheme to do all of the above:

(define (zlamb)
  (lambda (z)
    (lambda (x)
      (* (lambda (y) (* z 4)) 2))))

When I run it, all I get is this:

Welcome to DrRacket, version 5.3 [3m].
Language: R5RS; memory limit: 128 MB.
( (zlamb) 3)
procedure:...lambdaefing1.rkt:3:4
>

Can anybody please explain to me what I’m doing wrong? What I wanted to get is (3 * 4) * 2 = 24. So I made (or thought I made) the inner function y = z * 4 and the outer function x = y(z) * 2.

I’ve searched all over the internet for explanations, but can’t find the particular needle I’m looking for in the haystack.

Answer 1

Let’s break your program down from the inside out:

(* z 4)

Multiply z by 4

(lambda (y) (* z 4))

A function returning z*4

(* (lambda (y) (* z 4)) 2)

The product of that function and 2. You cannot multiply a function by 2.
This is likely what is causing your bug; perhaps you mean to do the following:

(define (zlamb)
  (lambda (z)
    ((lambda (y) (* 2 (y z))) ; Note the two parenthesis before lambda - this is a function application
      (lambda (z2) (* z2 4)))))

Firstly note that both zs end up being the same, since z2 is bound to the value of the z in line 3. They could in fact both be named z but I named them differently to prevent confusion.

It further appears that your basic problem is in confusing the name of a function with its arguments:

(lambda (name) ...)

creates an anonymous function with an argument of name. The reason we are able to refer to the anonymous function in line 4 as y in line 3 is by making the construction

((lambda (y) ...) (lambda ...))

which passes the second function as an argument to the first, thus naming it y.