rewrite 0.0.6 → 0.1.0

data/History.txt

@@ -8,3 +8,5 @@
   * added Please to the Prelude
 * 4 tiny enhancement:
   * added Try to the Prelude
+* 5 minor enhancement:
+  * called_by_name

data/lib/rewrite/def_var.rb

@@ -6,6 +6,24 @@ require 'sexp_processor'
 
 module Rewrite
     
+  # Hygienically define a variable to be used in a chunk of code.
+  #
+  #   Defvar.new(:name, definition).process(exp)
+  #     => lambda { |name|
+  #          exp
+  #        }.call(definition)
+  #
+  # This is useful when you want to wrap some code in a let.
+  #
+  # There's an olptimization so that you can nest it without penalty:
+  #
+  #
+  #   Defvar.new(:name1, definition1).process(
+  #     Defvar.new(:name2, definition2).process(exp)
+  #   ) => lambda { |name1, name2|
+  #          exp
+  #        }.call(definition1, definition2)
+  #
   class DefVar
     
     def initialize(sym, sexp)

data/lib/rewrite/evaluation_strategies.rb

@@ -6,6 +6,13 @@ require 'sexp_processor'
 
 module Rewrite
   
+  # Takes a sexp representing a lambda and rewrites all of its parameter references as thunk calls.
+  #
+  # Example:
+  #
+  #   lambda { |a,b| a + b }
+  #     => lambda { |a,b| a.call + b.call }
+  #
   class RewriteParametersAsThunkCalls
   
     def sexp(exp)
@@ -41,10 +48,15 @@ module Rewrite
   end
     
   # Initialize with a list of names, e.g.
-  # CallByThunk.new(:foo, :bar)
+  #   CallByThunk.new(:foo, :bar)
+  #
+  # It then converts expressions of the form:
+  #
+  #    foo(expr1, expr2, ..., exprn)
+  #
+  # into:
   #
-  # It then converts expressions of the form foo(expr1, expr2, ..., exprn) into
-  # foo.call( lambda { expr1 }, lambda { expr2 }, ..., lambda { exprn })
+  #    foo.call( lambda { expr1 }, lambda { expr2 }, ..., lambda { exprn })
   #
   # This is handy when combined with RewriteVariablesAsThunkCalls in the following
   # manner: if you rewrite function invocations with CallByThunk and also rewrite the
@@ -82,5 +94,75 @@ module Rewrite
     end
     
   end
+    
+  # Initialize with a list of names, e.g.
+  #
+  #   CallSplattedByThunk.new(:foo, :bar)
+  #
+  # It then converts expressions of the form:
+  #
+  #    foo(expr1, expr2, ..., exprn)
+  #
+  # into:
+  #
+  #    foo.call( 
+  #      CallSplattedByThunk::Parameters.new(
+  #        lambda { expr1 }, lambda { expr2 }, ..., lambda { exprn }
+  #      )
+  #    )
+  #
+  # This is allows you to create call-by-name pseudo-functions that take
+  # an arbitrary number of arguments
+  #
+  class CallSplattedByThunk < SexpProcessor
+    
+    def initialize(*functions_to_splat_thunkify)
+      @functions_to_splat_thunkify = functions_to_splat_thunkify
+      super()
+    end
+    
+    def process_fcall(exp)
+      qua = exp.dup
+      exp.shift
+      name = exp.shift
+      if @functions_to_splat_thunkify.include? name
+        thunked = s(:call, s(:dvar, name), :call)
+        unless exp.empty?
+          arguments = exp.shift
+          raise "Do not understand arguments #{arguments}" unless arguments[0] == :array
+          thunked << s(:array,
+            s(:call,
+              s(:colon2, s(:colon2, s(:const, :Rewrite), :CallSplattedByThunk), :Parameters),
+              :new,
+              arguments[1..-1].inject(s(:array)) { |arr, arg| 
+                arr << s(:iter, s(:fcall, :lambda), nil, process(arg)) 
+              }
+            )
+          )
+        end
+      else
+        thunked = s(:fcall, name) # :fcall, name_of_the_function
+        thunked << process(exp.shift) unless exp.empty?
+      end
+      thunked
+    end
+    
+    class Parameters
+      
+      include Enumerable
+      
+      def initialize(*lambdas)
+        @lambdas = *lambdas
+      end
+      
+      def each
+        lambdas.each do |l|
+          yield l.call
+        end
+      end
+      
+    end
+    
+  end
   
 end

data/lib/rewrite/prelude/called_by_name.rb

@@ -2,7 +2,7 @@ module Rewrite
   
   module Prelude
   
-    # Warning: Extreme Funk ahead:
+    # See "Macros, Hygiene, and Call By Name in Ruby":http://weblog.raganwald.com/2008/06/macros-hygiene-and-call-by-name-in-ruby.html
     #
     # CalledByName allows you to define your own function-like-things that are called by name rather than
     # by value. Here is a trivial example:
@@ -29,7 +29,7 @@ module Rewrite
     #
     # Second, and this is the funky bit, parameters inside of your function-like-thing are called by name. Meaning,
     # when you call your function-like-thing, instead of evaluating each parameter's expression and passing its
-    # value, Ruby passes the expression itself. The expression is not evaluated until the parpameter is actually used,
+    # value, Ruby passes the a lambda containing expression itself. The expression is not evaluated until the parpameter is actually used,
     # and if you use it more than once the expression is evaluated more than once. This matters when there are side
     # effects.
     #
@@ -75,10 +75,36 @@ module Rewrite
     #    )
     #
     class CalledByName
+      
+      def splatted?(proc)
+        sexp = proc.to_sexp
+        raise "Expected a proc" unless sexp[0] == :proc
+        raise "Expected a proc with arity >= 1" if sexp[1] == nil
+        arguments = sexp[1]
+        arguments[0] == :masgn && arguments[1] && arguments[1].respond_to?(:first) && arguments[1].first != :array
+      end
+      
+      def as_lambda(proc_sexp)
+        s(:iter,
+          s(:fcall, :lambda),
+          *proc_sexp[1..-1]
+        )
+      end
   
       def initialize(name, &proc)
-        @let = Rewrite::DefVar.new(name, Rewrite::RewriteParametersAsThunkCalls.new.process(eval(proc.to_sexp.inspect)))
-        @call_by_thunk = Rewrite::CallByThunk.new(name) 
+        if splatted?(proc)
+          @let = Rewrite::DefVar.new(
+            name,
+            as_lambda(proc.to_sexp)
+          )
+          @call_by_thunk = Rewrite::CallSplattedByThunk.new(name) 
+        else
+          @let = Rewrite::DefVar.new(
+            name, 
+            Rewrite::RewriteParametersAsThunkCalls.new.process(eval(proc.to_sexp.inspect))
+          )
+          @call_by_thunk = Rewrite::CallByThunk.new(name) 
+        end
       end
   
       def process(exp)

data/lib/rewrite/variables.rb

@@ -6,7 +6,22 @@ require 'sexp_processor'
 require 'sexp'
 
 module Rewrite
-    
+  
+  #--
+  #
+  # TODO: Implement splat variables somehow
+  #
+  # def test_splat_variables
+  #   
+  #   assert_equal(
+  #     lambda { |*a| a[0].call }.to_sexp.to_a,
+  #     Rewrite::RewriteVariablesAsThunkCalls.new(:a).process(
+  #       lambda { |*a| a[0] }.to_sexp
+  #     ).to_a
+  #   )
+  #   
+  # end
+  
   class VariableRewriter < SexpProcessor
     
     attr_reader :replacement_sexp

data/lib/rewrite/version.rb

@@ -1,8 +1,8 @@
 module Rewrite #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 0
-    TINY  = 6
+    MINOR = 1
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/rewrite/with.rb

@@ -8,6 +8,11 @@ module Rewrite
   module With
     
     def self.with(*sexp_processors, &body)
+      ruby = expand(*sexp_processors, &body)
+      eval(ruby, body.binding())
+    end
+    
+    def self.expand(*sexp_processors, &body)
       rewritten = sexp_processors.flatten.inject(body.to_sexp.last) { |sexp, sexp_processor_parameter|  
         if sexp_processor_parameter.respond_to?(:new) && sexp_processor_parameter.kind_of?(Class)
           sexp_processor = sexp_processor_parameter.new
@@ -17,8 +22,7 @@ module Rewrite
         sexp_processor.process(sexp)
       }
       rewritten = eval(rewritten.to_s) # i don't know why i need this!!
-      ruby = Ruby2Ruby.new.process(rewritten)
-      eval(ruby, body.binding())
+      Ruby2Ruby.new.process(rewritten)
     end
       
     module ClassMethods
@@ -27,6 +31,10 @@ module Rewrite
         Rewrite::With.with(sexp_processors, &body)
       end
       
+      def expand(*sexp_processors, &body)
+        Rewrite::With.expand(sexp_processors, &body)
+      end
+      
     end
     
     module InstanceMethods

data/lib/rewrite.rb

@@ -8,6 +8,10 @@ Dir["#{File.dirname(__FILE__)}/rewrite/*.rb"].each do |element|
    require element
 end
 
+#--
+#
+# TODO: Hygienic Inline Methods
+#
 module Rewrite
   
   module ClassMethods

data/test/test_call_by_name.rb

@@ -2,8 +2,19 @@ require File.dirname(__FILE__) + '/test_helper.rb'
 
 class TestCalledByName < Test::Unit::TestCase
 
+  include Rewrite::With
   include Rewrite::Prelude
   
+  def test_andand_by_name
+    called_by_name(:our_and) { |x,y|
+      if temp = x
+        y
+      else
+        temp
+      end
+    }
+  end
+  
   def test_nullo_case
     assert_equal(
       Rewrite.arr_for do 
@@ -21,6 +32,40 @@ class TestCalledByName < Test::Unit::TestCase
     )
   end
   
+  def test_regular_rewrite
+    assert_equal(
+      Rewrite.arr_for do 
+         lambda { |foo| 
+           foo.call(lambda { 2 }, lambda { 2 })
+         }.call(
+          lambda { |x, y| x.call + y.call }
+         )
+      end, 
+      called_by_name(:foo) { |x, y| x + y }.process(
+        Rewrite.sexp_for do
+          foo(2,2)
+        end
+      ).to_a
+    )
+  end
+  
+  def test_splatted_rewrite
+    assert_equal(
+      Rewrite.arr_for do 
+         lambda { |foo| 
+           foo.call(Rewrite::CallSplattedByThunk::Parameters.new(lambda { 2 }, lambda { 2 }))
+         }.call(
+          lambda { |*args| args.inject { |acc, item| acc + item } }
+         )
+      end, 
+      called_by_name(:foo) { |*args| args.inject { |acc, item| acc + item } }.process(
+        Rewrite.sexp_for do
+          foo(2,2)
+        end
+      ).to_a
+    )
+  end
+  
   def test_thunk_semantics
     Rewrite.with(
       called_by_name(:foo) { |change_it, get_it| 

data/test/test_call_splatted_by_name.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+require 'rubygems'
+require 'parse_tree'
+require 'sexp_processor'
+
+module Rewrite
+
+  class TestWith < Test::Unit::TestCase
+  
+    include Rewrite::With
+    include Rewrite::Prelude
+  
+    def test_rewrite_splatted
+      assert_equal(
+        lambda { |foo|
+            Rewrite.arr_for { 
+            foo.call(Rewrite::CallSplattedByThunk::Parameters.new(lambda { :bar }))
+          }
+        }.call(nil), 
+        CallSplattedByThunk.new(:foo).process(
+          Rewrite.sexp_for { foo(:bar) }
+        ).to_a
+      )
+    end
+    
+    def raise_this(ex)
+      raise ex
+    end
+    
+    def test_rewrite_splatted_semantics
+      with(
+        called_by_name(:try_these) { |*clauses|
+          clauses.each { |clause| return clause rescue nil }
+          nil
+        }
+      ) do
+        assert_nothing_raised(Exception) do
+          try_these(raise_this("foo"), raise_this("bar"), :foo)
+        end
+      end
+    end
+  
+  end
+
+end

data/test/test_rewriter_helpers.rb

@@ -2,17 +2,6 @@ require File.dirname(__FILE__) + '/test_helper.rb'
 
 class TestRewriteHelpers < Test::Unit::TestCase
   
-  def test_splat_variables
-    
-    assert_equal(
-      lambda { |*a| a[0].call }.to_sexp.to_a,
-      Rewrite::RewriteVariablesAsThunkCalls.new(:a).process(
-        lambda { |*a| a[0] }.to_sexp
-      ).to_a
-    )
-    
-  end
-  
   def test_simple_rewrite
     
     assert_equal(

data/website/index.html

@@ -33,7 +33,7 @@
     <h1>rewrite</h1>
     <div id="version" class="clickable" onclick='document.location = "http://rubyforge.org/projects/rewrite"; return false'>
       <p>Get Version</p>
-      <a href="http://rubyforge.org/projects/rewrite" class="numbers">0.0.6</a>
+      <a href="http://rubyforge.org/projects/rewrite" class="numbers">0.1.0</a>
     </div>
     <h1>&#x2192; &#8216;rewrite&#8217;</h1>
 
@@ -104,6 +104,12 @@
 	<p>Rewrite restricts things like andand or try to your code and your code alone. Sure, if you introduce a bug in your code, you may break things that directly depend on your code. But if you introduce “try” using rewrite instead of modifying Object, you will not reach out across your project and break something entirely unrelated that happens to have defined its own version of try in a completely different way.</p>
 
 
+	<h2>New! called_by_name</h2>
+
+
+	<p>See <a href="http://weblog.raganwald.com/2008/06/macros-hygiene-and-call-by-name-in-ruby.html">Macros, Hygiene, and Call By Name in Ruby</a> for details, more docs to come presently&#8230;</p>
+
+
 	<h2>How does it work?</h2>
 
 
@@ -226,7 +232,7 @@ rake install_gem</pre>
 
 	<p>Comments are welcome. Send an email to <a href="mailto:raganwald+rewrite@gmail.com">Reg Braithwaite</a> email via the <a href="http://groups.google.com/group/rewrite">forum</a></p>
     <p class="coda">
-      <a href="http://weblog.raganwald.com/">Reginald Braithwaite</a>, 18th June 2008<br>
+      <a href="http://weblog.raganwald.com/">Reginald Braithwaite</a>, 23rd June 2008<br>
       Theme extended from <a href="http://rb2js.rubyforge.org/">Paul Battley</a>
     </p>
 </div>

data/website/index.txt

@@ -55,6 +55,10 @@ Also, imagine if you introduce try and are careful not to break anything. Now so
 
 Rewrite restricts things like andand or try to your code and your code alone. Sure, if you introduce a bug in your code, you may break things that directly depend on your code. But if you introduce “try” using rewrite instead of modifying Object, you will not reach out across your project and break something entirely unrelated that happens to have defined its own version of try in a completely different way.
 
+h2. New! called_by_name
+
+See "Macros, Hygiene, and Call By Name in Ruby":http://weblog.raganwald.com/2008/06/macros-hygiene-and-call-by-name-in-ruby.html for details, more docs to come presently...
+
 h2. How does it work?
 
 Rewrite takes your code, converts it to an sexp with Parse Tree, then rewrites the sexp using one or more rewriters you specify. Finally, it converts the sexp back to Ruby with Ruby2Ruby and evals it. It does this when the code is first read, not every time it is invoked, so we mitigate the “do not use andand in a tight loop” problem.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rewrite
 version: !ruby/object:Gem::Version 
-  version: 0.0.6
+  version: 0.1.0
 platform: ruby
 authors: 
 - Reg Braithwaite
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-06-18 00:00:00 -04:00
+date: 2008-06-23 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -97,7 +97,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: rewrite
-rubygems_version: 1.1.1
+rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: Syntactic metaprogramming for Ruby
@@ -105,6 +105,7 @@ test_files:
 - test/test_andand.rb
 - test/test_call_by_name.rb
 - test/test_call_by_thunk.rb
+- test/test_call_splatted_by_name.rb
 - test/test_helper.rb
 - test/test_rewriter_helpers.rb
 - test/test_syntax_let.rb