Lambda the Ultimate

Understand that, in addition to how the though experiment is formulated, this forum topic is also very much a question about the most profitable direction of my own future educational development regarding the theory, applicability, development pragmatics and implementation techniques of programming language "paradigms."

1) Imagine a simple language with features roughly the intersection of existing languages similar to ML or Haskell (and a host of similar, more obscure languages):

   * "mostly functional"
   * manifestly typed, 
   * a type inference system (maybe only "local" type inference)
   * algebraic data types
   * parametric polymorphism
   * a simple name space management oriented module system with the 
     possible addition of optional module level type parameters, 
     largely as a convenience feature - example) imagine something 
     simple such as: import ListLib[Int] as intls;
   * a "rich" pattern matching facility, perhaps with a pattern 
     variable unification feature included (.e.g., equality testing)
   * a "principle of least surprise" syntax friendly to constructing 
     manipulating lists, vectors, hash dictionaries, trees and other 
     sequences and data structures. 

2) Presume the accouterments of nicely supported modern language implementations:

 * a suitable FFI
 * common libraries such as regex, tcp/ip networking, a low level 
   interface to the operating system's preemptive threading system, 
 * library interface to all other common operating system features, such as
   memory mapped files, shared memory, process control, and so on and so forth.'
 * boring libraries for parsing the oodles of data formats floating around
   the world: XML and friends, JSON, text and numeric data files both text and
   and binary formatted, all the common RFC described file formats
 * some suitable full bore language parsing system
 * an Emacs major mode (or perhaps Visual Studio or Eclipse integration 
   if that floats your boat)
 * a source level debugger
 * at least some basic "from-source" documentation generation system
   such as Java Doc or its nicer brethren, whatever.

The goal here is to describe and envision a nice, but still mostly generic, simple and rather "innovation free" BASE LANGUAGE judged "practical and suitable to production development" by the criteria commonly applied to other (functional?) languages circa 2010.

THE THOUGHT EXPERIMENT: If one could add a significant new language feature or new additional "programming paradigm" (and thus, of course, attendant syntax extensions, compiler technology, runtime system, etc.) to this intentionally commonplace BASE LANGUAGE:

  * What would that new feature or new added language "paradigm" be?
  * What new problems would this language addition solve? 
  * Or perhaps an alternate motivation, what additional 
    "expressiveness" might it add to the language?
  * Why is this particular language technology "more important" than
    other options?
  * In what problem domains would this new feature or added paradigm
    be most useful (or is it mostly domain neutral/universal)
  * Does a "feature combination" or "multi paradigm" language such
    as, or similar to, this already exist?   

I truly appreciate any thoughtful answers, which may greatly influence where I "go next" in my ongoing studies of programming languages and their implementation.

Thanks a million in advance!

The call for papers for the SPLASH conference is now up.

SPLASH is the conference formerly known as OOPLSA, and the OOPSLA name is now being used for one of the two main colocated events at SPLASH (the other being Onward!). So if you've got a paper full of interesting results, send it in by March 25.

EDIT: both Martin Rinard in the comments below, and William Cook in email, have been very emphatic that the name change is to make clear that the conference is not just about objects any more -- anything that's (a) about programming languages maximally broadly construed, and (b) good work, is fair game for the conference now. Sorry for any confusion!