class Range

def bsearch
  return to_enum(:bsearch) unless block_given?
  from = self.begin
  to   = self.end
  unless from.is_a?(Numeric) && to.is_a?(Numeric)
    raise TypeError, "can't do binary search for #{from.class}"
  end
  midpoint = nil
  if from.is_a?(Integer) && to.is_a?(Integer)
    convert = Proc.new{ midpoint }
  else
    from = Backports.float_to_integer(from.to_f)
    to   = Backports.float_to_integer(to.to_f)
    convert = Proc.new{ Backport.integer_to_float(midpoint) }
  end
  to -= 1 if exclude_end?
  satisfied = nil
  while from <= to do
    midpoint = (from + to).div(2)
    result = yield(cur = convert.call)
    case result
    when Numeric
      return cur if result == 0
      result = result < 0
    when true
      satisfied = cur
    when nil, false
      # nothing to do
    else
      raise TypeError, "wrong argument type #{result.class} (must be numeric, true, false or nil)"
    end
    if result
      to = midpoint - 1
    else
      from = midpoint + 1
    end
  end
  satisfied
end

def cover_with_range_compatibility?(what)
  return cover_without_range_compatibility?(what) unless what.is_a?(Range)
  left = self.begin <=> what.begin
  right = self.end <=> what.end
  return false unless left && right
  left <= 0 && (
    right >= 1 ||
    right == 0 && (!exclude_end? || what.exclude_end?) ||
    what.exclude_end? && what.begin.is_a?(Integer) &&
      what.end.is_a?(Integer) && cover_without_range_compatibility?(what.end - 1)
  )
end

def overlap?(other)
  raise TypeError, "wrong argument type #{other.class} (expected Range)" unless other.is_a?(Range)
  [
    [other.begin, self.end, exclude_end?],
    [self.begin, other.end, other.exclude_end?],
    [self.begin, self.end, exclude_end?],
    [other.begin, other.end, other.exclude_end?],
  ].all? do |from, to, excl|
    less = (from || -Float::INFINITY) <=> (to || Float::INFINITY)
    less = +1 if less == 0 && excl
    less && less <= 0
  end
end

def reverse_each_with_endless_handling(&block)
  case self.end
  when nil
    raise "Hey"
  when Float::INFINITY
    raise "Hey"
  when Integer
    delta = exclusive? ? 1 : 0
    ((self.end - delta)..(self.begin)).each(&block)
  else
    reverse_each_without_endless_handling(&block)
  end
end

def size
  return nil unless self.begin.is_a?(Numeric) && self.end.is_a?(Numeric)
  size = self.end - self.begin
  return 0 if size <= 0
  return size if size == Float::INFINITY
  if exclude_end?
    size.ceil
  else
    size.floor + 1
  end
end