Ranges

# frozen_string_literal: true

def outcome
  yield.inspect
rescue StandardError => e
  "#{e.class}: #{e.message}"
end

# This file shows `Range#===` directly, which Style/CaseEquality discourages in application code.
# rubocop:disable Style/CaseEquality
letters = "a".."z"
p letters.include?("bb") # => false
p letters.cover?("bb") # => true
p letters === "bb" # => true
p letters.to_a.include?("bb") # => false

ratings = 1..5
p [ratings.include?(2.5), ratings.cover?(2.5), ratings === 2.5] # => [true, true, true]
p [ratings.include?(5), (1...5).include?(5), (1...5).cover?(5)] # => [true, false, false]
p [ratings.cover?(2..4), ratings.cover?(2..9), ratings.cover?(1...6), (1..).cover?(2..)] # => [true, false, true, true]
p [(..5).cover?(3), (..5).include?(3), (1..).include?(10)] # => [true, true, true]
p [ratings.cover?(nil), ratings === "x"] # => [false, false]
puts(outcome { ("a"..).include?("b") }) # => TypeError: cannot determine inclusion in beginless/endless ranges
puts(outcome { (.."c").include?("b") }) # => TypeError: cannot determine inclusion in beginless/endless ranges

# A loan period is a range of Time values: continuous, so it cannot be iterated.
lent_on = Time.utc(2026, 10, 1)
period = lent_on...(lent_on + (14 * 24 * 3600))
p period.cover?(Time.utc(2026, 10, 14, 23, 59)) # => true
p period.cover?(Time.utc(2026, 10, 15)) # => false
p period.include?(Time.utc(2026, 10, 2)) # => true
puts(outcome { period.each { nil } }) # => TypeError: can't iterate from Time
puts(outcome { period.size }) # => TypeError: can't iterate from Time

# Case equality is what `case`/`when` and Enumerable#grep call.
p [0, 3, 7, 12].grep(1..9) # => [3, 7]
p [0, 3, 7, 12].grep_v(1..9) # => [0, 12]
# rubocop:enable Style/CaseEquality

# frozen_string_literal: true

def outcome
  yield.inspect
rescue StandardError => e
  "#{e.class}: #{e.message}"
end

p (1..5).overlap?(5..9) # => true
p (1...5).overlap?(5..9) # => false
p (1..5).overlap?(6..9) # => false
p (1..5).overlap?(2..3) # => true
p (3..1).overlap?(1..5) # => false
p (1..).overlap?(..0) # => false
p (1..).overlap?(..1) # => true
p (nil..nil).overlap?(1..2) # => true
p (1.0..2.5).overlap?(2..4) # => true
puts(outcome { (1..5).overlap?(3) }) # => TypeError: wrong argument type Integer (expected Range)
puts(outcome { (1..5).overlap?("a".."c") }) # => false

# Two bookings of the same copy clash when their half-open periods overlap.
module Shelf
  Booking = Data.define(:reader, :period) do
    def clash?(other) = period.overlap?(other.period)
  end
end

def day(number) = Time.utc(2026, 10, number)

ana = Shelf::Booking.new("Ana", day(1)...day(8))
ben = Shelf::Booking.new("Ben", day(8)...day(15))
eva = Shelf::Booking.new("Eva", day(7)...day(10))

p ana.clash?(ben) # => false
p ana.clash?(eva) # => true
p ben.clash?(eva) # => true
clashes = [ana, ben, eva].combination(2).select { |a, b| a.clash?(b) }
readers = clashes.map { |pair| pair.map(&:reader) }
p readers # => [["Ana", "Eva"], ["Ben", "Eva"]]

# frozen_string_literal: true

module Shelf
  # Late fees in cents, decided by how many days a loan is overdue.
  module LateFee
    module_function

    def cents(days_overdue)
      case days_overdue
      when ..0 then 0
      when 1..7 then 25 * days_overdue
      when 8..30 then 175 + (50 * (days_overdue - 7))
      when 31.. then 2_500
      end
    end

    # The same decision with pattern matching.
    def tier(days_overdue)
      case days_overdue
      in ..0 then :on_time
      in 1..7 then :grace
      in 8..30 then :standard
      in 31.. then :capped
      end
    end

    def band(rating)
      case rating
      when 0.0...2.5 then :poor
      when 2.5...4.0 then :good
      when 4.0..5.0 then :excellent
      else :unrated
      end
    end

    def ordinal(code)
      case code
      when "A".."M" then :first_half
      when "N".."Z" then :second_half
      end
    end
  end
end

days = [-3, 0, 1, 7, 8, 30, 31, 400]
fees = days.map { |count| Shelf::LateFee.cents(count) }
tiers = days.map { |count| Shelf::LateFee.tier(count) }
p fees # => [0, 0, 25, 175, 225, 1325, 2500, 2500]
p tiers # => [:on_time, :on_time, :grace, :grace, :standard, :standard, :capped, :capped]

ratings = [0.0, 2.4999, 2.5, 3.99, 4.0, 5.0, 5.1, nil]
bands = ratings.map { |rating| Shelf::LateFee.band(rating) }
p bands # => [:poor, :poor, :good, :good, :excellent, :excellent, :unrated, :unrated]

codes = %w[A M N Z a]
halves = codes.map { |code| Shelf::LateFee.ordinal(code) }
p halves # => [:first_half, :first_half, :second_half, :second_half, nil]

reading = { title: "Dune", pages: 412, rating: 4.5 }
case reading
in { pages: ...100 } then puts "short"
in { pages: 100..399, rating: 4.0.. } then puts "medium and loved"
in { pages: 400.., rating: 4.0.. => rating }
  puts "long and loved: #{rating}" # => long and loved: 4.5
in { pages: 400.. } then puts "long"
end

begin
  Shelf::LateFee.tier(0.5)
rescue NoMatchingPatternError => e
  puts "#{e.class}: #{e.message}" # => NoMatchingPatternError: 0.5
end

# frozen_string_literal: true

def outcome
  yield.inspect
rescue StandardError => e
  "#{e.class}: #{e.message}"
end

titles = %w[Dune Emma Ulysses Beloved Hamlet]

p titles[1..2] # => ["Emma", "Ulysses"]
p titles[1...2] # => ["Emma"]
p titles[1..] # => ["Emma", "Ulysses", "Beloved", "Hamlet"]
p titles[..1] # => ["Dune", "Emma"]
p titles[...-1] # => ["Dune", "Emma", "Ulysses", "Beloved"]
p titles[-2..] # => ["Beloved", "Hamlet"]
p titles[5..] # => []
p titles[6..] # => nil
p titles[2..1] # => []
p titles[(0..) % 2] # => ["Dune", "Ulysses", "Hamlet"]
p titles[(-1..0).step(-1)] # => ["Hamlet", "Beloved", "Ulysses", "Emma", "Dune"]
p titles.values_at(0, 2..3, 8..9) # => ["Dune", "Ulysses", "Beloved", nil, nil]
p titles.first(2) # => ["Dune", "Emma"]
p titles.take(2) # => ["Dune", "Emma"]
p titles.slice(1, 2) # => ["Emma", "Ulysses"]

copy = titles.dup
p copy.slice!(3..) # => ["Beloved", "Hamlet"]
p copy # => ["Dune", "Emma", "Ulysses"]
p copy.fill("Walden", 1..2) # => ["Dune", "Walden", "Walden"]

word = "Frankenstein"
p word[0..4] # => "Frank"
p word[5..] # => "enstein"
p word[-5..-2] # => "stei"
p word[12..] # => ""
p word[13..] # => nil
shout = +"Dune"
shout[1..2] = "UN"
p shout # => "DUNe"

puts(outcome { titles.fetch(1..2) }) # => TypeError: no implicit conversion of Range into Integer

# clamp accepts a range, including endless and beginless ones.
p 15.clamp(1..10) # => 10
p 15.clamp(..10) # => 10
p(-3.clamp(0..)) # => 0
p 4.5.clamp(1..3) # => 3
puts(outcome { 15.clamp(1...10) }) # => ArgumentError: cannot clamp with an exclusive range

# Random#rand accepts ranges too: integer ranges give integers, float ranges give floats.
dice = Random.new(42)
p dice.rand(1..6).between?(1, 6) # => true
p dice.rand(0.0...1.0).class # => Float

# frozen_string_literal: true

module Shelf
  # A shelf number that can be used as a range endpoint: it needs <=> and succ.
  ShelfNo = Data.define(:number) do
    include Comparable

    def <=>(other) = other.is_a?(ShelfNo) ? number <=> other.number : nil
    def succ = with(number: number + 1)
    def to_s = format("S%02d", number)
  end
end

def outcome
  yield.inspect
rescue StandardError => e
  "#{e.class}: #{e.message}"
end

first = Shelf::ShelfNo.new(3)
last = Shelf::ShelfNo.new(6)
aisle = first..last

p aisle # => #<data Shelf::ShelfNo number=3>..#<data Shelf::ShelfNo number=6>
puts aisle.to_a.join(" ") # => S03 S04 S05 S06
p aisle.include?(Shelf::ShelfNo.new(4)) # => true
p aisle.cover?(Shelf::ShelfNo.new(9)) # => false
p aisle.size # => nil
p aisle.count # => 4
p aisle.min.to_s # => "S03"
p aisle.to_a.last.to_s # => "S06"
puts(outcome { aisle.step(2).to_a }) # => NoMethodError: undefined method '+' for an instance of Shelf::ShelfNo
puts(outcome { first..3 }) # => ArgumentError: bad value for range
puts(outcome { Object.new..Object.new }) # => ArgumentError: bad value for range
puts(outcome { (first..).each { |shelf| break shelf.to_s if shelf.number > 4 } }) # => "S05"

# frozen_string_literal: true

def outcome
  yield.inspect
rescue StandardError => e
  "#{e.class}: #{e.message}"
end

# Pages of results: windowing a range without building an array first.
catalogue_size = 23
page_size = 10
slices = (1..catalogue_size).each_slice(page_size)
pages = slices.map { |slice| [slice.first, slice.last] }
p pages # => [[1, 10], [11, 20], [21, 23]]
p slices.size # => 3
p (1..5).each_cons(2).to_a # => [[1, 2], [2, 3], [3, 4], [4, 5]]

# Sums have a closed form for integer ranges, so they cost nothing even for huge ones.
big = 1..(10**12)
squares = (1..10).sum { |n| n * n }
p (1..100).sum # => 5050
p big.sum # => 500000000000500000000000
p squares # => 385
p ("a".."e").sum("") # => "abcde"

# Everything from Enumerable is available on finite ranges.
evens, odds = (1..6).partition(&:even?)
p [evens, odds] # => [[2, 4, 6], [1, 3, 5]]
first_big_square = (1..10).find { |n| n * n > 40 }
doubled_odds = (1..10).filter_map { |n| n * 2 if n.odd? }
p [first_big_square, doubled_odds] # => [7, [2, 6, 10, 14, 18]]
p (1..3).zip(4..6) # => [[1, 4], [2, 5], [3, 6]]
p (1..3).to_set # => Set[1, 2, 3]

# Endless ranges plus a lazy enumerator give streams.
cubes = (1..).lazy.map { |n| n**3 }.select(&:even?)
p cubes.first(3) # => [8, 64, 216]
puts(outcome { (1..).to_set }) # => RangeError: cannot convert endless range to a set
puts(outcome { (1..).each_slice(2).first(2) }) # => [[1, 2], [3, 4]]

# Binary search needs a sorted range and a block that is false and then true (find-minimum mode)
# or returns a number (find-any mode).
p((0..100).bsearch { |n| n * n >= 50 }) # => 8
p((1..).bsearch { |n| n * n >= 10_000 }) # => 100
p((0.0..10.0).bsearch { |x| x >= 3.3 }) # => 3.3
p((0..100).bsearch { |n| 42 <=> n }) # => 42
puts(outcome { ("a".."z").bsearch { true } }) # => TypeError: can't do binary search for String

# frozen_string_literal: true

# These lines are deliberate mistakes, so the cops that would catch them are switched off.
# rubocop:disable Lint/RequireRangeParentheses, Lint/AmbiguousRange, Lint/FlipFlop

# 1. A trailing endless range swallows the next line.
from = 1..
limit = 10
p from # => 1..10
p limit # => 10

# 2. Operators bind tighter than `..`, and method calls bind tighter still.
p 1..2 + 3 # => 1..5
p 0..7 % 2 # => 0..1
p((0..7) % 2) # => ((0..7).%(2))
p((0..7).step(2).to_a) # => [0, 2, 4, 6]

# 3. A range written with variables inside a condition is a flip-flop, not a Range.
lines = %w[intro START body body END outro]
inside = lines.select { |line| true if (line == "START")..(line == "END") }
p inside # => ["START", "body", "body", "END"]

# 4. Reversed ranges are empty, they do not count down.
p (5..1).to_a # => []
p (5..1).sum # => 0
p 5.downto(1).to_a # => [5, 4, 3, 2, 1]
p (1..5).reverse_each.to_a # => [5, 4, 3, 2, 1]

# 5. Equal values are not always equal ranges, and ranges never act as Hash lookup patterns.
p (1..3) == (1.0..3.0) # => true
p (1..3).eql?(1.0..3.0) # => false
p({ (1..3) => :short }[2]) # => nil
p({ (1..3) => :short }[1..3]) # => :short

# 6. Repeated float addition drifts, a stepped range does not.
drift = []
tick = 0.0
while tick <= 1.0
  drift << tick
  tick += 0.1
end
p drift.last # => 0.9999999999999999
p (0.0..1.0).step(0.1).to_a.last # => 1.0

# rubocop:enable Lint/RequireRangeParentheses, Lint/AmbiguousRange, Lint/FlipFlop