Gray Soft / Higher-Order Ruby

22
FEB
2006
Currying

All the examples in this chapter are trivially translated (switch sub { ... } to lambda { ... }). Ironically, I have never seen a chunk of idiomatic Ruby do anything like this. Rubyists clearly favor blocks for this sort of work. Have a look at the stream addition and multiplication examples of this chapter, for example. You can also see this when MJD trying to create a suitable inject() for Perl (he calls it reduce/fold).

Another interesting point about this chapter is how much of it is spent warring with Perl's syntax. MJD really struggles to introduce a block-like syntax for curried methods and is outright defeated in a couple of attempts. I really like how easily Ruby yields to our attempts to reprogram her, in sharp contrast to her sister language.

Continuing that line of thought, here's my best effort at the Poor Man's Currying library:
```
#!/usr/bin/env ruby -w

class Proc
  def curry(&args_munger)
    lambda { |*args| call(*args_munger[args]) }
  end
end

class Object
  def curry(new_name, old_name, &args_munger)
    ([Class, Module].include?(self.class) ? self : self.class).class_eval do
      define_method(new_name) { |*args| send(old_name, *args_munger[args]) }
    end
  end
end
```
Read more…
In: Higher-Order Ruby | Tags: Functional Programming | 4 Comments

20

FEB
2006

Iterators (Chapters 4 and 5)

Due to a printing error, these two chapters actually came out longer than intended. Originally their contents were: "Use Ruby."

All jokes aside, there's really not a whole lot for me to talk about from these chapters, since iterators are so internal to Ruby. Readers from our camp should run into a lot less surprises here that the intended audience. Just translate MDJ's anonymous subroutines to blocks, replace his returns with yields, and you are 90% of the way there.

Here are translations for some of the examples in these chapters. I think these all come out cleaner and more natural in Ruby, but you be the judge:

Permutations

#!/usr/local/bin/ruby -w

def permute(items)
  0.upto(1.0/0.0) do |count|
    pattern = count_to_pattern(count, items.size) or break
    puts "Pattern #{pattern.join(' ')}:" if $DEBUG
    yield(pattern_to_permutation(pattern, items.dup))
  end
end

def pattern_to_permutation(pattern, items)
  pattern.inject(Array.new) { |results, i| results + items.slice!(i, 1) }
end

def count_to_pattern(count, item_count)
  pattern = (1..item_count).inject(Array.new) do |pat, i|
    pat.unshift(count % i)
    count /= i
    pat
  end
  count.zero? ? pattern : nil
end

if ARGV.empty?
  abort "Usage:  #{File.basename($PROGRAM_NAME)} LIST_OF_ITEMS"
end

permute(ARGV) { |perm| puts(($DEBUG ? "  " : "") + perm.join(" ")) }

17

JAN
2006

Dispatch Tables

I think in Ruby we tend to do a lot of this kind of work with method_missing(). I told you, Functional OO Programming.

Here's my attempt at something close to a direct translation of the RPN calculator example:

#!/usr/local/bin/ruby -w

$stack = Array.new

def rpn(expression, operations_table)
  tokens = expression.split(" ")
  tokens.each do |token|
    type = token =~ /\A\d+\Z/ ? :number : nil

    operations_table[type || token][token]
  end

  $stack.pop
end

if ARGV.size == 2 && ARGV.first == "-i" && ARGV.last =~ /\A[-+*\/0-9 ]+\Z/
  require "pp"

  def ast_to_infix(ast)
    if ast.is_a?(Array)
      op, left, right = ast
      "(#{ast_to_infix(left)} #{op} #{ast_to_infix(right)})"
    else
      ast.to_s
    end
  end

  ast_table = Hash.new do |table, token|
    lambda { |op| s = $stack.pop; $stack << [op, $stack.pop, s] }
  end.merge(:number => lambda { |num| $stack << num.to_i })

  puts "AST:"
  pp(ast = rpn(ARGV.last, ast_table))
  puts "Infix:"
  pp ast_to_infix(ast)
elsif ARGV.size == 1 && ARGV.first =~ /\A[-+*\/0-9 ]+\Z/
  calculation_table = Hash.new do |table, token|
    raise "Unknown token:  #{token}."
    end.merge(
      :number => lambda { |num| $stack << num.to_i },
      "+"     => lambda { $stack << $stack.pop + $stack.pop },
      "-"     => lambda { s = $stack.pop; $stack << $stack.pop - s },
      "*"     => lambda { $stack << $stack.pop * $stack.pop },
      "/"     => lambda { d = $stack.pop; $stack << $stack.pop / d }
    )

    puts rpn(ARGV.first, calculation_table)
else
  puts "Usage:  #{File.basename($PROGRAM_NAME)} [-i] RPN_EXPRESSION"
end