rdx 0.9.0.pre

data/examples/ruby-2.0.0-p0/install/stdlib/diffs/lib/securerandom.rb.diff

@@ -0,0 +1,144 @@
+--- stdlib/orig/lib/securerandom.rb	2015-06-11 07:51:45 +0000
++++ stdlib/patched/lib/securerandom.rb	2015-06-25 16:18:59 +0000
+@@ -1,3 +1,8 @@
++begin
++  require 'openssl'
++rescue LoadError
++end
++
+ # = Secure random number generator interface.
+ #
+ # This library is an interface for secure random number generator which is
+@@ -11,32 +16,24 @@
+ #
+ # == Example
+ #
+-# # random hexadecimal string.
+-# p SecureRandom.hex(10) #=> "52750b30ffbc7de3b362"
+-# p SecureRandom.hex(10) #=> "92b15d6c8dc4beb5f559"
+-# p SecureRandom.hex(11) #=> "6aca1b5c58e4863e6b81b8"
+-# p SecureRandom.hex(12) #=> "94b2fff3e7fd9b9c391a2306"
+-# p SecureRandom.hex(13) #=> "39b290146bea6ce975c37cfc23"
+-# ...
+-#
+-# # random base64 string.
+-# p SecureRandom.base64(10) #=> "EcmTPZwWRAozdA=="
+-# p SecureRandom.base64(10) #=> "9b0nsevdwNuM/w=="
+-# p SecureRandom.base64(10) #=> "KO1nIU+p9DKxGg=="
+-# p SecureRandom.base64(11) #=> "l7XEiFja+8EKEtY="
+-# p SecureRandom.base64(12) #=> "7kJSM/MzBJI+75j8"
+-# p SecureRandom.base64(13) #=> "vKLJ0tXBHqQOuIcSIg=="
+-# ...
+-#
+-# # random binary string.
+-# p SecureRandom.random_bytes(10) #=> "\016\t{\370g\310pbr\301"
+-# p SecureRandom.random_bytes(10) #=> "\323U\030TO\234\357\020\a\337"
+-# ...
+-
+-begin
+-  require 'openssl'
+-rescue LoadError
+-end
++#   # random hexadecimal string:
++#   SecureRandom.hex(10) #-> "52750b30ffbc7de3b362"
++#   SecureRandom.hex(10) #-> "92b15d6c8dc4beb5f559"
++#   SecureRandom.hex(11) #-> "6aca1b5c58e4863e6b81b8"
++#   SecureRandom.hex(12) #-> "94b2fff3e7fd9b9c391a2306"
++#   SecureRandom.hex(13) #-> "39b290146bea6ce975c37cfc23"
++#
++#   # random base64 string:
++#   SecureRandom.base64(10) #-> "EcmTPZwWRAozdA=="
++#   SecureRandom.base64(10) #-> "9b0nsevdwNuM/w=="
++#   SecureRandom.base64(10) #-> "KO1nIU+p9DKxGg=="
++#   SecureRandom.base64(11) #-> "l7XEiFja+8EKEtY="
++#   SecureRandom.base64(12) #-> "7kJSM/MzBJI+75j8"
++#   SecureRandom.base64(13) #-> "vKLJ0tXBHqQOuIcSIg=="
++#
++#   # random binary string:
++#   SecureRandom.random_bytes(10) #-> "\016\t{\370g\310pbr\301"
++#   SecureRandom.random_bytes(10) #-> "\323U\030TO\234\357\020\a\337"
+ 
+ module SecureRandom
+   # SecureRandom.random_bytes generates a random binary string.
+@@ -48,8 +45,8 @@
+   #
+   # The result may contain any byte: "\x00" - "\xff".
+   #
+-  #   p SecureRandom.random_bytes #=> "\xD8\\\xE0\xF4\r\xB2\xFC*WM\xFF\x83\x18\xF45\xB6"
+-  #   p SecureRandom.random_bytes #=> "m\xDC\xFC/\a\x00Uf\xB2\xB2P\xBD\xFF6S\x97"
++  #   SecureRandom.random_bytes #-> "\xD8\\\xE0\xF4\r\xB2\xFC*WM\xFF\x83\x18\xF45\xB6"
++  #   SecureRandom.random_bytes #-> "m\xDC\xFC/\a\x00Uf\xB2\xB2P\xBD\xFF6S\x97"
+   #
+   # If secure random number generator is not available,
+   # NotImplementedError is raised.
+@@ -132,8 +129,8 @@
+   #
+   # The result may contain 0-9 and a-f.
+   #
+-  #   p SecureRandom.hex #=> "eb693ec8252cd630102fd0d0fb7c3485"
+-  #   p SecureRandom.hex #=> "91dc3bfb4de5b11d029d376634589b61"
++  #   SecureRandom.hex #-> "eb693ec8252cd630102fd0d0fb7c3485"
++  #   SecureRandom.hex #-> "91dc3bfb4de5b11d029d376634589b61"
+   #
+   # If secure random number generator is not available,
+   # NotImplementedError is raised.
+@@ -151,8 +148,8 @@
+   #
+   # The result may contain A-Z, a-z, 0-9, "+", "/" and "=".
+   #
+-  #   p SecureRandom.base64 #=> "/2BuBuLf3+WfSKyQbRcc/A=="
+-  #   p SecureRandom.base64 #=> "6BbW0pxO0YENxn38HMUbcQ=="
++  #   SecureRandom.base64 #-> "/2BuBuLf3+WfSKyQbRcc/A=="
++  #   SecureRandom.base64 #-> "6BbW0pxO0YENxn38HMUbcQ=="
+   #
+   # If secure random number generator is not available,
+   # NotImplementedError is raised.
+@@ -178,11 +175,11 @@
+   # The result may contain A-Z, a-z, 0-9, "-" and "_".
+   # "=" is also used if _padding_ is true.
+   #
+-  #   p SecureRandom.urlsafe_base64 #=> "b4GOKm4pOYU_-BOXcrUGDg"
+-  #   p SecureRandom.urlsafe_base64 #=> "UZLdOkzop70Ddx-IJR0ABg"
++  #   SecureRandom.urlsafe_base64 #-> "b4GOKm4pOYU_-BOXcrUGDg"
++  #   SecureRandom.urlsafe_base64 #-> "UZLdOkzop70Ddx-IJR0ABg"
+   #
+-  #   p SecureRandom.urlsafe_base64(nil, true) #=> "i0XQ-7gglIsHGV2_BNPrdQ=="
+-  #   p SecureRandom.urlsafe_base64(nil, true) #=> "-M8rLhr7JEpJlqFGUMmOxg=="
++  #   SecureRandom.urlsafe_base64(nil, true) #-> "i0XQ-7gglIsHGV2_BNPrdQ=="
++  #   SecureRandom.urlsafe_base64(nil, true) #-> "-M8rLhr7JEpJlqFGUMmOxg=="
+   #
+   # If secure random number generator is not available,
+   # NotImplementedError is raised.
+@@ -202,15 +199,15 @@
+   # SecureRandom.random_number returns an integer:
+   # 0 <= SecureRandom.random_number(n) < n.
+   #
+-  #   p SecureRandom.random_number(100) #=> 15
+-  #   p SecureRandom.random_number(100) #=> 88
++  #   SecureRandom.random_number(100) #-> 15
++  #   SecureRandom.random_number(100) #-> 88
+   #
+   # If 0 is given or an argument is not given,
+   # SecureRandom.random_number returns a float:
+   # 0.0 <= SecureRandom.random_number() < 1.0.
+   #
+-  #   p SecureRandom.random_number #=> 0.596506046187744
+-  #   p SecureRandom.random_number #=> 0.350621695741409
++  #   SecureRandom.random_number #-> 0.596506046187744
++  #   SecureRandom.random_number #-> 0.350621695741409
+   #
+   def self.random_number(n=0)
+     if 0 < n
+@@ -235,9 +232,9 @@
+ 
+   # SecureRandom.uuid generates a v4 random UUID (Universally Unique IDentifier).
+   #
+-  #   p SecureRandom.uuid #=> "2d931510-d99f-494a-8c67-87feb05e1594"
+-  #   p SecureRandom.uuid #=> "bad85eb9-0713-4da7-8d36-07a8e4b00eab"
+-  #   p SecureRandom.uuid #=> "62936e70-1815-439b-bf89-8492855a7e6b"
++  #   SecureRandom.uuid #-> "2d931510-d99f-494a-8c67-87feb05e1594"
++  #   SecureRandom.uuid #-> "bad85eb9-0713-4da7-8d36-07a8e4b00eab"
++  #   SecureRandom.uuid #-> "62936e70-1815-439b-bf89-8492855a7e6b"
+   #
+   # The version 4 UUID is purely random (except the version).
+   # It doesn't contain meaningful information such as MAC address, time, etc.

data/examples/ruby-2.0.0-p0/install/stdlib/diffs/lib/set.rb.diff

@@ -0,0 +1,637 @@
+--- stdlib/orig/lib/set.rb	2015-06-11 07:51:45 +0000
++++ stdlib/patched/lib/set.rb	2015-06-25 16:24:02 +0000
+@@ -8,6 +8,7 @@
+ # All rights reserved.  You can redistribute and/or modify it under the same
+ # terms as Ruby.
+ #
++# :rdx: off
+ #   $Id: set.rb 37839 2012-11-24 18:51:45Z knu $
+ #
+ # == Overview
+@@ -45,31 +46,57 @@
+ # == Example
+ #
+ #   require 'set'
+-#   s1 = Set.new [1, 2]                   # -> #<Set: {1, 2}>
+-#   s2 = [1, 2].to_set                    # -> #<Set: {1, 2}>
+-#   s1 == s2                              # -> true
+-#   s1.add("foo")                         # -> #<Set: {1, 2, "foo"}>
+-#   s1.merge([2, 6])                      # -> #<Set: {6, 1, 2, "foo"}>
+-#   s1.subset? s2                         # -> false
+-#   s2.subset? s1                         # -> true
++#   s1 = Set.new [1, 2]                   # => Set[1, 2]
++#   s2 = [1, 2].to_set                    # => Set[1, 2]
++#   s1 == s2                              # => true
++#   s1.add("foo")                         # => Set[1, 2, "foo"]
++#   s1.merge([2, 6])                      # => Set[1, 2, "foo", 6]
++#   s1.subset? s2                         # => false
++#   s2.subset? s1                         # => true
+ #
+ # == Contact
+ #
++# :rdx: off
+ #   - Akinori MUSHA <knu@iDaemons.org> (current maintainer)
+ #
+ class Set
+   include Enumerable
+ 
+   # Creates a new set containing the given objects.
++	#   Set[]
++  #   Set[nil]
++  #   Set[1,2,3]
++	# Eventual duplicates will be removed:
++	#   Set[2,4,6,4] # => Set[2,4,6]
+   def self.[](*ary)
+     new(ary)
+   end
+ 
+   # Creates a new set containing the elements of the given enumerable
+   # object.
+-  #
++	#   Set.new()
++  #   Set.new(nil)
++  #   Set.new([])         # => Set[]
++  #   Set.new([1,2])      # => Set[1,2]
++  #   Set.new('a'..'c')   # => Set['a', 'b', 'c']
++	#   Set.new(false) # raises: ArgumentError
++	#   Set.new(1)     # raises: ArgumentError
++	#   Set.new(1,2)   # raises: ArgumentError
++	# An empty set is created if the parameter passed is +nil+:
++	#   Set.new().size #=> 0
++	#   Set.new(nil).size #=> 0
++	#   Set.new([]).size #=> 0
++	#   Set.new([nil]).size #=> 1
++	# The set doesn't rely on the collection used to build it:
++	#   ary = [2,4,6,4]
++  #   set = Set.new(ary)
++  #   ary.clear
++	#   set.empty? #=> false
++	#   set.size   #=> 3
+   # If a block is given, the elements of enum are preprocessed by the
+   # given block.
++	#   ary = [1,2,3]
++  #   Set.new(ary) { |o| o * 2 } #=> Set[2,4,6]
+   def initialize(enum = nil, &block) # :yields: o
+     @hash ||= Hash.new
+ 
+@@ -93,7 +120,20 @@
+   end
+   private :do_with_enum
+ 
++	# :rdx:
++	# test_clone
++	#   set1 = Set.new
++  #   set2 = set1.clone
++  #   set1 << 'abc'
++	#   set2 #=> Set.new
++	
+   # Copy internal hash.
++	#   set1 = Set[1,2]
++  #   set2 = set1.dup
++	#   set1 == set2      #=> true
++  #   set1.equal?(set2) #=> false   # but different objects
++	#   set1.add(3)
++	#   set1 == set2      #=> false   # now different content
+   def initialize_copy(orig)
+     @hash = orig.instance_variable_get(:@hash).dup
+   end
+@@ -117,17 +157,30 @@
+   end
+ 
+   # Returns the number of elements.
++	#   Set[].size       # => 0
++	#   Set[nil].size    # => 1
++	#   Set[[]].size     # => 1
++	#   Set[[nil]].size  # => 1
++	#-- rdx redundant for documentation
++	#   Set[].size       # => 0
++	#   Set[1,2].size    # => 2
++	#   Set[1,2,1].size  # => 2
+   def size
+     @hash.size
+   end
+   alias length size
+ 
+   # Returns true if the set contains no elements.
++	#   Set[].empty?      #=> true
++	#   Set[1,2].empty?   #=> false
+   def empty?
+     @hash.empty?
+   end
+ 
+   # Removes all elements and returns self.
++	#   set = Set[1,2]
++  #   set.clear #=> set   # still same object
++  #   set.empty?      #=> true
+   def clear
+     @hash.clear
+     self
+@@ -135,6 +188,9 @@
+ 
+   # Replaces the contents of the set with the contents of the given
+   # enumerable object and returns self.
++	#   set = Set[1,2]
++	#   set.replace('a'..'c') #=> set
++	#   set #=> Set['a','b','c']
+   def replace(enum)
+     if enum.instance_of?(self.class)
+       @hash.replace(enum.instance_variable_get(:@hash))
+@@ -146,7 +202,8 @@
+     self
+   end
+ 
+-  # Converts the set to an array.  The order of elements is uncertain.
++  # Converts the set to an array. The order of elements is uncertain.
++	#   Set[1,2,3,2].to_a.sort #=> [1,2,3]
+   def to_a
+     @hash.keys
+   end
+@@ -172,12 +229,42 @@
+ 
+   # Returns a new set that is a copy of the set, flattening each
+   # containing set recursively.
++	#   set1 = Set[1,
++	#     Set[5,
++	#       Set[7, Set[0] ],
++	#       Set[6,2],
++	#     1],
++	#   3, Set[3,4] ]
++	#   set2 = set1.flatten
++	#   set3 = Set.new(0..7)
++	#   set1.equal?(set2) #=> false
++	#   set2 == set3      #=> true
++	#   # destructive
++	#   orig_set1 = set1
++  #   set1.flatten! #=> orig_set1
++	#   set1 == set3 #=> true
++	#   # miscellaneous
++  #   empty = Set[]
++  #   set = Set[ Set[empty,"a"], Set[empty,"b"] ]
++	#   set.flatten #=> Set['a','b']
++	#   set1 = empty.merge(Set["no_more", set])
+   def flatten
+     self.class.new.flatten_merge(self)
+   end
+ 
+   # Equivalent to Set#flatten, but replaces the receiver with the
+   # result in place.  Returns nil if no modifications were made.
++	#   Set.new(0..31).flatten! #=> nil
++	#   Set[ Set[], Set[1,2] ].flatten! #=> Set[1,2]
++	# Multiple occurrences of a set in an set are simply ignored:
++	#   set1 = Set[1, 2]
++  #   set2 = Set[set1, Set[set1, 4], 3]
++	#   set2.flatten! #=> Set.new(1..4)
++	# By contrast the attempt to flatten a recursive set is detected:
++  #   set2 = Set[]
++	#   set1 = Set[1, set2]
++	#   set2.add(set1)
++	#   set1.flatten! # raises ArgumentError
+   def flatten!
+     if detect { |e| e.is_a?(Set) }
+       replace(flatten())
+@@ -187,12 +274,39 @@
+   end
+ 
+   # Returns true if the set contains the given object.
++	#   set = Set[1,2,3]
++	#   set.include?(0) #=> false
++	#   set.include?(1) #=> true
++	#-- rdx
++	#   set.include?(2) #=> true
++	#   set.include?(3) #=> true
++	#   set.include?(nil) #=> false
++	#   set = Set["1",nil,"2",nil,"0","1",false]
++	#   set.include?(nil) #=> true
++	#   set.include?(false) #=> true
++	#   set.include?('1') #=> true
++	#   set.include?(0) #=> false
++	#   set.include?(false) #=> true
++	#   set.include?(false) #=> true
+   def include?(o)
+     @hash.include?(o)
+   end
+   alias member? include?
+ 
+   # Returns true if the set is a superset of the given set.
++	#   set = Set[1,2,3]
++	#   set.superset?([2]) # raises: ArgumentError
++	#   set.superset?(Set[1,2]) #=> true
++	#   set >= Set[1,2,3] #=> true
++	#   set.superset?(Set[1,2,3,4]) #=> false
++	#   set.superset?(Set[]) #=> true
++	#   Set[].superset?(Set[]) #=> true
++	#-- rdx
++	#   set.superset?()    # raises: ArgumentError
++	#   set.superset?(2)   # raises: ArgumentError
++	#   set.superset?(Set[1,2,3]) #=> true
++	#   set >= Set[1,2] #=> true
++	#   set.superset?(Set[1,4]) #=> false
+   def superset?(set)
+     set.is_a?(Set) or raise ArgumentError, "value must be a set"
+     return false if size < set.size
+@@ -201,6 +315,19 @@
+   alias >= superset?
+ 
+   # Returns true if the set is a proper superset of the given set.
++	#   set = Set[1,2,3]
++	#   set.proper_superset?([2]) # raises: ArgumentError
++	#   set.proper_superset?(Set[1,2]) #=> true
++	#   set > Set[1,2,3] #=> false
++	#   set.proper_superset?(Set[1,2,3,4]) #=> false
++	#   set.proper_superset?(Set[]) #=> true
++	#   Set[].proper_superset?(Set[]) #=> false
++	#-- rdx
++	#   set.proper_superset?()    # raises: ArgumentError
++	#   set.proper_superset?(2)   # raises: ArgumentError
++	#   set.proper_superset?(Set[1,2,3]) #=> false
++	#   set > Set[1,2] #=> true
++	#   set.proper_superset?(Set[1,4]) #=> false
+   def proper_superset?(set)
+     set.is_a?(Set) or raise ArgumentError, "value must be a set"
+     return false if size <= set.size
+@@ -209,6 +336,19 @@
+   alias > proper_superset?
+ 
+   # Returns true if the set is a subset of the given set.
++	#   set = Set[1,2,3]
++	#   set.subset?([2]) # raises: ArgumentError
++	#   set.subset?(Set[1,2]) #=> false
++	#   set <= Set[1,2,3] #=> true
++	#   set.subset?(Set[1,2,3,4]) #=> true
++	#   set.subset?(Set[]) #=> false
++	#   Set[].subset?(Set[]) #=> true
++	#-- rdx
++	#   set.subset?()    # raises: ArgumentError
++	#   set.subset?(2)   # raises: ArgumentError
++	#   set.subset?(Set[1,2,3]) #=> true
++	#   set <= Set[1,2] #=> false
++	#   set.subset?(Set[1,4]) #=> false
+   def subset?(set)
+     set.is_a?(Set) or raise ArgumentError, "value must be a set"
+     return false if set.size < size
+@@ -217,6 +357,20 @@
+   alias <= subset?
+ 
+   # Returns true if the set is a proper subset of the given set.
++	# Returns true if the set is a subset of the given set.
++	#   set = Set[1,2,3]
++	#   set.proper_subset?([2]) # raises: ArgumentError
++	#   set.proper_subset?(Set[1,2]) #=> false
++	#   set < Set[1,2,3] #=> false
++	#   set.proper_subset?(Set[1,2,3,4]) #=> true
++	#   set.proper_subset?(Set[]) #=> false
++	#   Set[].proper_subset?(Set[]) #=> false
++	#-- rdx
++	#   set.proper_subset?()    # raises: ArgumentError
++	#   set.proper_subset?(2)   # raises: ArgumentError
++	#   set.proper_subset?(Set[1,2,3]) #=> false
++	#   set < Set[1,2] #=> false
++	#   set.proper_subset?(Set[1,4]) #=> false
+   def proper_subset?(set)
+     set.is_a?(Set) or raise ArgumentError, "value must be a set"
+     return false if set.size <= size
+@@ -227,6 +381,13 @@
+   # Calls the given block once for each element in the set, passing
+   # the element as parameter.  Returns an enumerator if no block is
+   # given.
++	#   ary = [1,3,5,7,10,20]
++  #   set = Set.new(ary)
++	#   set.each{ |o| } #=> set
++	#   set.each #=> #<Enumerator>
++	#--
++	#   set.each { |o| ary.delete(o) or raise "unexpected element: #{o}" }
++  #   ary.empty? or raise "forgotten elements: #{ary.join(', ')}" # pass
+   def each(&block)
+     block or return enum_for(__method__)
+     @hash.each_key(&block)
+@@ -235,6 +396,11 @@
+ 
+   # Adds the given object to the set and returns self.  Use +merge+ to
+   # add many elements at once.
++	#   set = Set[1,2,3]
++	#   set.add(2) #=> set
++	#   set #=> Set[1,2,3]
++	#   set.add(4) #=> set
++	#   set #=> Set[1,2,3,4]
+   def add(o)
+     @hash[o] = true
+     self
+@@ -243,6 +409,11 @@
+ 
+   # Adds the given object to the set and returns self.  If the
+   # object is already in the set, returns nil.
++	#   set = Set[1,2,3]
++	#   set.add?(2) #=> nil
++	#   set #=> Set[1,2,3]
++	#   set.add?(5) #=> set
++	#   set #=> Set[1,2,3,5]
+   def add?(o)
+     if include?(o)
+       nil
+@@ -253,6 +424,11 @@
+ 
+   # Deletes the given object from the set and returns self.  Use +subtract+ to
+   # delete many items at once.
++	#   set = Set[1,2,3]
++  #   set.delete(4) #=> set
++	#   set #=> Set[1,2,3]
++	#   set.delete(2) #=> set
++	#   set #=> Set[1,3]
+   def delete(o)
+     @hash.delete(o)
+     self
+@@ -260,6 +436,11 @@
+ 
+   # Deletes the given object from the set and returns self.  If the
+   # object is not in the set, returns nil.
++	#   set = Set[1,2,3]
++	#   set.delete?(4) #=> nil
++	#   set #=> Set[1,2,3]
++	#   set.delete?(1) #=> set
++	#   set #=> Set[2,3]
+   def delete?(o)
+     if include?(o)
+       delete(o)
+@@ -270,6 +451,11 @@
+ 
+   # Deletes every element of the set for which block evaluates to
+   # true, and returns self.
++	#   set = Set.new(1..10)
++  #   set.delete_if { |i| i > 10 } #=> set
++	#   set #=> Set[*1..10]
++	#   set.delete_if { |i| i % 3 == 0 } #=> set
++	#   set #=> Set[1,2,4,5,7,8,10]
+   def delete_if
+     block_given? or return enum_for(__method__)
+     to_a.each { |o| @hash.delete(o) if yield(o) }
+@@ -285,6 +471,15 @@
+   end
+ 
+   # Replaces the elements with ones returned by collect().
++	#   set = Set[1,2,3,'a','b','c',-1..1,2..4]
++  #   set.collect! do |i|
++  #     case i
++  #     when Numeric; i * 2
++  #     when String; i.upcase
++  #     else; nil
++  #     end
++  #   end #=> set
++	#   set # => Set[2,4,6,'A','B','C',nil]
+   def collect!
+     block_given? or return enum_for(__method__)
+     set = self.class.new
+@@ -295,6 +490,11 @@
+ 
+   # Equivalent to Set#delete_if, but returns nil if no changes were
+   # made.
++	#   set = Set[*1..10]
++	#   set.reject! { |i| i > 10 } #=> nil
++	#   set #=> Set[*1..10]
++	#   set.reject! { |i| i % 3 == 0 } #=> set
++	#   set #=> Set[1,2,4,5,7,8,10]
+   def reject!(&block)
+     block or return enum_for(__method__)
+     n = size
+@@ -313,6 +513,9 @@
+ 
+   # Merges the elements of the given enumerable object to the set and
+   # returns self.
++	#   set = Set[1,2,3]
++  #   set.merge([2,4,6]) #=> set
++	#   set #=> Set[1,2,3,4,6]
+   def merge(enum)
+     if enum.instance_of?(self.class)
+       @hash.update(enum.instance_variable_get(:@hash))
+@@ -325,6 +528,9 @@
+ 
+   # Deletes every element that appears in the given enumerable object
+   # and returns self.
++	#   set = Set[1,2,3]
++	#   set.subtract([2,4,6]) #=> set
++	#   set #=> Set[1,3]
+   def subtract(enum)
+     do_with_enum(enum) { |o| delete(o) }
+     self
+@@ -332,6 +538,9 @@
+ 
+   # Returns a new set built by merging the set and the elements of the
+   # given enumerable object.
++	#   set = Set[1,2,3]
++  #   set + [2,4,6] #=> Set[1,2,3,4,6]
++	#   set #=> Set[1,2,3]
+   def |(enum)
+     dup.merge(enum)
+   end
+@@ -340,6 +549,9 @@
+ 
+   # Returns a new set built by duplicating the set, removing every
+   # element that appears in the given enumerable object.
++	#   set = Set[1,2,3]
++  #   set - [2,4,6] #=> Set[1,3]
++	#   set #=> Set[1,2,3]
+   def -(enum)
+     dup.subtract(enum)
+   end
+@@ -347,6 +559,9 @@
+ 
+   # Returns a new set containing elements common to the set and the
+   # given enumerable object.
++	#   set = Set[1,2,3,4]
++  #   set & [2,4,6] #=> Set[2,4]
++	#   set #=> Set[1,2,3,4]
+   def &(enum)
+     n = self.class.new
+     do_with_enum(enum) { |o| n.add(o) if include?(o) }
+@@ -357,6 +572,9 @@
+   # Returns a new set containing elements exclusive between the set
+   # and the given enumerable object.  (set ^ enum) is equivalent to
+   # ((set | enum) - (set & enum)).
++	#   set = Set[1,2,3,4]
++  #   set ^ [2,4,5,5] #=> Set[1,3,5]
++	#   set #=> Set[1,2,3,4]
+   def ^(enum)
+     n = Set.new(enum)
+     each { |o| if n.include?(o) then n.delete(o) else n.add(o) end }
+@@ -365,6 +583,15 @@
+ 
+   # Returns true if two sets are equal.  The equality of each couple
+   # of elements is defined according to Object#eql?.
++	#   set1 = Set[2,3,1]
++  #   set2 = Set[1,2,3]
++	#   set1 == set1 #=> true
++	#   set1 == set2 #=> true
++	#   Set[1] == [1] #=> false
++	#   set1 == set1.clone #=> true
++	#-- rdx
++	#   set2 == set2.clone #=> true
++	#   Set[Exception.new,nil] != Set[Exception.new,Exception.new] #=> true # [ruby-dev:26127]
+   def ==(other)
+     if self.equal?(other)
+       true
+@@ -386,19 +613,53 @@
+     @hash.eql?(o.instance_variable_get(:@hash))
+   end
+ 
++	# :rdx: in_tmpdir!
++	# 
+   # Classifies the set by the return value of the given block and
+   # returns a hash of {value => set of elements} pairs.  The block is
+   # called once for each element of the set, passing the element as
+   # parameter.
+   #
+   # e.g.:
+-  #
++	# 
++	#-- rdx
++	#   {
++	#     'a' => 2000,
++	#     'b' => 2000,
++	#     'c' => 2001,
++	#     'd' => 2001,
++	#     'e' => 2001,
++	#     'f' => 2002
++	#   }.each do |fname,year|
++	#     fname = "#{fname}.rb"
++	#     File.write fname, ''
++	#     File.utime Time.at(0), Time.new(year), fname
++	#   end
++	#++
++	# 
+   #   require 'set'
+   #   files = Set.new(Dir.glob("*.rb"))
+-  #   hash = files.classify { |f| File.mtime(f).year }
+-  #   p hash    # => {2000=>#<Set: {"a.rb", "b.rb"}>,
+-  #             #     2001=>#<Set: {"c.rb", "d.rb", "e.rb"}>,
+-  #             #     2002=>#<Set: {"f.rb"}>}
++  #   files.classify { |f| File.mtime(f).year }
++	#   # => {
++	#   #   2000 => Set["a.rb", "b.rb"],
++	#   #   2001 => Set["c.rb", "d.rb", "e.rb"],
++	#   #   2002 => Set["f.rb"]
++	#   # }
++	#   
++	#   Set.new(1..10).classify { |i| i % 3 }
++	#   # => {
++	#   #   0 => Set[3,6,9],
++	#   #   1 => Set[1,4,7,10],
++	#   #   2 => Set[2,5,8]
++	#   # }
++	#-- the equivalent, more verbose
++	#   set = Set.new(1..10)
++  #   ret = set.classify { |i| i % 3 } #=> #<Hash:0x0001e42a>
++	#   ret.size #=> 3
++	#   # ret.each_value { |value| assert_instance_of(Set, value) }: REDUNDANT
++	#   ret[0] #=> Set[3,6,9]
++	#   ret[1] #=> Set[1,4,7,10]
++	#   ret[2] #=> Set[2,5,8]
+   def classify # :yields: o
+     block_given? or return enum_for(__method__)
+ 
+@@ -423,11 +684,29 @@
+   #
+   #   require 'set'
+   #   numbers = Set[1, 3, 4, 6, 9, 10, 11]
+-  #   set = numbers.divide { |i,j| (i - j).abs == 1 }
+-  #   p set     # => #<Set: {#<Set: {1}>,
+-  #             #            #<Set: {11, 9, 10}>,
+-  #             #            #<Set: {3, 4}>,
+-  #             #            #<Set: {6}>}>
++  #   numbers.divide { |i,j| (i - j).abs == 1 }
++	#   # => Set[
++	#   #   Set[1],
++	#   #   Set[11, 9, 10],
++	#   #   Set[3, 4],
++	#   #   Set[6]
++	#   # ]
++	#   
++	#   set = Set.new(1..10)
++  #   ret = set.divide { |i| i % 3 }
++	#   ret.size #=> 3
++	#   ret.reduce(0) { |s,p| s + p.size } #=> set.size
++	#   ret.flatten == set #=> true
++	#-- rdx similar to the example above
++	#   set = Set[7,10,5,11,1,3,4,9,0]
++	#   ret = set.divide { |a,b| (a - b).abs == 1 }
++	#   ret.size #=> 4
++	#   ret.reduce(0) { |s,p| s + p.size } #=> set.size
++	#   ret.flatten == set #=> true
++	#   ret.find{ |s| s.include?(0) } #=> Set[0,1]
++	#   ret.find{ |s| s.include?(3) } #=> Set[3,4,5]
++	#   ret.find{ |s| s.include?(7) } #=> Set[7]
++	#   ret.find{ |s| s.include?(9) } #=> Set[9,10,11]
+   def divide(&func)
+     func or return enum_for(__method__)
+ 
+@@ -462,6 +741,12 @@
+ 
+   # Returns a string containing a human-readable representation of the
+   # set. ("#<Set: {element1, element2, ...}>")
++	#   set1 = Set[1]
++	#   set1.inspect #=> '#<Set: {1}>'
++	#   set2 = Set[set1]
++	#   set2.inspect #=> '#<Set: {#<Set: {1}>}>'
++	#   set1.add(set2)
++	#   set1.inspect #=> '#<Set: {1, #<Set: {#<Set: {...}>}>}>'
+   def inspect
+     ids = (Thread.current[InspectKey] ||= [])
+ 
+@@ -508,18 +793,41 @@
+ # == Example
+ #
+ #   require "set"
+-#
++#   
+ #   set = SortedSet.new([2, 1, 5, 6, 4, 5, 3, 3, 3])
+ #   ary = []
+-#
++#   
+ #   set.each do |obj|
+ #     ary << obj
+ #   end
+-#
+-#   p ary # => [1, 2, 3, 4, 5, 6]
+-#
++#   ary # => [1, 2, 3, 4, 5, 6]
+ #   set2 = SortedSet.new([1, 2, "3"])
+-#   set2.each { |obj| } # => raises ArgumentError: comparison of Fixnum with String failed
++#   set2.each { |obj| } # raises ArgumentError: comparison of Fixnum with String failed
++#   
++#   s = SortedSet[4,5,3,1,2]
++#   s.to_a #=> [1,2,3,4,5]
++#   s.each{} #=> s
++#   s.collect{ |i| i } #=> [1,2,3,4,5]  # relies on +each+, which works fine
++#   s.map! { |o| -2 * o }.to_a #=> [-10,-8,-6,-4,-2]
++#-- rdx
++#   SortedSet.new([2,1,3]) { |o| o * -2 }.to_a #=> [-6,-4,-2]
++#   s = SortedSet.new(['one', 'two', 'three', 'four'])
++#   a = []
++#   s.delete_if { |o| a << o; o.start_with?('t') } #=> s
++#   s.to_a #=> ['four', 'one']
++#   a #=> %w[four one three two]
++#
++#   s = SortedSet.new(['one', 'two', 'three', 'four'])
++#   a = []
++#   s.reject! { |o| a << o; o.start_with?('t') } #=> s
++#   s.to_a #=> ['four', 'one']
++#   a #=> ['four', 'one', 'three', 'two']
++#
++#   s = SortedSet.new(['one', 'two', 'three', 'four'])
++#   a = []
++#   s.reject! { |o| a << o; false } #=> nil
++#   s.to_a #=> ['four', 'one', 'three', 'two']
++#   a #=> ['four', 'one', 'three', 'two']
+ #
+ class SortedSet < Set
+   @@setup = false
+@@ -632,6 +940,11 @@
+ module Enumerable
+   # Makes a set from the enumerable object with given arguments.
+   # Needs to +require "set"+ to use this method.
++	#   ary = [2,5,4,3,2,1,3]
++	#   ary.to_set                 #=> Set[2,5,4,3,1]
++	#   ary.to_set { |o| o * -2 }  #=> Set[-4,-10,-8,-6,-2]
++	#   ary.to_set(SortedSet)      #=> SortedSet[1,2,3,4,5]
++	#   ary.to_set { |o| o * -2 }  #=> SortedSet[-10,-8,-6,-4,-2]
+   def to_set(klass = Set, *args, &block)
+     klass.new(self, *args, &block)
+   end