Classic Scheme

What's supposed to be good about Scheme? As I understand it, Scheme didn't even originally have macros, eval, or apply. I can see why it was good for showing that lambda is the ultimate everything, but why did anyone ever try to make it into a real programming language?

Scheme was important in showing the importance of lexical scope and what you can do with just lambda and TCO. It provided a lot of very useful ideas for other languages to pick up, and it influenced many minds. It's also rather easy to implement, which makes it a target for people wanting minimal, yet still powerful languages. Some other Lisps(such as Common Lisp or Scheme R6RS+) are very useful for real work, but they tend to be more complex and lose the natural simplicity that early schemes had, thus they're not as easy to implement. I also see some CLers use Scheme for presenting some novel ideas simply because implementing toy implementations of their ideas is much simpler (for example, if you need a code walker, scheme has much less special operators to reimplement) - of course, most of them do full implementations in their language of choice, but Scheme remains useful as a presentation language for these ideas.

but why did anyone ever try to make it into a real programming language?
Because they can? There's a lot of popular languages considerably worse than Scheme. If they want to add implementation-specific stuff to make it into a real language that they can use for real tasks, why not? It's not like real Schemes lack functionality present in other languages - the main problem with them that you'll encounter is with the lack of portability between implementations (mitigated to some extent by SRFI's and newer revisions of the spec).

It's not like real Schemes lack functionality present in other languages
But they do. It's a bunch of weird functional programming stuff that doesn't support normal imperative programming, but without the features (pattern matching is an obvious one) that make functional languages usable.

What are you talking about, Scheme always had eval and apply.

It's not like real Schemes lack functionality present in other languages.
OOP.

>>4
That's just plain not true.

>>3
Just look at all those functions having ! in their name, then say that again.

>>5
IHBT

>>1
Actually, the very first Scheme did have EVALUATE and probably inherited APPLY/FUNCALL from the underlying Lisp system. It also had AMACROS but AIM 349 doesn't go into depth on them.

The Revised Report (AIM 452) has FSUBRs and a SCHMAC (SCHeme MACro) convenience form, and dropped EVAL. APPLY was not provided, but an implementation exploiting the ENCLOSE primitive was shown in the report.

The Revised Revised Report (AIM 848) had APPLY, but did not have EVAL or a standard macro facility.

The R3RS again only had APPLY (of these three). It cited the diversity of macro forms, and the problem of hygiene as reasons for their exclusion.

The R4RS had APPLY and specified the SYNTAX-RULES macro system in the appendix.

THE R5RS had EVAL, APPLY and SYNTAX-RULES.

The R6RS had EVAL, APPLY, SYNTAX-RULES, SYNTAX-CASE and identifier macros.

In any case, it "became a real programming language", because like many other research tools, it was useful.

>>3
While it is true that there is no standard MATCH facility. MATCH Macros have been around for a LONG LONG TIME. The First Lambda Paper even showed how to implement a `match` function. If you use a ``real'' Scheme, then your implementation will certainly have one.

As for imperative programming. Scheme has had imperative features right from the get go. ASET and DO and BLOCK (which would be completely useless without imperative programming) were in the original AIM, and they continue to live on as SET! DO and BEGIN.

I'm sure if you look harder you will find the features you claim to be missing, but I'm not holding my breath that you will lose your misconceptions.

>>5
First off, you will need to define ``OOP'' which is about as loosely defined as it is possible to be.
There was quite a lot of research done into OOP in Scheme (see http://library.readscheme.org/page4.html], and most useful Schemes have at least one. OOP Libraries I've used in Scheme are Racket/Class (single dispatch), Protobj (prototypes), Prometheus (prototypes), TinyClos [clos-like], Meroon (single dispatch) and GOOPS [clos-like]. I even have a design for my own, but that is for another day.

>>6
Scheme at some period of time could have material eval and apply in the future, but it still had them because having eval and apply is immanent to Scheme.

>>10
Then how do you explain the Schemes that compile to C?

>>11
They vagina.

>>11
Boilerplate.

>>11
They need a compiler at run-time or use an interpreter as fallback.