I think collections is a very good candidate for a DSL.
Take Java for example.
Before J2SE5.0 you had to use enumerator or iterator classes and call methods like hasMoreElements() and getNext().
Then they added a language feature that completely obliterates the need for those unnecessary classes.
Now I simply type
for(Type t: my_collection)
So here is real life proof that class libraries really benefits from language features that are not possible to do with classes.
The fact that some things are unpractical to implement with the collections api in Java does not make it obsolete. I still use it where it is possible, because of the flexibility.
The same case may happen with a collections language. Some things may be unpractical due to sheer size or whatever.
I can see the use of being able to add my own langage features.
In Perl you can write.
foreach (sort keys %myMap)
In Java you have to write something like.
List list = new LinkedList(myMap.keySet());
Collections.sort(list);
for(Type x: list)
There certainly is a lot of langauge features that would be handy to have with Java collection.
And just think about being able to add your own features as you need them.
There is a scary thing about a whole new language. But think about it. You can write your completely own collections library in Java. But then you will have to forget about using the for loop. You will have to resort to iterator class and stuff like that. A typical case where OOD messes up code that could have been nice and clean with sufficient language support.
And there are hundreds of APIs out there, and each one has to be learned. With language features to cover up the object goup behind, and with code completion and refactoring tools that have an understanding of the 'API', then a new 'API' will be really easy to learn.
So if one sees DSLs as modules, like Java APIs are today, but with custom language features to boost the API. Then this is just a better API.
I think what DSLs will do to APIs is similar to what OOD did to functional programming.
OOD added inheritance, overloading, polymorphism into the data structure that simplifies operations on that very data.
A DSL adds keywords and other structures that simpifies the usage of the API.
But I think the real trick will not be to design a specific DSL. The difficulty will be to make ten or a hundred languages interoperate.
Because there will be need to write programs using many langauages. To inline elements from many different DSLs into one program and referencing common objects from any place.
That in itself may be a language. A sort of glue language.
--
And then in the very end, there will be so many languages that the programmers must have interpreters when talking to each other. And altavista will add Babel Fish translation for programmers. And God will weep in heaven...
