casegen 2.0.0 → 3.0.0

data/lib/agents/sets/enum/nest.rb

@@ -1,117 +0,0 @@
-#!/usr/bin/env ruby
-
-module Enumerable
-
-  def nest(&compare)
-    ary = to_a
-    s = ary.size
-    i = 0
-    
-    # wrap into Array::Iterator?
-    items_left  = proc { i < s }
-    get_cur     = proc { ary[i] }
-    go_next     = proc { i += 1 }
-    
-    result = nil
-    while items_left[]
-      level_ary = Enumerable.nest items_left, get_cur, go_next, compare
-      result = result ? level_ary.unshift(result) : level_ary
-    end
-    result || []
-  end
-
-  # Handles a single level, recursing when the depth increases and
-  # backing out when the depth decreases.
-  def Enumerable.nest items_left, get_cur, go_next, compare
-    # should handle compare.arity == 2 like a <=> proc
-    result = []; item = depth = nil
-    while items_left[]
-      item = get_cur[]
-      depth = compare[item]
-      base_depth ||= depth
-        
-      if depth < base_depth
-        break
-      elsif depth > base_depth
-        result << nest(items_left, get_cur, go_next, compare)
-      else
-        result << item; go_next[]
-      end
-    end
-    return result
-  end
-  
-  def group(&test)
-    nest { |x| test[x] ? 1 : 0 }
-  end
-end
-
-=begin
-
-=module Enumerable
-==instance methods
----Enumerable#nest &compare
-
-(({nest})) is an inverse for (({Array#flatten})). (Well, actually only a right
-inverse since (({flatten})) is not injective.) You give it a proc that
-calculates the depth of each item, and it returns a nesting of arrays in which
-each item has the desired depth. It can be used to parse strings with
-Python-like indentation syntax, but it isn't limited to strings.
-
-The main improvement in this version is that the compare block can return
-a lower value for an element after the first, with the expected effect. See the first example at the end of the source file.
-
-===version
-
-Enumerable tools 1.6
-
-The current version of this software can be found at 
-((<"http://redshift.sourceforge.net/enum
-"|URL:http://redshift.sourceforge.net/enum>)).
-
-===license
-This software is distributed under the Ruby license.
-See ((<"http://www.ruby-lang.org"|URL:http://www.ruby-lang.org>)).
-
-===author
-Joel VanderWerf,
-((<vjoel@users.sourceforge.net|URL:mailto:vjoel@users.sourceforge.net>))
-
-=end
-
-if __FILE__ == $0
-
-str = <<END
-  a
-   aa
-   ab
-    aba
-    abb
-     abba
-      abbaa
-     abbb
-   ac
-   ad
-    ada
-     adaa
-    adb
-  b
-   ba
-   bb
-  c
-   ca
-X
- Y
-  Z
-END
-
-lines = str.split "\n"
-nested = lines.nest { |line| /\S/ =~ line }
-p nested
-flat = nested.flatten
-p flat
-p flat == lines
-
-p [1, 2, "three", "four", 5, "six"].group { |x| x.is_a? String }
-
-end

data/lib/agents/sets/enum/op.rb

@@ -1,283 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'enum/inject'
-
-module EnumerableOperator
-
-  class Product
-    include Enumerable
-
-    attr_reader :factors, :dim
-
-    def initialize(*factors)
-      @factors = factors
-      @dim = @factors.length
-    end
-
-    def each tuple = [nil]*@dim, i = 0, &block
-      if i == @dim - 1 then
-        @factors[i].each { |x| tuple[i] = x; yield tuple.dup }
-      elsif i > 0
-        @factors[i].each { |x| tuple[i] = x; each tuple, i + 1, &block }
-      else
-        @factors[i].each { |x| tuple[i] = x; each tuple, i + 1, &block }
-        self
-      end
-    end
-
-    def size
-      @factors.product { |enum| enum.size }
-    end
-
-  end
-
-  class Sum
-    include Enumerable
-
-    attr_reader :summands
-
-    def initialize(*summands)
-      @summands = summands
-    end
-
-    def each(&block)
-      @summands.each { |enum| enum.each(&block) }
-      self
-    end
-    
-    def size
-      @summands.sum { |enum| enum.size }
-    end
-
-  end
-
-  class Diagonal
-    include Enumerable
-  
-    attr_reader :factors, :dim
-
-    def initialize(*factors)
-      @factors = factors
-      @dim = @factors.length
-    end
-    
-    def each
-      factors = @factors.map { |factor|
-        if factor.kind_of? Array then factor else factor.entries end
-      }
-      minlength = factors.min { |f, g| f.length <=> g.length }.length
-      for i in 0..(minlength-1)
-        yield factors.map { |factor| factor[i] }
-      end
-      self
-    end
-  end
-
-
-  def product(*factors, &block)
-    if block
-      Product.new(*factors).each(&block)
-    else
-      Product.new(*factors)
-    end
-  end
-  alias :tuples :product
-
-  def sum(*summands, &block)
-    if block
-      Sum.new(*summands).each(&block)
-    else
-      Sum.new(*summands)
-    end
-  end
-  alias :concatenation :sum
-  alias :cat :sum
-
-  def diagonal(*factors, &block)
-    if block
-      Diagonal.new(*factors).each(&block)
-    else
-      Diagonal.new(*factors)
-    end
-  end
-
-  module_function :product, :sum, :diagonal
-end
-
-=begin
-
-==module EnumerableOperator
-===instance methods and module methods
----EnumerableOperator#product *factors, &block
----EnumerableOperator#sum *summands, &block
-
-The (({product})) operator iterates over the Cartesian product of the factors,
-each of which must be (({Enumerable})).
-
-The (({sum})) operator iterates over the concatenation of the summands, each of
-which must be (({Enumerable})).
-
-Both operators have aliases: (({tuples})) for (({product}));
-(({concatenation})) and (({cat})) for (({sum})).
-
-Called with a block, the operators yield one element of the sequence at a time
-to the block.
-
-With or without a block, the operators return an (({Enumerable})) which
-delegates to the original (({Enumerables})), but does not explicitly construct
-the entire collection. Calling another (({Enumerable})) method, such as
-(({select})) or (({collect})), on this return value is an efficient way of
-chaining these operators with other methods. Simply call (({entries})) to get
-the whole collection. Also, because the operators return an (({Enumerable})),
-they can be used with the (({for})) syntax; see the examples.
-
----EnumerableOperator#diagonal *factors, &block
-
-The (({diagonal})) operator iterates over the diagonal of the Cartesian product
-of the factors, each of which must be (({Enumerable})). In other words, the
-n-th entry of the diagonal is an array of the n-th entries of each factor. The
-resulting sequence terminates when any one factor terminates. Hence the
-sequence has the same length as the shortest factor.
-
-Called with a block, (({diagonal})) yields one element of the sequence at a
-time to the block.
-
-With or without a block, (({diagonal})) returns an (({Enumerable})) object
-which is ((*independent*)) of the original (({Enumerables})). As with
-(({product})) and (({sum})), this allows chaining with other iterators and
-using the (({for})) syntax. Unlike (({product})) and (({sum})), however, the
-entire collection is generated and stored in the object returned by
-(({diagonal})).
-
-Internally, (({diagonal})) does not enumerate the sequences in parallel, but in
-the order in which they are given. If the sequences have side-effects of
-enumeration, this may result in different behavior than if the sequences were
-truly enumerated in parallel (e.g., see matz's approach using threads in the
-Ruby FAQ:  ((<"http://www.rubycentral.com/faq/rubyfaq-5.html#ss5.5
-"|URL:http://www.rubycentral.com/faq/rubyfaq-5.html#ss5.5>))).
-
-===usage
-
-  include EnumerableOperator
-  diagonal enum0, enum1, ...
-or
-  EnumerableOperator.diagonal enum0, enum1, ...
-and similarly for product and sum.
-
-===examples
-
-  require 'enum/op'
-  include EnumerableOperator
-  
-  # using the 'for ... in ... end' construct:
-  for i, j in product 1..4, "bar".."baz"
-    printf "%6s", i.to_s + j; puts if j == "baz"
-  end
-  puts
-  
-  # prints:
-  #  1bar  1bas  1bat  1bau  1bav  1baw  1bax  1bay  1baz
-  #  2bar  2bas  2bat  2bau  2bav  2baw  2bax  2bay  2baz
-  #  3bar  3bas  3bat  3bau  3bav  3baw  3bax  3bay  3baz
-  
-  # directly passing a block:
-  sum 1..5, 'a'..'c', 90..92 do |i|
-    printf "%4s", i.to_s
-  end
-  puts "\n\n"
-  
-  # prints:
-  #   1   2   3   4   5   a   b   c  90  91  92
-
-  for i, j, k in diagonal 1..4, 'a'..'d', ?a..?d
-    printf "%4d. %s is 0x%x\n", i, j, k
-  end
-  puts
-
-  # prints:
-  #   1. a is 0x61
-  #   2. b is 0x62
-  #   3. c is 0x63
-  #   4. d is 0x64
-
-  # chaining with other iterators:
-  names = %w{ Ludwig Rudolf Bertrand Willard }
-  more_names = %w{ Jean-Paul Albert Martin Soren }
-  puts sum(names, more_names).sort.join ', '
-  puts
-
-  # prints:
-  #   Albert, Bertrand, Jean-Paul, Ludwig, Martin, Rudolf, Soren, Willard
-  
-  # note that chaining avoids constructing the intermediate collection:
-  big_product = product 1..10, 1..10, 1..10
-  big_product.select { |x, y, z|
-    x <= y and x**2 + y**2 == z**2
-  }.each { |x, y, z|
-    printf "#{x}**2 + #{y}**2 == #{z}**2\n"
-  }
-  
-  # prints:
-  #   3**2 + 4**2 == 5**2
-  #   6**2 + 8**2 == 10**2
-  
-==version
-
-Enumerable tools 1.6
-
-The current version of this software can be found at 
-((<"http://redshift.sourceforge.net/enum
-"|URL:http://redshift.sourceforge.net/enum>)).
-
-==license
-This software is distributed under the Ruby license.
-See ((<"http://www.ruby-lang.org"|URL:http://www.ruby-lang.org>)).
-
-==author
-Joel VanderWerf,
-((<vjoel@users.sourceforge.net|URL:mailto:vjoel@users.sourceforge.net>))
-
-=end
-
-
-if __FILE__ == $0
-
-  include EnumerableOperator
-
-  # using the 'for ... in ... end' construct:
-  for i, j in product 1..4, "bar".."baz"
-    printf "%6s", i.to_s + j; puts if j == "baz"
-  end
-  puts
-  
-  # directly passing a block:
-  sum 1..5, 'a'..'c', 90..92 do |i|
-    printf "%4s", i.to_s
-  end
-  puts "\n\n"
-  
-  for i, j, k in diagonal 1..4, 'a'..'d', ?a..?d
-    printf "%4d. %s is 0x%x\n", i, j, k
-  end
-  puts
-  
-  # chaining with other iterators:
-  names = %w{ Ludwig Rudolf Bertrand Willard }
-  more_names = %w{ Jean-Paul Albert Martin Soren }
-  puts sum(names, more_names).sort.join(', ')
-  puts
-  
-  # note that chaining avoids constructing the intermediate collection:
-  big_product = product 1..10, 1..10, 1..10
-  big_product.select { |x, y, z|
-    x <= y and x**2 + y**2 == z**2
-  }.each { |x, y, z|
-    printf "#{x}**2 + #{y}**2 == #{z}**2\n"
-  }
-  puts
-  
-  # size
-  puts "sum(1..10,11..20).size     = #{sum(1..10,11..20).size}"
-  puts "product(1..10,11..20).size = #{product(1..10,11..20).size}"
-  puts "product([1,2,3],[]).size   = #{product([1,2,3],[]).size}"
-end

data/lib/agents/sets/enum/pipe.rb

@@ -1,160 +0,0 @@
-#!/usr/bin/env ruby
-
-module Enumerable
-
-  class Pipe
-    include Enumerable
-    
-    attr_reader :enum, :filter_name, :filter_map, :args
-
-    def initialize enum, filter_spec = nil, *args, &filter_proc
-      @enum = enum
-      @args = args
-      
-      case filter_spec
-      when Symbol
-        @filter_name = filter_spec
-      when String
-        @filter_name = filter_spec.intern
-      when nil
-        @filter_map = filter_proc
-      else
-        unless filter_spec.respond_to? :[]
-          raise ArgumentError,
-            "filter_spec must be a method name or respond to []."
-        end
-        @filter_map = filter_spec
-      end
-      
-      unless @filter_name or @filter_map
-        raise ArgumentError,
-          "no filter specified."
-      end
-    end
-
-    def each
-      if @filter_name
-        filter_name = @filter_name
-        message = filter_name, *@args
-        @enum.each { |entry|
-          yield entry.send *message
-        }
-      elsif @filter_map
-        filter_map = @filter_map
-        args = *@args
-        @enum.each { |entry|
-          yield filter_map[entry, *args]
-        }
-      end
-    end
-    
-    self
-  end
-  
-  def pipe filter_spec = nil, *args, &filter_proc
-    Pipe.new self, filter_spec, *args, &filter_proc
-  end
-
-end
-
-
-=begin
-
-==class Enumerable
-===instance method
----Enumerable#pipe filter_spec = nil, *args, &filter_proc
-
-Can be used to "pipe" an (({Enumerable})) sequence through a filter.
-
-(({Enumerable#pipe})) returns an (({Enumerable})) object whose (({each}))
-method iterates over (({self})) and applies a filter to each enumerated
-object, as specified by the arguments. Only the current element of the
-sequence is kept in memory.
-
-If (({filter_spec})) is a string or symbol, (({filter_proc})) is ignored
-and (({filter_spec})) is treated as a method name. This method name is
-sent, along with arguments (({args})), to each element of the sequence
-being  enumerated.
-
-If (({filter_spec})) is anything else, except (({nil})), (({filter_proc}))
-is ignored and (({filter_spec})) is required to be an object that responds
-to (({[]})), such as a proc or a hash. The (({[]})) method of
-(({filter_spec})) is called with each element of the sequence in turn as
-an argument, along with (({args})).
-
-If (({next_spec})) is not given, or is (({nil})), a block is required. In
-this case, iteration proceeds as in the preceding paragraph.
-
-Using (({#pipe})) has potential performance advantages. The iteration
-
-  e.collect { |x| x.m }.each { |y| ... }
-
-can be rewritten as
-
-  e.pipe(:m).each { |y| ... }
-
-which doesn't generate an intermediate array, and uses a send instead of a
-proc call. Of course, it could also be written as
-
-  e.each { |x| y = x.m ... }
-
-but that may be undesirable for readability or because the block is to be
-taken from a proc contained in a variable:
-
-  pr = proc { ... }
-  e.pipe(:m).each &pr
-
-Also, chains of (({collect})) and (({select})), such as
-
-  (1..100).collect { |x| x**2 }.select { |y| y > 1000 && y < 2000 }
-
-can't be easily rewritten as a single (({select})).
-
-===examples
-
-  require 'enum/pipe'
-
-  [0,1,2,3,4].pipe { |x| x + 1 }.each { |x|
-    print x, " "
-  }
-  
-  # prints: 1 2 3 4 5
-  
-  stooges = ['lARRY', 'cURLY', 'mOE']
-  p stooges.pipe(:swapcase).reject { |x| x =~ /url/ }
-  p stooges.pipe(:tr, 'RlcOEL', 'gBboog').pipe(:capitalize).entries
-  
-  # prints:  ["Larry", "Moe"]
-  #          ["Baggy", "Buggy", "Moo"]
-
-==version
-
-Enumerable tools 1.6
-
-The current version of this software can be found at 
-((<"http://redshift.sourceforge.net/enum
-"|URL:http://redshift.sourceforge.net/enum>)).
-
-==license
-This software is distributed under the Ruby license.
-See ((<"http://www.ruby-lang.org"|URL:http://www.ruby-lang.org>)).
-
-==author
-Joel VanderWerf,
-((<vjoel@users.sourceforge.net|URL:mailto:vjoel@users.sourceforge.net>))
-
-=end
-
-
-if __FILE__ == $0
-
-  [0,1,2,3,4].pipe { |x| x + 1 }.each { |x|
-    print x, " "
-  }
-  puts
-
-  stooges = ['lARRY', 'cURLY', 'mOE']
-  p stooges.pipe(:swapcase).reject { |x| x =~ /url/ }
-  p stooges.pipe(:tr, 'RlcOEL', 'gBboog').pipe(:capitalize).entries
-
-end