About a month ago I first announced that I was working on IronRuby, a Ruby interpreter for .NET. Ever since I've made a decent amount of progress. I won't bore you with the details yet, but this progress includes:
- Generics. Both instantiation of generic types and deriving from them is supported.
- Interfaces. Ruby types can now implement an arbitrary amount of .NET interfaces and pass Ruby objects to methods that expect implementations of a certain interface type. Obviously, generic interfaces can be implemented as well.
- Code blocks/delegates. I sort of updated the previous post with some screenshots of a script that already demonstrated this. Basically you can pass any proc to .NET methods and they'll be converted to the appropriate delegate type.
- Debugging. I've added (basic) support for debugging Ruby scripts. In a nutshell, you can use a debugger such as the Visual Studio one to step through a Ruby script.
There are probably a few things I've left out, but I think these are the most interesting features that I have added. While you can do some pretty nifty things already (such as creating a front-end using WPF in an interactive fashion), there is still a lot that needs to be done. Some of the things that I think will be interesting are:
- CodeDom support. This would open a few possibilities, such as making it possible to use Ruby with ASP.NET.
- Improve debugging support. Right now you can pretty much only step through Ruby code. I plan on adding better support for local variables, etc. to improve the debugging experience.
- Error handling. Currently there isn't really a story for this yet in IronRuby.
Are there things that you think would be partically interesting to see in a Ruby implementation for .NET?