[plt-scheme] creating nested lists in DrScheme

From: Stephen Bloch (sbloch at adelphi.edu)
Date: Sat May 8 10:42:19 EDT 2010

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
sbloch at adelphi.edu

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.racket-lang.org/users/archive/attachments/20100508/be174ad5/attachment.html>

Posted on the users mailing list.