net-imap 0.6.6 → 0.6.8

data/lib/net/imap/sequence_set.rb

@@ -2,6 +2,8 @@
 
 require "set" unless defined?(::Set)
 
+require_relative "utils"
+
 module Net
   class IMAP
 
@@ -256,6 +258,20 @@ module Net
     # - #disjoint?:
     #   Returns whether +self+ and a given object have no common elements.
     #
+    # <i>Comparison to a number:</i>
+    # - #all_above?:
+    #   Returns whether every number in +self+ is greater than a given number.
+    # - #all_below?:
+    #   Returns whether every number in +self+ is less than a given number.
+    # - #any_above?:
+    #   Returns whether +self+ contains any numbers greater than a given number.
+    # - #any_below?:
+    #   Returns whether +self+ contains any numbers less than a given number.
+    # - #none_above?:
+    #   Returns whether +self+ contains no numbers greater than a given number.
+    # - #none_below?:
+    #   Returns whether +self+ contains no numbers less than a given number.
+    #
     # === Methods for Querying
     # These methods do not modify +self+.
     #
@@ -345,7 +361,7 @@ module Net
     # - #above: Return a copy of +self+ which only contains numbers above a
     #   given number.
     # - #below: Return a copy of +self+ which only contains numbers below a
-    #   given value.
+    #   given number.
     # - #limit: Returns a copy of +self+ which has replaced <tt>*</tt> with a
     #   given maximum value and removed all members over that maximum.
     #
@@ -409,6 +425,8 @@ module Net
     #   representation and returns +self+.
     #
     class SequenceSet
+      include Utils # :nodoc:
+
       # The largest possible non-zero unsigned 32-bit integer
       UINT32_MAX = 2**32 - 1
 
@@ -774,6 +792,225 @@ module Net
         empty? || import_runs(other).none? { intersect_run? _1 }
       end
 
+      # :call-seq:
+      #   all_above?(number) -> true or false
+      #
+      # Returns whether the set only contains numbers greater than +number+ (not
+      # inclusive of +number+).
+      #
+      #     Net::IMAP::SequenceSet["5:8"].all_above?(9)  => true
+      #     Net::IMAP::SequenceSet["5:8"].all_above?(7)  => false
+      #     Net::IMAP::SequenceSet["5:8"].all_above?(5)  => false
+      #
+      # <tt>"*"</tt> is evaluated as +UINT32_MAX+:
+      #     Net::IMAP::SequenceSet["*"].all_above?(UINT32_MAX - 1)  => true
+      #     Net::IMAP::SequenceSet["*"].all_above?(UINT32_MAX)      => false
+      #
+      # This is roughly equivalent to several other comparisons:
+      #
+      #     # Given the following assumptions:
+      #     set.empty?        => false
+      #     set.include_star? => false
+      #     number            => ^(1...UINT32_MAX)
+      #
+      #     # Then these expressions will always return the same result:
+      #     set.all_above?(number)       =>  result
+      #     set.none_below?(number + 1)  => ^result
+      #     !set.any_below?(number + 1)  => ^result
+      #
+      #     set == set.above(number)     => ^result
+      #     set.disjoint?(..number)      => ^result
+      #     number < set.min             => ^result
+      #
+      # Related: {other comparison methods}[rdoc-ref:SequenceSet@Methods+for+Comparing],
+      # #above
+      def all_above?(number)
+        number = nz_number(number)
+        empty? || number < min(star: UINT32_MAX)
+      end
+
+      # :call-seq:
+      #   all_below?(number) -> true or false
+      #
+      # Returns whether the set only contains numbers less than +number+ (not
+      # inclusive of +number+).
+      #
+      #     Net::IMAP::SequenceSet["5:8"].all_below?(9)  => true
+      #     Net::IMAP::SequenceSet["5:8"].all_below?(8)  => false
+      #     Net::IMAP::SequenceSet["5:8"].all_below?(5)  => false
+      #
+      # <tt>"*"</tt> is evaluated as +UINT32_MAX+:
+      #     Net::IMAP::SequenceSet["*"].all_below?(UINT32_MAX)  => false
+      #
+      # This is roughly equivalent to several other comparisons:
+      #
+      #     # Given the following assumptions:
+      #     set.empty?        => false
+      #     set.include_star? => false
+      #     number            => ^(2..UINT32_MAX)
+      #
+      #     # Then these expressions will always return the same result:
+      #     set.all_below?(number)       =>  result
+      #     set.none_above?(number - 1)  => ^result
+      #     !set.any_above?(number - 1)  => ^result
+      #
+      #     set == set.below(number)     => ^result
+      #     set.disjoint?(number..)      => ^result
+      #     set.max < number             => ^result
+      #
+      # Related: {other comparison methods}[rdoc-ref:SequenceSet@Methods+for+Comparing],
+      # #below
+      def all_below?(number)
+        number = nz_number(number)
+        empty? || max(star: UINT32_MAX) < number
+      end
+
+      # :call-seq:
+      #   any_above?(number) -> true or false
+      #
+      # Returns whether the set contains any numbers greater than +number+ (not
+      # inclusive of +number+).
+      #
+      #     Net::IMAP::SequenceSet["5:8"].any_above?(1)  => true
+      #     Net::IMAP::SequenceSet["5:8"].any_above?(7)  => true
+      #     Net::IMAP::SequenceSet["5:8"].any_above?(8)  => false
+      #
+      # <tt>"*"</tt> is evaluated as +UINT32_MAX+:
+      #     Net::IMAP::SequenceSet["1:*"].any_above?(UINT32_MAX - 1)  => true
+      #     Net::IMAP::SequenceSet["1:*"].any_above?(UINT32_MAX)      => false
+      #
+      # This is roughly equivalent to several other comparisons:
+      #
+      #     # Given the following assumptions:
+      #     set.empty?        => false
+      #     set.include_star? => false
+      #     number            => ^(1...UINT32_MAX)
+      #
+      #     # Then these expressions will always return the same result:
+      #     set.any_above?(number)         =>  result
+      #     !set.none_above?(number)       => ^result
+      #     !set.all_below?(number + 1)    => ^result
+      #
+      #     set.cover?(set.above(number))  => ^result
+      #     set.intersect?(number + 1..)   => ^result
+      #     number < set.max               => ^result
+      #
+      # Related: {other comparison methods}[rdoc-ref:SequenceSet@Methods+for+Comparing],
+      # #above
+      def any_above?(number)
+        number = nz_number(number)
+        valid? && number < max(star: UINT32_MAX)
+      end
+
+      # :call-seq:
+      #   any_below?(number) -> true or false
+      #
+      # Returns whether the set contains any numbers less than +number+ (not
+      # inclusive of +number+).
+      #
+      #     Net::IMAP::SequenceSet["5:8"].any_below? 5  => false
+      #     Net::IMAP::SequenceSet["5:8"].any_below? 6  => true
+      #     Net::IMAP::SequenceSet["5:8"].any_below? 9  => true
+      #
+      # <tt>"*"</tt> is evaluated as +UINT32_MAX+:
+      #     Net::IMAP::SequenceSet["*"].any_below?(UINT32_MAX)  => false
+      #
+      # This is roughly equivalent to several other comparisons:
+      #
+      #     # Given the following assumptions:
+      #     set.empty?        => false
+      #     set.include_star? => false
+      #     number            => ^(2..UINT32_MAX)
+      #
+      #     # Then these expressions will always return the same result:
+      #     set.any_below?(number)         =>  result
+      #     !set.none_below?(number)       => ^result
+      #     !set.all_above?(number - 1)    => ^result
+      #
+      #     set.cover?(set.below(number))  => ^result
+      #     set.intersect?(...number)      => ^result
+      #     set.min < number               => ^result
+      #
+      # Related: {other comparison methods}[rdoc-ref:SequenceSet@Methods+for+Comparing],
+      # #below
+      def any_below?(number)
+        number = nz_number(number)
+        valid? && min(star: UINT32_MAX) < number
+      end
+
+      # :call-seq:
+      #   none_above?(number) -> true or false
+      #
+      # Returns whether the set contains no numbers greater than +number+ (not
+      # inclusive of +number+).
+      #
+      #     Net::IMAP::SequenceSet["5:8"].none_above?(9)  => true
+      #     Net::IMAP::SequenceSet["5:8"].none_above?(8)  => true
+      #     Net::IMAP::SequenceSet["5:8"].none_above?(7)  => false
+      #
+      # <tt>"*"</tt> is evaluated as +UINT32_MAX+:
+      #     Net::IMAP::SequenceSet["*"].none_above?(UINT32_MAX - 1)  => false
+      #     Net::IMAP::SequenceSet["*"].none_above?(UINT32_MAX)      => true
+      #
+      # This is roughly equivalent to several other comparisons:
+      #
+      #     # Given the following assumptions:
+      #     set.empty?        => false
+      #     set.include_star? => false
+      #     number            => ^(1...UINT32_MAX)
+      #
+      #     # Then these expressions will always return the same result:
+      #     set.none_above?(number)      =>  result
+      #     !set.any_above?(number)      => ^result
+      #     set.all_below?(number + 1)   => ^result
+      #
+      #     set.above(number).empty?     => ^result
+      #     set.disjoint?(number..)      => ^result
+      #     set.max <= number            => ^result
+      #
+      # Related: {other comparison methods}[rdoc-ref:SequenceSet@Methods+for+Comparing],
+      # #above
+      def none_above?(number)
+        number = nz_number(number)
+        empty? || max(star: UINT32_MAX) <= number
+      end
+
+      # :call-seq:
+      #   none_below?(number) -> true or false
+      #
+      # Returns whether the set contains no numbers less than +number+ (not
+      # inclusive of +number+).
+      #
+      #     Net::IMAP::SequenceSet["5:8"].none_below?(4)  => true
+      #     Net::IMAP::SequenceSet["5:8"].none_below?(5)  => true
+      #     Net::IMAP::SequenceSet["5:8"].none_below?(6)  => false
+      #
+      # <tt>"*"</tt> is evaluated as +UINT32_MAX+:
+      #     Net::IMAP::SequenceSet["*"].none_below?(UINT32_MAX)  => true
+      #
+      # This is roughly equivalent to several other comparisons:
+      #
+      #     # Given the following assumptions:
+      #     set.empty?        => false
+      #     set.include_star? => false
+      #     number            => ^(2..UINT32_MAX)
+      #
+      #     # Then these expressions will always return the same result:
+      #     set.none_below?(number)      =>  result
+      #     !set.any_below?(number)      => ^result
+      #     set.all_above?(number - 1)   => ^result
+      #
+      #     set.above(number).empty?     => ^result
+      #     set.disjoint?(...number)     => ^result
+      #     number <= set.min            => ^result
+      #
+      # Related: {other comparison methods}[rdoc-ref:SequenceSet@Methods+for+Comparing],
+      # #below
+      def none_below?(number)
+        number = nz_number(number)
+        empty? || number <= min(star: UINT32_MAX)
+      end
+
       # :call-seq:
       #   max(star: :*) => integer or star or nil
       #   max(count) => SequenceSet
@@ -786,8 +1023,11 @@ module Net
       # is empty.  (+star+ is ignored when +count+ is given.)
       #
       # Related: #min, #minmax, #slice
-      def max(count = nil, star: :*)
-        if count
+      def max(count = (unset_count = true; nil), star: :*)
+        if !unset_count
+          count = implicit_int(count)
+          raise ArgumentError, 'negative count' if count < 0
+          return remain_frozen_empty if count == 0
           if cardinality <= count
             frozen? ? self : dup
           else
@@ -810,8 +1050,10 @@ module Net
       # is empty.  (+star+ is ignored when +count+ is given.)
       #
       # Related: #max, #minmax, #slice
-      def min(count = nil, star: :*)
-        if count
+      def min(count = (unset_count = true; nil), star: :*)
+        if !unset_count
+          count = implicit_int(count)
+          raise ArgumentError, 'negative count' if count < 0
           slice(0...count) || remain_frozen_empty
         elsif (val = min_num)
           val != STAR_INT ? val : star
@@ -1122,7 +1364,7 @@ module Net
       #
       # Related: #delete, #delete?, #slice!, #subtract, #difference
       def delete_at(index)
-        slice! Integer(index.to_int)
+        slice! implicit_int index
       end
 
       # :call-seq:
@@ -1138,9 +1380,10 @@ module Net
       # #string will be regenerated after deletion.
       #
       # Related: #slice, #delete_at, #delete, #delete?, #subtract, #difference
-      def slice!(index, length = nil)
+      def slice!(index, length = (length_unset = true; nil))
         modifying! # short-circuit before slice
-        deleted = slice(index, length) and subtract deleted
+        deleted = length_unset ? slice(index) : slice(index, length)
+        subtract deleted if deleted
         deleted
       end
 
@@ -1453,7 +1696,7 @@ module Net
         number = import_num number
         each_minmax_with_index(minmaxes) do |min, max, idx_min|
           number <  min and return nil
-          number <= max and return export_num(idx_min + (number - min))
+          number <= max and return idx_min + (number - min)
         end
         nil
       end
@@ -1466,7 +1709,7 @@ module Net
         number = import_num number
         each_minmax_with_index(each_entry_minmax) do |min, max, idx_min|
           if min <= number && number <= max
-            return export_num(idx_min + (number - min))
+            return idx_min + (number - min)
           end
         end
         nil
@@ -1482,7 +1725,7 @@ module Net
       #
       # Related: #[], #slice, #ordered_at
       def at(index)
-        seek_number_in_minmaxes(minmaxes, index)
+        export_num sorted_set_num_at implicit_int index
       end
 
       # :call-seq: ordered_at(index) -> integer or nil
@@ -1495,22 +1738,55 @@ module Net
       #
       # Related: #[], #slice, #ordered_at
       def ordered_at(index)
-        seek_number_in_minmaxes(each_entry_minmax, index)
+        export_num ordered_list_num_at implicit_int index
       end
 
       # :call-seq:
       #    seqset[index]         -> integer or :* or nil
       #    slice(index)          -> integer or :* or nil
-      #    seqset[start, length] -> sequence set or nil
-      #    slice(start, length)  -> sequence set or nil
+      #    seqset[index, length] -> sequence set or nil
+      #    slice(index, length)  -> sequence set or nil
       #    seqset[range]         -> sequence set or nil
       #    slice(range)          -> sequence set or nil
       #
       # Returns a number or a subset from the _sorted_ set, without modifying
       # the set.
       #
+      # With a single +index+ argument, returns an integer or +:*+ or nil:
+      #     set = Net::IMAP::SequenceSet["10:15,20:23,26"]
+      #     set[0]     #=> 10
+      #     set[-1]    #=> 26
+      #
+      # With +index+ and +length+ arguments, returns a new SequenceSet or nil:
+      #     set = Net::IMAP::SequenceSet["10:15,20:23,26"]
+      #     set[1, 2]  #=> Net::IMAP::SequenceSet["11:12"]
+      #     set[-2, 2] #=> Net::IMAP::SequenceSet["23,26"]
+      #
+      # With a single +range+ argument, returns a new SequenceSet or nil:
+      #     set = Net::IMAP::SequenceSet["10:15,20:23,26"]
+      #     set[0...2] #=> Net::IMAP::SequenceSet["10:11"]
+      #     set[0..2]  #=> Net::IMAP::SequenceSet["11:12"]
+      #     set[0..-2] #=> Net::IMAP::SequenceSet["10:15,20:23"]
+      #     set[-6..6] #=> Net::IMAP::SequenceSet["15,20"]
+      #
+      # Note that the result is based on the sorted and de-duplicated set, not
+      # on the ordered #entries in #string.
+      #
+      #     set = Net::IMAP::SequenceSet["12,20:23,11:16,21"]
+      #     set[0]   #=> 11
+      #     set[-1]  #=> 23
+      #
+      # This behaves like <tt>Array#slice</tt> on a virtual array of all of the
+      # monotonically sorted #numbers in +self+:
+      #     # WARNING: For illustration only.  Do NOT do this with large sets.
+      #     sliced_array = seqset.numbers[*args] and
+      #       sliced_set = Net::IMAP::SequenceSet(sliced_array)
+      #     set.slice(*args) == sliced_set  #=> true
+      #
+      # ==== Number lookup by index
+      #
       # When an Integer argument +index+ is given, the number at offset +index+
-      # in the sorted set is returned:
+      # in the sorted set is returned.
       #
       #     set = Net::IMAP::SequenceSet["10:15,20:23,26"]
       #     set[0]   #=> 10
@@ -1521,24 +1797,86 @@ module Net
       #     set = Net::IMAP::SequenceSet["10:15,20:23,26"]
       #     set[-1]  #=> 26
       #     set[-3]  #=> 22
-      #     set[-6]  #=> 15
-      #
-      # If +index+ is out of range, +nil+ is returned.
+      #     set[-11] #=> 10
       #
+      # The range for +index+ is <tt>-cardinality...cardinality</tt>.
+      # If +index+ is out of range, returns +nil+.
       #     set = Net::IMAP::SequenceSet["10:15,20:23,26"]
       #     set[11]  #=> nil
       #     set[-12] #=> nil
       #
-      # The result is based on the sorted and de-duplicated set, not on the
-      # ordered #entries in #string.
+      # With a single Integer argument, this behaves identically to #at.
       #
-      #     set = Net::IMAP::SequenceSet["12,20:23,11:16,21"]
-      #     set[0]   #=> 11
-      #     set[-1]  #=> 23
+      # ==== Subset slice by index and length
+      #
+      # When two Integer arguments, +index+ and +length+ are given, returns a
+      # new SequenceSet containing the +length+ successive numbers beginning at
+      # offset +index+.:
+      #     set = Net::IMAP::SequenceSet["10:15,20:23,26"]
+      #     set[0, 2]  #=> Net::IMAP::SequenceSet["10:11"]
+      #     set[1, 2]  #=> Net::IMAP::SequenceSet["11:12"]
+      #
+      # If <tt>index + length</tt> is greater than #cardinality, returns all
+      # elements from +index+ to the end:
+      #     set = Net::IMAP::SequenceSet["10:15,20:23,26"]
+      #     set[0, 15] #=> Net::IMAP::SequenceSet["10:15,20:23,26"]
+      #     set[5, 10] #=> Net::IMAP::SequenceSet["15,20:23,26"]
+      #     set[10, 5] #=> Net::IMAP::SequenceSet["26"]
+      #
+      # If +index+ is equal to #cardinality, returns a new empty SequenceSet.
+      #     set = Net::IMAP::SequenceSet["10:15,20:23,26"]
+      #     set[11, 5] #=> Net::IMAP::SequenceSet.empty
+      #
+      # If +length+ is negative, returns +nil+.
+      #     set = Net::IMAP::SequenceSet[1..10]
+      #     set[5, -1] #=> nil
+      #
+      # If +index+ is out of range (absolute value greater than #cardinality),
+      # returns +nil+.
+      #
+      # If +index+ is in range and +length+ is zero, returns a new empty
+      # SequenceSet.
+      #
+      # ==== Subset slice by index range
+      #
+      # When a single Range argument +range+ is given, returns a new SequenceSet
+      # containing the successive numbers at the offsets indicated by +range+.
+      #
+      #     set = Net::IMAP::SequenceSet["10:15,20:23,26"]
+      #     set[0...2]   #=> Net::IMAP::SequenceSet["10:11"]
+      #     set[2..4]    #=> Net::IMAP::SequenceSet["12:14"]
+      #
+      #     set[-2..-1]  #=> Net::IMAP::SequenceSet["23,26"]
+      #     set[-4...-2] #=> Net::IMAP::SequenceSet["21:22"]
+      #
+      #     set[4..-4]   #=> Net::IMAP::SequenceSet["14:15,20:21"]
+      #     set[-6...6]  #=> Net::IMAP::SequenceSet["15"]
       #
-      # Related: #at
-      def [](index, length = nil)
-        if    length              then slice_length(index, length)
+      # An end-less range slices until the last number, and a begin-less range
+      # slices from the first number.
+      #     set = Net::IMAP::SequenceSet["10:15,20:23,26"]
+      #     set[..3]    #=> Net::IMAP::SequenceSet["10:13"]
+      #     set[..-3]   #=> Net::IMAP::SequenceSet["10:15,20:22"]
+      #     set[-2..]   #=> Net::IMAP::SequenceSet["23,26"]
+      #     set[2..]    #=> Net::IMAP::SequenceSet["12:15,20:23,26"]
+      #
+      # When +range.begin+ points to a smaller index than +range.end+, a new
+      # empty SequenceSet is returned.
+      #
+      #     set = Net::IMAP::SequenceSet[1..10]
+      #     set[5.. 4]  #=> SequenceSet.empty
+      #     set[-4..-5] #=> SequenceSet.empty
+      #     set[5..-6]  #=> SequenceSet.empty
+      #
+      # If +range.begin+ is out of range (absolute value greater than
+      # #cardinality), returns +nil+.
+      #
+      # This behaves similarly to a slice with +range.begin+ as +index+ and
+      # +range.size+ as +length+, when that both sides of the range are either
+      # negative or non-negative.  Note that the minimum +range.size+ is zero,
+      # so this can't return +nil+ for a negative range length.
+      def [](index, length = (length_unset = true; nil))
+        if    !length_unset       then slice_length(index, length)
         elsif index.is_a?(Range)  then slice_range(index)
         else                           at(index)
         end
@@ -1560,7 +1898,9 @@ module Net
       #   Net::IMAP::SequenceSet["5,10:22,50"] & (21..)   # to_s => "21:22,50"
       #   Net::IMAP::SequenceSet["5,10:22,50"] - (..20)   # to_s => "21:22,50"
       #
-      # Related: #above, #-, #&
+      # Related: #below,
+      # {other set operations}[rdoc-ref:SequenceSet@Methods+for+Set+Operations],
+      # #all_above?, #any_above?, #none_above?
       def above(num)
         NumValidator.valid_nz_number?(num) or
           raise ArgumentError, "not a valid sequence set number"
@@ -1591,7 +1931,9 @@ module Net
       #   Net::IMAP::SequenceSet["5,10:22,*"].below(30)       # to_s => "5,10:22"
       #   Net::IMAP::SequenceSet["5,10:22,*"].limit(max: 29)  # to_s => "5,10:22,29"
       #
-      # Related: #above, #-, #&, #limit
+      # Related: #above,
+      # {other set operations}[rdoc-ref:SequenceSet@Methods+for+Set+Operations],
+      # #all_below?, #any_below?, #none_below?
       def below(num)
         NumValidator.valid_nz_number?(num) or
           raise ArgumentError, "not a valid sequence set number"
@@ -1869,8 +2211,9 @@ module Net
       def remain_frozen_empty; frozen? ? SequenceSet.empty : SequenceSet.new end
 
       # frozen clones are shallow copied
-      def initialize_clone(other)
-        @set_data = other.dup_set_data unless other.frozen?
+      def initialize_clone(other, freeze: nil)
+        @set_data = other.dup_set_data unless other.frozen? && freeze != false
+        freeze_set_data if freeze
         super
       end
 
@@ -1922,7 +2265,7 @@ module Net
       def number_input?(input)
         case input
         when *STARS, Integer then true
-        when String          then !input.include?(/[:,]/)
+        when String          then !input.match?(/[:,]/)
         end
       end
 
@@ -2039,15 +2382,22 @@ module Net
       ######################################################################{{{2
       # Number indexing methods
 
+      def sorted_set_num_at(index)
+        seek_number_in_minmaxes(minmaxes, index)
+      end
+
+      def ordered_list_num_at(index)
+        seek_number_in_minmaxes(each_entry_minmax, index)
+      end
+
       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))
+            idx_min <= index and return 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))
+            index <= idx_max and return min + (index - idx_min)
           end
         end
         nil
@@ -2073,30 +2423,41 @@ module Net
       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)
+        start  = implicit_int(start)
+        length = implicit_int(length)
+        return nil if length.negative?
+        stop   = start + length unless start.negative? && start.abs <= length
+        slice_range(start...stop)
       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)
+        first = implicit_int(range.begin || 0)
+        rend  = implicit_int(range.end) unless range.end.nil?
+        excl  = range.exclude_end?
+        last = !(excl && rend == 0) &&        # (i...0)
+          (excl && rend&.pred || rend || -1)  # (i...j) vs (i..j) vs (i...)
+        if !last || first.negative? == last.negative? && last < first
+          remain_frozen_empty if valid_slice_start?(first)
+        elsif (min = sorted_set_num_at(first))
+          max = sorted_set_num_at(last) || (last.negative? ? 0 : STAR_INT)
+          if    min <= max then intersection export_minmax_entry [min, max]
           else                  remain_frozen_empty
           end
+        elsif first.positive?
+          remain_frozen_empty if valid_slice_start?(first)
+        end
+      end
+
+      # By short-circuiting, this is a small performance improvement over
+      # `offset.abs <= cardinality`.  But, slice_range should get a bigger
+      # performance boost by combining this scan with the start offset scan.
+      def valid_slice_start?(offset)
+        offset = offset.abs
+        minmaxes.each do |min, max|
+          offset -= (max - min).succ
+          return true if offset.negative?
         end
+        !offset.positive?
       end
 
       ######################################################################{{{2

data/lib/net/imap/utils.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+
+# :enddoc:
+
+module Net
+  class IMAP < Protocol
+
+    # INTERNAL utility methods.  API is unstable and subject to change.
+    module Utils
+      module_function
+
+      # Something like this exists in ruby's C API.  Why not in ruby's ruby?
+      def implicit_int(input)
+        Integer.try_convert(input) or
+          raise TypeError, case input
+            when nil
+              "no implicit conversion from %p to Integer" % [input]
+            when true, false
+              "no implicit conversion of %p into Integer" % [input]
+            else
+              "no implicit conversion of %s into Integer" % [input.class.name]
+            end
+      end
+
+      if defined?(Ractor.shareable_proc)
+        def shareable
+          case obj = yield
+          when Proc
+            Ractor.shareable_proc(&obj)
+          else
+            Ractor.make_shareable obj
+          end
+        end
+
+      # simplecov:disable
+      elsif defined?(Ractor.make_shareable)
+        def shareable(&b)
+          obj = nil.instance_eval(&b).freeze
+          Ractor.make_shareable obj
+        end
+      else
+        def shareable(&b) nil.instance_eval(&b).freeze end
+      end
+      # simplecov:enable
+
+    end
+  end
+end