First, apologies for bouncing this back to the list, hope that’s okay… = > On Nov 4, 2015, at 2:20 AM, Marco Faustinelli <marco.faustine...@onebip.com> > wrote: > > > What I definitely AM missing (I can't see why you contradict my personal > statement at the same time you are actually taking it into consideration :-) > is the educational value of being able to "see" the code contained in a > continuation, which is the core problem of whoever approaches call/cc. > > myCont = (lambda(_) ...) > > As the stepper is there for educational purposes, this is something that > would be spot-on with its core business; I am ready to believe that a text > dump of the code contained in the continuation is not easy to achieve (I > assume that the code has been interpreted on the fly into a tree or > something).
Forgive me; I didn’t mean to suggest that it wouldn’t be educational. It would. > > But I see that the stepper is very good at substituting readable expressions. > That's the heart of its effectiveness, so there must be a way… Yep. There’s definitely a way, and if anyone was going to do it, it would probably be me :). Okay, I just thought about it for five minutes, and here’s what I think: 1) At a very basic level, the stepper is not currently enabled for any of the languages that include call/cc. IIRC, the first language that includes call/cc is advanced, which also includes mutation. Doing mutation right is kind of a bear. You should be able to enable half-baked stepper support in any language by setting the “PLTSTEPPERUNSAFE” environment variable. 1a) Okay, I just tried it, and it turns out that call/cc isn’t in Advanced, either. This means that you need to try this in full #lang racket, which is really not a language where the stepper is going to be too good at rendering. 1b) Hmm, interesting. I got a bit conservative in the 6.3 release, and currently PLTSTEPPERUNSAFE works for advanced but not for full #lang racket. I’ve just made a change that should allow this, but it DEFINITELY WON’T be a part of the 6.3 release. 2) You mention that “the stepper is very good at substituting.” In fact, for the most part, the stepper doesn’t know anything about substitution; it simply observes the computation as it proceeds. This actually turns out to be a big win for watching call/cc run; while the existing stepper has no idea how to render a continuation, as soon as you step *into* the continuation, the context should be correctly displayed. In my opinion, this is about three quarters of the way to understanding call/cc. Maybe I’m looking at the glass as more full than it is :). 3) The remaining piece would be to capture the current marks and associate them with the continuation. To do this, the stepper would have to know when a continuation was being captured. Not impossible, but interesting. 4) Rendering the continuation: this could be horrible, or easy. If you decide to try to render the continuation as a legal term in the language, it would be a good deal of the work. BUT… if you just deployed the existing mark-rendering machinery to render the set of marks as a context, and then put a special “kont-box” around it—that is, “this isn’t a legal term in the language, it’s a special context term that will replace the existing context if called”—it wouldn’t be too hard. 5) This is the unpleasant bullet. I’m at a teaching school, and I’ve got a whole bunch of exams to grade. This isn’t at the top of my list right now, and I’m not sure when it will be, especially given that call/cc doesn’t appear in Advanced; even if it worked as I suggest, using the stepper for call/cc would be like a trip to the jungle: “we’re going in here, to catch a glimpse of the jaguar. Whew! Done! Now, let’s retreat back to civilization.” Best, John Clements -- You received this message because you are subscribed to the Google Groups "Racket Users" group. To unsubscribe from this group and stop receiving emails from it, send an email to racket-users+unsubscr...@googlegroups.com. For more options, visit https://groups.google.com/d/optout.
