Programming: Wanted

So, what I'd like is a programming language environment with the following features:

1. It is nice and all to have automatic type inference, but it is missing half of the point if it doesn't annotate my source code interactively for me.
2. Real support for functional and object-oriented programming. Declarative logic style would be bonus.
3. Real support for recursion.
4. Real support for closures.
5. Real support for concurrency (e.g.: Erlang).
6. A language which automatically executes (as in: to kill) people who have more than one return statement in a routine, anywhere other than as the last line of that routine.
7. A build system based on a real language so you can more sanely figure out what is happening when dependencies go haywire. That really means: being able to run the build system in a great debugger. Make / rmake / nmake etc. suck ass. Maybe Ant is better than those, yes? No! Ah, how about SCons!
8. An interactive interpreter so you can try things out quickly and easily. I think that really really really contributes to rapid development, and also debugging for sure. Yay LISP, ML, etc.
9. Compilation down to decently fast stuff. Bytecode maybe, but preferably C or something so you can have something sorta portable yet fast. Clean is impressive here!
10. Automatic type inference. Thus also generic types. See ML, Haskell, etc.
11. Functional, higher-order everything. You can easily pass functions, you can easily call map() on things, etc.
12. Optional enforcement of e.g.: design by contract. Preconditions, postconditions, etc. built-in or easily added (e.g.: Perl is so extensible). Being able to mark things const. [Update: okay, doing things right by const can be a real nightmare, just like doing things right by non-Runtime Java exceptions. Drat!]
13. Some decent approach to error handling. Is there such a thing? Exceptions? Does anybody know what it might be?
14. Modularity through mix-ins. Monads? The "let's force everything to be inheritance based" approach to modeling is not conducive to maintainable/usable/expandable systems because people conflate subtyping with code sharing.
15. Optional parameters, with optional tags so you can have them in whatever order. C++'s default values suck so much. Perl's syntax sucks so much.
16. A real debugger! That's one of the biggest concerns I have with using Haskell, O'Caml, Clean. At least with C/C++, Java, Perl, etc. you can apply real debuggers to figure out what the heck is going wrong. Mercury has a debugger, but the entire project is only at like version 0.72 or something. There is an O'Caml debugger, but I haven't actually tried it out yet... maybe it will suffice.
17. LISP-like macros: structure sensitive, not whitespace sensitive.
18. Garbage collection that doesn't suck. Generational. Or whatever.
19. Perhaps not-too-difficult interfacing (e.g.: with SWIG) to other languages. Especially to C/C++ libraries?
20. Now, what about case-sensitivity? Yikes!
21. A real module system. But, no .h vs. .c/cpp bull-crap!
22. No evil c-like-preprocessor! Surely there has got to be a better way to get that kind of functionality?
23. Something with a built-in boolean type! It blows my mind that there are software systems (programming languages, data bases, etc.) that miss such a fundamental data type. Yowza.
24. Something that evaluates "1 + 2" like a human would, not like Smalltalk/Squeak would!
25. Lexical scoping, of course (see early LISP implementations).