Arrays

# frozen_string_literal: true

# Indexing and slicing
a = %w[a b c d e f] # => ["a", "b", "c", "d", "e", "f"]
a[0] # => "a"
a[-1] # => "f"
a[6] # => nil
a[-7] # => nil
a.at(2) # => "c"
a.first # => "a"
a.first(2) # => ["a", "b"]
a.last(2) # => ["e", "f"]
a[1, 3] # => ["b", "c", "d"]
a[1..3] # => ["b", "c", "d"]
a[1...3] # => ["b", "c"]
a[2..] # => ["c", "d", "e", "f"]
a[..2] # => ["a", "b", "c"]
a[-3..] # => ["d", "e", "f"]
a[4, 10] # => ["e", "f"]
a[6, 1] # => []
a[7, 1] # => nil
a[6..] # => []
a[7..] # => nil
a[(0..).step(2)] # => ["a", "c", "e"]
a[(..-1) % 3] # => ["a", "d"]
a.values_at(0, 2, -1, 9) # => ["a", "c", "f", nil]

# frozen_string_literal: true

# Iterating and transforming
nums = [3, 1, 4, 1, 5, 9, 2, 6]
nums.each_with_index.map { |n, i| n * i } # => [0, 1, 8, 3, 20, 45, 12, 42]
nums.each_slice(3).to_a # => [[3, 1, 4], [1, 5, 9], [2, 6]]
nums.each_cons(3).first(2) # => [[3, 1, 4], [1, 4, 1]]
nums.each_with_object([]) { |n, acc| acc.unshift(n) } # => [6, 2, 9, 5, 1, 4, 1, 3]
nums.map.with_index(1) { |n, i| "#{i}:#{n}" }.first(3) # => ["1:3", "2:1", "3:4"]
nums.select(&:even?) # => [4, 2, 6]
nums.reject { |n| n > 4 } # => [3, 1, 4, 1, 2]
nums.partition { |n| n > 3 } # => [[4, 5, 9, 6], [3, 1, 1, 2]]
nums.group_by(&:odd?) # => {true => [3, 1, 1, 5, 9], false => [4, 2, 6]}
nums.filter_map { |n| n * 10 if n > 4 } # => [50, 90, 60]
nums.flat_map { |n| [n] * (n > 5 ? 2 : 0) } # => [9, 9, 6, 6]
nums.tally # => {3 => 1, 1 => 2, 4 => 1, 5 => 1, 9 => 1, 2 => 1, 6 => 1}
nums.sum # => 31
nums.inject(:+) # => 31
nums.reduce(1) { |acc, n| acc * n } # => 6480
nums.count(1) # => 2
nums.count(&:even?) # => 3
nums.any? { |n| n > 8 } # => true
nums.all?(Integer) # => true
nums.none?(0) # => true
nums.one?(9) # => true
nums.find { |n| n > 4 } # => 5
nums.rfind { |n| n < 4 } # => 2
nums.find_index(4) # => 2
nums.index { |n| n > 4 } # => 4
nums.rindex(1) # => 3
nums.reverse_each.first(2) # => [6, 2]
nums.cycle.first(10) # => [3, 1, 4, 1, 5, 9, 2, 6, 3, 1]
nums.min # => 1
nums.max(2) # => [9, 6]
nums.minmax # => [1, 9]
nums.take_while { |n| n < 5 } # => [3, 1, 4, 1]
[1, 2, 4, 9, 10, 11].chunk_while { |a, b| b == a + 1 }.to_a # => [[1, 2], [4], [9, 10, 11]]
nums.slice_when { |a, b| b < a }.to_a # => [[3], [1, 4], [1, 5, 9], [2, 6]]
nums.each_entry.to_a.size # => 8
nums.lazy.select(&:odd?).map { |n| n * 2 }.first(2) # => [6, 2]

# frozen_string_literal: true

# Sorting
words = %w[pear Fig apple fig kiwi]
words.sort # => ["Fig", "apple", "fig", "kiwi", "pear"]
words.sort_by(&:downcase) # => ["apple", "Fig", "fig", "kiwi", "pear"]
words.sort_by { |w| [w.size, w] } # => ["Fig", "fig", "kiwi", "pear", "apple"]
words.sort { |a, b| b <=> a } # => ["pear", "kiwi", "fig", "apple", "Fig"]
words.sort_by { |w| -w.size } # => ["apple", "pear", "kiwi", "Fig", "fig"]
words.max_by(&:size) # => "apple"
words.min_by(2, &:size) # => ["Fig", "fig"]
words.minmax_by(&:size) # => ["Fig", "apple"]
words.max # => "pear"
words.max { |a, b| a.size <=> b.size } # => "apple"
words.reverse # => ["kiwi", "fig", "apple", "Fig", "pear"]
words.rotate # => ["Fig", "apple", "fig", "kiwi", "pear"]
words.rotate(-2) # => ["fig", "kiwi", "pear", "Fig", "apple"]
copy = words.dup
copy.sort! # => ["Fig", "apple", "fig", "kiwi", "pear"]
copy.sort!.equal?(copy) # => true
copy.reverse!.first # => "pear"
begin
  [3, "a", 1].sort
rescue ArgumentError => e
  e.message # => "comparison of Integer with String failed"
end
begin
  [3, nil].max
rescue ArgumentError => e
  e.message # => "comparison of Integer with nil failed"
end
[0.1, 0.2, 0.3].sum # => 0.6
[0.1, 0.2, 0.3].inject(:+) # => 0.6000000000000001
[[2, "b"], [1, "z"], [2, "a"]].sort # => [[1, "z"], [2, "a"], [2, "b"]]
[1, 2, 3, 4].sort_by { |n| n.even? ? 0 : 1 } # => [2, 4, 1, 3]
(1..20).sort_by { |n| n % 3 }.first(8) # => [3, 6, 18, 9, 12, 15, 1, 4]

# frozen_string_literal: true

# Set operations and uniqueness
a = [1, 2, 2, 3, 4]
b = [3, 4, 4, 5]
[a | b, a & b] # => [[1, 2, 3, 4, 5], [3, 4]]
a.union(b, [9]) # => [1, 2, 3, 4, 5, 9]
a.intersection(b) # => [3, 4]
a.difference(b) # => [1, 2, 2]
a.intersect?(b) # => true
a.uniq # => [1, 2, 3, 4]
%w[apple Avocado banana Blueberry].uniq { |w| w[0].downcase } # => ["apple", "banana"]
a.dup.uniq! # => [1, 2, 3, 4]
[1, 2].uniq! # => nil
words = %w[a b a]
[words - ["a"], words + ["z"]] # => [["b"], ["a", "b", "a", "z"]]
[words * 2, words * "-"] # => [["a", "b", "a", "a", "b", "a"], "a-b-a"]
[[1, 2], [3]].sum([]) # => [1, 2, 3]
[1, 1.0, 1r].uniq # => [1, 1.0, (1/1)]
[[1], [1]].uniq.size # => 1
a.to_set # => Set[1, 2, 3, 4]
Set.new(a).subset?(Set.new(1..5)) # => true

# frozen_string_literal: true

# Flatten, zip, product and friends
nested = [1, [2, [3, [4]]]]
nested.flatten # => [1, 2, 3, 4]
nested.flatten(1) # => [1, 2, [3, [4]]]
[1, [2]].flatten!.nil? # => false
[1, 2].flatten!.nil? # => true
[1, 2, 3].zip([4, 5, 6], [7, 8, 9]) # => [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
[1, 2, 3].zip([4]) # => [[1, 4], [2, nil], [3, nil]]
%w[a b].zip(1..) # => [["a", 1], ["b", 2]]
%w[a b c].zip(1..3).to_h # => {"a" => 1, "b" => 2, "c" => 3}
[[1, 2], [3, 4], [5, 6]].transpose # => [[1, 3, 5], [2, 4, 6]]
[1, 2].product([3, 4]) # => [[1, 3], [1, 4], [2, 3], [2, 4]]
[1, 2].product([3], [5, 6]).size # => 4
[1, 2, 3].combination(2).to_a # => [[1, 2], [1, 3], [2, 3]]
[1, 2, 3].permutation(2).count # => 6
[1, 2].repeated_permutation(2).to_a # => [[1, 1], [1, 2], [2, 1], [2, 2]]
[1, 2, 3].each_cons(2).to_a # => [[1, 2], [2, 3]]
[1, 2, 3, 4].each_slice(2).map(&:sum) # => [3, 7]
[3, 1, 2].sum { |n| n * 2 } # => 12
%w[a b].sum("") # => "ab"
[[1], [2]].sum([]) # => [1, 2]
begin
  %w[a b].sum
rescue TypeError => e
  e.message # => "String can't be coerced into Integer"
end
[1, 2, 3].inject { |a, b| a * b } # => 6
[1, [2, 3]].join(",") # => "1,2,3"
[1, nil, "a"].join("-") # => "1--a"
%w[a b c].join # => "abc"
[1, 2, 3].cycle(2).to_a # => [1, 2, 3, 1, 2, 3]
[1, 2, 3, 4, 5].values_at(0, 2..3) # => [1, 3, 4]
(1..10).each_slice(4).to_a # => [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10]]
[1, 2, 3].to_h { |n| [n, n * n] } # => {1 => 1, 2 => 4, 3 => 9}
[[:a, 1]].to_h # => {a: 1}

# frozen_string_literal: true

# pack and unpack
[65, 66, 67].pack("C*") # => "ABC"
[65, 66, 67].pack("c3") # => "ABC"
[1, 2].pack("S>L<").bytes # => [0, 1, 2, 0, 0, 0]
[1].pack("N").bytes # => [0, 0, 0, 1]
[1].pack("V").bytes # => [1, 0, 0, 0]
[97, 0x20AC].pack("U*") # => "a€"
%w[abc de].pack("A5a3").bytes # => [97, 98, 99, 32, 32, 100, 101, 0]
["abc"].pack("Z*").bytes # => [97, 98, 99, 0]
["hello"].pack("m") # => "aGVsbG8=\n"
["hello"].pack("m0") # => "aGVsbG8="
["616263"].pack("H*") # => "abc"
["a b"].pack("M") # => "a b=\n"
[1.5].pack("E").unpack1("E") # => 1.5
"AB".unpack("C*") # => [65, 66]
"\x00\x00\x01\x00".unpack1("N") # => 256
"aGVsbG8=\n".unpack1("m") # => "hello"
"abc".unpack1("H*") # => "616263"
"abc".unpack("a1 a1 a1") # => ["a", "b", "c"]
[1, 2, 3].pack("C*").encoding # => #<Encoding:BINARY (ASCII-8BIT)>
["x"].pack("a").encoding # => #<Encoding:BINARY (ASCII-8BIT)>
[1].pack("w").bytes # => [1]
[300].pack("w").bytes # => [130, 44]
begin
  [1].pack("y")
rescue ArgumentError => e
  e.message # => "unknown pack directive 'y' in 'y'"
end
begin
  ["a"].pack("C")
rescue TypeError => e
  e.message # => "no implicit conversion of String into Integer"
end
buffer = +"hdr:"
[1, 2].pack("C*", buffer: buffer) # => "hdr:\u0001\u0002"

# frozen_string_literal: true

# Equality, copies, freezing
a = [1, [2, 3]]
b = [1, [2, 3]]
[a == b, a.eql?(b), a.equal?(b), a.hash == b.hash] # => [true, true, false, true]
[[1, 2] == [1.0, 2.0], [1, 2].eql?([1.0, 2.0])] # => [true, false]
[[1, 2] <=> [1, 3], [1, 2] <=> [1], [1, 2] <=> [1, "a"]] # => [-1, 1, nil]
copy = a.dup
copy[1] << 4
a.to_a # => [1, [2, 3, 4]]
deep = Marshal.load(Marshal.dump(a))
deep[1] << 5
[a, deep] # => [[1, [2, 3, 4]], [1, [2, 3, 4, 5]]]
fixed = %w[x y].freeze
begin
  fixed << "z"
rescue FrozenError => e
  e.message # => "can't modify frozen Array: [\"x\", \"y\"]"
end
mutable = [+"x"].freeze
mutable.first << "!"
mutable.to_a # => ["x!"]
fixed.first.frozen? # => true
[fixed.frozen?, fixed.dup.frozen?, fixed.clone.frozen?] # => [true, false, true]
fixed.clone(freeze: false).frozen? # => false
sealed = Ractor.make_shareable([["a"], ["b"]])
[sealed.frozen?, sealed.first.frozen?, sealed.first.first.frozen?] # => [true, true, true]
list = [1, 2, 3, 4]
list.each { |n| list.delete(n) if n.even? }
list.to_a # => [1, 3]
numbers = [1, 2, 3, 4]
numbers.reject!(&:even?)
numbers.to_a # => [1, 3]
total = []
before = total.object_id
total += [1]
rebound = total.object_id != before # => true
current = total.object_id
total << 2
[rebound, total.object_id == current, total] # => [true, true, [1, 2]]

# frozen_string_literal: true

# Destructuring, pattern matching and conversion
first, second = [10, 20, 30]
[first, second] # => [10, 20]
head, *tail = [1, 2, 3]
[head, tail] # => [1, [2, 3]]
*init, last = [1, 2, 3]
[init, last] # => [[1, 2], 3]
x, (y, z) = [1, [2, 3]]
[x, y, z] # => [1, 2, 3]
[[1, 2], [3, 4]].map { |(p, q)| p + q } # => [3, 7]
[[1, [2, 3]]].map { |a, (b, c)| [a, b, c] } # => [[1, 2, 3]]
[[1, 2], [3, 4]].each_with_index.map { |(m, n), i| (m * n) + i } # => [2, 13]
case [1, [2, 3]]
in [Integer => a, [b, *rest]]
  [a, b, rest] # => [1, 2, [3]]
end
case [:ok, 200, "body"]
in [:ok, 200.. => code, String => body]
  [code, body] # => [200, "body"]
end
steps = %w[start x y end]
case steps
in [*, "x", "y", *]
  [:found].first # => :found
end
result = [1, "two", :three].then do |value|
  case value
  in [Integer, String, Symbol] then :typed
  else :other
  end
end
result.to_s # => "typed"
point = [3, 4]
point => [px, py]
Math.hypot(px, py) # => 5.0
[1, 2] in [_, _] # => true
[1, 2, 3] in [_, _] # => false
class Pair
  def initialize(left, right)
    @left = left
    @right = right
  end

  def to_ary = [@left, @right]
end
l, r = Pair.new(1, 2)
[l, r] # => [1, 2]
[[0, 0], Pair.new(1, 2)].flatten # => [0, 0, 1, 2]
[[0, 0], Pair.new(1, 2)].to_h { |lft, rgt| [lft, rgt] } # => {0 => 0, 1 => 2}

# frozen_string_literal: true

# Subclassing Array
class Playlist < Array
  def total = sum
end

list = Playlist.new([3, 4])
[list.class, list.total] # => [Playlist, 7]
[list.map { _1 }.class, list.select(&:odd?).class, list.dup.class] # => [Array, Array, Playlist]
[list.first(1).class, list[0, 1].class, list.reverse.class] # => [Array, Array, Array]
[list.flatten.class, list.uniq.class, list.take(1).class] # => [Array, Array, Array]
Playlist.new(2) { |i| i + 1 }.class # => Playlist
Playlist[1, 2].class # => Playlist

# frozen_string_literal: true

require "shelf"

# The shelf catalogue as an array pipeline
author = Shelf::Author.new(name: "Ursula K. Le Guin")
isbns = %w[9780306406157 9780131103627 9780201633610]
titles = ["The Dispossessed", "Tehanu", "A Wizard of Earthsea"]
books = titles.zip(isbns).map do |title, digits|
  Shelf::Book.new(isbn: Shelf::Isbn.new(digits:), title:, author:)
end
catalog = books.reduce(Shelf::Catalog.new) { |cat, book| cat.add(book) }
catalog.to_a.size # => 3
catalog.map(&:title) # => ["The Dispossessed", "Tehanu", "A Wizard of Earthsea"]
catalog.sort_by(&:title).map(&:title) # => ["A Wizard of Earthsea", "Tehanu", "The Dispossessed"]
catalog.min_by { |b| b.title.size }.title # => "Tehanu"
catalog.group_by { |b| b.title.split.first.downcase.to_sym }.keys # => [:the, :tehanu, :a]
catalog.partition { |b| b.title.include?("of") }.map(&:size) # => [1, 2]
catalog.each_slice(2).map { |pair| pair.map(&:title) } # => [["The Dispossessed", "Tehanu"], ["A Wizard of Earthsea"]]
catalog.first.isbn.to_s # => "9780306406157"
catalog.each_with_index.to_h { |b, i| [i, b.isbn.digits[-4..]] } # => {0 => "6157", 1 => "3627", 2 => "3610"}
loans = books.map { |b| Shelf::Loan.new(b, state: b.title.size > 10 ? :lent : :available) }
loans.map(&:state) # => [:lent, :available, :lent]
loans.map(&:describe) # => ["The Dispossessed is lent", "Tehanu is on the shelf", "A Wizard of Earthsea is lent"]
loans.count { |l| l.state == :lent } # => 2
books.first.to_s # => "The Dispossessed by Ursula K. Le Guin"
books.frozen? # => false

# frozen_string_literal: true

# Compound operations on a shared array need a lock
queue = []
lock = Thread::Mutex.new
workers = Array.new(4) do |n|
  Thread.new do
    100.times { |i| lock.synchronize { queue << ((n * 100) + i) } }
  end
end
workers.each(&:join)
[queue.size, queue.uniq.size] # => [400, 400]
shared = Ractor.make_shareable(%w[a b])
Ractor.shareable?(shared) # => true
Ractor.shareable?(%w[a b]) # => false