[plt-scheme] Help with ...
On May 16, Todd O'Bryan wrote:
> Maybe I should have put quotation marks around the ... so you'd know
> that was what I needed help with. :-)
>
> At any rate, I'm working through Eli Barzilay's CSU660 (Programming
> Languages) assignments, which are largely based on Shriram
> Krishnamurthi's PLAI, and I've had some issues with understanding
> ... already, but they've finally come to a head.
>
> Eli provided this macro:
>
> [...]
FWIW, understanding what this macro is doing is not necessary for the
homework...
> And I'm supposed to rewrite letfuns so that it can handle mutually
> recursive functions. More concretely, I write
>
> (rewrite (letfuns ([(f x) E] ...) B)
> => (my-code-here))
>
> so that something like this
>
> (letfuns
> ([(even? n) (if (= n 0) #t (odd? (- n 1)))]
> [(odd? n) (if (= n 0 #f (even? (- n 1))))])
> (even? 123))
>
> would produce the expected answer.
>
> I think I understand what I need to do if I could figure out what the heck
> that ... is doing.
>
> I think f ends up as a list of all the function names, x as a list of all
> the function arguments, and E as a list of all the bodies.
Yes. To be a little more specific, when you say "`f' ends up as a
list of all function names" -- the way that `f' is related to that is
by binding it as a "pattern identifier", it doesn't have a real value,
and can only be used on output patterns on the right side of the `=>'.
> I need to convert that into a big (match name ---) expression with a
> branch for each function name. I'd like to do something like
>
> (match name
> ['f? (more stuff here including things from x and E)] for each value in
> f, x, and E
>
> but I don't want for-each and I'm not even sure I can build up a
> list of branches this way. I *am* sure that I don't know how to do
> it if it's possible.
Well, since `f' (for example) is the list of function names, you could
write
(rewrite (letfuns ([(f x) E] ...) B)
=> (list 'f ...))
This will make a `letfuns' expression evaluate to a list of the
function names as symbols.
> So, two things:
>
> 1. Which function am I looking for to handle this example?, and
You're just using `...' on the right side to do the right thing.
There are of course some `map's that are used somewhere to actually
construct the result, but for most such code (and definitely for this
hw), you don't need to know how exactly it is implemented.
> 2. Is there a good, very basic, easy to understand explanation of
> what ... does in patterns that someone could suggest?
[I pointed Todd to the relevant part in my notes.]
--
((lambda (x) (x x)) (lambda (x) (x x))) Eli Barzilay:
http://www.barzilay.org/ Maze is Life!