pattern-proc

pattern matching Proc definitions

pattern-proc is a Ruby gem designed to allow creation of pattern-matching procs in a repeated declaration mechanism similar to Haskell.

Usage:

require 'pattern-proc'

• manually instantiate a proc

  cool_proc = PatternProc.new cool_proc.with(5,10).returns(30) cool_proc.with(3,70).returns(111) cool_proc.with(3) do |second_arg| second_arg * 10 end cool_proc.with do |first_arg, second_arg| do first_arg * second_arg end

  # later...

  regular_proc = cool_proc.to_proc regular_proc.(5,10) > 30 regular_proc.(3).(70) > 111 regular_proc.(3).(15) > 150 # second_arg * 10 case regular_proc.(5,5) > 25 # first_arg * second_arg case

• declare methods in a class

  class MyClass include PatternProc::ClassMethods

  pattern(:my_func).with(3,10).returns(30)
  pattern(:my_func).with(4,11).returns(40)
  

  end

  # later...

  obj = MyClass.new obj.my_func(3,10) > 30 obj.my_func(4).(11) > 40

  # or

  class MySingletonClass class << self include PatternProc::ClassMethods pattern(:my_class_func).with(:a, :b).returns(:c) pattern(:my_class_func).with(:c) do |other| other.to_s end end end

• "mock" out Funkify-style partial application methods in tests

  include PatternProc::TestMethods

  describe 'something' do it '"mocks" methods' do mock_obj = mock 'anything' mock_obj.pattern(:my_func).with(1,2).returns(10) mock_obj.pattern(:my_func).with(1) do |x| x + 3 end

    mock_obj.my_func(1).(2).should == 10
    mock_obj.my_func(1,5).should == 8
  
    SomeClass.pattern(:existing_func).with("hello").returns("goodbye")
  
    SomeClass.exsting_func("hello").should == "goodbyes"
  end
  

  end

This gem was initially created to ease testing when using the Funkify gem, as is most clear in the last example. However I would like to build on this library and make the ClassMethods "DSL" more robust. Additionally, right now pattern matching is done by specificity rather than declaration order, and you can only define a proc implementation for the rightmost N arguments (as opposed to any set of arguments, eg.

do_stuff 5 x = x * 2

in Haskell). Finally I would like PatternProc to subclass Proc directly rather than requiring a call to to_proc.