The Mirah Language: bringing modern features to the JVM without runtime overhead

Cool example.

* docs (as mentioned)

* some kind of javadoc / rubydoc mechanism (perhaps there is?)

* a NetBeans plugin

* a pony

OK, maybe I can get by without the last one :-)

I've spent the last several days trying to solidify a distribution (.zip), maven artifacts (with David Calavera's help) and refactor the codebase to make it more approachable. Last night I made some edits to the mirah.org web site, and today I may try to work on the wiki. There's definitely a lot missing as far as documentation and support, but we'll get there.

I appreciate your feedback and links to your projects. They will help us learn what needs to be better documented, and also help us produce better error/info messages from the compiler.

We'd also love to have your help :) This is OSS of course, so anything you can do to document your experiences (blog posts, add to wiki on github, ...) will help us and others.

    http://github.com/technomancy/ferrante

It's a huge improvement over a year ago, when I had to get Charles to fix a bunch of compiler issues just to get the simplest of apps to compile: http://github.com/technomancy/Garrett

Actually, that was part of the motivation behind Mirah; Rubyists don't want to contribute to the parts of JRuby that are implemented in Java.

See https://github.com/thbar/opaz-plugdk/tree/master/plugins/Dub... for an example.

The param:type notation I largely just stole from Scala, but it seems (in my novice opinion) easier to parse as well. It also fits better with optional type declarations, which we have in the case of interface impl or class extension (easier to omit syntax on the RHS than on the LHS for a typical parser).

It's easier to parse if your type syntax uses juxtaposition. "Some int" is a valid type, so it would make "<type> <var>" harder to parse. It's hard to tell when the type ends and the variable name starts without backtracking.

Since languages like Haskell and ML (and Scala, to a lesser extent) do type inference, type annotations are often unnecessary, and so having the type listed after the name probably makes more sense in that context: what's important is the name, and variable-specific type hints are usually there for the compiler, not the human reader. The exception is functions, which very often get type definitions just because it's very helpful to have that information as a human. Since ML/Haskell-like languages have multiple function definitions and rely on pattern matching, the postfix type notation fits in very well:

    func :: type1 -> type2
    func a = ...
    func b = ...

http://en.wikipedia.org/wiki/Pascal_(programming_language)#P...

As far as the others go...I don't disagree. Perfect integration with Java is perhaps a bit debateable, since you can't overload constructors, can't define real static methods Java can see, and so on. But those are minor items.

I don't intend Mirah to be a Scala-killer either. Scala is more of a platform now than just a language, and if you're on that platform, you have my blessing. If, however, you just want something to replace javac everywhere you use Java today, I believe Mirah is a better fit.