Coming soon...

(This is a snapshot of my old weblog. New posts and selected republished essays can be found at raganwald.com.)

Thursday, March 15, 2007


require "test/unit"

class TestComprehension < Test::Unit::TestCase
  
  def test_simple_cases
    with Comprehension::DSL do
      assert_equal(
          [1, 2, 3],
          list { x + 1 }.given(:x => 0..2) )
      assert_equal(
          [[0, :a], [0, :b], [1, :a], [1, :b]],
          list { [x, y] }.given(:x => [0, 1], :y => [:a, :b]) )
      assert_equal(
          [2, 4, 6, 8, 10],
          list { x }.given(:x => 1..10) { x % 2 == 0 } )
    end
  end
  
  def plus_seven num
    num + 7
  end
  
  def times_maker num
    lambda { x * num }
  end
  
  def test_closure_cases
    two = 2
    triple = times_maker(3)
    with Comprehension::DSL do
      assert_equal(
          [2, 4, 6],
          list { x * two }.given(:x => 1..3) )
      assert_equal(
          [3, 6, 9],
          list(&triple).given(:x => 1..3) )
      assert_equal(
          [8, 9, 10],
          list { plus_seven(x) }.given(:x => 1..3) )
    end
  end
  
end

March 16, 2007: An Approach to Composing Domain-Specific Languages in Ruby

Labels: ruby

¶ 12:45 AM

Comments on “Coming soon...”:

This better be FizzBuzz related, or I'm demanding a complete refund.

# posted by

Jeff Atwood : 1:43 AM

I presume that you're running the 'value' block, e.g. { [x,y] } with an internal binding that includes variables made from :x, :y. Although this lets you omit the |x,y| noise, won't it stop you from using closure blocks?

# posted by

Steve : 2:55 AM

The very moment you use a modulus operator, someone has to ask about FizzBuzz...

Seriously, I did consider writing a post about how the value of a piece of code lies in what you learned writing it not, in its final form.

So if someone hands you a list comprehensions gem and you write FizzBuzz in it, you learn a little if you have never used comprehensions in languages like Python or Haskell before.

Or if you actually write a comprehensions gem... you learn even more!

# posted by

Reginald Braithwaite : 6:37 AM

Steve:

Although this lets you omit the |x,y| noise, won't it stop you from using closure blocks?

Do you mean, won't it stop me from using another variable captured from its surrounding lexical scope?

Or do you mean, won't it stop me from using a block purloined from somewhere else as a first-class value?

Either way, answers coming up very shortly in the form of more unit tests.

Thanks for either question, and if you were actually thinking of another case entirely, please write back, either with a suggested test case or a simple explanation.

# posted by

Reginald Braithwaite : 6:40 AM

I was thinking of the first case, imagining that I would like to use a local method within the 'value' block. Looking forward to seeing what you come up with, because this is a neat hack.

# posted by

Steve : 12:40 PM

Steve:

Well, lookitthat! The exact case you suggest works as well as the two cases I thought you might have been suggesting.

Everything works right out of the box so far. The reason why they work is that the blocks for "mapping" and "selecting" the comprehension both have let semantics.

Not let as in Scheme, but the version of let I wrote as part of my DomainSpecificLanguages package handles these cases. The Comprehensions DSL dynamically generates lets. A little like a macro that writes a macro that write lambdas in Lisp.

Only it's more of a kludge than a hack ;-)

# posted by

Reginald Braithwaite : 12:57 PM

<< Home