rewrite 0.2.0 → 0.3.0

data/History.txt

@@ -10,3 +10,5 @@
   * added Try to the Prelude
 * 5 minor enhancement:
   * called_by_name
+* 6 minor enhancements:
+  * ByExample and Unhygienic rewriting

data/Manifest.txt

@@ -7,6 +7,22 @@ Rakefile
 config/hoe.rb
 config/requirements.rb
 lib/rewrite.rb
+lib/rewrite/by_example.rb
+lib/rewrite/by_example/any_entity.rb
+lib/rewrite/by_example/bind.rb
+lib/rewrite/by_example/bind_sequence.rb
+lib/rewrite/by_example/composition.rb
+lib/rewrite/by_example/entity_matcher.rb
+lib/rewrite/by_example/length_one.rb
+lib/rewrite/by_example/literal_entity.rb
+lib/rewrite/by_example/nil_entity.rb
+lib/rewrite/by_example/object_to_matcher.rb
+lib/rewrite/by_example/returning.rb
+lib/rewrite/by_example/sequence.rb
+lib/rewrite/by_example/sexp_entity.rb
+lib/rewrite/by_example/symbol_entity.rb
+lib/rewrite/by_example/unhygienic.rb
+lib/rewrite/by_example/union_of_entities_sequence.rb
 lib/rewrite/def_var.rb
 lib/rewrite/evaluation_strategies.rb
 lib/rewrite/prelude.rb
@@ -26,9 +42,12 @@ tasks/deployment.rake
 tasks/environment.rake
 tasks/website.rake
 test/test_andand.rb
+test/test_by_example.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_object_to_sequence_and_matcher.rb
 test/test_rewriter_helpers.rb
 test/test_syntax_let.rb
 test/test_with.rb

data/lib/rewrite/by_example.rb

@@ -0,0 +1,39 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+Dir["#{File.dirname(__FILE__)}/by_example/*.rb"].each do |element|
+   require File.expand_path(element)
+end
+
+module Rewrite
+  
+  module ByExample
+    module ClassMethods
+      # Sigh, I know that 'clever' variable names are not helpful, but I *need* to remind
+      # myself why I am doing this: Using a ByExample to extract what we want from a sexp
+      # is eating my own dog food.
+      DOGFOODER = ObjectToMatcher.from_object(
+        s(:proc,
+          nil,
+          Bind.new(:body, AnyEntity.new)
+        )
+      )
+      
+      def from(&proc)
+        body = DOGFOODER.unfold(proc.to_sexp) or raise "Don't know how to handle #{proc.to_ruby}"
+        SexpEntity.from(body)
+      end
+      
+    end
+    
+    module InstanceMethods
+      
+    end
+    
+    def self.included(receiver)
+      receiver.extend         ClassMethods
+      receiver.send :include, InstanceMethods
+    end
+  end
+  
+end

data/lib/rewrite/by_example/any_entity.rb

@@ -0,0 +1,32 @@
+$:.unshift File.dirname(__FILE__)
+
+require File.expand_path(File.dirname(__FILE__) +'/entity_matcher.rb')
+
+module Rewrite
+  
+  module ByExample
+    
+    # Matches any entity and optionally binds that entity's value to a name in the
+    # unfolded result. AnyEntity.new('name') binds whatever it matches to
+    # 'name'.
+    #
+    # Not isomorphic to BindSequence: if you want to match a sequence
+    # consisting of exactly one entity and bind that to 'name', you need
+    # to combine AnyEntity with LengthOne:
+    #
+    #   LengthOne.new(AnyEntity.new('name))
+    class AnyEntity < EntityMatcher
+      
+      def unfold (sexp)
+        {}
+      end
+      
+      def to_s
+        '__'
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/rewrite/by_example/bind.rb

@@ -0,0 +1,41 @@
+$:.unshift File.dirname(__FILE__)
+
+require File.expand_path(File.dirname(__FILE__) +'/entity_matcher.rb')
+
+module Rewrite
+  
+  module ByExample
+    
+    # Abstract class that matches any entity and optionally binds that entity's 
+    # value to a name in the unfolded result. Useful for creating classes that bind
+    # and match simultaneously
+    class Bind < EntityMatcher
+      
+      attr_accessor :name, :entity_matcher
+      
+      def initialize(name, entity_matcher)
+        self.name = name.to_sym
+        self.entity_matcher = entity_matcher
+      end
+      
+      def unfold (sexp)
+        { self.name => sexp } if entity_matcher.unfold(sexp)
+      end
+      
+      def fold (enum_of_bindings)
+        enum_of_bindings[self.name]
+      end
+      
+      def to_s
+        if name
+          "#{entity_matcher.to_s} => #{name.inspect}"
+        else
+          '*'
+        end
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/rewrite/by_example/bind_sequence.rb

@@ -0,0 +1,46 @@
+$:.unshift File.dirname(__FILE__)
+
+require File.expand_path(File.dirname(__FILE__) +'/sequence.rb')
+
+module Rewrite
+  
+  module ByExample
+    
+    # Matches any sequence of zero or more entities and binds the list
+    # to a name in the unfolded result. BindSequence.new('name') binds
+    # whatever sequence of entities it matches to 'name'.
+    #
+    # Not isomorphic to AnyEntity: AnyEntity matches one entity,
+    # BindSequence matches a sequence of entities. If you want to match
+    # a single entity that happens to consist
+    #
+    #   LengthOne.new(Bind.new('name), AnyEntity.new)
+    class BindSequence < Sequence
+      attr_reader :unfolder_lambda, :name
+      
+      def initialize(name)
+        @name = name.to_sym
+        @unfolder_lambda = lambda { |arr| { @name => s(*arr) } }
+      end
+      
+      def unfolders_by_length(length)
+        [ unfolder_lambda ]
+      end
+      
+      def length_range
+        0..10000
+      end
+      
+      def fold(enum_of_bindings)
+        enum_of_bindings[name]
+      end
+      
+      def to_s
+        "__* => #{name.inspect}"
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/rewrite/by_example/composition.rb

@@ -0,0 +1,104 @@
+$:.unshift File.dirname(__FILE__)
+
+module Rewrite
+  
+  module ByExample
+    
+    # A Composition is an aggregation of Sequence. So where a LengthOne and
+    # a BindSequence are both leaves of a sequence tree, a Composition is a
+    # node.
+    class Composition < Sequence
+      attr_reader :sub_sequences, :length_range
+      
+      def initialize(*sub_sequences)
+        @sub_sequences = sub_sequences#.map { |sub| Sequence.from_object(sub) }
+        @length_range = range_sum(@sub_sequences)
+      end
+      
+      def unfolders_by_length(length)
+        unfolders_by_length_helper(sub_sequences(), length)
+      end
+      
+      def to_s
+        sub_sequences.map { |ss| ss.to_s }.join(', ')
+      end
+      
+      def fold(enum_of_bindings)
+        sub_sequences.inject(s()) { |refolded, sub_sequence|
+          folded = sub_sequence.fold(enum_of_bindings)
+          if folded.nil?
+            s(*(refolded + [nil]))
+          elsif sub_sequence.is_a? LengthOne
+            s(*(refolded + [folded]))
+          else
+            s(*(refolded + folded))
+          end
+        }
+      end
+      
+      private
+    
+      def merge_results(result1, result2)
+        if result1 && result2
+          result = result1.dup
+          result2.each do |key, value|
+            if result.include?(key)
+              return nil unless result[key].eql?(value)
+            else
+              result[key] = value
+            end
+          end
+          result
+        end
+      end
+      
+      def unfolders_by_length_helper(subs, length)
+        range_of_lengths = range_sum(subs)
+        if !(range_of_lengths === length)
+          []
+        elsif subs.empty? # implied by the test above # TODO: short blog post about this
+          []
+        elsif subs.length == 1
+          subs.first.unfolders_by_length(length)
+        else
+          head_subsequence = subs.first
+          tail_subsequences = subs[1..-1]
+          range_of_tail_lengths = range_sum(tail_subsequences)
+          required_head_lengths = (length - range_of_tail_lengths.end)..(length - range_of_tail_lengths.begin)
+          head_lengths_to_try = range_intersection(head_subsequence.length_range, required_head_lengths)
+          return [] if head_lengths_to_try.begin > head_lengths_to_try.end
+          head_lengths_to_try.inject([]) { |accumulated_unfolders_for_entire_composition, length_of_head_subsequence_to_try|
+            head_unfolders = head_subsequence.unfolders_by_length(length_of_head_subsequence_to_try)
+            tail_unfolders = unfolders_by_length_helper(tail_subsequences, length - length_of_head_subsequence_to_try)
+            accumulated_unfolders_for_entire_composition + head_unfolders.inject([]) { |accumulated_unfolders_for_entire_composition2, head_unfolder|
+              accumulated_unfolders_for_entire_composition2 + tail_unfolders.map { |tail_unfolder|
+                lambda { |arr|
+                  head_portion, tail_portion = arr[0,length_of_head_subsequence_to_try], arr[length_of_head_subsequence_to_try..-1]
+                  merge_results(
+                    head_unfolder.call(head_portion), 
+                    tail_unfolder.call(tail_portion)
+                  )
+                }
+              }
+            }
+          }
+        end
+      end
+      
+      def range_intersection(range1, range2)
+        ([range1.begin, range2.begin].max)..([range1.end, range2.end].min)
+      end
+      
+      def range_sum(enumerable_of_sequences)
+        enumerable_of_sequences.inject(0..0) { |total_range, each_seq|
+          each_range = each_seq.length_range
+          (total_range.begin + each_range.begin)..(total_range.end + each_range.end)
+        }
+      end
+      
+      
+    end
+    
+  end
+  
+end

data/lib/rewrite/by_example/entity_matcher.rb

@@ -0,0 +1,48 @@
+$:.unshift File.dirname(__FILE__)
+
+module Rewrite
+  
+  module ByExample
+    
+    # Matches a single something against a sexp
+    # such as an array or a literal symbol
+    class EntityMatcher
+      
+      attr_accessor :predicate
+      
+      def such_that!(&predicate_clause)
+        self.predicate = predicate_clause
+        self
+      end
+      
+      # takes a sexp and returns nil or an enumeration of
+      # bindings, typically as a hash. Note that the empty hash
+      # is truthy, and this is what we want: it means a match
+      # that doesn't perform any bindings
+      #
+      # Note the identity: if x.fold(enum_of_bindings) is not nil, 
+      # then enum_of_bindings == x.unfold(x.fold(enum_of_bindings))
+      def unfold(sexp)
+        raise 'implemented by includer'
+      end
+      remove_method :unfold
+      
+      # takes an enumeration of bindings and returns nil or a sexp.
+      #
+      # Note the identity: if x.unfold(sexp) is not nil, then
+      # sexp == x.fold(x.unfold(sexp))
+      def fold(enum_of_bindings)
+        raise 'implemented by includer'
+      end
+      remove_method :fold
+      
+      # advice for unfold
+      def after_unfold
+        
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/rewrite/by_example/length_one.rb

@@ -0,0 +1,50 @@
+$:.unshift File.dirname(__FILE__)
+
+module Rewrite
+  
+  module ByExample
+    
+    # Natches a sequence containing one item. Wraps an entity matcher,
+    # with the wrapped matcher matching the one item.
+    #
+    # Confusing? Consider SymbolEntity.new(:foo). It matches a single
+    # entity, :foo. Whereas LengthOne.new(SymbolEntity.new(:foo)) matches
+    # a sequence of length one where that one thing happens to match :foo.
+    #
+    # This distinction is important because sequences can only consist of
+    # collections of other sequences. So the LengthOnes are leaves of
+    # the sequence trees.
+    class LengthOne < Sequence
+      
+      attr_reader :matcher
+      
+      def initialize(entity_matcher)
+        @matcher = entity_matcher
+        @lambda = lambda { |arr| entity_matcher.unfold(arr.first) }
+      end
+      
+      def unfolders_by_length(length)
+        if length == 1
+          [ @lambda ]
+        else
+          []
+        end
+      end
+      
+      def length_range
+        1..1
+      end
+      
+      def to_s
+        "<#{matcher.to_s}>"
+      end
+      
+      def fold(enum_of_bindings)
+        matcher.fold(enum_of_bindings)
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/rewrite/by_example/literal_entity.rb

@@ -0,0 +1,25 @@
+$:.unshift File.dirname(__FILE__)
+
+require File.expand_path(File.dirname(__FILE__) +'/any_entity.rb')
+require File.expand_path(File.dirname(__FILE__) +'/bind.rb')
+require File.expand_path(File.dirname(__FILE__) +'/sexp_entity.rb')
+
+module Rewrite
+  
+  module ByExample
+    
+    class LiteralEntity < SexpEntity
+      
+      def initialize(name = Rewrite.gensym)
+        super()
+        self.sequence = Composition.new(
+          LengthOne.new(ObjectToMatcher.from_object(:lit)),
+          LengthOne.new(Bind.new(name, AnyEntity.new))
+        )
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/rewrite/by_example/nil_entity.rb

@@ -0,0 +1,26 @@
+$:.unshift File.dirname(__FILE__)
+
+module Rewrite
+  
+  module ByExample
+    
+    # Matches nil.
+    class NilEntity < EntityMatcher
+      
+      def unfold (sexp)
+        {} if sexp.nil?
+      end
+      
+      def fold (enum_of_bindings)
+        nil
+      end
+      
+      def to_s
+        "nil"
+      end
+      
+    end
+    
+  end
+  
+end