Jon blow wrote his language so he can both modify the AST during compile time and write compile time rules without writing a plugin
I'd like more errors and warnings to be in a language, such as when I modify array [0] and [2] but not element [1] and extra warnings when I do strange things with a bunch of if's (hard to explain so I'll spare you).
What are yours?
Another thing I would like to have is better bitwise manipulation operations. I find the MOR instruction of MMIX is sometimes useful, and so is the ~ operation of INTERCAL. I also thought of a operator which can be like any one of the C operators + or | or ^ since it is assumed the result is the same in all cases (which will be the case if the bitwise AND of the left and right operands will be zero).
I also agree I want to modify the AST during compile time, using macros.
Many modern programming languages lack a GOTO command, but I think that imperative programming languages should have a GOTO command.
Something that I might want to have is something like LLVM with macros added, although LLVM is itself deficient in some ways (e.g. no support for decimal arithmetic, no support for overlapping data with instructions (e.g. reading/writing immediate operands of other instructions), some calling conventions are missing, and you can't make stable undefined values longer than one bit).
For GPU programming, I think to want something like Checkout.
A try...catch block allows one to define how an exception is handled within a given block. You can take the same function, and wrap it in a different try...catch block, and have the exception handled in a different manner.
Algebraic effects would allow one to define how a side effect (e.g. database queries, logging, etc) is performed within a given block. You can take the same function, wrap it in a different block, and have its side effects handled differently. You could have Logging effects write out to stdout in tests, and write to Splunk in production code, for example.
This would give a nice language-level, type-safe construct for implementing dependency injection, without the usual kludges of traditional DI frameworks.
You can get close using Callable 2. 'var' function argument and return types. Basically allow type inference to work through a call stack. Basically I want F# features to be in more popular languages.