[philly-lambda] Re: Good references for syntax-case?

[edw <edw@poseur.com>]

D'oh! Aside from the typos littered throughout my hastily-written
message, there's a problem with the code I atttached: COROUTINE-
COMPLETE should be changed to GENERATOR-COMPLETE. I first wrote a MAKE-
COROUTINE procedure, which I modified slightly to come up with MAKE-
GENERATOR, but I didn't want to paste all that code. With MAKE-
COROUTINE, you can send data back through the yield call:

(define incr (make-coroutine (lambda (yield first)
                   (let loop ((next-value first))
                     (loop (+ next-value (yield next-value)))))))

(incr 0) ==> 0
(incr 1) ==> 1
(incr 1) ==> 2
(incr 10) ==> 12

Not an impressive example in operation, but I think you get the idea.
Without macros!

Ed

On Aug 23, 8:50 am, edw <e...@poseur.com> wrote:
> I agree with Andrew: that chapter of TSPL is a pretty good guide to
> SYNTAX-CASE macros. Kent devised SYNTAX-CASE, I believe.
>
> But -- and I say this as someone whose comment got modded down to
> negative eight or so in the Reddit discussion -- SYNTAX-CASE and
> unhygienic macros are evil. A few Scheme programming tips:
>
> * If you think you need to use EVAL, you're probably wrong.
> * If you think you need to use a macro, you're probably wrong.
> * If you think you need to use unhygienic macros, you're probably
> wrong.
>
> What are you trying to do?
>
> I wrote an article a year or two ago on Python generators, Java 1.5,
> and why most programming languages suck:
>
> <http://xmog.com/java-sucks/>
>
> In it I developed a SYNTAX-RULES macro for defining generators. Pascal
> Costanza took me to task for my too-quick use of macros. He said what
> I could do could be done with macros of any kind. I blew him off. Last
> week, I was thinking about his comments and wondered if it was
> possible to do what he said was possible. It is, and the source is
> included at the end of this message. I'm going to update my article
> when I get a chance. The point is no longer will no longer be that
> "macros let you bend real programming languages to your will" but that
> "first-class continuations and procedures and (maybe, sometimes)
> macros let you bend real programming languages to your will."
>
> (define fibonacci
>   (make-generator
>    (lambda (yield)
>      (let loop ((a 0) (b 1))
>        (loop b (+ (yield a) b))))))
>
> (define generator-complete (vector "generator complete"))
>
> (define (make-generator proc)
>   (let ((continue #f))
>     (lambda arguments
>       (call-with-current-continuation
>        (lambda (exit)
>          (if (not continue)
>              (let ((yield
>                     (lambda return-values
>                       (apply (lambda return-values
>                                (call-with-current-continuation
>                                 (lambda (k)
>                                   (set! continue
>                                         (lambda () (apply k return-
> values)))
>                                   (apply exit return-values))))
>                              return-values))))
>                (apply proc yield arguments)
>                coroutine-complete)
>              (continue)))))))
>
> On Aug 23, 7:37 am, Andrew Gwozdziewycz <apg...@gmail.com> wrote:
>
> > On Aug 22, 2007, at 9:50 PM, Kyle R. Burton wrote:
>
> > > I've found JRM's primer [1] on syntax-rules to be mind-expanding, but
> > > I was wondering if anyone had any good references for syntax-case.
> > > I'm asking because something went across p.r.c today asking about the
> > > differences between CL and Scheme's macro systems and syntax-case came
> > > up a lot in the comments/discussion.
>
> > You might try out _The Scheme Programming Language_ chapter freely
> > available herehttp://scheme.com/tspl3/syntax.html#./syntax:h3
> > It's from R. Kent Dyvbig, who I *think* is the original author (or  
> > one of) of syntax-case.
>
> > It's not as enlightening as JRM's primer on syntax-rules, but if you  
> > now are
> > comfortable with syntax-rules, syntax-case does nothing more than  
> > allow you to
> > break hygiene. The pattern language is still the same. The only thing  
> > to really
> > learn are the techniques used to create the unhygienic portions of  
> > your macro. I
> > admittedly haven't done much with syntax-case, so I may be off a bit.
>
> > Good Luck
>
> > --
> > Andrew Gwozdziewycz
> > apg...@gmail.comhttp://www.apgwoz.com|  http://www.photub.com


--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups "Philly Lambda" group.
To unsubscribe from this group, send email to philly-lambda-unsubscribe@googlegroups.com
For more options, visit this group at http://groups.google.com/group/philly-lambda?hl=en
-~----------~----~----~----~------~----~------~--~---