do_notation 0.2.0 → 0.3.0

data/.gitignore

@@ -3,3 +3,4 @@ coverage
 doc
 *.tmproj
 *.gem
+Gemfile.lock

data/.rspec

@@ -0,0 +1 @@
+--colour

data/.travis.yml

@@ -0,0 +1,5 @@
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+gemspec
+

data/{README.rdoc → README.md}

@@ -1,4 +1,5 @@
-= Haskell-style monad do-notation for Ruby
+Haskell-style monad do-notation for Ruby
+========================================
 
 Example:
 
@@ -6,20 +7,20 @@ Example:
 
     class Array
       include Monad
-      
+
       def self.unit x
         [x]
       end
-      
+
       def bind &f
-        map(&f).inject([]){ |a,b| a+b }
+        map(&f).inject([], &:+)
       end
     end
-    
+
     Array.run do
       x <- ["first", "second"]
       y <- ["once", "twice"]
-  
+
       unit("#{x} cousin #{y} removed")
     end
 
@@ -32,11 +33,9 @@ The above code returns the array:
 
 For more examples, see the test suite.
 
-== Installation
-
-There's a gem hosted on Github, so follow the setup instructions
-at http://gems.github.com and then run:
+Installation
+============
 
-    sudo gem install aanand-ruby-do-notation
+    gem install do_notation
 
 By Aanand Prasad (aanand.prasad@gmail.com)

data/Rakefile

@@ -1,32 +1,11 @@
-require 'spec/rake/spectask'
-
-spec_list = FileList['test/*.rb']
+require 'rspec/core/rake_task'
 
 task :default => :spec
 
 desc "Run all specs"
-Spec::Rake::SpecTask.new('spec') do |t|
-  t.spec_files = spec_list
-end
+RSpec::Core::RakeTask.new('spec')
 
 desc "Run all specs with RCov"
-Spec::Rake::SpecTask.new('rcov') do |t|
-  t.spec_files = spec_list
+RSpec::Core::RakeTask.new('rcov') do |t|
   t.rcov = true
 end
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gemspec|
-    gemspec.name = "do_notation"
-    gemspec.summary = 'Haskell-style monad do-notation for Ruby'
-    gemspec.description = 'Haskell-style monad do-notation for Ruby'
-    gemspec.email = 'aanand.prasad@gmail.com'
-    gemspec.homepage = 'http://github.com/aanand/do_notation'
-    gemspec.authors = ["Aanand Prasad"]
-    gemspec.add_dependency('ParseTree')
-    gemspec.add_dependency('ruby2ruby', '1.1.9')
-  end
-rescue LoadError
-  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
-end

data/do_notation.gemspec

@@ -0,0 +1,14 @@
+Gem::Specification.new do |s|
+  s.name     = "do_notation"
+  s.version  = "0.3.0"
+  s.summary  = 'Haskell-style monad do-notation for Ruby'
+  s.email    = 'aanand.prasad@gmail.com'
+  s.homepage = 'https://github.com/aanand/do_notation'
+  s.authors  = ["Aanand Prasad"]
+
+  s.files = `git ls-files`.split
+
+  s.add_dependency('sourcify')
+  s.add_development_dependency('rake')
+  s.add_development_dependency('rspec', '~> 2.0')
+end

data/lib/do_notation.rb

@@ -1,12 +1,39 @@
-$: << File.dirname(__FILE__)
+require 'sourcify'
 
-require 'rubygems'
+module DoNotation
+  def self.run(klass, &block)
+    eval(ruby_for(klass, block), block.binding).call
+  end
 
-gem 'ruby2ruby', '1.1.9'
+  def self.ruby_for(klass, block)
+    "#{klass.name}.instance_eval { #{ruby_for_block(block)} }"
+  end
 
-require 'parse_tree'
-require 'sexp_processor'
-require 'ruby2ruby'
+  def self.ruby_for_block(block)
+    @cached_ruby ||= {}
+    @cached_ruby[block.to_s] ||= Ruby2Ruby.new.process(DoNotation::Rewriter.new.process(block.to_sexp))
+  end
+
+  def self.pp(obj, indent='')
+    return obj.inspect unless obj.is_a? Array
+    return '()' if obj.empty?
+
+    str = '(' + pp(obj.first, indent + ' ')
+
+    if obj.length > 1
+      str << ' '
+
+      next_indent = indent + (' ' * str.length)
+
+      str << obj[1..-1].map{ |o| pp(o, next_indent) }.join("\n#{next_indent}")
+    end
+
+    str << ')'
+
+    str
+  end
+end
 
 require 'do_notation/rewriter'
 require 'do_notation/monad'
+

data/lib/do_notation/monad.rb

@@ -1,24 +1,13 @@
 module Monad
-  module ClassMethods
-    def run &block
-      eval(ruby_for(block), block).call
-    end
-
-    def ruby_for block
-      @cached_ruby ||= {}
-      @cached_ruby[block.to_s] ||= "#{self.name}.instance_eval { #{Ruby2Ruby.new.process(Rewriter.new.process(block.to_method.to_sexp)[2])} }"
-    end
-  end
-
-  def bind_const &block
-    bind { |_| block.call() }
+  def run &block
+    DoNotation.run(self, &block)
   end
 
-  def >> n
-    bind_const { n }
+  def bind_const value, &block
+    bind(value) { block.call }
   end
 
-  def self.included m
-    m.extend ClassMethods
+  def compose a, b
+    bind_const(a) { b }
   end
 end

data/lib/do_notation/monads/array.rb

@@ -1,21 +1,24 @@
+require 'do_notation'
 require 'do_notation/monad_plus'
 
 class Array
-  include Monad
+  extend Monad
 
   def self.unit x
     [x]
   end
-  
-  def bind &f
-    map(&f).inject([]){ |a,b| a+b }
+
+  def self.bind value, &f
+    value.map(&f).inject([], &:+)
   end
-  
+
   extend MonadPlus
-  
+
   def self.mzero
     []
   end
-  
-  alias_method :mplus, :+
+
+  def self.mplus(a, b)
+    a + b
+  end
 end

data/lib/do_notation/monads/identity.rb

@@ -0,0 +1,16 @@
+require 'do_notation'
+
+module Identity
+  extend Monad
+
+  class << self
+    def unit(obj)
+      obj
+    end
+
+    def bind(obj, &fn)
+      fn.call(obj)
+    end
+  end
+end
+

data/lib/do_notation/monads/maybe.rb

@@ -1,31 +1,32 @@
+require 'do_notation'
 require 'do_notation/monad_plus'
 
-class Maybe < Struct.new(:value)
-  include Monad
-  
+class Maybe
+  extend Monad
+
   def self.unit value
-    self.new(value)
+    value
   end
-  
-  def bind &f
+
+  def self.bind value, &f
     if value.nil?
-      self
+      nil
     else
       f.call(value)
     end
   end
-  
+
   extend MonadPlus
-  
+
   def self.mzero
     unit(nil)
   end
-  
-  def mplus m
-    if value.nil?
-      m
+
+  def self.mplus a, b
+    if b.nil?
+      a
     else
-      self
+      b
     end
   end
 end

data/lib/do_notation/monads/simulations.rb

@@ -2,37 +2,39 @@
 # http://eigenclass.org/hiki/warm-fuzzy-things-for-random-simulations
 # http://eigenclass.org/hiki.rb?c=plugin;plugin=attach_download;p=warm-fuzzy-things-for-random-simulations;file_name=fuzzy-warm-simulations.rb
 
-module PRNG 
+require 'do_notation'
+
+module PRNG
   def next_state(s); (69069 * s + 5) % (2**32) end
 end
 
 class Simulation
   extend PRNG
-  include Monad
-  
+  extend Monad
+
   attr_reader :f
 
   def initialize(&b)
     @f = b
   end
-  
+
   def self.unit(x)
     new { |s| [x, s] }
   end
-  
+
   def self.rand(n)
     self.new do |s|
       [s.abs % n, next_state(s)]
     end
   end
 
-  def bind(&b)
-    self.class.new do |s|
-      x, s = @f.call(s)
+  def self.bind(simulation, &b)
+    self.new do |s|
+      x, s = simulation.f.call(s)
       b.call(x).f.call(s)
     end
   end
-  
+
   def play(s = 12345)
     @f.call(s).first
   end
@@ -40,33 +42,33 @@ end
 
 class Distribution
   extend PRNG
-  include Monad
-  
+  extend Monad
+
   attr_reader :a
 
   def initialize(a)
     @a = a
   end
-  
+
   def self.wrap(a)
     new(a)
   end
-  
+
   def self.unit(x)
     wrap [[x, 1.0]]
   end
 
-  def self.rand(n) 
+  def self.rand(n)
     p = 1.0 / n
     new((0...n).map{|i| [i, p]})
   end
 
-  def bind(&b)
-    if @a.empty?
-      self.class.wrap([])
+  def self.bind(distribution, &b)
+    if distribution.a.empty?
+      wrap([])
     else
-      x, p = @a[0]
-      self.class.wrap(mulp(p, b.call(x)) + self.class.new(@a[1..-1]).bind(&b).a)
+      x, p = distribution.a[0]
+      wrap(mulp(p, b.call(x)) + bind(self.new(distribution.a[1..-1]), &b).a)
     end
   end
 
@@ -77,21 +79,21 @@ class Distribution
   end
 
   private
-  def mulp(p, l)
+  def self.mulp(p, l)
     l.a.map{|x, p1| [x, p * p1]}
   end
 end
 
 class Expectation
   extend PRNG
-  include Monad
-  
+  extend Monad
+
   attr_reader :f
 
   def initialize(&b)
     @f = b
   end
-  
+
   def self.wrap(&proc)
     new(&proc)
   end
@@ -107,8 +109,8 @@ class Expectation
     end
   end
 
-  def bind(&b)
-    self.class.wrap{|k| @f.call(lambda{|x| b.call(x).f.call(k)}) }
+  def self.bind(expectation, &b)
+    wrap{|k| expectation.f.call(lambda{|x| b.call(x).f.call(k)}) }
   end
 
   def play(x)

data/lib/do_notation/rewriter.rb

@@ -1,63 +1,45 @@
-class Rewriter < SexpProcessor
-  def process_bmethod exp
-    type = exp.shift
-  
-    exp.shift # throw away arguments
-  
-    body = process(exp.shift)
-  
-    if body[0] == :block
-       body.shift
+class DoNotation::Rewriter
+  def process exp
+    raise ArgumentError, "expected :iter, got #{exp[0].inspect}"                             unless exp[0] == :iter
+    raise ArgumentError, "expected s(:call, nil, :proc, s(:arglist)), got #{exp[1].inspect}" unless exp[1] == s(:call, nil, :proc, s(:arglist))
+    raise ArgumentError, "expected nil, got #{exp[2].inspect}"                               unless exp[2] == nil
+
+    if exp[3].is_a?(Sexp) and exp[3][0] == :block
+      iter, call, nil_val, block = exp.shift, exp.shift, exp.shift, exp.shift
+      raise ArgumentError, "unexpected extra syntax: #{exp.inspect}" unless exp.empty?
+      s(iter, call, nil_val, *rewrite_assignments(block[1..-1]))
     else
-       body = s([*body])
+      exp
     end
-
-    s(:iter,  s(:fcall, :proc),  nil, *rewrite_assignments(body))
   end
 
   def rewrite_assignments exp
     return [] if exp.empty?
-  
+
     head = exp.shift
-  
-    if head.first == :call and head[1].first == :vcall and head[2] == :< and head[3].first == :array and head[3][1].last == :-@
-      var_name = head[1][1]
+
+
+    if head[0] == :call and head[1] and head[1][0] == :call and head[2] == :< and head[3][0] == :arglist and head[3][1][2] == :-@
+      var_name = head[1][2]
       expression = head[3][1][1]
-    
+
       body = rewrite_assignments(exp)
-    
+
       if body.first.is_a? Symbol
         body = [s(*body)]
       end
-    
+
       [s(:iter,
-         s(:call, process(expression), :bind),
-         s(:dasgn_curr, var_name),
+         s(:call, nil, :bind, s(:arglist, expression)),
+         s(:lasgn, var_name),
          *body)]
     elsif exp.empty?
-      [process(head)]
+      [head]
     else
-      [s(:iter, s(:call, process(head)  , :bind_const), nil , 
-             *rewrite_assignments(exp)) ]
-    end
-  end
-
-  def self.pp(obj, indent='')
-    return obj.inspect unless obj.is_a? Array
-    return '()' if obj.empty?
-
-    str = '(' + pp(obj.first, indent + ' ')
-
-    if obj.length > 1
-      str << ' '
-
-      next_indent = indent + (' ' * str.length)
-
-      str << obj[1..-1].map{ |o| pp(o, next_indent) }.join("\n#{next_indent}")
+      [s(:iter,
+         s(:call, nil, :bind_const, s(:arglist, head)),
+         nil,
+         *rewrite_assignments(exp))]
     end
-
-    str << ')'
-
-    str
   end
 end

data/{test/array.rb → spec/array_spec.rb}

@@ -6,8 +6,8 @@ describe "Array:" do
     array = Array.run do
       x <- ["first", "second"]
       y <- ["once", "twice"]
-  
-      unit("#{x} cousin #{y} removed")
+
+      ["#{x} cousin #{y} removed"]
     end
 
     array.should == ["first cousin once removed",

data/spec/do_notation_spec.rb

@@ -0,0 +1,16 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "DoNotation.pp" do
+  specify "should produce correct output" do
+    array = [:a, [:b],
+                 [:c, :d,
+                      :e]]
+
+    DoNotation.pp(array).should == <<CODE.strip
+(:a (:b)
+    (:c :d
+        :e))
+CODE
+  end
+end
+

data/spec/identity_spec.rb

@@ -0,0 +1,27 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+require 'do_notation/monads/identity'
+
+describe "Identity:" do
+  specify "just works like sequential code" do
+    value = Identity.run do
+      x <- 1
+      y <- 2
+
+      x + y
+    end
+
+    value.should == 3
+  end
+
+  specify "doesn't do anything special with nil" do
+    lambda {
+      value = Identity.run do
+        x <- 1
+        y <- nil
+
+        x + y
+      end
+    }.should raise_error(TypeError)
+  end
+end
+

data/{test/maybe.rb → spec/maybe_spec.rb}

@@ -3,24 +3,24 @@ require 'do_notation/monads/maybe'
 
 describe "Maybe:" do
   specify "one or more nils results in nil" do
-    maybe = Maybe.run do
-      x <- unit(1)
-      y <- unit(nil)
-  
-      unit(x+y)
+    value = Maybe.run do
+      x <- 1
+      y <- nil
+
+      x + y
     end
 
-    maybe.value.should == nil
+    value.should == nil
   end
 
   specify "all non-nil results in complete calculation" do
-    maybe = Maybe.run do
-      x <- unit(1)
-      y <- unit(2)
-  
-      unit(x+y)
+    value = Maybe.run do
+      x <- 1
+      y <- 2
+
+      x + y
     end
-    
-    maybe.value.should == 3
+
+    value.should == 3
   end
 end

data/spec/monad_plus_spec.rb

@@ -0,0 +1,37 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+require 'do_notation/monads/array'
+require 'do_notation/monads/maybe'
+
+describe "MonadPlus:" do
+  [Maybe, Array].each do |monad|
+    describe monad do
+      specify "mzero >>= f = mzero" do
+        monad.bind(monad.mzero){ |x| unit(x+1) }.should == monad.mzero
+      end
+
+      specify "v >> mzero = mzero" do
+        monad.compose(monad.unit(1), monad.mzero).should == monad.mzero
+      end
+
+      specify "mzero `mplus` m = m" do
+        monad.mplus(monad.mzero, monad.unit(1)).should == monad.unit(1)
+      end
+
+      specify "m `mplus` mzero = m" do
+        monad.mplus(monad.unit(1), monad.mzero).should == monad.unit(1)
+      end
+    end
+  end
+
+  specify "guard() prunes the execution tree" do
+    array = Array.run do
+      x <- [0,1,2,3]
+      y <- [0,1,2,3]
+      guard(x + y == 3)
+
+      unit([x,y])
+    end
+
+    array.should == [[0, 3], [1, 2], [2, 1], [3, 0]]
+  end
+end

data/{test/specs.rb → spec/monad_spec.rb}

@@ -1,5 +1,7 @@
 require File.join(File.dirname(__FILE__), 'spec_helper')
+
 require 'do_notation/monads/array'
+require 'do_notation/monads/maybe'
 
 describe "Monad.run" do
   specify "should have lexical scope" do
@@ -10,7 +12,7 @@ describe "Monad.run" do
       x <- ["first", "second"]
       y <- ["once", "twice"]
 
-      unit("#{x} #{foo} #{y} #{bar}")
+      ["#{x} #{foo} #{y} #{bar}"]
     end
 
     array.should == ["first cousin once removed",
@@ -18,26 +20,38 @@ describe "Monad.run" do
                      "second cousin once removed",
                      "second cousin twice removed"]
   end
-  
+
+  it "can be run on the same block multiple times, using different monads" do
+    block = proc do
+      x <- unit(1)
+      y <- unit(2)
+      unit(x+y)
+    end
+
+    [Identity, Maybe, Array].each do |monad|
+      monad.run(&block).should == monad.unit(3)
+    end
+  end
+
   specify "should be nestable" do
     array = Array.run do
       x <- run do
         a <- ['A','a']
         b <- ['B','b']
 
-        unit(a+b)
+        [a+b]
       end
 
       y <- run do
         c <- ['C','c']
         d <- ['D','d']
 
-        unit(c+d)
+        [c+d]
       end
 
-      unit(x+y)
+      [x+y]
     end
-    
+
     array.should == ["ABCD", "ABCd", "ABcD", "ABcd",
                      "AbCD", "AbCd", "AbcD", "Abcd",
                      "aBCD", "aBCd", "aBcD", "aBcd",
@@ -45,22 +59,9 @@ describe "Monad.run" do
   end
 end
 
-describe 'Monad#>>' do
+describe 'compose' do
   specify "should compose two values, discarding the first" do
-    ([1] >> [2]).should == [2]
+    Array.compose([1], [2]).should == [2]
   end
 end
 
-describe "Rewriter.pp" do
-  specify "should produce correct output" do
-    array = [:a, [:b],
-                 [:c, :d,
-                      :e]]
-
-    Rewriter.pp(array).should == <<CODE.strip
-(:a (:b)
-    (:c :d
-        :e))
-CODE
-  end
-end

data/spec/rewriter_spec.rb

@@ -0,0 +1,68 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "Rewriter" do
+  it "leaves uninteresting blocks alone" do
+    in_block  = proc { x + y }
+    out_block = proc { x + y }
+
+    process(in_block.to_sexp).should == out_block.to_sexp
+  end
+
+  it "rewrites the <- operator" do
+    in_block  = proc do
+      x <- 1
+      y
+    end
+
+    out_block = proc do
+      bind 1 do |x|
+        y
+      end
+    end
+
+    process(in_block.to_sexp).should == out_block.to_sexp
+  end
+
+  it "rewrites multiple <- operators" do
+    in_block  = proc do
+      x <- 1
+      y <- 2
+      z
+    end
+
+    out_block = proc do
+      bind 1 do |x|
+        bind 2 do |y|
+          z
+        end
+      end
+    end
+
+    process(in_block.to_sexp).should == out_block.to_sexp
+  end
+
+  it "rewrites statements without a <- to use bind_const" do
+    in_block  = proc do
+      x <- 1
+      do_something
+      y <- 2
+      z
+    end
+
+    out_block = proc do
+      bind 1 do |x|
+        bind_const(do_something) do
+          bind 2 do |y|
+            z
+          end
+        end
+      end
+    end
+
+    process(in_block.to_sexp).should == out_block.to_sexp
+  end
+
+  def process(sexp)
+    DoNotation::Rewriter.new.process(sexp)
+  end
+end

data/spec/simulations_spec.rb

@@ -0,0 +1,65 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+require 'do_notation/monads/simulations'
+
+EPSILON = 0.001
+
+RSpec::Matchers.define :approximate_floats do |expected|
+  match do |actual|
+    all_approximate?(actual, expected)
+  end
+
+  def all_approximate?(actual, expected)
+    case actual
+    when Array
+      actual.zip(expected).all? { |pair| all_approximate?(pair.first, pair.last) }
+    when Float
+      (expected - actual).abs < EPSILON
+    else
+      expected == actual
+    end
+  end
+end
+
+roll_3d6 = proc do
+  d1 <- rand(6)
+  d2 <- rand(6)
+  d3 <- rand(6)
+
+  unit(1+d1 + 1+d2 + 1+d3)
+end
+
+roll_3d6_b = proc do
+  d1 <- rand(6)
+  d2 <- rand(6)
+  d3 <- rand(6)
+
+  if [d1, d2, d3].include?(5)
+    run do
+      d4 <- rand(6)
+      unit(1+d1 + 1+d2 + 1+d3 + 1+d4)
+    end
+  else
+    unit(1+d1 + 1+d2 + 1+d3)
+  end
+end
+
+describe "Simulation" do
+  specify "generates correct answers" do
+    Simulation.run(&roll_3d6).play.should   == 9
+    Simulation.run(&roll_3d6_b).play.should == 9
+  end
+end
+
+describe "Distribution" do
+  specify "generates correct answers" do
+    Distribution.run(&roll_3d6).play.should approximate_floats([[3, 0.005], [4, 0.014], [5, 0.028], [6, 0.046], [7, 0.069], [8, 0.097], [9, 0.116], [10, 0.125], [11, 0.125], [12, 0.116], [13, 0.097], [14, 0.069], [15, 0.046], [16, 0.028], [17, 0.014], [18, 0.005]])
+    Distribution.run(&roll_3d6_b).play.should approximate_floats([[3, 0.005], [4, 0.014], [5, 0.028], [6, 0.046], [7, 0.069], [8, 0.083], [9, 0.09], [10, 0.09], [11, 0.083], [12, 0.069], [13, 0.063], [14, 0.06], [15, 0.058], [16, 0.056], [17, 0.053], [18, 0.046], [19, 0.035], [20, 0.024], [21, 0.015], [22, 0.008], [23, 0.003], [24, 0.001]])
+  end
+end
+
+describe "Expectation" do
+  specify "generates correct answers" do
+    (1..21).collect { |x| Expectation.run(&roll_3d6).play(x) }.should approximate_floats([0.0, 0.0, 0.005, 0.014, 0.028, 0.046, 0.069, 0.097, 0.116, 0.125, 0.125, 0.116, 0.097, 0.069, 0.046, 0.028, 0.014, 0.005, 0.0, 0.0, 0.0])
+    (1..21).collect { |x| Expectation.run(&roll_3d6_b).play(x) }.should approximate_floats([0.0, 0.0, 0.005, 0.014, 0.028, 0.046, 0.069, 0.083, 0.09, 0.09, 0.083, 0.069, 0.063, 0.06, 0.058, 0.056, 0.053, 0.046, 0.035, 0.024, 0.015])
+  end
+end

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: do_notation
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  hash: 19
+  prerelease: 
+  segments: 
+  - 0
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Aanand Prasad
@@ -9,90 +15,116 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-29 00:00:00 -04:00
-default_executable: 
+date: 2011-11-14 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: ParseTree
+  name: sourcify
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
   type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
         version: "0"
-    version: 
+  type: :development
+  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: ruby2ruby
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
-    - - "="
+    - - ~>
       - !ruby/object:Gem::Version 
-        version: 1.1.9
-    version: 
-description: Haskell-style monad do-notation for Ruby
+        hash: 3
+        segments: 
+        - 2
+        - 0
+        version: "2.0"
+  type: :development
+  version_requirements: *id003
+description: 
 email: aanand.prasad@gmail.com
 executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- README.rdoc
+extra_rdoc_files: []
+
 files: 
 - .gitignore
-- Manifest
-- README.rdoc
+- .rspec
+- .travis.yml
+- Gemfile
+- README.md
 - Rakefile
-- VERSION
-- do-notation.gemspec
+- do_notation.gemspec
 - lib/do_notation.rb
 - lib/do_notation/monad.rb
 - lib/do_notation/monad_plus.rb
 - lib/do_notation/monads/array.rb
+- lib/do_notation/monads/identity.rb
 - lib/do_notation/monads/maybe.rb
 - lib/do_notation/monads/simulations.rb
 - lib/do_notation/rewriter.rb
-- ruby-do-notation.gemspec
-- test/array.rb
-- test/maybe.rb
-- test/monad_plus.rb
-- test/simulations.rb
-- test/spec_helper.rb
-- test/specs.rb
-has_rdoc: true
-homepage: http://github.com/aanand/do_notation
+- spec/array_spec.rb
+- spec/do_notation_spec.rb
+- spec/identity_spec.rb
+- spec/maybe_spec.rb
+- spec/monad_plus_spec.rb
+- spec/monad_spec.rb
+- spec/rewriter_spec.rb
+- spec/simulations_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/aanand/do_notation
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.4
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Haskell-style monad do-notation for Ruby
-test_files: 
-- test/array.rb
-- test/maybe.rb
-- test/monad_plus.rb
-- test/simulations.rb
-- test/spec_helper.rb
-- test/specs.rb
+test_files: []
+

data/Manifest

@@ -1,15 +0,0 @@
-lib/do_notation/monad.rb
-lib/do_notation/monad_plus.rb
-lib/do_notation/monads/array.rb
-lib/do_notation/monads/maybe.rb
-lib/do_notation/monads/simulations.rb
-lib/do_notation/rewriter.rb
-lib/do_notation.rb
-README.rdoc
-test/array.rb
-test/maybe.rb
-test/monad_plus.rb
-test/simulations.rb
-test/spec_helper.rb
-test/specs.rb
-Manifest

data/VERSION

@@ -1 +0,0 @@
-0.2.0

data/do-notation.gemspec

@@ -1,67 +0,0 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE
-# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = %q{do-notation}
-  s.version = "0.2.0"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Aanand Prasad"]
-  s.date = %q{2009-09-29}
-  s.description = %q{Haskell-style monad do-notation for Ruby}
-  s.email = %q{aanand.prasad@gmail.com}
-  s.extra_rdoc_files = [
-    "README.rdoc"
-  ]
-  s.files = [
-    ".gitignore",
-     "Manifest",
-     "README.rdoc",
-     "Rakefile",
-     "lib/do_notation.rb",
-     "lib/do_notation/monad.rb",
-     "lib/do_notation/monad_plus.rb",
-     "lib/do_notation/monads/array.rb",
-     "lib/do_notation/monads/maybe.rb",
-     "lib/do_notation/monads/simulations.rb",
-     "lib/do_notation/rewriter.rb",
-     "ruby-do-notation.gemspec",
-     "test/array.rb",
-     "test/maybe.rb",
-     "test/monad_plus.rb",
-     "test/simulations.rb",
-     "test/spec_helper.rb",
-     "test/specs.rb"
-  ]
-  s.homepage = %q{http://github.com/aanand/do-notation}
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.4}
-  s.summary = %q{Haskell-style monad do-notation for Ruby}
-  s.test_files = [
-    "test/array.rb",
-     "test/maybe.rb",
-     "test/monad_plus.rb",
-     "test/simulations.rb",
-     "test/spec_helper.rb",
-     "test/specs.rb"
-  ]
-
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<ParseTree>, [">= 0"])
-      s.add_runtime_dependency(%q<ruby2ruby>, ["= 1.1.9"])
-    else
-      s.add_dependency(%q<ParseTree>, [">= 0"])
-      s.add_dependency(%q<ruby2ruby>, ["= 1.1.9"])
-    end
-  else
-    s.add_dependency(%q<ParseTree>, [">= 0"])
-    s.add_dependency(%q<ruby2ruby>, ["= 1.1.9"])
-  end
-end

data/ruby-do-notation.gemspec

@@ -1,59 +0,0 @@
-
-# Gem::Specification for Ruby-do-notation-0.2
-# Originally generated by Echoe
-
-Gem::Specification.new do |s|
-  s.name = %q{ruby-do-notation}
-  s.version = "0.2"
-
-  s.specification_version = 2 if s.respond_to? :specification_version=
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Aanand Prasad"]
-  s.date = %q{2008-06-20}
-  s.description = %q{Haskell-style monad do-notation for Ruby}
-  s.email = %q{aanand.prasad@gmail.com}
-  s.extra_rdoc_files = ["lib/do_notation/monad.rb", "lib/do_notation/monad_plus.rb", "lib/do_notation/monads/array.rb", "lib/do_notation/monads/maybe.rb", "lib/do_notation/monads/simulations.rb", "lib/do_notation/rewriter.rb", "lib/do_notation.rb", "README.markdown"]
-  s.files = ["lib/do_notation/monad.rb", "lib/do_notation/monad_plus.rb", "lib/do_notation/monads/array.rb", "lib/do_notation/monads/maybe.rb", "lib/do_notation/monads/simulations.rb", "lib/do_notation/rewriter.rb", "lib/do_notation.rb", "README.markdown", "test/array.rb", "test/maybe.rb", "test/monad_plus.rb", "test/simulations.rb", "test/spec_helper.rb", "test/specs.rb", "Manifest", "ruby-do-notation.gemspec"]
-  s.has_rdoc = true
-  s.homepage = %q{http://github.com/aanand/ruby-do-notation/tree/master}
-  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Ruby-do-notation", "--main", "README.markdown"]
-  s.require_paths = ["lib"]
-  s.rubyforge_project = %q{ruby-do-notation}
-  s.rubygems_version = %q{1.1.0}
-  s.summary = %q{Haskell-style monad do-notation for Ruby}
-
-  s.add_dependency(%q<ParseTree>, [">= 0"])
-  s.add_dependency(%q<ruby2ruby>, [">= 0"])
-end
-
-
-# # Original Rakefile source (requires the Echoe gem):
-# 
-# require 'spec/rake/spectask'
-# 
-# spec_list = FileList['test/*.rb']
-# 
-# task :default => :test
-# 
-# desc "Run all specs"
-# Spec::Rake::SpecTask.new('spec') do |t|
-#   t.spec_files = spec_list
-# end
-# 
-# desc "Run all specs with RCov"
-# Spec::Rake::SpecTask.new('rcov') do |t|
-#   t.spec_files = spec_list
-#   t.rcov = true
-# end
-# 
-# require 'echoe'
-# 
-# Echoe.new('ruby-do-notation') do |p|
-#   p.author = 'Aanand Prasad'
-#   p.summary = 'Haskell-style monad do-notation for Ruby'
-#   p.email = 'aanand.prasad@gmail.com'
-#   p.url = 'http://github.com/aanand/ruby-do-notation/tree/master'
-#   p.version = '0.2'
-#   p.dependencies = ['ParseTree', 'ruby2ruby']
-# end

data/test/monad_plus.rb

@@ -1,37 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-require 'do_notation/monads/array'
-require 'do_notation/monads/maybe'
-
-describe "MonadPlus:" do
-  specify "mzero >>= f = mzero" do
-    Array.mzero.bind{ |x| unit(x+1) }.should == Array.mzero
-    Maybe.mzero.bind{ |x| unit(x+1) }.should == Maybe.mzero
-  end
-  
-  specify "v >> mzero = mzero" do
-    ([1,2,3] >> Array.mzero).should == Array.mzero
-    (Maybe.unit(1) >> Maybe.mzero).should == Maybe.mzero
-  end
-  
-  specify "mzero `mplus` m = m" do
-    Array.mzero.mplus([1,2,3]).should == [1,2,3]
-    Maybe.mzero.mplus(Maybe.unit(1)).should == Maybe.unit(1)
-  end
-  
-  specify "m `mplus` mzero = m" do
-    [1,2,3].mplus(Array.mzero).should == [1,2,3]
-    Maybe.unit(1).mplus(Maybe.mzero).should == Maybe.unit(1)
-  end
-
-  specify "guard() prunes the execution tree" do
-    array = Array.run do
-      x <- [0,1,2,3]
-      y <- [0,1,2,3]
-      guard(x + y == 3)
-
-      unit([x,y])
-    end
-
-    array.should == [[0, 3], [1, 2], [2, 1], [3, 0]]
-  end
-end

data/test/simulations.rb

@@ -1,46 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-require 'do_notation/monads/simulations'
-
-roll_3d6 = proc do
-  d1 <- rand(6)
-  d2 <- rand(6)
-  d3 <- rand(6)
-  
-  unit(1+d1 + 1+d2 + 1+d3)
-end
-
-roll_3d6_b = proc do
-  d1 <- rand(6)
-  d2 <- rand(6)
-  d3 <- rand(6)
-  
-  if [d1, d2, d3].include?(5)
-    run do
-      d4 <- rand(6)
-      unit(1+d1 + 1+d2 + 1+d3 + 1+d4)
-    end
-  else
-    unit(1+d1 + 1+d2 + 1+d3)
-  end
-end
-
-describe "Simulation" do
-  specify "generates correct answers" do
-    Simulation.run(&roll_3d6).play.should   == 9
-    Simulation.run(&roll_3d6_b).play.should == 9
-  end
-end
-
-describe "Distribution" do
-  specify "generates correct answers" do
-    Distribution.run(&roll_3d6).play.inspect.should == "[[3, 0.00462962962962963], [4, 0.0138888888888889], [5, 0.0277777777777778], [6, 0.0462962962962963], [7, 0.0694444444444444], [8, 0.0972222222222222], [9, 0.115740740740741], [10, 0.125], [11, 0.125], [12, 0.115740740740741], [13, 0.0972222222222222], [14, 0.0694444444444444], [15, 0.0462962962962963], [16, 0.0277777777777778], [17, 0.0138888888888889], [18, 0.00462962962962963]]"
-    Distribution.run(&roll_3d6_b).play.inspect.should == "[[3, 0.00462962962962963], [4, 0.0138888888888889], [5, 0.0277777777777778], [6, 0.0462962962962963], [7, 0.0694444444444444], [8, 0.0833333333333333], [9, 0.0902777777777777], [10, 0.0902777777777778], [11, 0.0833333333333333], [12, 0.0694444444444445], [13, 0.0625000000000001], [14, 0.0601851851851853], [15, 0.0578703703703705], [16, 0.0555555555555557], [17, 0.0532407407407408], [18, 0.0462962962962964], [19, 0.0354938271604938], [20, 0.0239197530864198], [21, 0.0146604938271605], [22, 0.00771604938271605], [23, 0.00308641975308642], [24, 0.000771604938271605]]"
-  end
-end
-
-describe "Expectation" do
-  specify "generates correct answers" do
-    (1..21).collect { |x| Expectation.run(&roll_3d6).play(x) }.inspect.should == "[0.0, 0.0, 0.00462962962962963, 0.0138888888888889, 0.0277777777777778, 0.0462962962962963, 0.0694444444444444, 0.0972222222222222, 0.115740740740741, 0.125, 0.125, 0.115740740740741, 0.0972222222222222, 0.0694444444444444, 0.0462962962962963, 0.0277777777777778, 0.0138888888888889, 0.00462962962962963, 0.0, 0.0, 0.0]"
-    (1..21).collect { |x| Expectation.run(&roll_3d6_b).play(x) }.inspect.should == "[0.0, 0.0, 0.00462962962962963, 0.0138888888888889, 0.0277777777777778, 0.0462962962962963, 0.0694444444444444, 0.0833333333333333, 0.0902777777777778, 0.0902777777777777, 0.0833333333333333, 0.0694444444444444, 0.0625, 0.0601851851851852, 0.0578703703703704, 0.0555555555555556, 0.0532407407407407, 0.0462962962962963, 0.0354938271604938, 0.0239197530864197, 0.0146604938271605]"
-  end
-end