range_extd 1.1.1 → 2.0

data/lib/{range_extd/range_extd.rb → range_extd.rb}

@@ -1,31 +1,22 @@
 # -*- encoding: utf-8 -*-
 
-## Load required files.
-err1st = nil
-req_files = %w(lib/range_extd/infinity/infinity)
+## Load required files in this library.  (At the end of this file, "range_extd/range" is also required.)
+req_files = %w(range_extd/infinity range_extd/nowhere range_extd/nil_class)
 req_files.each do |req_file|
-  while ! req_file.empty?
-    begin
-      require req_file 
-    rescue LoadError => errLoad
-      err1st = errLoad if err1st.nil?
-      if %r@/@ =~ req_file
-        if req_file.sub!(%r@[^/]*/@, '').nil?	# Will search for the next directory down.
-          raise
-        end
-      else
-        req_file = ''
-        break
-      end
-    else
-      break
-    end
+  begin
+    require_relative req_file 
+  rescue LoadError
+    require req_file 
   end
-  if req_file.empty?
-    raise err1st
-  end
-end	# req_files.each do |req_file|
+end
 
+if $DEBUG
+  puts "NOTE: Library full paths:"
+  req_files.each do |elibbase|
+    ar = $LOADED_FEATURES.grep(/(^|\/)#{Regexp.quote(File.basename(elibbase))}(\.rb)?$/).uniq
+    print elibbase+": " if ar.empty?; p ar
+  end
+end
 
 # =Class RangeExtd
 #
@@ -36,20 +27,22 @@ end	# req_files.each do |req_file|
 #
 # Extended Range class that features:
 #  1. includes exclude_begin? (to exclude the "begin" boundary),
-#  2. allows open-ended range (to the infinity),
+#  2. allows open-ended range to the infinity (very similar to beginless/endless Range),
 #  3. defines NONE and ALL constants,
 #  4. the first self-consistent logical structure,
-#  5. complete backward compatibility within the built-in Range.
+#  5. complete compatibility with the built-in Range.
 #
 # The instance of this class is immutable, that is, you can not
 # alter the element once an instance is generated.
 #
+# This class has some constants
+#
 # What is valid is checked with the class method {RangeExtd.valid?}.
 # See the document of that method for the definition.
 #
-# To express open-ended ranges is simple; you just use either of
-# the two (negative and positive, or former and later) constants
-# in RangeExtd::Infinity class.  See the document for detail.
+# This class has two constants:
+# {RangeExtd::NONE} representing an empty range and 
+# {RangeExtd::ALL} representing the entire range, both in the abstract sense.
 #
 # @example An instance of a range of 5 to 8 with both ends being exclusive is created as
 #   r = RangeExtd(5...8, true) 
@@ -93,7 +86,7 @@ class RangeExtd < Range
   #   @option opts [Boolean] :exclude_end If specified, this has the highest priority, or false in default.
   #
   # @overload new(obj_begin, obj_end, [exclude_begin=false, [exclude_end=false]], opts)
-  #   @param obj_begin [Object] Any object that is {Comparable} with end
+  #   @param obj_begin [Object] Any object that is +Comparable+ with end
   #   @param obj_end [Object] Any object that is Comparable with begin
   #   @param exclude_begin [Boolean] If specified, this has the lower priority, or false in default.
   #   @param exclude_end [Boolean] If specified, this has the lower priority, or false in default.
@@ -101,9 +94,9 @@ class RangeExtd < Range
   #   @option opts [Boolean] :exclude_end If specified, this has the higher priority, or false in default.
   #
   # @overload new(obj_begin, string_form, obj_end, [exclude_begin=false, [exclude_end=false]], opts)
-  #   @param obj_begin [Object] Any object that is {Comparable} with end
+  #   @param obj_begin [Object] Any object that is +Comparable+ with end
   #   @param string_form [Object] String form (without pre/postfix) of range expression set by {RangeExtd.middle_strings=}()
-  #   @param obj_end [Object] Any object that is Comparable with begin
+  #   @param obj_end [Object] Any object that is +Comparable+ with begin
   #   @param exclude_begin [Boolean] If specified, this has the lower priority, or false in default.
   #   @param exclude_end [Boolean] If specified, this has the lower priority, or false in default.
   #   @option opts [Boolean] :exclude_begin If specified, this has the higher priority, or false in default.
@@ -126,17 +119,31 @@ class RangeExtd < Range
   # @raise [ArgumentError] particularly if the range to be created is not {#valid?}.
   def initialize(*inar, **hsopt)	# **k expression from Ruby 1.9?
 
+    # This is true only for RangeExtd::NONE,
+    # which is identical to +RangeExtd(nil, nil, true, true)+ without this.
+    @is_none = false
+
     if inar[4] == :Constant
-      # Special case to create two Constants
-      super(*inar[0..2])
+      # Special case to create two Constants (NONE and ALL)
       @rangepart = (inar[2] ? (inar[0]...inar[1]) : (inar[0]..inar[1]))
       @exclude_end, @exclude_begin = inar[2..3]
+
+      # In Ruby-2.7+ and hence RangeExtd Ver.2+, RangeExtd::NONE looks very similar to (nil...nil)
+      # except RangeExtd::NONE.@exclude_begin == true
+      #@is_none = (@rangepart.begin.nil? && @rangepart.end.nil? && @exclude_begin && @exclude_end)
+      @is_none = (@rangepart.begin.respond_to?(:nowhere?) &&
+                  @rangepart.begin.nowhere? &&
+                  @rangepart.end.respond_to?(:nowhere?) &&
+                  @rangepart.end.nowhere? &&
+                  @exclude_begin &&
+                  @exclude_end)
+      raise(ArgumentError, "NONE has been already defined.") if @is_none && self.class.const_defined?(:NONE)  
+      super(*inar[0..2])
       return
     end
 
-    # Note: the order of exclude_begin? and end? is reversed from the input!
     arout = RangeExtd.send(:_get_init_args, *inar, **hsopt)
-    # == [RangeBeginValue, RangeEndValue, exclude_end?, exclude_begin?]
+    # == [RangeBeginValue, RangeEndValue, exclude_begin?, exclude_end?]
 
     ### The following routine is obsolete.
     ### Users, if they wish, should call RangeExtd::Infinity.overwrite_compare() beforehand.
@@ -171,30 +178,27 @@ class RangeExtd < Range
       raise RangeError, "the combination of the arguments does not constitute a valid RangeExtd instance."
     end
 
+    @exclude_end   = arout.pop
     @exclude_begin = arout.pop
-    @exclude_end   = arout[-1]
-    @rangepart = Range.new(*arout)
-    super(*arout)
-
-  end	# def initialize(*inar)
+    artmp = [arout[0], arout[1], @exclude_end]
+    @rangepart = Range.new(*artmp)
+    super(*artmp)
+  end	# def initialize(*inar, **hsopt)
 
 
   # true if self is identical to {RangeExtd::NONE}.
+  #
+  # Overwriting {Range#is_none?}
   # This is different from {#==} method!
+  #
   # @example 
-  #    RangeExtd(0,0,false,false) == RangeExtd::NONE  # => true
-  #    RangeExtd(0,0,false,false).empty?    # => true
-  #    RangeExtd(0,0,false,false).is_none?  # => false
+  #    RangeExtd(0,0,true,true).valid?    # => true
+  #    RangeExtd(0,0,true,true) == RangeExtd::NONE  # => true
+  #    RangeExtd(0,0,true,true).empty?    # => true
+  #    RangeExtd(0,0,true,true).is_none?  # => false
   #    RangeExtd::NONE.is_none?     # => true
   def is_none?
-    self.begin.nil? && self.end.nil? && @exclude_begin && @exclude_end	# Direct comparison with object_id should be OK?
-  end
-
-  # true if self is identical to {RangeExtd::ALL} ({#==} does not mean it at all!)
-  # @example
-  #    (RangeExtd::Infinity::NEGATIVE..RangeExtd::Infinity::POSITIVE).is_all?  # => false
-  def is_all?
-    self.begin.object_id == Infinity::NEGATIVE.object_id && self.end.object_id == Infinity::POSITIVE.object_id && !@exclude_begin && !@exclude_end	# Direct comparison with object_id should not work for this one!! (because users can create an identical one.)
+    @is_none
   end
 
 
@@ -217,11 +221,10 @@ class RangeExtd < Range
   # this returns true, regardless of their boundary values.
   # And any empty range is equal to RangeExtd::Infinity::NONE.
   # 
-  # Note the last example will return false for {#eql?} -- see {#eql?}
-  # 
-  # See {#eql?}
+  # Note the last example will return false for +#eql?+
   # 
   # @example
+  #   (1...1)    == RangeExtd::NONE # => false (b/c the Range is invalid)
   #   (1<...1)   == RangeExtd::NONE # => true
   #   (?a<...?b) == RangeExtd::NONE # => true
   #   (1<...1) == (2<...2)     # => true
@@ -232,25 +235,27 @@ class RangeExtd < Range
   # 
   # @return [Boolean]
   def ==(r)
-    re_equal_core(r, :==)
+    _re_equal_core(r, :==)
   end	# def ==(r)
 
-  # The same as {#==} but it uses eql?() as each comparison.
-  # For the empty ranges, it is similar to {#==}, except
-  # the immediate class has to agree to return true.
-  # Only the exception is the comparison with RangeExtd::Infinity::NONE.
-  # Therefore, 
-  # @example
-  #   (1...5) ==  (1.0...5.0)  # => true
-  #   (1...5).eql?(1.0...5.0)  # => false
-  #   (1<...1).eql?(  RangeExtd::NONE)  # => true
-  #   (?a<...?b).eql?(RangeExtd::NONE)  # => true
-  #   (1<...1).eql?(    3<...4)  # => true
-  #   (1.0<...1.0).eql?(3<...4)  # => false
-  #
-  def eql?(r)
-    re_equal_core(r, :eql?)
-  end	# def eql?(r)
+  # Modification to {#eql?} is dropped in RangeExtd Ver.2
+  #
+  ## The same as {#==} but it uses eql?() as each comparison.
+  ## For the empty ranges, it is similar to {#==}, except
+  ## the immediate class has to agree to return true.
+  ## Only the exception is the comparison with RangeExtd::Infinity::NONE.
+  ## Therefore, 
+  ## @example
+  ##   (1...5) ==  (1.0...5.0)  # => true
+  ##   (1...5).eql?(1.0...5.0)  # => false
+  ##   (1<...1).eql?(  RangeExtd::NONE)  # => true
+  ##   (?a<...?b).eql?(RangeExtd::NONE)  # => true
+  ##   (1<...1).eql?(    3<...4)  # => true
+  ##   (1.0<...1.0).eql?(3<...4)  # => false
+  ##
+  #def eql?(r)
+  #  _re_equal_core(r, :eql?)
+  #end	# def eql?(r)
 
 
   # If the object is open-ended to the negative (Infinity),
@@ -264,7 +269,7 @@ class RangeExtd < Range
   # In the case of the former, after finite trials of [#succ] from ?c, it reaches the end (?z).
   # In the latter, after finit trials of [#succ] from the begin ?a, it reaches the end (?z).
   # Therefore it is theoretically possible to prove it (n.b., the actual
-  # algorithm of built-in {Range#include?} is different and cheating!
+  # algorithm of built-in +Range#include?+ is different and cheating!
   # See below.).
   #
   # However, in the case of
@@ -276,11 +281,11 @@ class RangeExtd < Range
   #
   # Note
   #    (?B..?z) === 'dd'  # => false
-  # as Ruby's {Range} knows the algorithm of {String#succ} and {String#<=>}
-  # and specifically checks with it, before using {Enumerable#include?}.
+  # as Ruby's {Range} knows the algorithm of +String#succ+ and +String#<=>+
+  # and specifically checks with it, before using +Enumerable#include?+.
   # {https://github.com/ruby/ruby/blob/trunk/range.c}
   #
-  # Therefore, even if you change the definition of {String#succ}
+  # Therefore, even if you change the definition of +String#succ+
   # so that 'B'.succ => 'dd', 'dd'.succ => 'z', as follows,
   #    class String
   #      alias :succ_orig :succ
@@ -294,7 +299,7 @@ class RangeExtd < Range
   #        end
   #      end
   #    end
-  # the resutl of {Range#===} will unchange;
+  # the resutl of +Range#===+ will unchange;
   #   (?B..?z) === 'dd'  # => false
   #   (?B..?z).to_a      # => ["B", "dd", "z"]
   #
@@ -307,29 +312,31 @@ class RangeExtd < Range
   def ===(obj)
     # ("a".."z")===("cc")	# => false
 
-    return false if is_none?	# No need of null?(), supposedly!
+    return false if empty?   # n.b, NONE includes nothing, even NOWHERE (because of exclude_begin/end)
 
-    begin
-      1.0+(obj)	# OK if Numeric.
+    rapart = _converted_rangepart
+    beg = rapart.begin
+    if beg.nil? && !beg.nowhere?
+      return rapart.send(__method__, obj)
+    end
 
+    begin
+      _ = 1.0+obj	# OK if Numeric.
+      return cover?(obj)  # This excludes begin() if need be.
     rescue TypeError
-      # obj is not Numeric, hence runs brute-force check.
-      beg = self.begin()
-      if defined?(beg.infinity?) && beg.infinity? || beg == -Infinity::FLOAT_INFINITY
-        return nil
-        # raise TypeError "can't iterate from -Infinity"
-      end
+    end
 
-      each do |ei|
-        if ei == obj
-          return true
-        end
-      end
-      false
+    # obj is not Numeric, hence runs brute-force check.
+    beg = self.begin()
+    if beg.respond_to?(:infinity?) && beg.infinity?
+      return nil
+      # raise TypeError "can't iterate from -Infinity"
+    end
 
-    else
-      cover?(obj)
+    each do |ei|  # This excludes begin() if need be.
+      return true if ei == obj
     end
+    false
   end	# def ===(obj)
 
   alias :include? :===
@@ -443,8 +450,8 @@ class RangeExtd < Range
   #    (Rational(36,10)..5).bsearch{|i| ary[i] >= 11}	=> # TypeError: can't do binary search for Rational (Ruby 2.1)
   #    (3..Rational(61,10)).bsearch{|i| ary[i] >= 11}	=> # TypeError: can't do binary search for Fixnum (Ruby 2.1)
   #
-  # In short, bsearch works only with Integer and/or Float (as in Ruby 2.1).
-  # If either of begin and end is an Float, the search is conducted in Float and the returned value will be Float, unless nil.
+  # +Range#bsearch+ works only with Integer and/or Float (as in Ruby 2.1), not even Rational (as in Ruby 3.1).
+  # If either of begin and end is a Float, the search is conducted in Float and the returned value will be a Float, unless nil.
   # If Float, it searches on the binary plane.
   # If Integer, the search is conducted on the descrete Integer points only,
   # and no search will be made in between the adjascent integers.
@@ -452,7 +459,7 @@ class RangeExtd < Range
   # Given that, {RangeExtd#bsearch} follows basically the same, even when exclude_begin? is true.
   # If either end is Float, it searches between begin*(1+Float::EPSILON) and end.
   # If both are Integer, it searches from begin+1.
-  # When {#exclude_begin?} is false, {RangeExtd#bsearch} is identical to {Range#bsearch}.
+  # When {#exclude_begin?} is false, {RangeExtd#bsearch} is identical to +Range#bsearch+.
   #
   def bsearch(*rest, &bloc)
     if is_none?	# No need of null?(), supposedly!
@@ -482,97 +489,110 @@ class RangeExtd < Range
   end	# def bsearch(*rest, &bloc)
 
 
-  # See {#include?} or {#===}, and {Range#cover?}
+  # This works without modification mostly.
+  #
+  # Presumably because Enumerable#count is called and #each is internally used.
+  # Exceptions are infinities and borderless (nil).
+  #
+  #   (5..).count             # => Float::INFINITY  # exceptional case
+  #   (..5).count             # => Float::INFINITY  # exceptional case
+  #   (..nil).count           # => Float::INFINITY  # exceptional case
+  #   (-Float::INFINITY..nil) # => Float::INFINITY  # exceptional case
+  #   (-Float::INFINITY..Float::INFINITY).count  # raises (TypeError) "can't iterate from Float"
+  #   (..5).count(4)          # raises (TypeError)
+  #   (..5).count{|i| i<3}    # raises (TypeError)
+  #   (1..).count{|i| i<3}    # infinite loop!
+  #
+  # Here I define as another exceptional case:
+  #   RangeExtd::ALL.count    # => Float::INFINITY
+  #
+  # @return [Integer]
+  def count(*rest, &block)
+    return Float::INFINITY if self == RangeExtd::ALL
+    super
+  end
+
+
+  # See {#include?} or {#===}, and +Range#cover?+
   def cover?(i)
     # ("a".."z").cover?("cc")	# => true
     # (?B..?z).cover?('dd')	# => true  (though 'dd'.succ would never reach ?z)
 
-    return false if is_none?	# No need of null?(), supposedly!
+    return false if empty?  # equivalent to null? in this case because self is alwasy true==valid?
 
-    if @exclude_begin
-      if self.begin == i
-        false
-      else
-        @rangepart.send(__method__, i)
-      end
+    if @exclude_begin && self.begin == i
+      false
     else
       @rangepart.send(__method__, i)
     end
   end	# def cover?(i)
 
 
-  # @raise [TypeError] If {#exclude_begin?} is true, and {#begin}() or {#rangepart} does not have a method of [#succ], then even if no block is given, this method raises TypeError straightaway.
+  # slightly modified for {#exclude_begin?} being true
+  #
+  # @raise [TypeError] If {#exclude_begin?} is true, and {#begin}() (+@rangepart+) does not have a method of [#succ], then even if no block is given, this method raises TypeError straightaway.
   # @return [RangeExtd] self
   # @return [Enumerator] if block is not given.
-  #
   def each(*rest, &bloc)
     # (1...3.5).each{|i|print i}	# => '123' to STDOUT
     # (1.3...3.5).each	# => #<Enumerator: 1.3...3.5:each>
     # (1.3...3.5).each{|i|print i}	# => TypeError: can't iterate from Float
     # Note: If the block is not given and if @exclude_begin is true, the self in the returned Enumerator is not the same as self here.
-    if @exclude_begin	# including RangeExtd::NONE
-      if defined? self.begin.succ
-        ret = Range.new(self.begin.succ,self.end,exclude_end?).send(__method__, *rest, &bloc)
-        if block_given?
-          self
-        else
-          ret
-        end
-      elsif is_none?
-        raise TypeError, "can't iterate for NONE range"
-      else
-        raise TypeError, "can't iterate from "+self.begin.class.name
-      end
+
+    _step_each_core(__method__, *rest, &bloc)
+  end
+
+  # Core routine for {#each} and {#step}
+  #
+  # @raise [TypeError] If {#exclude_begin?} is true, and {#begin}() or {#rangepart} does not have a method of [#succ], then even if no block is given, this method raises TypeError straightaway.
+  # @return [RangeExtd] self
+  # @return [Enumerator] if block is not given.
+  def _step_each_core(method, *rest, &bloc)
+    raise TypeError, "can't iterate for NONE range" if is_none?
+
+    if block_given?
+      # when a block is given to {#each}, self should be returned.
+      _converted_rangepart(consider_exclude_begin: true, raises: true ).send(method, *rest, &bloc)
+      self
     else
-      @rangepart.send(__method__, *rest, &bloc)
+      _converted_rangepart(consider_exclude_begin: true, raises: false).send(method, *rest)
     end
   end
+  private :_step_each_core
 
-
-  # Like {Range#last}, if no argument is given, it behaves like {#begin}(), that is, it returns the initial value, regardless of {#exclude_begin?}.
-  # However, if an argument is given (nb., acceptable since Ruby 1.9) when {#exclude_begin?} is true, it returns the array that starts from {#begin}().succ().
+  # Like +Range#last+, if no argument is given, it behaves like {#begin}(), that is, it returns the initial value, regardless of {#exclude_begin?}.
+  #
+  # If an argument is given (nb., acceptable since Ruby 1.9.2) when {#exclude_begin?} is true, it returns the array that starts from {#begin}().succ(), in the same way as +Range#last+ with {#exclude_end?} of +true+.
+  #
+  # The default behaviours are:
+  #
+  #   (1...3.1).last	# => 3.1
+  #   (1...3.1).last(1)	# => [3]
+  #   (1...3.0).last(1)	# => [2]
+  #   (3.0..8).first(1) # raise: can't iterate from Float (TypeError)
+  #
   # @raise [TypeError] if the argument (Numeric) is given and if {#exclude_begin?} is true, yet if {#begin}().succ is not defined, or yet if {#is_none?}
-  # @param rest [Integer] Optional.  Must be non-negative.  Consult {Range#first} for detail.
+  # @raise [RangeError] "cannot get the first element of beginless range" as per Range.
+  # @raise [ArgumentError] if more than 1 arguments are specified (delegated to {Range})
+  # @param rest [Integer] Optional.  Must be non-negative.  Consult +Range#first+ for detail.
   # @return [Object] if no argument is given, equivalent to {#end}.
   # @return [Array] if an argument is given.
   def first(*rest)
-    # (1...3.1).last	# => 3.1
-    # (1...3.1).last(1)	# => [3]
-    if ! @exclude_begin	# hence, not NONE.
-      @rangepart.first(*rest)
-    else
-      case rest.size
-      when 0
-        self.begin
-      when 1
-        if (RUBY_VERSION < "1.9.1") && (1 == rest[0])	# Range#first() does not accept an argument in Ruby 1.8.
-          raise ArgumentError, "wrong number of arguments (#{rest.size} for 0) (Use Ruby 1.9.2 or later)."
-        end
-
-        ## Check the argument.
-        Array.new[ rest[0] ]	# Check Type of rest[0] (if invalid, it should raise TypeError)
-
-        begin
-          if rest[0] < 0
-            raise ArgumentError, "negative array size (or size too big)"
-          end
-        rescue NoMethodError
-          # Should not happen, but just to play safe.
-        end
-
-        ## Main
-        if ! defined? self.begin.succ
-          raise TypeError, "can't iterate from "+self.begin.class.name
-        end
+    if is_none?
+      raise RangeError, "cannot get the first element of RangeExtd::NONE"
+    end
 
-        Range.new(self.begin.succ, self.end, exclude_end?).send(__method__, *rest)
-      else
-        raise ArgumentError, "wrong number of arguments (#{rest.size} for 0..1)"
-      end
-    end		# if ! @exclude_begin
+    ran = _converted_rangepart(transform_to_nil: false, consider_exclude_begin: (1 == rest.size && exclude_begin?))
+    ran.send(__method__, *rest)
   end	# def first(*rest)
 
 
+  # Redefines the hash definition
+  # 
+  # Without re-definition, the hash value does NOT depend on {#exclude_begin?}
+  # presumably because the parent class method +Range#hash+ does not take it
+  # into account (of course).
+  # 
   # When {#exclude_begin?} is true, the returned value is not strictly guaranteed to be unique, though in pracrtice it is most likely to be so.
   # 
   def hash(*rest)
@@ -599,7 +619,8 @@ class RangeExtd < Range
   end
 
 
-  # See {Range#last}.
+  # Updated version of +Range#last+, considering {#exclude_begin?}.
+  #
   # If either (let alone both) side of the edge is Infinity, you can not give
   # an argument in practice, the number of the members of the returned array.
   #
@@ -607,41 +628,55 @@ class RangeExtd < Range
   # @return [Object] if no argument is given, equivalent to {#end}.
   # @return [Array] if an argument is given.
   def last(*rest)
-    return nil if null?
-    nSize = rest.size
-    case nSize
-    when 0
-      self.end
-    when 1
-        if (RUBY_VERSION < "1.9.1") && (1 == rest[0])	# Range#first() does not accept an argument in Ruby 1.8.
-          raise ArgumentError, "wrong number of arguments (#{rest.size} for 0) (Use Ruby 1.9.2 or later)."
-        end
+    if is_none?
+      raise RangeError, "cannot get the last element of RangeExtd::NONE"
+    end
 
-      if  defined?(self.begin.infinity?) && self.begin.infinity? || self.begin == -Infinity::FLOAT_INFINITY
-        raise TypeError, "can't iterate from "+self.begin.to_s
-      elsif defined?(self.end.infinity?) && self.end.infinity?   || self.end   ==  Infinity::FLOAT_INFINITY
-        raise TypeError, "can't get elements to "+self.end.to_s
-      elsif ! defined? self.begin.succ
-        raise TypeError, "can't iterate from "+self.begin.class.name
-      else
-        @rangepart.send(__method__, *rest)
+    _converted_rangepart(transform_to_nil: false).send(__method__, *rest)
+  end	# def last(*rest)
+
+
+  # Converts RangeExtd::Infinity to nil in @rangepart
+  #
+  # @param consider_exclude_begin [Boolean] If true (Default), and if {#exclude_begin?} is true, the first element is ignored.  Note the resultant Range may be +invalid+.
+  # @param transform_to_nil [Boolean] If true (Default), {RangeExtd::Infinity} objects are transformed into nil when appropriate (i.e., {RangeExtd::Infinity::NEGATIVE} should be {RangeExtd#begin} and not at the end, and vice versa).
+  # @param raises [Boolean] If true (Def: false), and if {#exclude_begin?} is true but [#succ] is not defined for {#begin}, this routine raises an Exception as per (almost) Ruby default.
+  # @return [Range]
+  def _converted_rangepart(consider_exclude_begin: true, transform_to_nil: true, raises: false)
+    rbeg = @rangepart.begin
+    if consider_exclude_begin && exclude_begin?
+      if rbeg.respond_to? :succ
+        rbeg = rbeg.succ
+      elsif raises
+        if rbeg.nil?
+          raise RangeError, "cannot get the first element of beginless range"
+        elsif is_none?	# maybe empty?() in some cases?
+          raise RangeError, "cannot get the first element of NONE range"
+        else
+          # This includes {RangeExtd::Infinity} class objects (RangeExtd::Infinity.infinity?(rbeg) == true) and Float::INFINITY.
+          raise TypeError, "can't iterate from "+self.begin.class.name
+        end
       end
-    else
-      raise ArgumentError, "wrong number of arguments (#{rest.size} for 0..1)"
     end
-  end	# def last(*rest)
 
+    rbeg = nil if RangeExtd::Infinity::NEGATIVE == rbeg && transform_to_nil
+    rend = @rangepart.end
+    rend = nil if RangeExtd::Infinity::POSITIVE == rend && transform_to_nil
+
+    Range.new(rbeg, rend, exclude_end?)
+  end
+  private :_converted_rangepart
 
   # See {#first} for the definition when {#exclude_begin?} is true.
   #
   def min(*rest, &bloc)
-    re_min_max_core(__method__, *rest, &bloc)
+    _re_min_max_core(__method__, *rest, &bloc)
   end
 
   # See {#first} for the definition when {#exclude_begin?} is true.
   #
   def min_by(*rest, &bloc)
-    re_min_max_core(__method__, *rest, &bloc)
+    _re_min_max_core(__method__, *rest, &bloc)
   end
 
 
@@ -652,7 +687,7 @@ class RangeExtd < Range
     # (1.3...5).minmax	# => TypeError: can't iterate from Float
     # Note that max() for the same Range raises an exception.
     # In that sense, it is inconsistent!
-    re_min_max_core(__method__, *rest, &bloc)
+    _re_min_max_core(__method__, *rest, &bloc)
   end
 
   # See {#first} for the definition when {#exclude_begin?} is true.
@@ -661,31 +696,31 @@ class RangeExtd < Range
     # (0...3.5).minmax	# => [0, 3]
     # Note that max() for the same Range raises an exception.
     # In that sense, it is inconsistent!
-    re_min_max_core(__method__, *rest, &bloc)
+    _re_min_max_core(__method__, *rest, &bloc)
   end
 
 
   # See {#first} for the definition when {#exclude_begin?} is true.
   #
   def max(*rest, &bloc)
-    re_min_max_core(__method__, *rest, &bloc)
+    _re_min_max_core(__method__, *rest, &bloc)
   end
 
   # See {#first} for the definition when {#exclude_begin?} is true.
   #
   def max_by(*rest, &bloc)
-    re_min_max_core(__method__, *rest, &bloc)
+    _re_min_max_core(__method__, *rest, &bloc)
   end
 
 
-  # Implementation of {Range#size} to this class.
+  # Implementation of +Range#size+ to this class.
   #
   # It is essentially the same, but the behaviour when {#exclude_begin?} is true
   # may not always be natural.
   # See {#first} for the definition when {#exclude_begin?} is true.
   #
-  # {Range#size} only works for Numeric ranges.
-  # And in {Range#size}, the value is calculated when the initial value is
+  # +Range#size+ only works for Numeric ranges.
+  # And in +Range#size+, the value is calculated when the initial value is
   # non-Integer, by stepping by 1.0 from the {#begin} value, and the returned
   # value is an integer.
   # For example,
@@ -746,18 +781,19 @@ class RangeExtd < Range
   #   (Float::INFINITY..Float::INFINITY).size
   #
   # has changed (I do not know in which Ruby version)!
-  # It used to be 0.  However, As of Ruby 2.6, it is +FloatDomainError: NaN+
+  # It used to be 0 (in Ruby-2.1).  However, As of Ruby 2.6, it raises +FloatDomainError: NaN+
   # Again this class now follows Ruby's default ({RangeExtd} Ver.1.0 or later).
   #
   # @note When both ends n are the same INFINITY (of the same parity),
   #   +(n..n).size+ used to be 0.  As of Ruby 2.6, it is FloatDomainError: NaN.
   #   This routine follows what Ruby produces, depending on Ruby's version it is run on.
   #
-  # @see http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-list/49797 [ruby-list:49797] from matz for how {Range#size} behaves (in Japanese).
+  # @see http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-list/49797 [ruby-list:49797] from matz for how +Range#size+ behaves (in Japanese).
   #
   # @return [Integer]  0 if {RangeExtd::NONE}
   # @return [Float]  Float::INFINITY if either (or both) the end is infinity, regardless of the class of the elements. 
   # @return [nil] if the range is non-Numeric.
+  # @raise [FloatDomainError] (Infinity..Infinity).size (as in Ruby-3.1, though it used to be 0 in Ruby-2.1)
   def size(*rest)
     # (1..5).size	# => 5
     # (1...5).size	# => 4
@@ -770,92 +806,60 @@ class RangeExtd < Range
     # (1.5...4.5).size	# => 3
     # (0...Float::INFINITY).size	# => Infinity
 
-    if is_none?	# No need of null?(), supposedly!
-      return 0
-
-    ### (Infinity..Infinity) => 0  (as in Ruby 2.1)
-    # elsif self.begin().infinity? || self.end().infinity?
-    #   return Infinity::FLOAT_INFINITY
-
-    # Checking Infinity.
-    # Note (Infinity..Infinity) => 0  (Range as in Ruby 2.1)
-    # however, 
-    elsif (defined?(self.begin.infinity?) && self.begin.infinity? || self.begin == -Infinity::FLOAT_INFINITY) ||
-          (defined?(self.end.infinity?)   && self.end.infinity?   || self.end == Infinity::FLOAT_INFINITY) ||
-          (self.end.nil?)  # RangeExtd#end can be nil only for Ruby-2.6
-      if self.begin == self.end
-        # This varies, depending on Ruby's version!  It used to be 0.  As of Ruby 2.6, it is FloatDomainError: NaN.
-        return (Float::INFINITY..Float::INFINITY).size
-        # return 0
-      elsif self.end.nil?
-        # Behaves as Ruby does -
-        #  Infinity::FLOAT_INFINITY for Numeric and nil for any other
-        return (self.begin..nil).size
-      else
-        return Infinity::FLOAT_INFINITY
-      end
+    return 0 if is_none?	# No need of null?(), supposedly!
+      
+    if self.begin.nil? || self.end.nil?   # RangeExtd#begin/end can be nil only in Ruby-2.7+/2.6+
+      # Behaves as Ruby does -
+      #  Infinity::FLOAT_INFINITY for Numeric and nil, but nil for any other
+      #  {#exclude_end?} does not matter.
+      return (self.begin..self.end).size
+    end
 
-    elsif @exclude_begin
+    rbeg = self.begin
+    rend = self.end
 
-      begin
-        _dummy = 1.0 + self.begin()	# _dummy to suppress warning: possibly useless use of + in void context
+    # Either or both sides are (general or Float) Infinity
+    if RangeExtd::Infinity.infinite?(rbeg) || RangeExtd::Infinity.infinite?(rend)
+      return @rangepart.send(__method__, *rest)  # delegates to {Range#size}
+    end
 
-        # Numeric
-        if defined? (self.begin().succ)
-          Range.new(self.begin().succ, self.end, exclude_end?).send(__method__, *rest)
-        else
-          size_no_exclude = Range.new(self.begin, self.end).send(__method__, *rest)	# exclude_end? == true, ie., Range with both ends inclusinve.
-          diff = self.end - self.begin
-          if diff.to_i == diff		# Integer difference
-            return size_no_exclude - 1	# At least exclude_begin?==true (so exclude_end? does not matter)
-          else
-            return size_no_exclude
-          end
-        end
-      rescue TypeError
-        # Non-Numeric
-        if defined? self.begin().succ
-          Range.new(self.begin().succ, self.end, exclude_end?).send(__method__, *rest)	# => nil in Ruby 2.1
-        else
-          nil	# See the line above.
-          # raise TypeError, "can't iterate from "+self.begin.class.name
-        end
+    return @rangepart.send(__method__, *rest) if !exclude_begin?
 
+    # Now, {#exclude_begin?} is true:
+    begin
+      _dummy = 1.0 + rbeg	# _dummy to suppress warning: possibly useless use of + in void context
+    rescue TypeError
+      # Non-Numeric
+      if defined? rbeg.succ
+        return Range.new(rbeg.succ, rend, exclude_end?).send(__method__, *rest)	# => nil in Ruby 2.1+
+      else
+        return nil	# See the line above.
+        # raise TypeError, "can't iterate from "+self.begin.class.name
       end
+    end
 
+    # Numeric
+    if rbeg.respond_to? :succ
+      Range.new(rbeg.succ, rend, exclude_end?).send(__method__, *rest)
     else
-      @rangepart.send(__method__, *rest)
+      size_no_exclude = Range.new(rbeg, rend).send(__method__, *rest)	# exclude_end? == true, ie., Range with both ends inclusinve.
+      diff = self.end - self.begin
+      if diff.to_i == diff		# Integer difference
+        return size_no_exclude - 1	# At least exclude_begin?==true (so exclude_end? does not matter)
+      else
+        return size_no_exclude
+      end
     end
   end	# def size
 
 
   # See {#each}.
+  #
   # @raise [TypeError] If {#exclude_begin?} is true, and {#begin}() does not have the method [#succ], then even if no block is given, this method raises TypeError straightaway.
   # @return [RangeExtd] self
   # @return [Enumerator] if block is not given.
-  #
   def step(*rest, &bloc)
-    # (1...3.5).each{|i|print i}	# => '123' to STDOUT
-    # (1.3...3.5).each	# => #<Enumerator: 1.3...3.5:each>
-    # (1.3...3.5).each{|i|print i}	# => TypeError: can't iterate from Float
-    # Note: If the block is not given and if exclude_begin?() is true, the self in the returned Enumerator is not the same as self here.
-
-    if @exclude_begin	# including RangeExtd::NONE
-      if defined? self.begin.succ
-        ret = Range.new(self.begin.succ,self.end,exclude_end?).send(__method__, *rest, &bloc)
-        if block_given?
-          self
-        else
-          ret
-        end
-      elsif is_none?	# No need of null?(), supposedly!
-        raise TypeError, "can't iterate for NONE range"
-      else
-        raise TypeError, "can't iterate from "+self.begin.class.name
-      end
-    else
-      @rangepart.send(__method__, *rest, &bloc)
-    end
+    _step_each_core(__method__, *rest, &bloc)
   end
 
 
@@ -865,7 +869,15 @@ class RangeExtd < Range
 
   # Private class method to evaluate the arguments.
   #
+  # @note The specification changed from RangeExtd Ver.1 to Ver.2.
+  #    In Ver.1 or earlier, this returns [begin, end, exclude_end, exclude_begin]
+  #    In Ver.2+, this returns [begin, end, exclude_begin, exclude_end]
+  #    Notice the third and fourth elements are swapped. Now it is in line
+  #    with {RangeExtd.new}.
+  #
+  # @param (see RangeExtd#initialize) (or valid)
   # @raise [ArgumentError] if the input format is invalid (otherwise the caller may raise RangeError (it depends))
+  # @return [Array<Object, Object, Boolean, Boolean>] 4-compoents: [begin, end, exclude_begin, exclude_end]
   def self._get_init_args(*inar, **hsopt)
     nMin = 1; nMax = 5
     if inar.size < nMin || nMax < inar.size
@@ -903,8 +915,6 @@ class RangeExtd < Range
       end
 
       beginend = [inar[0].begin, inar[0].end]
-      # arRet = [inar[0].begin, inar[0].end, exclude_end, exclude_begin]
-      # @rangepart = Range.new(inar[0].begin, inar[0].end, exclude_end)
 
     when :object
       nMin = 2; nMax = 5
@@ -924,8 +934,8 @@ class RangeExtd < Range
       # Originally, defined?(inar[1].=~) seemed enough.  But as of Ruby 2.6 (maybe even before),
       # Numeric has :=~ method as well!
       if (inar.size > 2 &&
-          inar[1].class.method_defined?(:=~) &&
-          inar[1].class.method_defined?(:to_str))
+          inar[1].respond_to?(:=~) &&
+          inar[1].respond_to?(:to_str))
         begin
           cmp = (inar[0] <=> inar[2]).abs
         rescue
@@ -936,16 +946,8 @@ class RangeExtd < Range
           # Hence all the default values are overwritten.
           beginend = [inar[0], inar[2]]
           hsFlag[:excl_offset] = 1
-          if $1 == @@middle_strings[1]
-            exclude_begin = false
-          else
-            exclude_begin = true
-          end
-          if $2 == @@middle_strings[4]
-            exclude_end   = true
-          else
-            exclude_end   = false
-          end
+          exclude_begin = ($1 != @@middle_strings[1])
+          exclude_end   = ($2 == @@middle_strings[4])
         else
           nMin = 2; nMax = 4
           if inar.size > nMax
@@ -967,9 +969,6 @@ class RangeExtd < Range
         exclude_end   = (true ^! inar[3+hsFlag[:excl_offset]])	# 4th or 5th argument
       end
 
-      # arRet = [inar[0], inar[1], exclude_end, exclude_begin]
-      # @rangepart = Range.new(inar[0], inar[1], exclude_end)
-
     else
       raise	# (for coding safety)
     end		# case hsFlag[:prm1st]
@@ -981,23 +980,23 @@ class RangeExtd < Range
       exclude_end   = (hsopt[:exclude_end] && true)
     end
 
-    # [RangeBeginValue, RangeEndValue, exclude_end?, exclude_begin?]
-    _normalize_infinity_float(beginend) + [exclude_end, exclude_begin]
+    # [RangeBeginValue, RangeEndValue, exclude_begin?, exclude_end?]
+    _normalize_infinity_float(beginend) + [exclude_begin, exclude_end]
   end	# def self._get_init_args(*inar)
   private_class_method :_get_init_args	# From Ruby 1.8.7 (?)
 
   # Replaces {RangeExtd::Infinity} with {Float::INFINITY} when appropriate
   #
-  # @param beginend [Array] 2-compoents
-  # @return [Array] 2-compoents
+  # @param beginend [Array] 2-compoents(begin, end)
+  # @return [Array] 2-compoents(begin, end)
   def self._normalize_infinity_float(beginend)
     is_begin_inf = Infinity.infinity?(beginend[0])
     return beginend if is_begin_inf ^! Infinity.infinity?(beginend[1])
 
     # Now, only one of them is a {RangeExtd::Infinity} type object.
-    if is_begin_inf && beginend[1].class.method_defined?(:divmod)
+    if is_begin_inf && beginend[1].respond_to?(:divmod)
       [_normalize_infinity_float_core(beginend[0]), beginend[1]] # "begin" is Infinity
-    elsif beginend[0].class.method_defined?(:divmod)
+    elsif beginend[0].respond_to?(:divmod)
       [beginend[0], _normalize_infinity_float_core(beginend[1])] # "end" is Infinity
     else
       beginend
@@ -1009,7 +1008,7 @@ class RangeExtd < Range
   # @return [RangeExtd::Infinity, Float] +/-Float::INFINITY if Float
   def self._normalize_infinity_float_core(inf)
     msg = 'RangeExtd component of the RangeExtd::Infinity object replaced with Float::INFINITY.'
-    warn msg if !$VERBOSE.nil?
+    warn msg if $DEBUG || $VERBOSE
     (inf.positive? ? 1 : -1) * Float::INFINITY
   end
   private_class_method :_normalize_infinity_float_core  # From Ruby 1.8.7 (?)
@@ -1018,7 +1017,7 @@ class RangeExtd < Range
   # Returns true if the range to be constructed (or given) is valid,
   # as a range, accepted in {RangeExtd}.
   #
-  # This routine is also impremented as a method in {Range},
+  # This routine is also implemented as a method in {Range},
   # and accordingly its sub-classes.
   #
   # This routine is called from {RangeExtd.new}, hence
@@ -1028,23 +1027,31 @@ class RangeExtd < Range
   #
   # 1. The {#begin} and {#end} elements must be Comparable to each other,
   #    and the comparison results must be consistent betwen the two.
-  #    The two sole exceptions are {RangeExtd::NONE} and Endless Range
-  #    introduced in Ruby 2.6 (see below for the exceptions), both of which are valid.
-  #    For example, (nil..nil) is NOT valid (nb., it raised Exception in Ruby 1.8).
-  # 2. Except for {RangeExtd::NONE}, {#begin} must have the method +<=+.
-  #    Therefore, some Endless Ranges (Ruby 2.6 and later) like (true..) are *not* valid.
-  #    Note even "true" has the method +<=>+ and hence checking +<=+ is essential.
-  # 3. {#begin} must be smaller than or equal to {#end},
+  #    The three exceptions are {RangeExtd::NONE} and Beginless and Endless Ranges
+  #    introduced in Ruby 2.7 and 2.6, respectively (see below for the exceptions),
+  #    which are all valid.  Accordingly, +(nil..nil)+ is
+  #    valid in {RangeExtd} Ver.1.0+ (nb., it used to raise Exception in Ruby 1.8).
+  # 2. Except for {RangeExtd::NONE} and Beginless Range, {#begin} must have the method +<=+.
+  #    Therefore, some Endless Ranges (Ruby 2.6 and later) like +(true..)+ are *not* valid.
+  #    Note even "+true+" has the method +<=>+ and hence checking +<=+ is essential.
+  # 3. Similarly, except for {RangeExtd::NONE} and Endless Range, {#end} must have the method +<=+.
+  #    Therefore, some Beginless Ranges (Ruby 2.7 and later) like +(..true)+ are *not* valid.
+  # 4. {#begin} must be smaller than or equal to {#end},
   #    that is, ({#begin} <=> {#end}) must be either -1 or 0.
-  # 4. If {#begin} is equal to {#end}, namely, ({#begin} <=> {#end}) == 0,
-  #    the exclude status of the both ends must agree.
-  #    That is, if the {#begin} is excluded, {#end} must be also excluded,
+  # 5. If {#begin} is equal to {#end}, namely, ({#begin} <=> {#end}) == 0,
+  #    the exclude status of the both ends must agree, except for the cases
+  #    where both {#begin} and {#end} ani +nil+ (beginless and endless Range).
+  #    In other words, if the {#begin} is excluded, {#end} must be also excluded,
   #    and vice versa.
-  #    For example, (1...1) is NOT valid for that reason,
+  #    For example, +(1...1)+ is NOT valid for this reason,
   #    because any built-in Range object has the exclude status
-  #    of false (namely, inclusive) for {#begin}.
+  #    of +false+ (namely, inclusive) for {#begin}, whereas
+  #    +RangeExtd(1...1, true)+ is valid and equal (+==+) to
+  #    {RangeExtd::NONE}.
+  # 6. If either or both of {#begin} and {#end} is {RangeExtd::Nowhere::NOWHERE},
+  #    the range has to be {RangeExtd::NONE}.
   #
-  # Note the last example may change in the future release.
+  # Note the second last point may change in the future release.
   #
   # Note ([2]..[5]) is NOT valid, because Array does not include Comparable
   # for some reason, as of Ruby 2.1.1, even though it has the redefined
@@ -1053,8 +1060,10 @@ class RangeExtd < Range
   #
   # @example
   #
-  #    RangeExtd.valid?(nil..nil)     # => false
-  #    RangeExtd.valid?(nil...nil)    # => false
+  #    RangeExtd.valid?(nil..nil)     # => true
+  #    RangeExtd.valid?(nil...nil)    # => true
+  #    RangeExtd.valid?(nil<..nil)    # => true
+  #    RangeExtd.valid?(nil<...nil)   # => true
   #    RangeExtd.valid?(0..0)         # => true
   #    RangeExtd.valid?(0...0)        # => false
   #    RangeExtd.valid?(0...)         # => true
@@ -1068,6 +1077,7 @@ class RangeExtd < Range
   #    RangeExtd.valid?(3..Float::INFINITY, true)  # => true
   #    RangeExtd.valid?(RangeExtd::Infinity::NEGATIVE..?d)        # => true
   #    RangeExtd.valid?(RangeExtd::Infinity::NEGATIVE..?d, true)  # => true
+  #    RangeExtd.valid?(RangeExtd::Nowhere::NOWHERE..nil)  # => false
   #
   # @note The flag of exclude_begin|end can be given in the arguments in a couple of ways.
   #  If there is any duplication, those specified in the optional hash have the highest
@@ -1075,14 +1085,14 @@ class RangeExtd < Range
   #  If not, the values embeded in the {Range} or {RangeExtd} object
   #  in the parameter are used.  In default, both of them are false.
   #
-  # @overload new(range, [exclude_begin=false, [exclude_end=false]])
+  # @overload valid?(range, [exclude_begin=false, [exclude_end=false]])
   #   @param range [Object] Instance of Range or its subclasses, including RangeExtd
   #   @param exclude_begin [Boolean] If specified, this has the higher priority, or false in default.
   #   @param exclude_end [Boolean] If specified, this has the higher priority, or false in default.
   #
-  # @overload new(obj_begin, obj_end, [exclude_begin=false, [exclude_end=false]])
-  #   @param obj_begin [Object] Any object that is {Comparable} with end
-  #   @param obj_end [Object] Any object that is Comparable with begin (or nil, for Ruby 2.6 onwards)
+  # @overload valid?(obj_begin, obj_end, [exclude_begin=false, [exclude_end=false]])
+  #   @param obj_begin [Object] Any object that is +Comparable+ with end
+  #   @param obj_end [Object] Any object that is +Comparable+ with begin (or nil, for Ruby 2.6 onwards)
   #   @param exclude_begin [Boolean] If specified, this has the lower priority, or false in default.
   #   @param exclude_end [Boolean] If specified, this has the lower priority, or false in default.
   #
@@ -1090,21 +1100,32 @@ class RangeExtd < Range
     (vbeg, vend, exc_beg, exc_end) = _get_init_args(*inar)
 
     if defined?(inar[0].is_none?) && inar[0].is_none? && exc_beg && exc_end
+      # inar[0] is RangeExtd::NONE
+      return true
+    elsif vbeg.nil? && vbeg.nowhere? || vend.nil? && vend.nowhere?
+      # RangeExtd::Nowhere::NOWHERE should not reside anywhere but in RangeExtd::NONE
+      return false
+    elsif vbeg.nil? && vend.nil?
       return true
     end
+
+    return false if !vbeg.respond_to?(:<=>)
     begin
       t = (vbeg <=> vend)
       begin
-        if vend.nil?
+        if vbeg.nil?  # Beginless Range introduced in Ruby 2.7
+          return vend.respond_to?(:<=)
+        elsif vend.nil?
           begin
             _ = (vbeg..nil)  # Endless Range introduced in Ruby 2.6
-            return vbeg.class.method_defined?(:<=)
+            return vbeg.respond_to?(:<=)
           rescue ArgumentError
             # Before Ruby 2.6
             return false
           end
         end
-        return false if t != -1*(vend <=> vbeg)	# false if not commutative, or possibly exception (such as -1*nil).
+        return false if !vend.respond_to?(:<=>)
+        return false if t != -1*(vend <=> vbeg)	# false if not commutative (n.b., an exception should not happen).
       rescue NoMethodError, TypeError
         if (Float === vend && defined?(vbeg.infinity?) && vbeg.infinity?) ||
            (Float === vbeg && defined?(vend.infinity?) && vend.infinity?)
@@ -1112,7 +1133,8 @@ class RangeExtd < Range
         end
         return false	# return
       end
-    rescue # NoMethodError
+    rescue
+      warn "This should not happen. Contact the code developer (warn01)."
       false	# return
     else
       case t
@@ -1127,6 +1149,7 @@ class RangeExtd < Range
       when 1
         false
       else
+        warn "This should not happen. Contact the code developer (warn02)."
         if (Float === vend && defined?(vbeg.infinity?) && vbeg.infinity?) ||
            (Float === vbeg && defined?(vend.infinity?) && vend.infinity?)
           warn self.const_get(:ERR_MSGS)[:infinity_compare] if !$VERBOSE.nil?  # not tested so far?
@@ -1265,365 +1288,96 @@ class RangeExtd < Range
   end	# def re_inspect_core_orig(method)
 
 
-  # Core routine for {#===} and {#eql?}
+  # Core routine for {#===}
+  #
   # @param [Object] r to compare.
   # @param [Symbol] method of the method name.
-  def re_equal_core(r, method)
-    if defined? r.empty?
-      is_r_empty = r.empty?
-    else
-      return false	# Not Range family.
-    end
-    if ! defined? r.exclude_end?
-      false	# Not Range family.
-    elsif is_none? && is_r_empty	# RangeExtd::NONE
-      true
-    elsif empty? && defined?(r.is_none?) && r.is_none?	# r is RangeExtd::NONE
-      true
-    elsif empty?   && is_r_empty
-      if method == :eql?
-        # More strict
-        if self.begin().class == r.begin().class
-          true	#     (1<...1).eql? (2<...2)	# => true  (Fixnum <-> Fixnum) Yes!
-        else
-          false	# (1.0<...1.0).eql? (2<...2)	# => false (Float  <-> Fixnum) No!
-        end
-      else
-        (self.begin.class.ancestors - self.begin.class.included_modules - [Object, BasicObject]).each do |ec|
-          if ec === r.begin
-            return true	# (1.0<...1.0) == (2<...2)	# (Float<Numeric <-> Fixnum<Numeric) Yes!
-          end
+  def _re_equal_core(r, method=:==)
+    return false if !r.respond_to? :exclude_end?  # Not Range family.
+    return false if !r.respond_to? :empty?  # Not Range family.
+    return false if !r.respond_to? :valid?  # Not Range family.
+
+    return false if !r.valid?  # always returns false with an invalid Range; n.b., RangeExtd#valid? is always true, hence they cannot be identical (eql?).
+
+    is_r_empty = r.empty?
+    return !!is_r_empty if is_none?  # RangeExtd::NONE==(1<...1); n.b. "!!" is redundant because r must be valid.
+    return true if empty? && r.respond_to?(:is_none?) && r.is_none?	# r is RangeExtd::NONE
+    return false if !_both_same_nowhere_parity?(r)  # inconsistent nil, non-nil, NOWHERE combination
+
+    if empty?   && is_r_empty
+      (self.begin.class.ancestors - self.begin.class.included_modules - [Object, BasicObject]).each do |ec|
+        if ec === r.begin
+          return true	# (1.0<...1.0) == (2<...2)	# (Float<Numeric <-> Fixnum<Numeric) Yes!
         end
-        false		#    (?a...?a) != (2<...2)	# (String <-> Numeric) No!
       end
+      return false	#    (?a...?a) != (2<...2)	# (String <-> Numeric) No!
+    end
+
+    return false if !(self.exclude_end? ^! r.exclude_end?)
 
-    elsif defined? r.exclude_begin?
+    # Neither self nor r is guaranteed to be RangeExtd::NONE
+    is_nil_equal = _both_eqleql_nil?(r, method)
+
+    if defined? r.exclude_begin? # r is RangeExtd
       (self.exclude_begin? ^! r.exclude_begin?) &&
         (self.exclude_end? ^! r.exclude_end?) &&
-        (self.begin.send(method, r.begin)) &&
-        (self.end.send(  method, r.end))
-        # (self.begin == r.begin) &&
-        # (self.end == r.end)
+        (self.begin.send(method, r.begin) && self.end.send(method, r.end) || is_nil_equal)
     else 
       # r is Range
       if self.exclude_begin?
         false
       else
-        @rangepart.send(method, r)	# Comparison as two Range-s.
+        is_nil_equal || @rangepart.send(method, r)	# Comparison as two Range-s.
       end
     end
-  end	# def re_equal_core(r, method)
+  end	# def _re_equal_core(r, method)
+  private :_re_equal_core
 
   # Core routine for {#min}, {#max}, {#minmax} etc.
   # @param method [Symbol] of the method name.
   # @param rest [Object]
-  def re_min_max_core(method, *rest, &bloc)
+  def _re_min_max_core(method, *rest, &bloc)
     # (1...3.5).max	# => TypeError: cannot exclude non Integer end value
-    if is_none?
+    if is_none? || self.begin.nil? && self.begin.nowhere? || self.end.nil? && self.end.nowhere?
+      # In fact, Range#minmax etc should be modified to deal with RangeExtd::Nowhere::NOWHERE (it is treated as nil at the moment)...
       raise TypeError, "no meaningful range."
-    elsif @exclude_begin
-      if defined?(self.begin.infinity?) && self.begin.infinity? || self.begin == -Infinity::FLOAT_INFINITY
-        raise TypeError, "can't exclude "+self.begin.to_s
-      elsif ! defined? self.begin.succ
-        raise TypeError, "can't iterate from "+self.begin.class.name
-      else
-        Range.new(self.begin.succ, self.end, exclude_end?).send(method, *rest, &bloc)
-      end
-    else
-      @rangepart.send(method, *rest)
     end
-  end	# def re_min_max_core(method, *rest, &bloc)
 
+    if !@exclude_begin ||
+       [:max, :max_by].include?(method) ||
+       self.begin.respond_to?(:succ) ||
+       [:min_by, :minmax_by].include?(method) && !block_given?
+      # For the last one, if Range starts from something uniterable, it returns
+      # Enumerator (without errors); but once it is executed, it will raise TypeError
+      # "can't iterate from Float" or RangeError "cannot get the minimum of beginless range"
+      return _converted_rangepart(transform_to_nil: false).send(method, *rest, &bloc)
+    end
+
+    # Now @exclude_begin is true, "begin" is not discrete, and block is given (if _by).
+    raise TypeError, "can't exclude non-iterable begin value" #+self.begin.to_s
+  end	# def _re_min_max_core(method, *rest, &bloc)
+  private :_re_min_max_core
+
+  self.remove_const :NONE if defined? self::NONE  # tricky manoeuvre for documentation purposes... (see infinity.rb for the explanatory document)
   # No range.
   # In Ruby1.8, this causes  ArgumentError: bad value for range (because (nil..nil) is unaccepted).
-  NONE = RangeExtd.new(nil, nil, true, true, :Constant)
-  #NONE= RangeExtd.new(nil...nil, true, true, :Constant)
+  #NONE = RangeExtd.new(nil, nil, true, true, :Constant)
+  NONE = RangeExtd.new(RangeExtd::Nowhere::NOWHERE, RangeExtd::Nowhere::NOWHERE, true, true, :Constant)
 
+  self.remove_const :ALL if defined? self::ALL  # tricky manoeuvre for documentation purposes... (see infinity.rb for the explanatory document)
   # Range covers everything.
   ALL  = RangeExtd.new(Infinity::NEGATIVE, Infinity::POSITIVE, false, false, :Constant)
-  #ALL = RangeExtd.new(Infinity::NEGATIVE..Infinity::POSITIVE, false, false, :Constant)
 
 end	# class RangeExtd < Range
 
-
-#= Class Range
-#
-#== Summary
-#
-# Modifies {#==}, {#eql?} and add methods of
-# {#valid?}, {#empty?}, {#null?}, {#is_none?} and {#is_all?}.
-#
-class Range
-
-  alias_method :equal_prerangeextd?, :==  if ! self.method_defined?(:equal_prerangeextd?)	# No overwriting.
-
-  # It is extended to handle {RangeExtd} objects.
-  # For each element, that is, {#begin} and {#end},
-  # this uses their method of ==().  See {#eql?}.
-  #
-  # As long as the comparison is limited within {Range} objects,
-  # the returned value of this method has unchanged.
-  #
-  # A note of caution is, some ranges which the built-in Range accepts,
-  # are now regarded as NOT valid, such as, (1...1) and (nil..nil)
-  # (the latter was not permitted in Ruby 1.8), though you can still
-  # use them;
-  #    (1...1).valid?   # => false
-  # On the other hand, {RangeExtd} class does not accept or create
-  # any invalid range; for any {RangeExtd} object, RangeExtd#valid?
-  # returns true.  For example, there is no {RangeExtd} object
-  # that is expressed as (1...1) (See {#valid?} for detail).
-  #
-  # For that reason, when those non-valid Range objects are compared
-  # with a {RangeExtd} object, the returned value may not be what
-  # you would expect.  For example,
-  #    (1...1) == RangeExtd(1, 1, true, true)  # => false.
-  # The former is an invalid range, while the latter is
-  # a rigidly-defined empty range.
-  #
-  # Consult {#valid?} and {RangeExtd#==} for more detail.
-  def ==(r)
-    equal_core(r, :==, :equal_prerangeextd?)
-  end
-
-
-  alias :eql_prerangeextd? :eql?  if ! self.method_defined?(:eql_prerangeextd?)	# No overwriting.
-
-  # Same as {#==}, but the comparison is made with eql?() method.
-  def eql?(r)
-    equal_core(r, :eql?, :eql_prerangeextd?)
-  end
-
-
-  # Returns true if self is valid as a comparable range.
-  #
-  # See {RangeExtd.valid?} for the definition of what is valid
-  # and more examples.
-  #
-  # See {#empty?} and {#null?}, too.
-  # 
-  # @example
-  #    (nil..nil).valid? # => false
-  #    (0..0).valid?     # => true
-  #    (0...0).valid?    # => false
-  #    (2..-1).valid?    # => false
-  #    RangeExtd(0...0, true)   # => true
-  #    (3..Float::INFINITY).valid?  # => true
-  #    RangeExtd::NONE.valid?       # => true
-  #    RangeExtd::ALL.valid?        # => true
-  # 
-  # @note By definition, all the {RangeExtd} instances are valid,
-  #  because {RangeExtd.new} checks the validity.
-  def valid?
-    RangeExtd.valid?(self)
-  end	# def valid?
-
-
-  # Returns true if self is empty.
-  # Returns nil if self is not valid (nb., any RangeExtd instance is valid.)
-  # Otherwise false.
-  #
-  # The definition of what is empty is as follow.
-  #
-  # 1. the range must be valid: {#valid?} => true
-  # 2. if the range id discrete, that is, {#begin} has
-  #    [#succ] method, there must be no member within the range: 
-  #    {#to_a}.empty? => true
-  # 3. if the range is continuous, that is, {#begin} does not have
-  #    [#succ] method, {#begin} and {#end} must be equal
-  #    (({#begin} <=> {#end}) => 0) and both the boundaries must
-  #    be excluded: ({#exclude_begin?} && {#exclude_end?}) => true.
-  #    Note that ranges with equal {#begin} and {#end} with
-  #    inconsistent two exclude status are not valid, and the built-in
-  #    Range always has the {#begin}-exclude status of false.
-  #
-  # In these conditions, none of Range instance would return true in {#empty?}.
-  #
-  # @example
-  #   (nil..nil).empty?  # => nil
-  #   (1...1).empty?     # => nil
-  #   (1..1).empty?      # => false
-  #   RangeExtd(1...1,   true).empty? # => true
-  #   RangeExtd(1...2,   true).empty? # => true
-  #   RangeExtd(1.0...2, true).empty? # => false
-  #   RangeExtd(?a...?b, true).empty? # => true
-  #   RangeExtd::NONE.empty?          # => true
-  #
-  # @note to check whether it is either empty or invalid, use {#null?}.
-  # See {#valid?} and {RangeExtd.valid?}, too.
-  #
-  # @return [Boolean, nil]
-  def empty?
-    # This is basically for the sake of sub-classes, as any built-in Range instance
-    # always returns either nil or false.
-
-    if !valid?
-      return nil
-    elsif defined?(self.is_none?) && self.is_none?
-      return true
-    end
-
-    t = (self.begin() <=> self.end())
-    case t
-    when -1
-      if (defined?(self.exclude_begin?)) &&
-          exclude_begin? &&
-          exclude_end? &&
-          defined?(self.begin().succ) &&
-          (self.begin().succ == self.end())
-        true	# e.g., ("a"<..."b")
-      else
-        false
-      end
-    when 0
-      if defined?(self.boundary) && self.boundary.nil?	# for RangeOpen
-        # RangeExtd::NONE or RangeExtd::All
-        if self.exclude_end?
-          true	# RangeOpen::NONE
-        else
-          false	# RangeOpen::ALL
-        end
-      else
-        if defined?(self.exclude_begin?)
-          t2 = self.exclude_begin?
-        else
-          t2 = false	# == return false
-        end
-        (t2 && exclude_end?)
-      end
-    when 1
-      nil	# redundant, as it should not be valid in the first place.
-    else
-      nil	# redundant, as it should not be valid in the first place.
-    end
-  end	# def empty?
-
-
-  # Returns true if it is either empty or invalid.  false otherwise.
-  # See {#empty?} and {#valid?}.
-  def null?
-    (! valid?) || empty?
-  end
-
-  # @return [FalseClass]
-  def is_none?
-    false
-  end
-
-  # @return [FalseClass]
-  def is_all?
-    false
-  end
-
-
-  # Return true if self and the other are equivalent; if [#to_a] is defined, it is similar to
-  #    (self.to_a == other.to_a)
-  # (though the ends are checked more rigorously), and if not, equivalent to
-  #    (self == other)
-  #
-  # @example
-  #    (3...7).equiv?(3..6)      # => true
-  #    (3...7).equiv?(3..6.0)    # => false
-  #    (3...7).equiv?(3.0..6.0)  # => false
-  #    (3...7).equiv?(3..6.5)    # => false
-  #    (3...7).equiv?(3.0...7.0) # => true
-  #    (3...7.0).equiv?(3..6)    # => true
-  #    (3...7.0).equiv?(3.0..6)  # => false
-  #
-  # @param other [Range, RangeExtd]
-  def equiv?(other)
-    t_or_f = (defined?(self.begin.succ) && defined?(other.begin.succ) && defined?(other.end) && defined?(other.exclude_end?))
-    if ! t_or_f
-      return(self == other)	# succ() for begin is not defined.
-    else
-      # Checking the begins.
-      if defined?(other.exclude_begin?) && other.exclude_begin?	# The other is RangeExtd with exclude_begin?==true.
-        if self.begin != other.begin.succ
-          return false
-        else
-          # Pass
-        end
-      elsif (self.begin != other.begin)
-        return false
-      end
-
-      # Now, the begins agreed.  Checking the ends.
-      if (self.end == other.end)
-        if (exclude_end? ^! other.exclude_end?)
-          return true
-        else
-          return false
-        end
-      else	# if (self.end == other.end)
-        if (exclude_end? ^! other.exclude_end?)
-          return false
-        elsif (      exclude_end? && defined?(other.end.succ) && (self.end == other.end.succ)) ||
-              (other.exclude_end? && defined?( self.end.succ) && (self.end.succ == other.end))
-          return true
-        else
-          return false
-        end
-      end	# if (self.end == other.end)
-    end	# if ! t_or_f
-
-  end	# def equiv?(other)
-
-
-  ############## pravate methods of Range ##############
-
-  private
-
-  # True if obj is Comparable.
-  def is_comparable?(obj)
-    if defined?(obj.<=)	# Comparable?
-      true
-    else
-      false
-    end
-  end
-
-  # @param r [Object] to compare.
-  # @param method [Symbol] of the method name.
-  # @param method_pre [Symbol] of the backed-up original method name.
-  def equal_core(r, method, method_pre)
-    if (! defined? r.exclude_end?) || (! defined? r.is_none?) || (! defined? r.empty?)
-      false	# Not Range family.
-    # elsif empty? && defined?(r.is_none?) && r.is_none?	# r is RangeExtd::NONE
-    #   true
-    # elsif empty? && r.empty?
-    #   # None of built-in Range class object can be #empty?==true - This is for sub-class.
-    # 
-    elsif defined? r.exclude_begin?
-      # Either RangeExtd or RangeOpen object.
-      if r.exclude_begin?
-        false	# self(Range) has always the inclusive begin.
-      else
-        # It could do with a single line,
-        #    self.begin.send(method_pre, r)
-        # if this was for RangeExtd===r, but not for RangeOpen.
-        if (self.exclude_end? ^ r.exclude_end?)
-          false
-        elsif (self.begin.send(method, r.begin) && self.end.send(method, r.end))
-          true
-        else
-          false
-        end
-      end
-    else
-      self.send(method_pre, r)	# r is Range.
-    end
-  end	# def equal_core(r, method, method_pre)
-
-end	# class Range
-
+# require Range; it is necessary to modify Range if in a backward-compatible way.
+require_relative "range_extd/range"   if !Range.method_defined?(:eql_prerangeextd?)
 
 # Constant-form of {#RangeExtd}.
-# #RangeExtd(*) is equivalent to {#RangeExtd.new}.
 #
-# NOTE:
-#   "warning: Using the last argument as keyword parameters is deprecated; maybe ** should be added to the call"
-#   is raised if '**hs*' is completely omitted.  I do not know how to
-#   deal with this, other than adding **hs.
+# +RangeExtd()+ is equivalent to {#RangeExtd.new}().
+#
+# @return [RangeExtd]
 def RangeExtd(*rest, **hs, &b)
   RangeExtd.new(*rest, **hs, &b)
 end