tdiary 5.5.0 → 5.6.0

data/vendor/bundle/ruby/3.4.0/gems/{net-imap-0.5.15 → net-imap-0.6.6}/lib/net/imap/sequence_set.rb

@@ -145,6 +145,10 @@ module Net
     # #entries and #elements are identical.  Use #append to preserve #entries
     # order while modifying a set.
     #
+    # Non-normalized sets store both representations of the set, which can more
+    # than double memory usage.  Very large sequence sets should avoid
+    # denormalizing methods (such as #append) unless order is significant.
+    #
     # == Using <tt>*</tt>
     #
     # \IMAP sequence sets may contain a special value <tt>"*"</tt>, which
@@ -179,7 +183,7 @@ module Net
     #
     # When a set includes <tt>*</tt>, some methods may have surprising behavior.
     #
-    # For example, #complement treats <tt>*</tt> as its own number.  This way,
+    # For example, #complement treats <tt>*</tt> as its own member.  This way,
     # the #intersection of a set and its #complement will always be empty.  And
     # <tt>*</tt> is sorted as greater than any other number in the set.  This is
     # not how an \IMAP server interprets the set: it will convert <tt>*</tt> to
@@ -199,7 +203,7 @@ module Net
     #   (set.limit(max: 4) & (~set).limit(max: 4)).to_a => [4]
     #
     # When counting the number of numbers in a set, <tt>*</tt> will be counted
-    # _except_ when UINT32_MAX is also in the set:
+    # as if it were equal to UINT32_MAX:
     #   UINT32_MAX = 2**32 - 1
     #   Net::IMAP::SequenceSet["*"].count                   => 1
     #   Net::IMAP::SequenceSet[1..UINT32_MAX - 1, :*].count => UINT32_MAX
@@ -208,6 +212,12 @@ module Net
     #   Net::IMAP::SequenceSet[UINT32_MAX, :*].count        => 1
     #   Net::IMAP::SequenceSet[UINT32_MAX..].count          => 1
     #
+    # Use #cardinality to count the set members wxth <tt>*</tt> counted as a
+    # distinct member:
+    #   Net::IMAP::SequenceSet[1..].cardinality            #=> UINT32_MAX + 1
+    #   Net::IMAP::SequenceSet[UINT32_MAX, :*].cardinality #=> 2
+    #   Net::IMAP::SequenceSet[UINT32_MAX..].cardinality   #=> 2
+    #
     # == What's here?
     #
     # SequenceSet provides methods for:
@@ -271,8 +281,10 @@ module Net
     #   occurrence in entries.
     #
     # <i>Set cardinality:</i>
-    # - #count (aliased as #size): Returns the count of numbers in the set.
-    #   Duplicated numbers are not counted.
+    # - #cardinality: Returns the number of distinct members in the set.
+    #   <tt>*</tt> is counted as its own member, distinct from UINT32_MAX.
+    # - #count: Returns the count of distinct numbers in the set.
+    #   <tt>*</tt> is counted as equal to UINT32_MAX.
     # - #empty?: Returns whether the set has no members.  \IMAP syntax does not
     #   allow empty sequence sets.
     # - #valid?: Returns whether the set has any members.
@@ -280,12 +292,18 @@ module Net
     #   <tt>*</tt>.
     #
     # <i>Denormalized properties:</i>
+    # - #normalized?: Returns whether #entries are sorted, deduplicated, and
+    #   coalesced, and all #string entries are in normalized form.
     # - #has_duplicates?: Returns whether the ordered entries repeat any
     #   numbers.
-    # - #count_duplicates: Returns the count of repeated numbers in the ordered
-    #   entries.
+    # - #size: Returns the total size of all #entries, including repeated
+    #   numbers.  <tt>*</tt> is counted as its own member, distinct from
+    #   UINT32_MAX.
     # - #count_with_duplicates: Returns the count of numbers in the ordered
-    #   entries, including any repeated numbers.
+    #   #entries, including repeated numbers.  <tt>*</tt> is counted as
+    #   equal to UINT32_MAX.
+    # - #count_duplicates: Returns the count of repeated numbers in the ordered
+    #   #entries.  <tt>*</tt> is counted as equal to UINT32_MAX.
     #
     # === Methods for Iterating
     #
@@ -332,7 +350,7 @@ module Net
     #   given maximum value and removed all members over that maximum.
     #
     # === Methods for Assigning
-    # These methods add or replace elements in +self+.
+    # These methods add or replace numbers in +self+.
     #
     # <i>Normalized (sorted and coalesced):</i>
     #
@@ -341,8 +359,12 @@ module Net
     # - #add (aliased as #<<): Adds a given element to the set; returns +self+.
     # - #add?: If the given element is not fully included the set, adds it and
     #   returns +self+; otherwise, returns +nil+.
-    # - #merge: Adds all members of the given sets into this set; returns +self+.
-    # - #complement!: Replaces the contents of the set with its own #complement.
+    # - #merge: In-place set #union.  Adds all members of the given sets into
+    #   this set; returns +self+.
+    # - #complement!: In-place set #complement.  Replaces the contents of this
+    #   set with its own #complement; returns +self+.
+    # - #xor!: In-place +XOR+ operation.  Adds numbers that are unique to the
+    #   other set and removes numbers that are common to both; returns +self+.
     #
     # <i>Order preserving:</i>
     #
@@ -355,7 +377,7 @@ module Net
     #   of a given object.
     #
     # === Methods for Deleting
-    # These methods remove elements from +self+, and update #string to be fully
+    # These methods remove numbers from +self+, and update #string to be fully
     # sorted and coalesced.
     #
     # - #clear: Removes all elements in the set; returns +self+.
@@ -363,10 +385,12 @@ module Net
     # - #delete?: If the given element is included in the set, removes it and
     #   returns it; otherwise, returns +nil+.
     # - #delete_at: Removes the number at a given offset.
+    # - #intersect!: In-place set #intersection.  Removes numbers that are not
+    #   in the given set; returns +self+.
     # - #slice!: Removes the number or consecutive numbers at a given offset or
     #   range of offsets.
-    # - #subtract: Removes all members of the given sets from this set; returns
-    #   +self+.
+    # - #subtract: In-place set #difference.  Removes all members of the given
+    #   sets from this set; returns +self+.
     # - #limit!: Replaces <tt>*</tt> with a given maximum value and removes all
     #   members over that maximum; returns +self+.
     #
@@ -531,12 +555,17 @@ module Net
       #   combined with set operations (#|, #&, #^, #-, etc) to make new sets.
       #
       # See SequenceSet@Creating+sequence+sets.
-      def initialize(input = nil) input ? replace(input) : clear end
+      def initialize(input = nil)
+        @set_data = new_set_data
+        @string = nil
+        replace(input) unless input.nil?
+      end
 
       # Removes all elements and returns self.
       def clear
-        modifying! # redundant check, to normalize the error message for JRuby
-        @tuples, @string = [], nil
+        modifying! # redundant check (normalizes the error message for JRuby)
+        set_data.clear
+        @string = nil
         self
       end
 
@@ -549,7 +578,7 @@ module Net
         case other
         when SequenceSet then
           modifying! # short circuit before doing any work
-          @tuples = other.deep_copy_tuples
+          @set_data = other.dup_set_data
           @string = other.instance_variable_get(:@string)
         when String      then self.string = other
         else                  clear; merge other
@@ -580,7 +609,7 @@ module Net
       # the set is updated the string will be normalized.
       #
       # Related: #valid_string, #normalized_string, #to_s, #inspect
-      def string; @string ||= normalized_string if valid? end
+      def string; @string || normalized_string if valid? end
 
       # Returns an array with #normalized_string when valid and an empty array
       # otherwise.
@@ -599,13 +628,18 @@ module Net
           clear
         elsif (str = String.try_convert(input))
           modifying! # short-circuit before parsing the string
-          tuples = str_to_tuples str
-          @tuples, @string = [], -str
-          tuples_add tuples
+          entries = each_parsed_entry(str).to_a
+          clear
+          if normalized_entries?(entries)
+            replace_minmaxes entries.map!(&:minmax)
+          else
+            add_minmaxes entries.map!(&:minmax)
+            @string = -str
+          end
         else
           raise ArgumentError, "expected a string or nil, got #{input.class}"
         end
-        str
+        input
       end
 
       # Returns the \IMAP +sequence-set+ string representation, or an empty
@@ -618,8 +652,7 @@ module Net
       # Freezes and returns the set.  A frozen SequenceSet is Ractor-safe.
       def freeze
         return self if frozen?
-        string
-        @tuples.each(&:freeze).freeze
+        freeze_set_data
         super
       end
 
@@ -641,7 +674,7 @@ module Net
       # Related: #eql?, #normalize
       def ==(other)
         self.class == other.class &&
-          (to_s == other.to_s || tuples == other.tuples)
+          (to_s == other.to_s || set_data == other.set_data)
       end
 
       # :call-seq: eql?(other) -> true or false
@@ -682,7 +715,7 @@ module Net
       # object that would be accepted by ::new.
       #
       # Related: #===, #include?, #include_star?, #intersect?
-      def cover?(other) input_to_tuples(other).none? { !include_tuple?(_1) } end
+      def cover?(other) import_runs(other).none? { !include_run?(_1) } end
 
       # Returns +true+ when a given number or range is in +self+, and +false+
       # otherwise.  Returns +nil+ when +number+ isn't a valid SequenceSet
@@ -709,14 +742,14 @@ module Net
       #
       # Related: #include_star?, #cover?, #===, #intersect?
       def include?(element)
-        tuple = input_to_tuple element rescue nil
-        !!include_tuple?(tuple) if tuple
+        run = import_run element rescue nil
+        !!include_run?(run) if run
       end
 
       alias member? include?
 
       # Returns +true+ when the set contains <tt>*</tt>.
-      def include_star?; @tuples.last&.last == STAR_INT end
+      def include_star?; max_num == STAR_INT end
 
       # Returns +true+ if the set and a given object have any common elements,
       # +false+ otherwise.
@@ -726,7 +759,7 @@ module Net
       #
       # Related: #intersection, #disjoint?, #cover?, #include?
       def intersect?(other)
-        valid? && input_to_tuples(other).any? { intersect_tuple? _1 }
+        valid? && import_runs(other).any? { intersect_run? _1 }
       end
       alias overlap? intersect?
 
@@ -738,7 +771,7 @@ module Net
       #
       # Related: #intersection, #intersect?
       def disjoint?(other)
-        empty? || input_to_tuples(other).none? { intersect_tuple? _1 }
+        empty? || import_runs(other).none? { intersect_run? _1 }
       end
 
       # :call-seq:
@@ -755,14 +788,12 @@ module Net
       # Related: #min, #minmax, #slice
       def max(count = nil, star: :*)
         if count
-          # n.b: #cardinality has not been backported to 0.5
-          cardinality = @tuples.sum(@tuples.count) { _2 - _1 }
           if cardinality <= count
             frozen? ? self : dup
           else
             slice(-count..) || remain_frozen_empty
           end
-        elsif (val = @tuples.last&.last)
+        elsif (val = max_num)
           val == STAR_INT ? star : val
         end
       end
@@ -782,7 +813,7 @@ module Net
       def min(count = nil, star: :*)
         if count
           slice(0...count) || remain_frozen_empty
-        elsif (val = @tuples.first&.first)
+        elsif (val = min_num)
           val != STAR_INT ? val : star
         end
       end
@@ -800,10 +831,10 @@ module Net
       def valid?; !empty? end
 
       # Returns true if the set contains no elements
-      def empty?; @tuples.empty? end
+      def empty?; runs.empty? end
 
       # Returns true if the set contains every possible element.
-      def full?; @tuples == [[1, STAR_INT]] end
+      def full?; set_data == FULL_SET_DATA end
 
       # :call-seq:
       #   self + other -> sequence set
@@ -879,9 +910,7 @@ module Net
       # * <tt>lhs - (lhs - rhs)</tt>
       # * <tt>lhs - (lhs ^ rhs)</tt>
       # * <tt>lhs ^ (lhs - rhs)</tt>
-      def &(other)
-        remain_frozen dup.subtract SequenceSet.new(other).complement!
-      end
+      def &(other) remain_frozen dup.intersect! other end
       alias intersection :&
 
       # :call-seq:
@@ -906,7 +935,7 @@ module Net
       # * <tt>(lhs | rhs) - (lhs & rhs)</tt>
       # * <tt>(lhs - rhs) | (rhs - lhs)</tt>
       # * <tt>(lhs ^ other) ^ (other ^ rhs)</tt>
-      def ^(other) remain_frozen (dup | other).subtract(self & other) end
+      def ^(other) remain_frozen dup.xor! other end
       alias xor :^
 
       # :call-seq:
@@ -945,8 +974,8 @@ module Net
       #
       # Related: #add?, #merge, #union, #append
       def add(element)
-        modifying! # short-circuit before input_to_tuple
-        tuple_add input_to_tuple element
+        modifying! # short-circuit before import_run
+        add_run import_run element
         normalize!
       end
       alias << add
@@ -956,16 +985,55 @@ module Net
       # Unlike #add, #merge, or #union, the new value is appended to #string.
       # This may result in a #string which has duplicates or is out-of-order.
       #
-      # See SequenceSet@Ordered+and+Normalized+sets.
+      #    set = Net::IMAP::SequenceSet.new
+      #    set.append(1..2)  # => Net::IMAP::SequenceSet("1:2")
+      #    set.append(5)     # => Net::IMAP::SequenceSet("1:2,5")
+      #    set.append(4)     # => Net::IMAP::SequenceSet("1:2,5,4")
+      #    set.append(3)     # => Net::IMAP::SequenceSet("1:2,5,4,3")
+      #    set.append(2)     # => Net::IMAP::SequenceSet("1:2,5,4,3,2")
+      #
+      # If +entry+ is a string, it will be converted into normal form.
+      #
+      #    set = Net::IMAP::SequenceSet("4:5,1:2")
+      #    set.append("6:6") # => Net::IMAP::SequenceSet("4:5,1:2,6")
+      #    set.append("9:8") # => Net::IMAP::SequenceSet("4:5,1:2,6,8:9")
+      #
+      # If +entry+ adjacently follows the last entry, they will coalesced:
+      #    set = Net::IMAP::SequenceSet.new("2,1,9:10")
+      #    set.append(11..12) # => Net::IMAP::SequenceSet("2,1,9:12")
+      #
+      # Non-normalized sets store the string <em>in addition to</em> an internal
+      # normalized uint32 set representation.  This can more than double memory
+      # usage, so large sets should avoid using #append unless preserving order
+      # is required.  See SequenceSet@Ordered+and+Normalized+sets.
       #
       # Related: #add, #merge, #union
       def append(entry)
-        modifying! # short-circuit before input_to_tuple
-        tuple = input_to_tuple entry
-        entry = tuple_to_str tuple
-        string unless empty? # write @string before tuple_add
-        tuple_add tuple
-        @string = -(@string ? "#{@string},#{entry}" : entry)
+        modifying! # short-circuit before import_minmax
+        minmax = import_minmax entry
+        adj = minmax.first - 1
+        if @string.nil? && (runs.empty? || max_num <= adj)
+          # append to elements or coalesce with last element
+          add_minmax minmax
+          return self
+        elsif @string.nil?
+          # generate string for out-of-order append
+          head, comma = normalized_string, ","
+        else
+          # @string already exists... maybe coalesce with last entry
+          head, comma, last_entry = @string.rpartition(",")
+          last_min, last_max = import_minmax last_entry
+          if last_max == adj
+            # coalesce with last entry
+            minmax[0] = last_min
+          else
+            # append to existing string
+            head, comma = @string, ","
+          end
+        end
+        entry = export_minmax minmax
+        add_minmax minmax
+        @string = -"#{head}#{comma}#{entry}"
         self
       end
 
@@ -991,8 +1059,8 @@ module Net
       #
       # Related: #delete?, #delete_at, #subtract, #difference
       def delete(element)
-        modifying! # short-circuit before input_to_tuple
-        tuple_subtract input_to_tuple element
+        modifying! # short-circuit before import_run
+        subtract_run import_run element
         normalize!
       end
 
@@ -1029,17 +1097,17 @@ module Net
       #
       # Related: #delete, #delete_at, #subtract, #difference, #disjoint?
       def delete?(element)
-        modifying! # short-circuit before input_to_tuple
+        modifying! # short-circuit before import_minmax
         element = input_try_convert(element)
-        tuple = input_to_tuple element
+        minmax = import_minmax element
         if number_input?(element)
-          return unless include_tuple? tuple
-          tuple_subtract tuple
+          return unless include_minmax? minmax
+          subtract_minmax minmax
           normalize!
-          from_tuple_int tuple.first
+          export_num minmax.first
         else
           copy = dup
-          tuple_subtract tuple
+          subtract_minmax minmax
           normalize!
           copy if copy.subtract(self).valid?
         end
@@ -1076,8 +1144,8 @@ module Net
         deleted
       end
 
-      # Merges all of the elements that appear in any of the +sets+ into the
-      # set, and returns +self+.
+      # In-place set #union.  Merges all of the elements that appear in any of
+      # the +sets+ into this set, and returns +self+.
       #
       # The +sets+ may be any objects that would be accepted by ::new.
       #
@@ -1085,19 +1153,20 @@ module Net
       #
       # Related: #add, #add?, #union
       def merge(*sets)
-        modifying! # short-circuit before input_to_tuples
-        tuples_add input_to_tuples sets
+        modifying! # short-circuit before import_runs
+        add_runs import_runs sets
         normalize!
       end
 
-      # Removes all of the elements that appear in any of the given +sets+ from
-      # the set, and returns +self+.
+      # In-place set #difference.  Removes all of the elements that appear in
+      # any of the given +sets+ from this set, and returns +self+.
       #
       # The +sets+ may be any objects that would be accepted by ::new.
       #
       # Related: #difference
       def subtract(*sets)
-        tuples_subtract input_to_tuples sets
+        modifying! # short-circuit before import_runs
+        subtract_runs import_runs sets
         normalize!
       end
 
@@ -1189,7 +1258,7 @@ module Net
       # Related: #entries, #each_element
       def each_entry(&block) # :yields: integer or range or :*
         return to_enum(__method__) unless block_given?
-        each_entry_tuple do yield tuple_to_entry _1 end
+        each_entry_run do yield export_run_entry _1 end
       end
 
       # Yields each number or range (or <tt>:*</tt>) in #elements to the block
@@ -1201,39 +1270,17 @@ module Net
       # Related: #elements, #each_entry
       def each_element # :yields: integer or range or :*
         return to_enum(__method__) unless block_given?
-        @tuples.each do yield tuple_to_entry _1 end
-        self
-      end
-
-      private
-
-      def each_entry_tuple(&block)
-        return to_enum(__method__) unless block_given?
-        if @string
-          @string.split(",") do block.call str_to_tuple _1 end
-        else
-          @tuples.each(&block)
-        end
+        runs.each do yield export_run_entry _1 end
         self
       end
 
-      def tuple_to_entry((min, max))
-        if    min == STAR_INT then :*
-        elsif max == STAR_INT then min..
-        elsif min == max      then min
-        else                       min..max
-        end
-      end
-
-      public
-
       # Yields each range in #ranges to the block and returns self.
       # Returns an enumerator when called without a block.
       #
       # Related: #ranges
       def each_range # :yields: range
         return to_enum(__method__) unless block_given?
-        @tuples.each do |min, max|
+        minmaxes.each do |min, max|
           if    min == STAR_INT then yield :*..
           elsif max == STAR_INT then yield min..
           else                       yield min..max
@@ -1252,7 +1299,7 @@ module Net
       def each_number(&block) # :yields: integer
         return to_enum(__method__) unless block_given?
         raise RangeError, '%s contains "*"' % [self.class] if include_star?
-        @tuples.each do each_number_in_tuple _1, _2, &block end
+        minmaxes.each do each_number_in_minmax _1, _2, &block end
         self
       end
 
@@ -1266,16 +1313,7 @@ module Net
       def each_ordered_number(&block)
         return to_enum(__method__) unless block_given?
         raise RangeError, '%s contains "*"' % [self.class] if include_star?
-        each_entry_tuple do each_number_in_tuple _1, _2, &block end
-      end
-
-      private def each_number_in_tuple(min, max, &block)
-        if    min == STAR_INT then yield :*
-        elsif min == max      then yield min
-        elsif max != STAR_INT then (min..max).each(&block)
-        else
-          raise RangeError, "#{SequenceSet} cannot enumerate range with '*'"
-        end
+        each_entry_minmax do each_number_in_minmax _1, _2, &block end
       end
 
       # Returns a Set with all of the #numbers in the sequence set.
@@ -1287,35 +1325,103 @@ module Net
       # Related: #elements, #ranges, #numbers
       def to_set; Set.new(numbers) end
 
-      # Returns the count of #numbers in the set.
+      # Returns the number of members in the set.
+      #
+      # Unlike #count, <tt>"*"</tt> is considered to be distinct from
+      # <tt>2³² - 1</tt> (the maximum 32-bit unsigned integer value).
+      #
+      #     set = Net::IMAP::SequenceSet[1..10]
+      #     set.count        #=> 10
+      #     set.cardinality  #=> 10
+      #
+      #     set = Net::IMAP::SequenceSet["4294967295,*"]
+      #     set.count        #=> 1
+      #     set.cardinality  #=> 2
+      #
+      #     set = Net::IMAP::SequenceSet[1..]
+      #     set.count        #=> 4294967295
+      #     set.cardinality  #=> 4294967296
+      #
+      # Related: #count, #count_with_duplicates
+      def cardinality = minmaxes.sum(runs.count) { _2 - _1 }
+
+      # Returns the count of distinct #numbers in the set.
       #
-      # <tt>*</tt> will be counted as <tt>2**32 - 1</tt> (the maximum 32-bit
-      # unsigned integer value).
+      # Unlike #cardinality, <tt>"*"</tt> is considered to be equal to
+      # <tt>2³² - 1</tt> (the maximum 32-bit unsigned integer value).
       #
-      # Related: #count_with_duplicates
+      #     set = Net::IMAP::SequenceSet[1..10]
+      #     set.count        #=> 10
+      #     set.cardinality  #=> 10
+      #
+      #     set = Net::IMAP::SequenceSet["4294967295,*"]
+      #     set.count        #=> 1
+      #     set.cardinality  #=> 2
+      #
+      #     set = Net::IMAP::SequenceSet[1..]
+      #     set.count        #=> 4294967295
+      #     set.cardinality  #=> 4294967296
+      #
+      # Related: #cardinality, #count_with_duplicates
       def count
-        @tuples.sum(@tuples.count) { _2 - _1 } +
-          (include_star? && include?(UINT32_MAX) ? -1 : 0)
+        cardinality + (include_star? && include?(UINT32_MAX) ? -1 : 0)
       end
 
-      alias size count
-
       # Returns the count of numbers in the ordered #entries, including any
       # repeated numbers.
       #
-      # <tt>*</tt> will be counted as <tt>2**32 - 1</tt> (the maximum 32-bit
-      # unsigned integer value).
-      #
-      # When #string is normalized, this behaves the same as #count.
-      #
-      # Related: #entries, #count_duplicates, #has_duplicates?
+      # When #string is normalized, this returns the same as #count.  Like
+      # #count, <tt>"*"</tt> is considered to be equal to <tt>2³² - 1</tt> (the
+      # maximum 32-bit unsigned integer value).
+      #
+      # In a range, <tt>"*"</tt> is _not_ considered a duplicate:
+      #     set = Net::IMAP::SequenceSet["4294967295:*"]
+      #     set.count_with_duplicates  #=> 1
+      #     set.size                   #=> 2
+      #     set.count                  #=> 1
+      #     set.cardinality            #=> 2
+      #
+      # In a separate entry, <tt>"*"</tt> _is_ considered a duplicate:
+      #     set = Net::IMAP::SequenceSet["4294967295,*"]
+      #     set.count_with_duplicates  #=> 2
+      #     set.size                   #=> 2
+      #     set.count                  #=> 1
+      #     set.cardinality            #=> 2
+      #
+      # Related: #count, #cardinality, #size, #count_duplicates,
+      # #has_duplicates?, #entries
       def count_with_duplicates
         return count unless @string
-        each_entry_tuple.sum {|min, max|
+        each_entry_minmax.sum {|min, max|
           max - min + ((max == STAR_INT && min != STAR_INT) ? 0 : 1)
         }
       end
 
+      # Returns the combined size of the ordered #entries, including any
+      # repeated numbers.
+      #
+      # When #string is normalized, this returns the same as #cardinality.
+      # Like #cardinality, <tt>"*"</tt> is considered to be be distinct from
+      # <tt>2³² - 1</tt> (the maximum 32-bit unsigned integer value).
+      #
+      #     set = Net::IMAP::SequenceSet["4294967295:*"]
+      #     set.size                   #=> 2
+      #     set.count_with_duplicates  #=> 1
+      #     set.count                  #=> 1
+      #     set.cardinality            #=> 2
+      #
+      #     set = Net::IMAP::SequenceSet["4294967295,*"]
+      #     set.size                   #=> 2
+      #     set.count_with_duplicates  #=> 2
+      #     set.count                  #=> 1
+      #     set.cardinality            #=> 2
+      #
+      # Related: #cardinality, #count_with_duplicates, #count, #entries
+      def size
+        return cardinality unless @string
+        each_entry_minmax.sum {|min, max| max - min + 1 }
+      end
+
       # Returns the count of repeated numbers in the ordered #entries, the
       # difference between #count_with_duplicates and #count.
       #
@@ -1333,7 +1439,7 @@ module Net
       #
       # Always returns +false+ when #string is normalized.
       #
-      # Related: #entries, #count_with_duplicates, #count_duplicates?
+      # Related: #entries, #count_with_duplicates, #count_duplicates
       def has_duplicates?
         return false unless @string
         count_with_duplicates != count
@@ -1344,10 +1450,10 @@ module Net
       #
       # Related: #[], #at, #find_ordered_index
       def find_index(number)
-        number = to_tuple_int number
-        each_tuple_with_index(@tuples) do |min, max, idx_min|
+        number = import_num number
+        each_minmax_with_index(minmaxes) do |min, max, idx_min|
           number <  min and return nil
-          number <= max and return from_tuple_int(idx_min + (number - min))
+          number <= max and return export_num(idx_min + (number - min))
         end
         nil
       end
@@ -1357,38 +1463,15 @@ module Net
       #
       # Related: #find_index
       def find_ordered_index(number)
-        number = to_tuple_int number
-        each_tuple_with_index(each_entry_tuple) do |min, max, idx_min|
+        number = import_num number
+        each_minmax_with_index(each_entry_minmax) do |min, max, idx_min|
           if min <= number && number <= max
-            return from_tuple_int(idx_min + (number - min))
+            return export_num(idx_min + (number - min))
           end
         end
         nil
       end
 
-      private
-
-      def each_tuple_with_index(tuples)
-        idx_min = 0
-        tuples.each do |min, max|
-          idx_max = idx_min + (max - min)
-          yield min, max, idx_min, idx_max
-          idx_min = idx_max + 1
-        end
-        idx_min
-      end
-
-      def reverse_each_tuple_with_index(tuples)
-        idx_max = -1
-        tuples.reverse_each do |min, max|
-          yield min, max, (idx_min = idx_max - (max - min)), idx_max
-          idx_max = idx_min - 1
-        end
-        idx_max
-      end
-
-      public
-
       # :call-seq: at(index) -> integer or nil
       #
       # Returns the number at the given +index+ in the sorted set, without
@@ -1399,7 +1482,7 @@ module Net
       #
       # Related: #[], #slice, #ordered_at
       def at(index)
-        lookup_number_by_tuple_index(tuples, index)
+        seek_number_in_minmaxes(minmaxes, index)
       end
 
       # :call-seq: ordered_at(index) -> integer or nil
@@ -1412,21 +1495,7 @@ module Net
       #
       # Related: #[], #slice, #ordered_at
       def ordered_at(index)
-        lookup_number_by_tuple_index(each_entry_tuple, index)
-      end
-
-      private def lookup_number_by_tuple_index(tuples, index)
-        index = Integer(index.to_int)
-        if index.negative?
-          reverse_each_tuple_with_index(tuples) do |min, max, idx_min, idx_max|
-            idx_min <= index and return from_tuple_int(min + (index - idx_min))
-          end
-        else
-          each_tuple_with_index(tuples) do |min, _, idx_min, idx_max|
-            index <= idx_max and return from_tuple_int(min + (index - idx_min))
-          end
-        end
-        nil
+        seek_number_in_minmaxes(each_entry_minmax, index)
       end
 
       # :call-seq:
@@ -1477,37 +1546,6 @@ module Net
 
       alias slice :[]
 
-      private
-
-      def slice_length(start, length)
-        start  = Integer(start.to_int)
-        length = Integer(length.to_int)
-        raise ArgumentError, "length must be positive" unless length.positive?
-        last = start + length - 1 unless start.negative? && start.abs <= length
-        slice_range(start..last)
-      end
-
-      def slice_range(range)
-        first = range.begin ||  0
-        last  = range.end   || -1
-        if range.exclude_end?
-          return remain_frozen_empty if last.zero?
-          last -= 1 if range.end && last != STAR_INT
-        end
-        if (first * last).positive? && last < first
-          remain_frozen_empty
-        elsif (min = at(first))
-          max = at(last)
-          max = :* if max.nil?
-          if    max == :*  then self & (min..)
-          elsif min <= max then self & (min..max)
-          else                  remain_frozen_empty
-          end
-        end
-      end
-
-      public
-
       # Returns a copy of +self+ which only contains the numbers above +num+.
       #
       #   Net::IMAP::SequenceSet["5,10:22,50"].above(10) # to_s => "11:22,50"
@@ -1579,7 +1617,7 @@ module Net
       #
       # Related: #limit!
       def limit(max:)
-        max = to_tuple_int(max)
+        max = import_num(max)
         if    empty?                      then self.class.empty
         elsif !include_star? && max < min then self.class.empty
         elsif max(star: STAR_INT) <= max  then frozen? ? self : dup.freeze
@@ -1592,53 +1630,134 @@ module Net
       #
       # Related: #limit
       def limit!(max:)
-        modifying! # short-circuit, and normalize the error message for JRuby
+        modifying! # short-circuit before querying
         star = include_star?
-        max  = to_tuple_int(max)
-        tuple_subtract [max + 1, STAR_INT]
-        tuple_add      [max,     max     ] if star
+        max  = import_num(max)
+        subtract_minmax [max + 1, STAR_INT]
+        add_minmax      [max,     max     ] if star
         normalize!
       end
 
       # :call-seq: complement! -> self
       #
-      # Converts the SequenceSet to its own #complement.  It will contain all
-      # possible values _except_ for those currently in the set.
+      # In-place set #complement.  Replaces the contents of this set with its
+      # own #complement.  It will contain all possible values _except_ for those
+      # currently in the set.
       #
       # Related: #complement
       def complement!
-        modifying! # short-circuit, and normalize the error message for JRuby
+        modifying! # short-circuit before querying
         return replace(self.class.full) if empty?
         return clear                    if full?
-        flat = @tuples.flat_map { [_1 - 1, _2 + 1] }
+        flat = minmaxes.flat_map { [_1 - 1, _2 + 1] }
         if flat.first < 1         then flat.shift else flat.unshift 1        end
         if STAR_INT   < flat.last then flat.pop   else flat.push    STAR_INT end
-        @tuples = flat.each_slice(2).to_a
+        replace_minmaxes flat.each_slice(2).to_a
         normalize!
       end
 
-      # Returns a new SequenceSet with a normalized string representation.
+      # In-place set #intersection.  Removes any elements that are missing from
+      # +other+ from this set, keeping only the #intersection, and returns
+      # +self+.
+      #
+      # +other+ can be any object that would be accepted by ::new.
+      #
+      #     set = Net::IMAP::SequenceSet.new(1..5)
+      #     set.intersect! [2, 4, 6]
+      #     set #=> Net::IMAP::SequenceSet("2,4")
+      #
+      # Related: #intersection, #intersect?
+      def intersect!(other)
+        modifying! # short-circuit before processing input
+        subtract SequenceSet.new(other).complement!
+      end
+
+      # In-place set #xor.  Adds any numbers in +other+ that are missing from
+      # this set, removes any numbers in +other+ that are already in this set,
+      # and returns +self+.
+      #
+      # +other+ can be any object that would be accepted by ::new.
+      #
+      #     set = Net::IMAP::SequenceSet.new(1..5)
+      #     set.xor! [2, 4, 6]
+      #     set #=> Net::IMAP::SequenceSet["1,3,5:6"]
+      #
+      # Related: #xor, #merge, #subtract
+      def xor!(other)
+        modifying! # short-circuit before processing input
+        other = SequenceSet.new(other)
+        copy  = dup
+        merge(other).subtract(other.subtract(copy.complement!))
+      end
+
+      # Returns whether #string is fully normalized: entries have been sorted,
+      # deduplicated, and coalesced, and all entries are in normal form.  See
+      # SequenceSet@Ordered+and+Normalized+sets.
+      #
+      #   Net::IMAP::SequenceSet["1,3,5"].normalized?  #=> true
+      #   Net::IMAP::SequenceSet["20:30"].normalized?  #=> true
+      #
+      #   Net::IMAP::SequenceSet["3,5,1"].normalized?  #=> false, not sorted
+      #   Net::IMAP::SequenceSet["1,2,3"].normalized?  #=> false, not coalesced
+      #   Net::IMAP::SequenceSet["1:5,2"].normalized?  #=> false, repeated number
+      #
+      #   Net::IMAP::SequenceSet["1:1"].normalized?    #=> false, number as range
+      #   Net::IMAP::SequenceSet["5:1"].normalized?    #=> false, backwards range
+      #
+      # Returns +true+ if (and only if) #string is equal to #normalized_string:
+      #   seqset = Net::IMAP::SequenceSet["1:3,5"]
+      #   seqset.string             #=> "1:3,5"
+      #   seqset.normalized_string  #=> "1:3,5"
+      #   seqset.entries            #=> [1..3, 5]
+      #   seqset.elements           #=> [1..3, 5]
+      #   seqset.normalized?        #=> true
+      #
+      #   seqset = Net::IMAP::SequenceSet["3,1,2"]
+      #   seqset.string             #=> "3,1,2"
+      #   seqset.normalized_string  #=> "1:3"
+      #   seqset.entries            #=> [3, 1, 2]
+      #   seqset.elements           #=> [1..3]
+      #   seqset.normalized?        #=> false
+      #
+      # Can return +false+ even when #entries and #elements are the same:
+      #   seqset = Net::IMAP::SequenceSet["5:1"]
+      #   seqset.string             #=> "5:1"
+      #   seqset.normalized_string  #=> "1:5"
+      #   seqset.entries            #=> [1..5]
+      #   seqset.elements           #=> [1..5]
+      #   seqset.normalized?        #=> false
+      #
+      # Note that empty sets are normalized, even though they are not #valid?:
+      #   seqset = Net::IMAP::SequenceSet.empty
+      #   seqset.normalized?        #=> true
+      #   seqset.valid?             #=> false
+      #
+      # Related: #normalize, #normalize!, #normalized_string
+      def normalized?
+        @string.nil? || normal_string?(@string)
+      end
+
+      # Returns a SequenceSet with a normalized string representation: entries
+      # have been sorted, deduplicated, and coalesced, and all entries
+      # are in normal form.  Returns +self+ for frozen normalized sets, and a
+      # normalized duplicate otherwise.
       #
-      # The returned set's #string is sorted and deduplicated.  Adjacent or
-      # overlapping elements will be merged into a single larger range.
       # See SequenceSet@Ordered+and+Normalized+sets.
       #
       #   Net::IMAP::SequenceSet["1:5,3:7,10:9,10:11"].normalize
       #   #=> Net::IMAP::SequenceSet["1:7,9:11"]
       #
-      # Related: #normalize!, #normalized_string
+      # Related: #normalize!, #normalized_string, #normalized?
       def normalize
-        str = normalized_string
-        return self if frozen? && str == string
-        remain_frozen dup.instance_exec { @string = str&.-@; self }
+        frozen? && normalized? ? self : remain_frozen(dup.normalize!)
       end
 
       # Resets #string to be sorted, deduplicated, and coalesced.  Returns
       # +self+.  See SequenceSet@Ordered+and+Normalized+sets.
       #
-      # Related: #normalize, #normalized_string
+      # Related: #normalize, #normalized_string, #normalized?
       def normalize!
-        modifying! # redundant check, to normalize the error message for JRuby
+        modifying! # redundant check (normalizes the error message for JRuby)
         @string = nil
         self
       end
@@ -1652,9 +1771,9 @@ module Net
       #
       # Returns +nil+ when the set is empty.
       #
-      # Related: #normalize!, #normalize, #string, #to_s
+      # Related: #normalize!, #normalize, #string, #to_s, #normalized?
       def normalized_string
-        @tuples.empty? ? nil : -@tuples.map { tuple_to_str _1 }.join(",")
+        export_runs(runs) unless runs.empty?
       end
 
       # Returns an inspection string for the SequenceSet.
@@ -1691,8 +1810,8 @@ module Net
             head = @string[INSPECT_ABRIDGED_HEAD_RE]
             tail = @string[INSPECT_ABRIDGED_TAIL_RE]
           else
-            head = export_string_entries(@tuples.first(INSPECT_TRUNCATE_LEN)) + ","
-            tail = "," + export_string_entries(@tuples.last(INSPECT_TRUNCATE_LEN))
+            head = export_runs(runs.first(INSPECT_TRUNCATE_LEN)) + ","
+            tail = "," + export_runs(runs.last(INSPECT_TRUNCATE_LEN))
           end
           '#<%s %d entries "%s...(%d entries omitted)...%s"%s>' % [
             self.class, count,
@@ -1702,10 +1821,6 @@ module Net
         end
       end
 
-      private def count_entries
-        @string ? @string.count(",") + 1 : @tuples.count
-      end
-
       ##
       # :method: to_sequence_set
       # :call-seq: to_sequence_set -> self
@@ -1736,15 +1851,17 @@ module Net
 
       # For YAML deserialization
       def init_with(coder) # :nodoc:
-        @tuples = []
+        @set_data = new_set_data
         self.string = coder['string']
       end
 
+      # :stopdoc:
       protected
 
-      attr_reader :tuples # :nodoc:
+      attr_reader :set_data
 
-      def deep_copy_tuples; @tuples.map { _1.dup } end # :nodoc:
+      alias runs set_data
+      alias minmaxes runs
 
       private
 
@@ -1753,38 +1870,42 @@ module Net
 
       # frozen clones are shallow copied
       def initialize_clone(other)
-        @tuples = other.deep_copy_tuples unless other.frozen?
+        @set_data = other.dup_set_data unless other.frozen?
         super
       end
 
       def initialize_dup(other)
-        @tuples = other.deep_copy_tuples
+        @set_data = other.dup_set_data
         super
       end
 
-      def input_to_tuple(entry)
-        entry = input_try_convert entry
+      ######################################################################{{{2
+      # Import methods
+
+      def import_minmax(input)
+        entry = input_try_convert input
         case entry
-        when *STARS, Integer then [int = to_tuple_int(entry), int]
-        when Range           then range_to_tuple(entry)
-        when String          then str_to_tuple(entry)
+        when *STARS, Integer then [int = import_num(entry), int]
+        when Range           then import_range_minmax(entry)
+        when String          then parse_minmax(entry)
         else
-          raise DataFormatError, "expected number or range, got %p" % [entry]
+          raise DataFormatError, "expected number or range, got %p" % [input]
         end
       end
+      alias import_run import_minmax
 
-      def input_to_tuples(set)
-        set = input_try_convert set
+      def import_runs(input)
+        set = input_try_convert input
         case set
-        when *STARS, Integer, Range then [input_to_tuple(set)]
-        when String      then str_to_tuples set
-        when SequenceSet then set.tuples
-        when Set         then set.map      { [to_tuple_int(_1)] * 2 }
-        when Array       then set.flat_map { input_to_tuples _1 }
+        when *STARS, Integer, Range then [import_run(set)]
+        when String      then parse_runs set
+        when SequenceSet then set.runs
+        when Set         then set.map      { [import_num(_1)] * 2 }
+        when Array       then set.flat_map { import_runs _1 }
         when nil         then []
         else
           raise DataFormatError, "expected nz-number, range, '*', Set, Array; " \
-                                 "got %p" % [set]
+                                 "got %p" % [input]
         end
       end
 
@@ -1805,9 +1926,9 @@ module Net
         end
       end
 
-      def range_to_tuple(range)
-        first = to_tuple_int(range.begin || 1)
-        last  = to_tuple_int(range.end   || :*)
+      def import_range_minmax(range)
+        first = import_num(range.begin || 1)
+        last  = import_num(range.end   || :*)
         last -= 1 if range.exclude_end? && range.end && last != STAR_INT
         unless first <= last
           raise DataFormatError, "invalid range for sequence-set: %p" % [range]
@@ -1815,71 +1936,260 @@ module Net
         [first, last]
       end
 
-      def to_tuple_int(obj) STARS.include?(obj) ? STAR_INT : nz_number(obj) end
-      def from_tuple_int(num) num == STAR_INT ? :* : num end
+      def import_num(obj) STARS.include?(obj) ? STAR_INT : nz_number(obj) end
+      def nz_number(num) = NumValidator.coerce_nz_number(num)
+
+      ######################################################################{{{2
+      # Export methods
+
+      def export_num(num) num == STAR_INT ? :* : num end
+
+      def export_minmaxes(minmaxes)
+        -minmaxes.map { export_minmax _1 }.join(",")
+      end
+
+      def export_minmax(minmax) minmax.uniq.map { export_num _1 }.join(":") end
 
-      def export_string_entries(entries)
-        -entries.map { tuple_to_str _1 }.join(",")
+      alias export_runs export_minmaxes
+      alias export_run  export_minmax
+
+      def export_minmax_entry((min, max))
+        if    min == STAR_INT then :*
+        elsif max == STAR_INT then min..
+        elsif min == max      then min
+        else                       min..max
+        end
+      end
+      alias export_run_entry export_minmax_entry
+
+      def each_number_in_minmax(min, max, &block)
+        if    min == STAR_INT then yield :*
+        elsif min == max      then yield min
+        elsif max != STAR_INT then (min..max).each(&block)
+        else
+          raise RangeError, "#{SequenceSet} cannot enumerate range with '*'"
+        end
       end
 
-      def tuple_to_str(tuple) tuple.uniq.map{ from_tuple_int _1 }.join(":") end
-      def str_to_tuples(str) str.split(",", -1).map! { str_to_tuple _1 } end
-      def str_to_tuple(str)
+      ######################################################################{{{2
+      # Parse methods
+
+      def parse_runs(str) str.split(",", -1).map! { parse_run _1 } end
+      def parse_minmax(str) parse_entry(str).minmax end
+      alias parse_run parse_minmax
+
+      def parse_entry(str)
         raise DataFormatError, "invalid sequence set string" if str.empty?
-        str.split(":", 2).map! { to_tuple_int _1 }.minmax
+        str.split(":", 2).map! { import_num _1 }
       end
 
-      def include_tuple?((min, max)) range_gte_to(min)&.cover?(min..max) end
+      # yields validated but unsorted [num] or [num, num]
+      def each_parsed_entry(str)
+        return to_enum(__method__, str) unless block_given?
+        str&.split(",", -1) do |entry| yield parse_entry(entry) end
+      end
+
+      def normal_string?(str) normalized_entries? each_parsed_entry str end
+
+      def normalized_entries?(entries)
+        max = nil
+        entries.each do |first, last|
+          return false if last && last  <= first    # 1:1 or 2:1
+          return false if max  && first <= max + 1  # 2,1 or 1,1 or 1,2
+          max = last || first
+        end
+        true
+      end
+
+      ######################################################################{{{2
+      # Ordered entry methods
+
+      def count_entries
+        @string ? @string.count(",") + 1 : runs.count
+      end
+
+      def each_entry_minmax(&block)
+        return to_enum(__method__) unless block_given?
+        if @string
+          @string.split(",") do block.call parse_minmax _1 end
+        else
+          minmaxes.each(&block)
+        end
+        self
+      end
+      alias each_entry_run each_entry_minmax
+
+      ######################################################################{{{2
+      # Search methods
 
-      def intersect_tuple?((min, max))
-        range = range_gte_to(min) and
+      def include_minmax?((min, max)) bsearch_range(min)&.cover?(min..max) end
+
+      def intersect_minmax?((min, max))
+        range = bsearch_range(min) and
           range.include?(min) || range.include?(max) || (min..max).cover?(range)
       end
 
+      alias include_run?   include_minmax?
+      alias intersect_run? intersect_minmax?
+
+      def bsearch_index(num)  = minmaxes.bsearch_index { _2 >= num }
+      def bsearch_minmax(num) = minmaxes.bsearch       { _2 >= num }
+      def bsearch_range(num)  = (min, max = bsearch_minmax(num)) && (min..max)
+
+      ######################################################################{{{2
+      # Number indexing methods
+
+      def seek_number_in_minmaxes(minmaxes, index)
+        index = Integer(index.to_int)
+        if index.negative?
+          reverse_each_minmax_with_index(minmaxes) do |min, max, idx_min, idx_max|
+            idx_min <= index and return export_num(min + (index - idx_min))
+          end
+        else
+          each_minmax_with_index(minmaxes) do |min, _, idx_min, idx_max|
+            index <= idx_max and return export_num(min + (index - idx_min))
+          end
+        end
+        nil
+      end
+
+      def each_minmax_with_index(minmaxes)
+        idx_min = 0
+        minmaxes.each do |min, max|
+          idx_max = idx_min + (max - min)
+          yield min, max, idx_min, idx_max
+          idx_min = idx_max + 1
+        end
+        idx_min
+      end
+
+      def reverse_each_minmax_with_index(minmaxes)
+        idx_max = -1
+        minmaxes.reverse_each do |min, max|
+          yield min, max, (idx_min = idx_max - (max - min)), idx_max
+          idx_max = idx_min - 1
+        end
+        idx_max
+      end
+
+      def slice_length(start, length)
+        start  = Integer(start.to_int)
+        length = Integer(length.to_int)
+        raise ArgumentError, "length must be positive" unless length.positive?
+        last = start + length - 1 unless start.negative? && start.abs <= length
+        slice_range(start..last)
+      end
+
+      def slice_range(range)
+        first = range.begin ||  0
+        last  = range.end   || -1
+        if range.exclude_end?
+          return remain_frozen_empty if last.zero?
+          last -= 1 if range.end && last != STAR_INT
+        end
+        if (first * last).positive? && last < first
+          remain_frozen_empty
+        elsif (min = at(first))
+          max = at(last)
+          max = :* if max.nil?
+          if    max == :*  then self & (min..)
+          elsif min <= max then self & (min..max)
+          else                  remain_frozen_empty
+          end
+        end
+      end
+
+      ######################################################################{{{2
+      # Core set data create/freeze/dup primitives
+
+      def new_set_data    = []
+      def freeze_set_data = set_data.each(&:freeze).freeze
+      def dup_set_data    = set_data.map { _1.dup }
+      protected :dup_set_data
+
+      ######################################################################{{{2
+      # Core set data query/enumeration primitives
+
+      def min_num                 = minmaxes.first&.first
+      def max_num                 = minmaxes.last&.last
+
+      def min_at(idx)             = minmaxes[idx][0]
+      def max_at(idx)             = minmaxes[idx][1]
+
+      ######################################################################{{{2
+      # Core set data modification primitives
+
+      def set_min_at(idx, min)         = minmaxes[idx][0] = min
+      def set_max_at(idx, max)         = minmaxes[idx][1] = max
+      def replace_minmaxes(other)      = minmaxes.replace(other)
+      def append_minmax(min, max)      = minmaxes << [min, max]
+      def insert_minmax(idx, min, max) = minmaxes.insert idx, [min, max]
+      def delete_run_at(idx)           = runs.delete_at(idx)
+      def slice_runs!(...)             = runs.slice!(...)
+      def truncate_runs!(idx)          = runs.slice!(idx..)
+
+      ######################################################################{{{2
+      # Update methods
+
       def modifying!
         if frozen?
           raise FrozenError, "can't modify frozen #{self.class}: %p" % [self]
         end
       end
 
-      def tuples_add(tuples)      tuples.each do tuple_add _1      end; self end
-      def tuples_subtract(tuples) tuples.each do tuple_subtract _1 end; self end
+      def add_minmaxes(minmaxes)
+        minmaxes.each do |minmax|
+          add_minmax minmax
+        end
+        self
+      end
+
+      def subtract_minmaxes(minmaxes)
+        minmaxes.each do |minmax|
+          subtract_minmax minmax
+        end
+        self
+      end
 
       #
-      #   --|=====| |=====new tuple=====|                 append
-      #   ?????????-|=====new tuple=====|-|===lower===|-- insert
+      #   --|=====| |=====new run=======|                 append
+      #   ?????????-|=====new run=======|-|===lower===|-- insert
       #
-      #             |=====new tuple=====|
+      #             |=====new run=======|
       #   ---------??=======lower=======??--------------- noop
       #
       #   ---------??===lower==|--|==|                    join remaining
       #   ---------??===lower==|--|==|----|===upper===|-- join until upper
       #   ---------??===lower==|--|==|--|=====upper===|-- join to upper
-      def tuple_add(tuple)
+      def add_minmax(minmax)
         modifying!
-        min, max = tuple
-        lower, lower_idx = tuple_gte_with_index(min - 1)
-        if    lower.nil?              then tuples << [min, max]
-        elsif (max + 1) < lower.first then tuples.insert(lower_idx, [min, max])
-        else  tuple_coalesce(lower, lower_idx, min, max)
+        min, max   = minmax
+        lower_idx  = bsearch_index(min - 1)
+        lmin, lmax = min_at(lower_idx), max_at(lower_idx) if lower_idx
+        if    lmin.nil?        then append_minmax min, max
+        elsif (max + 1) < lmin then insert_minmax lower_idx, min, max
+        else  add_coalesced_minmax(lower_idx, lmin, lmax, min, max)
         end
       end
 
-      def tuple_coalesce(lower, lower_idx, min, max)
-        return if lower.first <= min && max <= lower.last
-        lower[0] = [min, lower.first].min
-        lower[1] = [max, lower.last].max
-        lower_idx += 1
-        return if lower_idx == tuples.count
-        tmax_adj = lower.last + 1
-        upper, upper_idx = tuple_gte_with_index(tmax_adj)
-        if upper
-          tmax_adj < upper.first ? (upper_idx -= 1) : (lower[1] = upper.last)
+      def add_coalesced_minmax(lower_idx, lmin, lmax, min, max)
+        return if lmin <= min && max <= lmax
+        set_min_at lower_idx, (lmin = min) if min < lmin
+        set_max_at lower_idx, (lmax = max) if lmax < max
+        next_idx = lower_idx + 1
+        return if next_idx == runs.count
+        tmax_adj = lmax + 1
+        if (upper_idx = bsearch_index(tmax_adj))
+          if tmax_adj < min_at(upper_idx)
+            upper_idx -= 1
+          else
+            set_max_at lower_idx, max_at(upper_idx)
+          end
         end
-        tuples.slice!(lower_idx..upper_idx)
+        slice_runs! next_idx..upper_idx
       end
 
-      #         |====tuple================|
+      #         |====subtracted run=======|
       # --|====|                               no more       1. noop
       # --|====|---------------------------|====lower====|-- 2. noop
       # -------|======lower================|---------------- 3. split
@@ -1892,61 +2202,59 @@ module Net
       # -------??=====lower====|--|====|       no more       6. delete rest
       # -------??=====lower====|--|====|---|====upper====|-- 7. delete until
       # -------??=====lower====|--|====|--|=====upper====|-- 8. delete and trim
-      def tuple_subtract(tuple)
+      def subtract_minmax(minmax)
         modifying!
-        min, max = tuple
-        lower, idx = tuple_gte_with_index(min)
-        if    lower.nil?        then nil # case 1.
-        elsif max < lower.first then nil # case 2.
-        elsif max < lower.last  then tuple_trim_or_split   lower, idx, min, max
-        else                         tuples_trim_or_delete lower, idx, min, max
+        min, max   = minmax
+        idx        = bsearch_index(min)
+        lmin, lmax = min_at(idx), max_at(idx) if idx
+        if    lmin.nil?  then nil # case 1.
+        elsif max < lmin then nil # case 2.
+        elsif max < lmax then trim_or_split_minmax  idx, lmin,       min, max
+        else                  trim_or_delete_minmax idx, lmin, lmax, min, max
         end
       end
 
-      def tuple_trim_or_split(lower, idx, tmin, tmax)
-        if lower.first < tmin # split
-          tuples.insert(idx, [lower.first, tmin - 1])
+      def trim_or_split_minmax(idx, lmin, tmin, tmax)
+        set_min_at idx, tmax + 1
+        if lmin < tmin # split
+          insert_minmax idx, lmin, tmin - 1
         end
-        lower[0] = tmax + 1
       end
 
-      def tuples_trim_or_delete(lower, lower_idx, tmin, tmax)
-        if lower.first < tmin # trim lower
-          lower[1] = tmin - 1
+      def trim_or_delete_minmax(lower_idx, lmin, lmax, tmin, tmax)
+        if lmin < tmin # trim lower
+          lmax = set_max_at lower_idx, tmin - 1
           lower_idx += 1
         end
-        if tmax == lower.last                           # case 5
-          upper_idx = lower_idx
-        elsif (upper, upper_idx = tuple_gte_with_index(tmax + 1))
-          upper_idx -= 1                                # cases 7 and 8
-          upper[0] = tmax + 1 if upper.first <= tmax    # case 8 (else case 7)
+        if tmax == lmax                                 # case 5
+          delete_run_at lower_idx
+        elsif (upper_idx = bsearch_index(tmax + 1))
+          if min_at(upper_idx) <= tmax                  # case 8
+            set_min_at upper_idx, tmax + 1
+          end
+          slice_runs! lower_idx..upper_idx - 1          # cases 7 and 8
+        else                                            # case 6
+          truncate_runs! lower_idx
         end
-        tuples.slice!(lower_idx..upper_idx)
-      end
-
-      def tuple_gte_with_index(num)
-        idx = tuples.bsearch_index { _2 >= num } and [tuples[idx], idx]
       end
 
-      def range_gte_to(num)
-        first, last = tuples.bsearch { _2 >= num }
-        first..last if first
-      end
-
-      def nz_number(num)
-        String === num && !/\A[1-9]\d*\z/.match?(num) and
-          raise DataFormatError, "%p is not a valid nz-number" % [num]
-        NumValidator.ensure_nz_number Integer num
-      rescue TypeError # To catch errors from Integer()
-        raise DataFormatError, $!.message
-      end
+      alias add_runs      add_minmaxes
+      alias add_run       add_minmax
+      alias subtract_runs subtract_minmaxes
+      alias subtract_run  subtract_minmax
 
+      ######################################################################{{{2
       # intentionally defined after the class implementation
 
+      FULL_SET_DATA = [[1, STAR_INT].freeze].freeze
+      private_constant :FULL_SET_DATA
+
       EMPTY = new.freeze
       FULL  = self["1:*"]
       private_constant :EMPTY, :FULL
 
+      # }}}
+      # vim:foldmethod=marker
     end
   end
 end