········@notam02.no wrote:
> (Just in case its already done:)
>
> Does anyone know of available packages for Common-lisp to Scheme
> translation?
You GOT to be kidding!
Cheers
--
Marco Antoniotti
Marco Antoniotti <·······@cs.nyu.edu> wrote in message news:<···············@typhoon.nyu.edu>...
> ········@notam02.no wrote:
>
> > Does anyone know of available packages for Common-lisp to Scheme
> > translation?
>
> You GOT to be kidding!
So what about something less ambitious. Often I'll see a coding
example in Lisp, but would prefer to experiment in Scheme. Some sort
of quick-reference mapping common Lisp constructs to the equivalent
Scheme might be useful.
·················@hotmail.com (P.M.) writes:
> Marco Antoniotti <·······@cs.nyu.edu> wrote in message
> news:<···············@typhoon.nyu.edu>...
> > ········@notam02.no wrote:
> >
> > > Does anyone know of available packages for Common-lisp to Scheme
> > > translation?
> >
>
> > You GOT to be kidding!
>
> So what about something less ambitious. Often I'll see a coding
> example in Lisp, but would prefer to experiment in Scheme. Some sort
> of quick-reference mapping common Lisp constructs to the equivalent
> Scheme might be useful.
The "big joke" is that there are a *lot* of fundamental Common Lisp
constructs that don't (AFAIK) have any Scheme equivalent e.g., special
variables (aka dynamically scoped variables), packages, restarts,
CLOS, the LOOP macro, and more. Don't let the superficially similar
syntax fool you--they are very different languages and there are no
simple mappings.
If I was faced with a chunk of Common Lisp that I needed to
understand, and I didn't know Common Lisp real well, I'd set up a
Common Lisp development environment and use the documentation-finding
facilities (like hyperspec-apropos in GNU/X emacs w/ilisp) on the
operators I didn't understand.
Gabe Garza
Gabe Garza <·······@ix.netcom.com> writes:
> ·················@hotmail.com (P.M.) writes:
>
>> Marco Antoniotti <·······@cs.nyu.edu> wrote in message
>> news:<···············@typhoon.nyu.edu>...
>> > ········@notam02.no wrote:
>> >
>> > > Does anyone know of available packages for Common-lisp to Scheme
>> > > translation?
>> >
>>
>> > You GOT to be kidding!
>>
>> So what about something less ambitious. Often I'll see a coding
>> example in Lisp, but would prefer to experiment in Scheme. Some sort
>> of quick-reference mapping common Lisp constructs to the equivalent
>> Scheme might be useful.
>
> The "big joke" is that there are a *lot* of fundamental Common Lisp
> constructs that don't (AFAIK) have any Scheme equivalent e.g., special
> variables (aka dynamically scoped variables), packages, restarts,
> CLOS, the LOOP macro, and more. Don't let the superficially similar
> syntax fool you--they are very different languages and there are no
> simple mappings.
>
> Gabe Garza
There are times when you'd like to develop with nice Common Lisp
tools, but port to a small implementation because of memory
contraints:
Both Robby and Tooth were programmed using Lisp. On Robby we
actually ran Lisp on-board. The Lisp we used was T 3.1 which
was ported from a Sun3 to vxWorks with a great deal of help
from Jim Firby, who came to JPL from Yale. Jim also wrote a
T-in-common-lisp compatibility package called Common T. Using
Common T we could do code development on a Macintosh (using
Macintosh Common Lisp and a Robbie simulator, also written by
Jim) and then run the resulting code directly on Robby with no
changes.
Tooth's processors didn't have nearly enough RAM to run Lisp
directly [1] so instead we used a custom-designed compiler
written in Lisp to generate 6811 code. At first we used Rod
Brooks's subsumption compiler, but later I decided I didn't
like the constraints imposed by the subsumption architecture
and wrote my own for a language called ALFA [2]. ALFA was
subsequently used to program a whole series of rovers, the
Rocky series, which eventually led to the Sojourner rover on
the Mars Pathfinder mission. (Sojourner had an Intel 8085
processor with 1 MB of bank-switched RAM. It was programmed in
C. More on this decision later.)
from Eran Gat in http://www.flownet.com/gat/jpl-lisp.html
Chris
P.M. wrote:
> Marco Antoniotti wrote in message news:...
>
> >········@notam02.no wrote:
> >
> >
> >>Does anyone know of available packages for Common-lisp to Scheme
> >>translation?
> >
>
> >You GOT to be kidding!
>
>
> So what about something less ambitious. Often I'll see a coding
> example in Lisp, but would prefer to experiment in Scheme. Some sort
> of quick-reference mapping common Lisp constructs to the equivalent
> Scheme might be useful.
Scheme (sans the overkill call/cc) is a strict and tiny subset of Common
Lisp. You cannot reliably translate something like the following
not-at-all-sophisticated CL code
(in-package "GEOMETRY")
(defstruct point (x 0.0 :type real) (y 0.0 :type real))
into Scheme.
Get yourself a Common Lisp (you can start at www.alu.org) and start
using and learning the real thing.
Cheers
--
Marco Antoniotti
>>>>> "Marco" == Marco Antoniotti <·······@cs.nyu.edu> writes:
Marco> Scheme (sans the overkill call/cc) is a strict and tiny subset of
Marco> Common Lisp.
That, of course, is nonsense. Most immediately, proper tail recursion
and hygienic macros come to mind. As for strictness, I think there's
a terminology confusion here: both Common Lisp and Scheme are strict
in the "strict vs. lazy" sense.
Marco> You cannot reliably translate something like the
Marco> following not-at-all-sophisticated CL code
Marco> (in-package "GEOMETRY")
Marco> (defstruct point (x 0.0 :type real) (y 0.0 :type real))
Marco> into Scheme.
Sure you can. Look at the reference implementation of SRFI 9 for how
it's done.
--
Cheers =8-} Mike
Friede, V�lkerverst�ndigung und �berhaupt blabla
Michael Sperber [Mr. Preprocessor] wrote:
>>>>>> "Marco" == Marco Antoniotti <·······@cs.nyu.edu> writes:
>
> Marco> Scheme (sans the overkill call/cc) is a strict and tiny subset
> of Marco> Common Lisp.
>
> That, of course, is nonsense. Most immediately, proper tail recursion
> and hygienic macros come to mind. As for strictness, I think there's
> a terminology confusion here: both Common Lisp and Scheme are strict
> in the "strict vs. lazy" sense.
I read the "strict" as "strict subset".
--
Jens Axel S�gaard
Michael Sperber [Mr. Preprocessor] wrote:
> >>>>>"Marco" == Marco Antoniotti writes:
>
>
> Marco> Scheme (sans the overkill call/cc) is a strict and tiny subset of
> Marco> Common Lisp.
>
> That, of course, is nonsense. Most immediately, proper tail recursion
> and hygienic macros come to mind. As for strictness, I think there's
> a terminology confusion here: both Common Lisp and Scheme are strict
> in the "strict vs. lazy" sense.
>
> Marco> You cannot reliably translate something like the
> Marco> following not-at-all-sophisticated CL code
>
> Marco> (in-package "GEOMETRY")
>
> Marco> (defstruct point (x 0.0 :type real) (y 0.0 :type real))
>
> Marco> into Scheme.
>
> Sure you can. Look at the reference implementation of SRFI 9 for how
> it's done.
No you cannot. You are missing the
(in-package "GEOMETRY")
bit. (I happen to know at SRFI 9 - another application of Greenspun's
Tenth :) That is why I stuck the IN-PACKAGE bit before the DEFSTRUCT :) ).
The bottom line is always the same.
Use Common Lisp instead of reinventing it. :)
--
Marc Antoniotti
>>>>> "anders" == andersvi <········@notam02.no> writes:
anders> (Just in case its already done:)
anders> Does anyone know of available packages for Common-lisp to Scheme
anders> translation?
PseudoScheme seems closest to what you're looking for, even thought
it's bound to have accumulated some dust by now. Web search machines
know about it.
--
Cheers =8-} Mike
Friede, V�lkerverst�ndigung und �berhaupt blabla
Michael Sperber [Mr. Preprocessor] wrote:
> >>>>>"anders" == andersvi writes:
>
>
> anders> (Just in case its already done:)
>
> anders> Does anyone know of available packages for Common-lisp to Scheme
> anders> translation?
>
> PseudoScheme seems closest to what you're looking for, even thought
> it's bound to have accumulated some dust by now. Web search machines
> know about it.
Last I checked PseudoScheme was doing the right thing: making a Scheme
subsystem available within a serious Common Lisp implementation.
This is the opposite of what the OP asked
Cheers
--
Marco Antoniotti