Object Mentor Blog: Tighter Ruby Methods with Functional-style Pattern Matching, Using the Case Gem

Tighter Ruby Methods with Functional-style Pattern Matching, Using the Case Gem

Dean Wampler — Mon, 16 Mar 2009 19:59:00 -0500

Ruby doesn’t have overloaded methods, which are methods with the same name, but different signatures when you consider the argument lists and return values. This would be somewhat challenging to support in a dynamic language with very flexible options for method argument handling.

You can “simulate” overloading by parsing the argument list and taking different paths of execution based on the structure you find. This post discusses how pattern matching, a hallmark of functional programming, gives you powerful options.

First, let’s look at a typical example that handles the arguments in an ad hoc fashion. Consider the following Person class. You can pass three arguments to the initializer, the first_name, the last_name, and the age. Or, you can pass a hash using the keys :first_name, :last_name, and :age.


require "rubygems" 
require "spec" 

class Person
  attr_reader :first_name, :last_name, :age
  def initialize *args
    arg = args[0]
    if arg.kind_of? Hash       # 1
      @first_name = arg[:first_name]
      @last_name  = arg[:last_name]
      @age        = arg[:age]
    else
      @first_name = args[0]
      @last_name  = args[1]
      @age        = args[2]
    end
  end
end

describe "Person#initialize" do 
  it "should accept a hash with key-value pairs for the attributes" do
    person = Person.new :first_name => "Dean", :last_name => "Wampler", :age => 39
    person.first_name.should == "Dean" 
    person.last_name.should  == "Wampler" 
    person.age.should        == 39
  end
  it "should accept a first name, last name, and age arguments" do
    person = Person.new "Dean", "Wampler", 39
    person.first_name.should == "Dean" 
    person.last_name.should  == "Wampler" 
    person.age.should        == 39
  end
end

The condition on the # 1 comment line checks to see if the first argument is a Hash. If so, the attribute’s values are extracted from it. Otherwise, it is assumed that three arguments were specified in a particular order. They are passed to #initialize in a three-element array. The two rspec examples exercise these behaviors. For simplicity, we ignore some more general cases, as well as error handling.

Another approach that is more flexible is to use duck typing, instead. For example, we could replace the line with the # 1 comment with this line:


if arg.respond_to? :has_key?

There aren’t many objects that respond to #has_key?, so we’re highly confident that we can use [symbol] to extract the values from the hash.

This implementation is fairly straightforward. You’ve probably written code like this yourself. However, it could get complicated for more involved cases.

Pattern Matching, a Functional Programming Approach

Most programming languages today have switch or case statements of some sort and most have support for regular expression matching. However, in functional programming languages, pattern matching is so important and pervasive that these languages offer very powerful and convenient support for pattern matching.

Fortunately, we can get powerful pattern matching, typical of functional languages, in Ruby using the Case gem that is part of the MenTaLguY’s Omnibus Concurrency library. Omnibus provides support for the hot Actor model of concurrency, which Erlang has made famous. However, it would be a shame to restrict the use of the Case gem to parsing Actor messages. It’s much more general purpose than that.

Let’s rework our example using the Case gem.


require "rubygems" 
require "spec" 
require "case" 

class Person
  attr_reader :first_name, :last_name, :age
  def initialize *args
    case args
    when Case[Hash]       # 1
      arg = args[0]
      @first_name = arg[:first_name]
      @last_name  = arg[:last_name]
      @age        = arg[:age]
    else
      @first_name = args[0]
      @last_name  = args[1]
      @age        = args[2]
    end
  end
end

describe "Person#initialize" do 
  it "should accept a first name, last name, and age arguments" do
    person = Person.new "Dean", "Wampler", 39
    person.first_name.should == "Dean" 
    person.last_name.should  == "Wampler" 
    person.age.should        == 39
  end
  it "should accept a has with :first_name => fn, :last_name => ln, and :age => age" do
    person = Person.new :first_name => "Dean", :last_name => "Wampler", :age => 39
    person.first_name.should == "Dean" 
    person.last_name.should  == "Wampler" 
    person.age.should        == 39
  end
end

We require the case gem, which puts the #=== method on steroids. In the when statement in #initialize, the expression when Case[Hash] matches on a one-element array where the element is a Hash. We extract the key-value pairs as before. The else clause assumes we have an array for the arguments.

So far, this is isn’t very impressive, but all we did was to reproduce the original behavior. Let’s extend the example to really exploit some of the neat features of the Case gem’s pattern matching. First, let’s narrow the allowed array values.


require "rubygems" 
require "spec" 
require "case" 

class Person
  attr_reader :first_name, :last_name, :age
  def initialize *args
    case args
    when Case[Hash]       # 1
      arg = args[0]
      @first_name = arg[:first_name]
      @last_name  = arg[:last_name]
      @age        = arg[:age]
    when Case[String, String, Integer]
      @first_name = args[0]
      @last_name  = args[1]
      @age        = args[2]
    else
      raise "Invalid arguments: #{args}" 
    end
  end
end

describe "Person#initialize" do 
  it "should accept a first name, last name, and age arguments" do
    person = Person.new "Dean", "Wampler", 39
    person.first_name.should == "Dean" 
    person.last_name.should  == "Wampler" 
    person.age.should        == 39
  end
  it "should accept a has with :first_name => fn, :last_name => ln, and :age => age" do
    person = Person.new :first_name => "Dean", :last_name => "Wampler", :age => 39
    person.first_name.should == "Dean" 
    person.last_name.should  == "Wampler" 
    person.age.should        == 39
  end
  it "should not accept an array unless it is a [String, String, Integer]" do
    lambda { person = Person.new "Dean", "Wampler", "39" }.should raise_error(Exception)
  end
end

The new expression when Case[String, String, Integer] only matches a three-element array where the first two arguments are strings and the third argument is an integer, which are the types we want. If you use an array with a different number of arguments or the arguments have different types, this when clause won’t match. Instead, you’ll get the default else clause, which raises an exception. We added another rspec example to test this condition, where the user’s age was specified as a string instead of as an integer. Of course, you could decide to attempt a conversion of this argument, to make your code more “forgiving” of user mistakes.

Similarly, what happens if the method supports default values some of the parameters. As written, we can’t support that option, but let’s look at a slight variation of Person#initialize, where a hash of values is not supported, to see what would happen.


require "rubygems" 
require "spec" 
require "case" 

class Person
  attr_reader :first_name, :last_name, :age
  def initialize first_name = "Bob", last_name = "Martin", age = 29
    case [first_name, last_name, age]
    when Case[String, String, Integer]
      @first_name = first_name
      @last_name  = last_name
      @age        = age
    else
      raise "Invalid arguments: #{first_name}, #{last_name}, #{age}" 
    end
  end
end

def check person, expected_fn, expected_ln, expected_age
  person.first_name.should == expected_fn
  person.last_name.should  == expected_ln
  person.age.should        == expected_age
end

describe "Person#initialize" do 
  it "should require a first name (string), last name (string), and age (integer) arguments" do
    person = Person.new "Dean", "Wampler", 39
    check person, "Dean", "Wampler", 39
  end
  it "should accept the defaults for all parameters" do
    person = Person.new
    check person, "Bob", "Martin", 29
  end
  it "should accept the defaults for the last name and age parameters" do
    person = Person.new "Dean" 
    check person, "Dean", "Martin", 29
  end
  it "should accept the defaults for the age parameter" do
    person = Person.new "Dean", "Wampler" 
    check person, "Dean", "Wampler", 29
  end
  it "should not accept the first name as a symbol" do
    lambda { person = Person.new :Dean, "Wampler", "39" }.should raise_error(Exception)
  end
  it "should not accept the last name as a symbol" do
  end
  it "should not accept the age as a string" do
    lambda { person = Person.new "Dean", "Wampler", "39" }.should raise_error(Exception)
  end
end

We match on all three arguments as an array, asserting they are of the correct type. As you might expect, #initialize always gets three parameters passed to it, including when default values are used.

Let’s return to our original example, where the object can be constructed with a hash or a list of arguments. There are two more things (at least …) that we can do. First, we’re not yet validating the types of the values in the hash. Second, we can use the Case gem to impose constraints on the values, such as requiring non-empty name strings and a positive age.


require "rubygems" 
require "spec" 
require "case" 

class Person
  attr_reader :first_name, :last_name, :age
  def initialize *args
    case args
    when Case[Hash]
      arg = args[0]
      @first_name = arg[:first_name]
      @last_name  = arg[:last_name]
      @age        = arg[:age]
    when Case[String, String, Integer]
      @first_name = args[0]
      @last_name  = args[1]
      @age        = args[2]
    else
      raise "Invalid arguments: #{args}" 
    end
    validate_name @first_name, "first_name" 
    validate_name @last_name, "last_name" 
    validate_age
  end

  protected

  def validate_name name, field_name
    case name
    when Case::All[String, Case.guard {|s| s.length > 0 }]
    else
      raise "Invalid #{field_name}: #{first_name}" 
    end
  end

  def validate_age
    case @age
    when Case::All[Integer, Case.guard {|n| n > 0 }]
    else
      raise "Invalid age: #{@age}" 
    end
  end
end

describe "Person#initialize" do 
  it "should accept a first name, last name, and age arguments" do
    person = Person.new "Dean", "Wampler", 39
    person.first_name.should == "Dean" 
    person.last_name.should  == "Wampler" 
    person.age.should        == 39
  end
  it "should accept a has with :first_name => fn, :last_name => ln, and :age => age" do
    person = Person.new :first_name => "Dean", :last_name => "Wampler", :age => 39
    person.first_name.should == "Dean" 
    person.last_name.should  == "Wampler" 
    person.age.should        == 39
  end
  it "should not accept an array unless it is a [String, String, Integer]" do
    lambda { person = Person.new "Dean", "Wampler", "39" }.should raise_error(Exception)
  end
  it "should not accept a first name that is a zero-length string" do
    lambda { person = Person.new "", "Wampler", 39 }.should raise_error(Exception)
  end    
  it "should not accept a first name that is not a string" do
    lambda { person = Person.new :Dean, "Wampler", 39 }.should raise_error(Exception)
  end    
  it "should not accept a last name that is a zero-length string" do
    lambda { person = Person.new "Dean", "", 39 }.should raise_error(Exception)
  end    
  it "should not accept a last name that is not a string" do
    lambda { person = Person.new :Dean, :Wampler, 39 }.should raise_error(Exception)
  end    
  it "should not accept an age that is less than or equal to zero" do
    lambda { person = Person.new "Dean", "Wampler", -1 }.should raise_error(Exception)
    lambda { person = Person.new "Dean", "Wampler", 0 }.should raise_error(Exception)
  end    
  it "should not accept an age that is not an integer" do
    lambda { person = Person.new :Dean, :Wampler, "39" }.should raise_error(Exception)
  end    
end

We have added validate_name and validate_age methods that are invoked at the end of #initialize. In validate_name, the one when clause requires “all” the conditions to be true, that the name is a string and that it has a non-zero length. Similarly, validate_age has a when clause that requires age to be a positive integer.

Final Thoughts

So, how valuable is this? The code is certainly longer, but it specifies and enforces expected behavior more precisely. The rspec examples verify the enforcement. It smells a little of static typing, which is good or bad, depending on your point of view. ;)

Personally, I think the conditional checks are a good way to add robustness in small ways to libraries that will grow and evolve for a long time. The checks document the required behavior for code readers, like new team members, but of course, they should really get that information from the tests. ;) (However, it would be nice to extract the information into the rdocs.)

For small, short-lived projects, I might not worry about the conditional checks as much (but how many times have those “short-lived projects” refused to die?).

You can read more about Omnibus and Case in this InfoQ interview with MenTaLguY. I didn’t discuss using the Actor model of concurrency, for which these gems were designed. For an example of Actors using Omnibus, see my Better Ruby through Functional Programming presentation or the Confreak’s video of an earlier version of the presentation I gave at last year’s RubyConf.

"Tighter Ruby Methods with Functional-style Pattern Matching, Using the Case Gem" by toms shoes

Wed, 08 Feb 2012 21:33:52 -0600

You will find that toms shoes are comfortable to wear While you can get cheap toms at low price online. Maybe toms last chance shoes will be your favorite.

"Tighter Ruby Methods with Functional-style Pattern Matching, Using the Case Gem" by http://www.jerseyscheapusa.com

Sat, 28 Jan 2012 20:44:31 -0600

cheapjerseysusa ,site http://www.jerseyscheapusa.com , offer cheap nfl jerseys and cheapjerseysusa .our mission is to gain a cheap jerseys sustainable competitive advantage by providing cheap jerseys customers the highest quality jerseys and cheapjerseysusa services. offering all the authentic cheap jerseys , cheap nfl jerseys ,nhl cheap nfl jerseys ,nba jerseys,mlb cheapjerseysusa ,” cheap jerseys Quantity first and customer foremost”is our jerseys top priority. We really hope to expand our cheapjerseysusa business and cheap nfl jerseys through cooperation with cheap jerseys individuals and companies from all over the world.

"Tighter Ruby Methods with Functional-style Pattern Matching, Using the Case Gem" by dealers license

Mon, 23 Jan 2012 04:41:41 -0600

very nice blog i like it and wanna say thank you for sharing it here so keep it up man for your fellows

"Tighter Ruby Methods with Functional-style Pattern Matching, Using the Case Gem" by calcular peso ideal

Sun, 18 Dec 2011 08:30:07 -0600

What a nice piece of ruby code. Love Ruby and Dynamic languages

"Tighter Ruby Methods with Functional-style Pattern Matching, Using the Case Gem" by tv guide

Wed, 07 Dec 2011 14:06:43 -0600

thanks alot. great stuff

"Tighter Ruby Methods with Functional-style Pattern Matching, Using the Case Gem" by Sac Gucci

Thu, 24 Nov 2011 20:23:48 -0600

Conception unique de la Sac Gucci est très sympa,Sac Gucci Soldes sont de qualité fiable et à prix raisonnable.Sac Gucci Pas Cher a été considéré comme un Gucci Soldes signe de tendances de la mode et des Gucci Sac a main sélection symbole de statut social,Gucci Soldes online sélectionnez en ligne un Gucci Pas Cher, facile d’avoir un Sac a Main Gucci Soldes 2011 populaire.Oui,désormais tomber en amour avec Sac Gucci Guccissima.

"Tighter Ruby Methods with Functional-style Pattern Matching, Using the Case Gem" by beats by dr dre

Tue, 15 Nov 2011 18:46:32 -0600

A university studentbeats by dr dre caught by the enemy, the enemy tied him at the poles,just beats solo headphones purple and then asked him: say, where are you? You do not say it electrocuted! Scheap dr.dre beats studio headphones balck/yellowtudents back to the enemy a word, the result was electrocuted, he said: I am TVU.Hot sale beats by dr dre pro headphones

"Tighter Ruby Methods with Functional-style Pattern Matching, Using the Case Gem" by beats by dr dre

Tue, 15 Nov 2011 03:54:23 -0600

"Tighter Ruby Methods with Functional-style Pattern Matching, Using the Case Gem" by christian louboutin

Thu, 03 Nov 2011 11:42:50 -0500

Very interseting , i make the remark of this blog , i will come back again . your blog is very interesting

"Tighter Ruby Methods with Functional-style Pattern Matching, Using the Case Gem" by http://www.uggssale2011.com

Tue, 01 Nov 2011 03:38:34 -0500

UGG Stiefel günstig , dazu neigen schon mal jemand understandthat Regenwälder innerhalb der Rate in 6 entblößt werden , 000 Hektar pro Stunde Es sollte in der Tat eine überraschende Nachricht, dass unsere unerfahrenen Länder auf diese Art von schnellen Ebene abgeschafft werden eher sein, und führen die Menschen herauszufinden, was die schädlichen Auswirkungen ist in der Regel Nun, die Antwort oft Mischung auf yes plus no.Others können, sind überzeugt, dass die Prämisse, auf eine sterbende Welt gut gesagt, während andere Leute den Vorteil, dass solche Elemente könnte wirklich arise.However leugnen, in Fragen etwas wie dieses, haben die Menschen hat zu glauben, nur von einem Ding gewonnen, und das ist genau das: Regenwald Abholzung würde es über eine etwas höhere Geschwindigkeit und auch seine besondere schädliche Vorteile sind fast unstoppable.We Diskussion der Entwaldung jeden Tag noch wir nie bemerken es die schnelle Ankunft Tempo. Vielleicht ist es als Folge des Mannes fahrlässig, dass andere bestehen zu zerstören, ohne zu sehen Ihr Potential Ergebnisse ihrer dient könnte carry.Man kann nur wahrscheinlich bereuen, wenn die Dinge zu sein, die sie betreffen auf diese Weise dazu neigen, dass sie alle zu einem fabelhaften Störung so etwas wie ein guter Alltags living.By Beobachten und Sehen und Hören die wahrscheinlichen Ergebnisse in Entwaldung, muss eine haben Seiten im Inneren der Auswahl unter den guten und bösen.

"Tighter Ruby Methods with Functional-style Pattern Matching, Using the Case Gem" by canada goose jakke

Mon, 31 Oct 2011 10:33:35 -0500

Very interseting , i make the remark of this blog , i will come back again . your blog is very interesting

"Tighter Ruby Methods with Functional-style Pattern Matching, Using the Case Gem" by Nike run free

Mon, 31 Oct 2011 10:31:47 -0500

Pretty good post. I just stumbled upon your blog and wanted to say that I have really enjoyed reading your blog

"Tighter Ruby Methods with Functional-style Pattern Matching, Using the Case Gem" by vendita scarpe mbt

Mon, 31 Oct 2011 10:29:55 -0500

real a good post , i am very like it , will come back again

"Tighter Ruby Methods with Functional-style Pattern Matching, Using the Case Gem" by flac converter

Thu, 27 Oct 2011 02:48:09 -0500

Thank you for sharing, I’ll definitely dig deeper into it.

"Tighter Ruby Methods with Functional-style Pattern Matching, Using the Case Gem" by ysbearing

Wed, 19 Oct 2011 03:11:46 -0500

Slewing bearing called slewing ring bearings, is a comprehensive load to bear a large bearing, can bear large axial, radial load and overturning moment.

"Tighter Ruby Methods with Functional-style Pattern Matching, Using the Case Gem" by Ashley Bowling

Sat, 15 Oct 2011 15:40:43 -0500

Better late than never Better safe than sorry Better the Devil you know than the Devil you don’t

"Tighter Ruby Methods with Functional-style Pattern Matching, Using the Case Gem" by Evering2010

Sat, 15 Oct 2011 04:08:53 -0500

Thank you for sharing them with us , I think it’s worth reading

"Tighter Ruby Methods with Functional-style Pattern Matching, Using the Case Gem" by christianlouboutin

Fri, 16 Sep 2011 22:27:56 -0500

All among us realise that if you MBT boots or shoes within get hold of, Jimmy Choo Sandaleseducation-women’ vertisements mbt tunisha providing may easily really encourages lymphatic circulation,Jimmy Choo Bottines you’ chemical in all probability more significant receive boots or shoes clearance retail store as a result of MBT while it a good number of at no cost submitting in combination with MBT boots or shoes are almost always pay for and also profit designed notnaxcanada goose outlet.

A particular low-priced MBT Nama Boots and shoes out of a number of online space boots and shoes plus boot footwear MBT great bargains preferred now in now would be to simply and even safely mbt sandals pay for consumers pay for progressively more over the internetcanada goose jakke, have MBT footwear and remaining grown to be a sample. MBT boots providing now, ways to explain any one preventthe north face
? Brand-new assumed to test a person's MBT boots pay for, generate a test? My wife and i reassurance any one, we have a special working experienceNorth Face Denali Jakker Kvinder hoodie
.

"Tighter Ruby Methods with Functional-style Pattern Matching, Using the Case Gem" by Uniformes De Fútbol

Fri, 16 Sep 2011 07:20:44 -0500

I really like your article. Please keep on writing excellent posts. To find out more please go to http://baratasfutbolcamiseta.es/ http://baratasfutbolcamiseta.es/category.php?id=9 http://baratasfutbolcamiseta.es/goods.php?id=76 http://www.camisetas-de-futbol.es/ http://www.camisetas-de-futbol.es/category-66-b0-FIFA+del+Copa+del+Mundo.html http://www.camisetas-de-futbol.es/goods-4080-10+11+Holland+Tercel+Blanco+camiseta+del+futbol.html http://www.camisetasfutbolchina.es/ http://www.camisetasfutbolchina.es/category-122-b0-Real+Madrid.html http://www.camisetasfutbolchina.es/goods-4605-11+12+England+Titular+Blando+camiseta+del+futbol.html

"Tighter Ruby Methods with Functional-style Pattern Matching, Using the Case Gem" by dvd ripper

Sun, 11 Sep 2011 07:16:54 -0500

good post, i think so.Thank you!

"Tighter Ruby Methods with Functional-style Pattern Matching, Using the Case Gem" by cheap beats by dre uk

Sun, 28 Aug 2011 21:57:24 -0500

good post

"Tighter Ruby Methods with Functional-style Pattern Matching, Using the Case Gem" by beats by dre store

Tue, 23 Aug 2011 03:06:08 -0500

I really enjoyed reading it and will certainly share this post with my friendshigh quality headphones new design headphones

"Tighter Ruby Methods with Functional-style Pattern Matching, Using the Case Gem" by onlyshox

Mon, 22 Aug 2011 02:42:28 -0500

Fantastic post. Your post was that great, keep it up.

"Tighter Ruby Methods with Functional-style Pattern Matching, Using the Case Gem" by Crystal Jewellery

Thu, 18 Aug 2011 13:09:54 -0500

Great post! Nice and informative, I really enjoyed reading it and will certainly share this post with my friends . Learn everything about what is cubic zirconia

"Tighter Ruby Methods with Functional-style Pattern Matching, Using the Case Gem" by dentist in houston

Wed, 17 Aug 2011 22:10:14 -0500

This is an wonderful article which mentioned the important program code by using Tighter Ruby Methods .IT is really a helpful article. I like it so so.