Login

Don't know how hidden this is, but I've found it useful when needing to make a Hash out of a one-dimensional array:

fruit = ["apple","red","banana","yellow"]
=> ["apple", "red", "banana", "yellow"]

Hash[*fruit]
=> {"apple"=>"red", "banana"=>"yellow"}

One final one - in ruby you can use any character you want to delimit strings. Take the following code:

message = "My message"
contrived_example = "<div id=\"contrived\">#{message}</div>"

If you don't want to escape the double-quotes within the string, you can simply use a different delimiter:

contrived_example = %{<div id="contrived-example">#{message}</div>}
contrived_example = %[<div id="contrived-example">#{message}</div>]

As well as avoiding having to escape delimiters, you can use these delimiters for nicer multiline strings:

sql = %{
SELECT strings
FROM complicated_table
WHERE complicated_condition = '1'
}

# module_function
Module methods that are declared as *module_function* will create copies of themselves as **private** instance methods in the class that includes the Module:

module M
def not!
'not!'
end
module_function :not!
end

class C
include M

def fun
not!
end
end

M.not! # => 'not!
C.new.fun # => 'not!'
C.new.not! # => NoMethodError: private method `not!' called for #<C:0x1261a00>

If you use *module_function* without any arguments, then any module methods that comes after the module_function statement will automatically become module_functions themselves.

module M
module_function

def not!
'not!'
end

def yea!
'yea!'
end
end

class C
include M

def fun
not! + ' ' + yea!
end
end
M.not! # => 'not!'
M.yea! # => 'yea!'
C.new.fun # => 'not! yea!'

`Class.new()`

Create a new class at run time. The argument can be a class to derive from, and the block is the class body. You might also want to look at `const_set/const_get/const_defined?` to get your new class properly registered, so that `inspect` prints out a name instead of a number.

Not something you need every day, but quite handy when you do.

Ruby has a [call/cc][1] mechanism allowing one to freely hop up and down the stack.

Simple example follows. This is certainly not how one would multiply a sequence in ruby, but it demonstrates how one might use call/cc to reach up the stack to short-circuit an algorithm. In this case, we're recursively multiplying a list of numbers until we either have seen every number or we see zero (the two cases where we know the answer). In the zero case, we can be arbitrarily deep in the list and terminate.

#!/usr/bin/env ruby

def rprod(k, rv, current, *nums)
puts "#{rv} * #{current}"
k.call(0) if current == 0 || rv == 0
nums.empty? ? (rv * current) : rprod(k, rv * current, *nums)
end

def prod(first, *rest)
callcc { |k| rprod(k, first, *rest) }
end

puts "Seq 1: #{prod(1, 2, 3, 4, 5, 6)}"
puts ""
puts "Seq 2: #{prod(1, 2, 0, 3, 4, 5, 6)}"

You can see the output here:

[