Lesson 2 Intro


"I lambda Racket"

This week we will learn a new special form, lambda, that can make procedures! Make sure you learn it well, for it will be used extensively for the rest of this course.

Prerequisites and What to Expect

Prerequisites: Lesson 1 is required before working on this lesson. You should be familiar with concepts such as functions, procedures, and calling a procedure.

What to Expect: In this lesson, we will:

  • explain lambdas and higher order functions
  • learn a basic concept in Racket, or any other function-oriented programming language -- the manipulation of functions using other functions.


Here are the relevant readings for this lesson:

Sneak Peek

We learned how to create, modify, and call procedures in Lesson 1. Every procedure has a name, its arguments, and a body where we tell the function what to do with its arguments.

For instance, here is the procedure cube, which takes in one argument x and returns x cubed:

(define (cube x)  
   (* x x x))

We define a procedure whose name is cube, argument is x, and body is (* x x x). You should be able to tell by now that the body multiplies three x's together and returns x cubed.

cube is a procedure, or abstraction, that we can treat like a box and throw around, just like any other number or symbol. It has a value and we can give it a name.

Now that we think about it, defining cube the way we did above is not too far off from defining var like this:

(define var 10)


In the box var, we put 10. In the box (cube x), we put (* x x x). In one box, we put a number, and in the other, we put an expression. Pretty similar, right? What if, instead putting a primitive value or expression into the box, we put a function inside? Inconceivable!

It'll probably look something like this:

(define f [some function])

[some function] is where we would put a lambda. Keep reading to find out more!