I did read the GitHub announcement but was just trying to make the point that re-using names of software packages isn't a good idea, thanks for providing an example.
I doubt that would be an issue. I think it has more to do about the correctness of the list implementation. In r5rs you can mutate a list from underneath your own feet, and ensuring a correct program state requires some extra checks that may slow list operations down.
Shawn,
Is your Lumen system compatible with COMMON-LISP (Lisp-2), or Scheme (Lisp-1) ?
If Lumen is a Lisp-1 then it does not allow the same name to be used for a function and a variable simultaneously. If Lumen is a Lisp-2 then functions and variables are in separate namespaces.
Perhaps someone knows if there a library of code that you can load to make all the common-lisp functions available to you? Would that make your system a common lisp?
Is there an equivalent library you can load to make Lumen a Scheme at some compatibility level?
The cool thing about Lumen is that it’s literally JavaScript: every lumen expression compiles into equivalent JS (or Lua). There aren’t any special calling conventions.
I would say Lumen is quite close to Scheme out of the box, but without syntax transformers. It wouldn't be hard to implement the missing parts of Scheme.
If you want to collaborate on some of this, shoot me an email. :)
Your claim is revisionist and, in my view, nonsense. Scheme is most certainly a Lisp. I mean, you can think what you like, and of course postmodernism is a thing, "the author is dead" and so forth, but if you look at the history, it's very, very clear that Scheme is a Lisp; that is, it is a member of the Lisp language family.
You can even read the words of the people who invented and developed the language:
"SCHEME is essentially a full-funarg LISP." - page 1, "Scheme, an interpreter for extended lambda calculus", Sussman and Steele, Dec 1975. AI memo #349.
"SCHEME is a dialect of LISP." - abstract, "The Revised Report on SCHEME, a Dialect of LISP", Steele and Sussman, Jan 1978. AI memo #452.
"Scheme is a statically scoped and properly tail-recursive dialect of the Lisp programming language [...] Scheme differs from Common Lisp in its emphasis upon simplicity and function over compatibility with older dialects of Lisp." - page 4, "The Revised Revised Report on Scheme, or An UnCommon Lisp", Rees and Clinger (eds.), Aug 1985. AI memo #848.
"Scheme has influenced the evolution of Lisp. [...] Scheme was the first major dialect of Lisp to [do many things]" - introduction, "Revised^3 Report on the Algorithmic Language Scheme", Rees and Clinger (eds.), Dec 1986. ACM SIGPLAN Notices 21(12).
"Scheme is a statically scoped and properly tail-recursive dialect of the Lisp programming language" - summary of the R4RS, the R5RS, the R6RS and even the bloody R7RS.
Compare and contrast to the opening words of the Introduction to CLtL2, which are "Common Lisp is a new dialect of Lisp, a successor to MacLisp, influenced strongly by Zetalisp and to some extent by Scheme and Interlisp."
If Scheme is "not a Lisp", then neither is Common Lisp.
Common Lisp is a successor ro Maclisp, which was a successor for the original Lisp implementation. Common Lisp was designed such that the old code can be ported to a modernized version of Lisp. This code moved from Lisp 1.5 to Maclisp to ZetaLisp and to Common Lisp.
Scheme OTOH has its own code bases, its own libraries, its own standards, its own books, its own community.
It is a Lisp, but that has become more or less meaningless for practical work. Being 'a Lisp" means practically very little. It's just a name with an unclear definition and less and less practical value. Thus 'a Lisp' means mostly an unspecified bunch of dialects which are in practical terms mostly unrelated.
I prefer a stronger definition, where Lisp means those dialects and their implementation which actually share code, books, libraries, tools.
Otherwise people get the impression of some compatibility, which in real life isn't given.
It's like a family member, which used to carry your name, but now has left the house and has its own life.
For folks who are confused, an interesting and useful article on why Scheme could be considered a Lisp, why it might not, and why it doesn't really matter. http://wiki.c2.com/?IsSchemeLisp
While it's true folks argue that it doesn't really matter (evidence: the section 'Arguments why it doesn't matter' on that page), I'll counter-argue that they're wrong. Scheme simply isn't the same language as Lisp. That's okay: the entire world doesn't need to standardise on a single language (although if it's going to, Lisp would be preferable to Scheme).
And, honestly, the arguments that it doesn't matter presented on that page are pretty weak. 'It's a pointless distraction' is an assertion, not an argument. Scheme and Lisp are different; they have different philosophies and they solve the same problems in different ways; recognising those differences is recognising the facts; ignoring them is simply ignoring reality. 'The benefits of choice far outweigh the disadvantages of redundant/wasted development work on two incompatible platforms' is clearly, I believe, falsified by the experience of the last couple of decades. When I think of the work which went into Racket (originally a Scheme, but now its own thing) and Clojure, I think of how much better Lisp could have been if that effort had instead been spent on it (and aficionados of either of those languages could say the same thing about effort spent on the other, on Lisp & on other Lisp-like languages).
