This is a Wish List for Ruby. Ruby is an excellent language, however here are some small things that I would like to see added to Ruby:

• Threading
  I wish ruby had real threads. The threading support currently provided is really sad. If Rite could actually have OS threads as Ruby threads, like in the .Net framework it would be awesome, instead of doing them as interpreter threads. Write now doing any sort of meaningful multithreaded application in ruby is meaningless.
  
  
• C/C++ style operators
  I wish ruby had ++, -- operators. They really do not contribute to unmanageable code and on the whole are nice things to have.
  
• Use of Curly Braces { }
  I wish that Ruby would let the usage of curly braces to define blocks of code other than just parameter blocks that receive yield results. I would like to use {} to enclose methods, classes, if statements, loops etc.
  
  Write now code that is written like:
  
  def func(a)
     [1,2,3].each {|n|
        if(n % 2 == 0)
           print “This is even”
         else
           print “Odd”
           print “Multiple of 3” if (n%3==0)
         end
     }
  end
  
  being very C-ish in my ways I would really like it if I could avoid all those clumsy ends.
  
  def func(a) {
    [1,2,3].each {|n|
      if(n%2 == 0)
        print “This is even”
       else {
           print “Odd”
           print “Multiple of 3” if (n%3==0)
       }
    }
  }
   
  These days since the Python bug has bitten a bit, I am warming up to the idea of scope by indentation.
  
  def func(a)
    [1,2,3].each |n|
      if(n%2 == 0)
        print “This is even”
       else
           print “Odd”
           print “Multiple of 3” if (n%3==0)
  
  This actually looks quiet nice, but it may not be a good think to have because such code often tends to get messed up real bad when you copy paste it around and spoils the indentation.
  
  
• Better Win32Ole libraries
  This is something that I must have. I use scripting to be able to talk to WMI (Windows Management Instrumentation).
  
  The libraries that Ruby ship for this is really sad. Very unstable. At the time of this writing the current Ruby distribution has removed the win32ole libraries from Ruby. I hope they will come back, stabler.
  
  The reason why Win32Ole is important to me is that it is the mechanism used to talk to WMI and WMI can let you some really awesome stuff.
  
  WMI Primer on MSDN
  
  
• Auto Initialization of variables
  When I write code like this
  
  sum = 0
  10.times{|n| sum = sum + n }
  
  I wish I need not have to initialize ‘sum’. I wish there was some unambiguous way of saying that ‘I know sum hasn’t been defined before, so please use its initial value as ’. I would just like to be able to say 10.times {|n| sum = sum + n } and things should just work, assuming that sum gets initialized as 0. I wish there was some shorthand hand initializing a variable for its first appearance in an expression.
  
  Like I could probably replace:
  
  sum  = 0
  prod = 1
  10.times {|n| sum = sum + n; prod = prod * n }
  
  with
  
  10.times {|n| sum = sum<0> + n; prod = prod<1> + n; }
  
  or better if I had support for C++ style operators, I could write
  
  10.times{|n| sum<0> += n; prod<1> *= n; }
  
  
  
•  Run on .Net
  I wish ruby could run on .Net. There are python variants that run on Java and now Python is coming up for .Net (IronPython). Imagine the power of having the flexibility of Ruby with the power and expanse of the .Net framework.
  
  Maybe more work needs to be done before this is possible.
  
  
•  Currying of Methods and Partial Evaluations
  I wish I could have currying/partial evaluation possible for ruby methods.
  In many functional languages, functions are defined like this:
  
  - fn add x y = x + y
  > int -> int -> int
  
  Consider the ML like code above. The first line I have defines a function called ‘add’ that takes x and y and does x+y. The second line is what the interpreter echoes back to me about the function.
  
  It is simply is trying to say that the method consumes two integers and produces an integer. The two integers how ever are not used up at one go, rather, they are used up sequentially. First the integer x is taken and bound to the function and then the value y.
  
  By being able to do that, we can define other function instances of add that have one of the variables bound.
  
  - fn add10 = add 10
  - fn add5 = add 5
  - add10 2
  > 12
  - add5 2
  > 7
  
  This shows off some very powerful features of what currying can do. Here add10 and add5 are created as new functions, but with the value of x substituted as 10 and 5 respectively. Now we can treat add10 and add5 as proper functions that take only one parameter. 
  
  
  What these languages let us do is that we can apply a subset of the parameters of a function and created a curried or partially evaluated function instance. Such an instance can, if the runtime is optimizing enough, already do all the processes possible in the code upfront. Whenever the remaining parameters are supplied, it could just go on to complete the operations.  

Imagine that the method we were calling is this

fn mult x y = 10 * x * y

and then we wish to do

mult 10 2

mult 10 3

mult 10 4

 

These calls will now cause it to do 10 * 10 * 2, 10 * 10 * 3 and 10 * 10 * 4

However if we could partially evaluate a function we could say

 

fn mult10 = mult 10
mult10 2

mult10 3

mult10 4

 

When mult10 is created it is already evaluated to being “100 * y”. So, subsequent calls would cause it to do only 100 * 2, 100 * 3 and 100 * 4.

 

To add this sort of support to Ruby will have to bring large changes to the language. A simpler implementation would be to create a method object (yes that’s possible in Ruby) and also a hash of the partial list of parameters. The call itself could be formally executed only when all formal parameters are satisfied by the parameter hash table collection.

 

If you are still reading this might interest you:

http://www.svendtofte.com/code/curried_javascript/

Whew!

Well, that’s about it for now. But as you can see most of what I am asking for here are simple things and superficial changes. I would however really like to see the win32ole, threads and ++ operators in Ruby, even if none of the others work out.

Matz, (Yukihiro Matsumoto), the creator of Ruby is planning to introduce some significant changes to the language and more importantly going to get it running off a formal virtual machine that he is writing for Ruby called Rite.

Here are some of the plans for Rite and Ruby:

http://www.rubygarden.org/ruby?Rite

I found this on one of the websites, this is about how Matz wanted to work on Rite:

http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/76588
|* will Rite be developed publicly.. Or will you keep it souce secret?

From my experience and observation, an open source software needs to

have running code before the ball rolling to success.  I think I need to work alone until the first running version.

|* still use Ruby license scheme?

It will be open source software for sure.  License terms may be

changed.

|* do you need help?  Say what we should do and we will do it

This is very important.  Listen carefully.

From the reason I stated above, I feel like I will work alone.

But if someone shows his talent, and comes up with his own _good_

implementation of new Ruby earlier than me, and if he is willing to

contribute his code, and if he allows me to hack and chop his code to

make it "Rite", I will name it "Rite".  And he will be honored for ever.