# [plt-scheme] creating nested lists in DrScheme

 From: Stephen Bloch (sbloch at adelphi.edu) Date: Sat May 8 10:42:19 EDT 2010 Previous message: [plt-scheme] creating nested lists in DrScheme Next message: [plt-scheme] creating nested lists in DrScheme Messages sorted by: [date] [thread] [subject] [author]

```On May 7, 2010, at 11:55 PM, Aniket Karmarkar wrote:

> That's what this function does:
> (define (equal L1 L2)
>   (cond
>     ((eq? (caar L1) (car L2)) (car L1))
>     (else (equal (cdr L1) L2))
>   )
> )
>
> This function find the sublist which match. I had it before but I
> forgot to include it. So it returns (b c d). I tried the map
> function but you need the arguments to have same number in both
> arguments. :(

There's a standard trick to get around that.

Suppose I want to make a list of the two-element lists ' (a x), '(b
x), '(c x), '(d x).  I'm doing the same thing to each element of the
list '(a b c d), and producing a list of the results, so "map" seems
like the right tool.  What is it that I want to do to each of these
elements?  Create a pair with that element and x.  So I write a function
(define (pair-with-x something)
(list something x))
then call
(map pair-with-x '(a b c d))

Sound good so far?  It has a problem: it only works if you have a
FIXED x that you can hard-code into the "pair-with-x" function.  If
the thing you want to combine with is a parameter, or has just been
computed, or something like that, you define "pair-with-x" LOCALLY:

(define (pair-with-a-b-c-d x)
(define (pair-with-x something) (list something x))
(map pair-with-x '(a b c d)))

Make sense?

Now, a brief digression.  Suppose you wanted to compute 3+4*5.  One
way to do it would be in two steps:
(define temp (* 4 5))
(+ 3 temp)
But if the only reason for having "temp" is to use it in one
subsequent expression, why bother giving it a name?  It's shorter and
simpler to say
(+ 3 (* 4 5))

Similarly, Scheme allows you to define a function without bothering
to give it a name, if you're just going to use it once, using "lambda".

(define (pair-with-a-b-c-d x)
(map (lambda (something) (list something x)) '(a b c d)))

In general, anything you can do with a local definition can also be
done with lambda, possibly shorter, and anything you can do with
lambda can also be done with a local definition, possibly clearer (if
you like having names for things).

Hope that helps!

Stephen Bloch