Edit Question - KnowledgeHub

Title Body

For a long time I've been trying different languages to find the feature-set I want and I've not been able to find it. I have languages that fit decently for various projects of mine, but I've come up with an intersection of these languages that will allow me to do 99.9% of my projects in a single language. I want the following: Built on top of .NET or has a .NET implementation Has few dependencies on the .NET runtime both at compile-time and runtime (this is important since one of the major use cases is in embedded development where the .NET runtime is completely custom) Has a compiler that is 100% .NET code with no unmanaged dependencies Supports arbitrary expression nesting (see below) Supports custom operator definitions Supports type inference Optimizes tail calls Has explicit immutable/mutable definitions (nicety -- I've come to love this but can live without it) Supports real macros for strong metaprogramming (absolute must-have) The primary two languages I've been working with are Boo and Nemerle, but I've also played around with F#. Main complaints against Nemerle: The compiler has horrid error reporting, the implementation is buggy as hell (compiler and libraries), the macros can only be applied inside a function or as attributes, and it's fairly heavy dependency-wise (although not enough that it's a dealbreaker). Main complaints against Boo: No arbitrary expression nesting (dealbreaker), macros are difficult to write, no custom operator definition (potential dealbreaker). Main complaints against F#: Ugly syntax, hard to understand metaprogramming, non-free license (epic dealbreaker). So the more I think about it, the more I think about developing my own language. Pros: Get the exact syntax I want Get a turnaround time that will be a good deal faster; difficult to quantify, but I wouldn't be su

Tags (comma-separated) Cancel