Fastruby 0.0.15 released. Callcc and continuation objects!

Fastruby is a gem which allows to execute ruby code much faster than normal, currently in a state of transition between a spike and a usable gem, it is released when possible with incremental improvements.
The v0.0.15 release adds the support for continuation objects created using callcc function. To acchieve this, the implementation uses the non-lineal stack created on previous releases.

Also this release adds a few extra language support improvements such as method default arguments

Install

You can clone the repository at github:

git clone git://github.com/tario/fastruby.git
git checkout v0.0.15

Or install it using gem install:

gem install fastruby

New Features

• Continuation calls, non-local gotos
• Support for default method arguments
• Support for passing proc as block on method call
• Support for receiving block as proc object

Fixes

• Internal fix to support unlimited number of arguments on methods when called from normal ruby
• Minor fixes to splat arguments on blocks
• Removed yield_signature (inference of yield arguments) since this is not longer applicable

Examples of code being supported

Example of continuation calls, tail recursion

require "fastruby"

fastruby '
class X
def fact( n )
    a = callcc { |k| [ n, 1, k ] }
    n = a[0]
    f  = a[1]
    k  = a[2]
    if ( n == 0 ) then return f
    else
 k.call n-1, n*f, k
    end
end
end
'

p X.new.fact(6) # 720

Default Arguments

require "fastruby"

fastruby '
class X
def foo(a,b = a.reverse)
  a + b
end
end
'

p X.new.foo("13") # 1331
p X.new.foo("xx", "yy") # xxyy

Passing proc objects as blocks

require "fastruby"

fastruby '
class X
def bar
  yield(1)
  yield(2)
  yield(3)
end

def foo
  pr = proc do |x|
    p x
  end

  bar(&pr) # passing proc as a block
end
end
'

X.new.foo

Receiving blocks as proc objects

require "fastruby"

fastruby '
class X
def bar(&pr)
  pr.call(1)
  pr.call(2)
  pr.call(3)
end

def foo
  bar do |x|
    p x
  end
end
end
'

X.new.foo

Fastruby 0.0.9 released with support for proc

Fastruby is a gem which allows to execute ruby code much faster than normal, currently in a state of transition between a spike and a usable gem, it is released when possible with incremental improvements.
Following the release of version v0.0.8 which did implement several internal improvements including a new non-linear stack structure, the new release v0.0.9 implements the support for procedure objects based in the previous implementation

Install

You can clone the repository at github:

git clone git://github.com/tario/fastruby.git
git checkout v0.0.9

Or install it using gem install:

gem install fastruby

New Features

• Support for proc
  

Examples of code being supported

return method from proc

require "fastruby"

fastruby '
class X
  def foo
    pr = Proc.new do
      return "return foo from inside proc"
    end

    pr.call

    return "return foo"
  end
end
'

x = X.new
x.foo # this returns "return foo from inside proc"

The behavior of Proc objects (those created using Proc.new) are very similar to the behavior of lambdas, but with a few little differences:

• It is possible to do non-local return's from Proc.new of the method where the block was defined, this non-local return will fail with LocalJumpError when the method scope is closed in the moment of invoking the return (in lambdas, return only acts as next; ie, only ends the lambda function)
• Break jumps are illegal from Proc.new blocks and always fails with LocalJumpError (in lambdas, break acts as next)
  

As additional note, block objects created using proc method are exact the same block objects created using lambda method, only check the the ruby 1.8 source code to see something like that:

   ...
 rb_define_global_function("proc", proc_lambda, 0);
 rb_define_global_function("lambda", proc_lambda, 0);
 ...

Fastruby 0.0.8 released with support for lambdas

Fastruby is a gem which allows to execute ruby code much faster than normal, currently in a state of transition between a spike and a usable gem, it is released when possible with incremental improvements.
The version v0.0.8 was released with the new feature of supporting lambdas. Functional improvement does not appear to be important, but the underlying internal implementation will allow new features in the next release such as the support for proc and continuation objects.

Install

You can clone the repository at github:

git clone git://github.com/tario/fastruby.git

Or install it using gem install:

gem install fastruby

New Features

• Support for lambdas
  
• Internal: new structure to represent stack
• Better implementation of break statement
  

Examples of code being supported

Scope retention (lambda has a reference to the scope where it was created)

require "fastruby"

fastruby '
class X
  attr_accessor :lambda_set, :lambda_get
  def initialize
    a = nil

    @lambda_set = lambda{|x| a = x}
    @lambda_get = lambda{a}
  end
end
'

x = X.new

x.lambda_set.call(88)
p x.lambda_get.call

Yield block of the scope

require "fastruby"

fastruby '
class X
  def bar
    lambda_obj = lambda{
      yield
    }
    lambda_obj
  end

  def foo
    a = 77
    bar do
      a
    end
  end
end
'

x = X.new

lambda_obj = x.foo
p lambda_obj.call  # 77