Hashes

# frozen_string_literal: true

shelf = { a: 1, b: 2, c: 3 }
shelf[:a] = 10 # => 10
shelf.keys # => [:a, :b, :c]
shelf.delete(:a) # => 10
shelf[:a] = 1
shelf.keys # => [:b, :c, :a]
p(shelf == { c: 3, a: 1, b: 2 }) # => true
shelf.eql?({ c: 3, a: 1, b: 2 }) # => true
shelf.to_a # => [[:b, 2], [:c, 3], [:a, 1]]
shelf.first # => [:b, 2]
shelf.first(2) # => [[:b, 2], [:c, 3]]
shelf.min_by { |_, v| v } # => [:a, 1]
shelf.shift # => [:b, 2]
p shelf # => {c: 3, a: 1}
{}.shift # => nil
{ "a" => 1, a: 2 }.length # => 2

# frozen_string_literal: true

visits = Hash.new(0)
%w[ico bach ico].each { |title| visits[title] += 1 }
p visits # => {"ico" => 2, "bach" => 1}
visits["missing"] # => 0
visits.key?("missing") # => false
visits.fetch("missing", :none) # => :none
visits.default # => 0
visits.default = 5
visits["still-missing"] # => 5
visits.size # => 2

shared = Hash.new([]) # rubocop:disable Lint/SharedMutableDefault
shared[:a] << "Ico"
shared[:b] << "Bach"
p shared # => {}
shared[:zzz] # => ["Ico", "Bach"]
shared.default # => ["Ico", "Bach"]

by_author = Hash.new { |hash, author| hash[author] = [] }
by_author["Ueda"] << "Ico"
by_author["Ueda"] << "Shadow of the Colossus"
by_author["Bach"] << "Cello Suites"
p by_author # => {"Ueda" => ["Ico", "Shadow of the Colossus"], "Bach" => ["Cello Suites"]}
by_author.default_proc.class # => Proc
by_author.default_proc.lambda? # => false

lazy = Hash.new { |_hash, key| key.to_s * 2 }
lazy[:ab] # => "abab"
lazy.size # => 0
lazy.fetch(:ab, nil) # => nil

tree = Hash.new { |hash, key| hash[key] = Hash.new(&hash.default_proc) }
tree[:a][:b][:c] = 1
p tree # => {a: {b: {c: 1}}}

lookup = { a: 1 }
lookup.default_proc = ->(_hash, key) { "no #{key}" }
lookup[:z] # => "no z"
lookup.default # => nil

Hash.new(capacity: 1000).default # => nil

begin
  Hash.new(0) { |_h, _k| 1 }
rescue ArgumentError => e
  e.message # => "wrong number of arguments (given 1, expected 0)"
end

begin
  Hash.new(&->(_a) { 1 })
rescue TypeError => e
  e.message # => "default_proc takes two arguments (2 for 1)"
end

# frozen_string_literal: true

stock = { "9780134685991" => 3, "9781492078005" => 1 }
stock["9780134685991"] += 1 # => 4
stock.store("9780596516177", 2) # => 2
stock.delete("9781492078005") # => 1
stock.delete("nope") # => nil
stock.delete("nope") { |key| "#{key} was absent" } # => "nope was absent"
stock.merge("9780134685991" => 10) # => {"9780134685991" => 10, "9780596516177" => 2}
stock.merge({ "9780134685991" => 10 }) { |_k, old, new| old + new } # => {"9780134685991" => 14, "9780596516177" => 2}
stock.merge({ "a" => 1 }, { "b" => 2 }) # => {"9780134685991" => 4, "9780596516177" => 2, "a" => 1, "b" => 2}
stock.merge # => {"9780134685991" => 4, "9780596516177" => 2}
stock.update("9780596516177" => 0) # => {"9780134685991" => 4, "9780596516177" => 0}
stock.reject! { |_isbn, copies| copies.zero? } # => {"9780134685991" => 4}
stock.reject! { |_isbn, copies| copies.zero? } # => nil
stock.select! { |_isbn, copies| copies.positive? } # => nil
stock.compact! # => nil
{ a: 1, b: nil }.compact # => {a: 1}
stock.delete_if { |_isbn, copies| copies > 100 } # => {"9780134685991" => 4}
stock.keep_if { |_isbn, copies| copies > 100 } # => {}
stock.replace({ "k" => 1 }) # => {"k" => 1}
stock.clear # => {}

counts = { a: 1, b: 2 }
counts.each_key { |key| counts.delete(key) if key == :a }
p counts # => {b: 2}

begin
  counts.each_key { |key| counts[:"#{key}2"] = 0 }
rescue RuntimeError => e
  e.class # => RuntimeError
  e.message # => "can't add a new key into hash during iteration"
end

counts.each_key { |key| counts[key] = 99 }
p counts # => {b: 99}

frozen = { a: 1 }.freeze
begin
  frozen[:b] = 2
rescue FrozenError => e
  e.message # => "can't modify frozen Hash: {a: 1}"
end
frozen.merge(b: 2) # => {a: 1, b: 2}
frozen.frozen? # => true
frozen.merge(b: 2).frozen? # => false
{ a: { b: 1 } }.freeze[:a].frozen? # => false

# frozen_string_literal: true

stock = { "Ico" => 3, "Bach" => 0, "Shadow" => 1 }

stock.each { |title, copies| puts "#{title}: #{copies}" }
stock.each_pair { |pair| p pair }
stock.each_with_index { |(title, copies), index| puts "#{index} #{title} #{copies}" }
stock.each.next # => ["Ico", 3]
stock.each_key.to_a # => ["Ico", "Bach", "Shadow"]
stock.each_value.sum # => 4
stock.map { |title, copies| "#{title}x#{copies}" } # => ["Icox3", "Bachx0", "Shadowx1"]
stock.map { it } # => [["Ico", 3], ["Bach", 0], ["Shadow", 1]]
stock.map { _1 } # => [["Ico", 3], ["Bach", 0], ["Shadow", 1]]
stock.filter_map { |title, copies| title if copies.positive? } # => ["Ico", "Shadow"]
stock.flat_map { |title, copies| [title] * copies } # => ["Ico", "Ico", "Ico", "Shadow"]
stock.sum { |_title, copies| copies } # => 4
stock.sort_by { |_title, copies| -copies } # => [["Ico", 3], ["Shadow", 1], ["Bach", 0]]
stock.sort_by { |_title, copies| -copies }.to_h # => {"Ico" => 3, "Shadow" => 1, "Bach" => 0}
stock.max_by { |_title, copies| copies } # => ["Ico", 3]
stock.partition { |_title, copies| copies.zero? } # => [[["Bach", 0]], [["Ico", 3], ["Shadow", 1]]]
stock.each_with_object({}) { |(title, copies), acc| acc[copies] = title } # => {3 => "Ico", 0 => "Bach", 1 => "Shadow"}
stock.reduce(0) { |sum, (_title, copies)| sum + copies } # => 4
stock.zip([1, 2, 3]) # => [[["Ico", 3], 1], [["Bach", 0], 2], [["Shadow", 1], 3]]
stock.min_by(2) { |_title, copies| copies } # => [["Bach", 0], ["Shadow", 1]]
stock.each_slice(2).to_a # => [[["Ico", 3], ["Bach", 0]], [["Shadow", 1]]]
stock.sort # => [["Bach", 0], ["Ico", 3], ["Shadow", 1]]
stock.to_a.transpose # => [["Ico", "Bach", "Shadow"], [3, 0, 1]]
stock.flatten # => ["Ico", 3, "Bach", 0, "Shadow", 1]
{ a: [1, [2]] }.flatten(2) # => [:a, 1, [2]]
stock.all? { |_title, copies| copies >= 0 } # => true
stock.any?(["Ico", 3]) # => true
stock.include?("Ico") # => true
stock.lazy.select { |_t, c| c.positive? }.map(&:first).first(1) # => ["Ico"]

Ico: 3
Bach: 0
Shadow: 1
["Ico", 3]
["Bach", 0]
["Shadow", 1]
0 Ico 3
1 Bach 0
2 Shadow 1

# frozen_string_literal: true

stock = { "Ico" => 3, "Bach" => 0 }

two = ->(title, copies) { "#{title}:#{copies}" }
one = ->(pair) { pair.join(":") }

begin
  stock.map(&two)
rescue ArgumentError => e
  e.message # => "wrong number of arguments (given 1, expected 2)"
end

stock.map(&one) # => ["Ico:3", "Bach:0"]
stock.map { |title, copies| two.call(title, copies) } # => ["Ico:3", "Bach:0"]
stock.map(&proc { |title, copies| "#{title}:#{copies}" }) # => ["Ico:3", "Bach:0"]
stock.each_with_index.map { |(title, copies), index| "#{index}#{title}#{copies}" } # => ["0Ico3", "1Bach0"]
stock.any? { |title, copies| title.size == copies } # => true
stock.sum { _2 } # => 3

# frozen_string_literal: true

stock = { "Ico" => 3, "Bach" => 0, "Shadow" => 1 }

stock.transform_values { it * 2 } # => {"Ico" => 6, "Bach" => 0, "Shadow" => 2}
stock.transform_values(&:to_s) # => {"Ico" => "3", "Bach" => "0", "Shadow" => "1"}
stock.transform_keys(&:to_sym) # => {Ico: 3, Bach: 0, Shadow: 1}
stock.transform_keys(&:upcase) # => {"ICO" => 3, "BACH" => 0, "SHADOW" => 1}
stock.transform_keys("Ico" => "ICO") # => {"ICO" => 3, "Bach" => 0, "Shadow" => 1}
stock.transform_keys({ "Ico" => "ICO" }, &:downcase) # => {"ICO" => 3, "bach" => 0, "shadow" => 1}
stock.transform_keys { :same } # => {same: 1}
copy = stock.dup
copy.transform_values!(&:succ) # => {"Ico" => 4, "Bach" => 1, "Shadow" => 2}
copy.transform_keys!(&:downcase) # => {"ico" => 4, "bach" => 1, "shadow" => 2}

stock.to_h { |title, copies| [title.downcase.to_sym, copies] } # => {ico: 3, bach: 0, shadow: 1}
stock.select { |_title, copies| copies.positive? } # => {"Ico" => 3, "Shadow" => 1}
stock.filter { |title, _copies| title.start_with?("S") } # => {"Shadow" => 1}
stock.reject { |_title, copies| copies.zero? } # => {"Ico" => 3, "Shadow" => 1}
stock.slice("Ico", "missing") # => {"Ico" => 3}
stock.except("Ico", "missing") # => {"Bach" => 0, "Shadow" => 1}
stock.invert # => {3 => "Ico", 0 => "Bach", 1 => "Shadow"}
{ a: 1, b: 1 }.invert # => {1 => :b}
stock.min_by { |_title, copies| copies } # => ["Bach", 0]
stock.sum { |_title, copies| copies } # => 4
stock.group_by { |_title, copies| copies.zero? ? :out : :in }
# => {in: [["Ico", 3], ["Shadow", 1]], out: [["Bach", 0]]}
stock.group_by { |_title, copies| copies.zero? ? :out : :in }.transform_values(&:to_h)
# => {in: {"Ico" => 3, "Shadow" => 1}, out: {"Bach" => 0}}
stock.each_with_object(Hash.new { |h, k| h[k] = [] }) { |(title, n), acc| acc[n.zero?] << title }
# => {false => ["Ico", "Shadow"], true => ["Bach"]}
%w[ico bach ico shadow ico].tally # => {"ico" => 3, "bach" => 1, "shadow" => 1}
%w[ico bach ico].map(&:upcase).tally # => {"ICO" => 2, "BACH" => 1}
%w[ico bach ico].tally({ "ico" => 10 }) # => {"ico" => 12, "bach" => 1}
%w[ico bach shadow].group_by(&:size) # => {3 => ["ico"], 4 => ["bach"], 6 => ["shadow"]}
%w[ico bach shadow].to_h { [it.to_sym, it.size] } # => {ico: 3, bach: 4, shadow: 6}
%w[ico bach].each_with_index.to_h # => {"ico" => 0, "bach" => 1}
%w[ico bach].zip([1, 2]).to_h # => {"ico" => 1, "bach" => 2}

# frozen_string_literal: true

module Shelf
  Author = Data.define(:name)
  Book = Data.define(:isbn, :title, :author)
end

ueda = Shelf::Author.new("Ueda")
bach = Shelf::Author.new("Bach")
books = [
  Shelf::Book.new("9780134685991", "Ico", ueda),
  Shelf::Book.new("9781492078005", "Shadow of the Colossus", ueda),
  Shelf::Book.new("9780596516177", "Cello Suites", bach)
]

by_isbn = books.to_h { [it.isbn, it] }
by_isbn.fetch("9780596516177").title # => "Cello Suites"

by_author = books.group_by(&:author)
by_author.transform_values { |list| list.map(&:title) }
# => {#<data Shelf::Author name="Ueda"> => ["Ico", "Shadow of the Colossus"], #<data Shelf::Author name="Bach"> => ["Cello Suites"]}

counts = books.map { it.author.name }.tally
p counts # => {"Ueda" => 2, "Bach" => 1}
counts.max_by(&:last) # => ["Ueda", 2]
counts.min_by { |name, n| [-n, name] } # => ["Ueda", 2]
counts.sum { _2 } # => 3

titles_by_initial = books.each_with_object(Hash.new { |hash, key| hash[key] = [] }) do |book, acc|
  acc[book.title[0]] << book.title
end
p titles_by_initial # => {"I" => ["Ico"], "S" => ["Shadow of the Colossus"], "C" => ["Cello Suites"]}

# Memoise an expensive lookup with a self-filling Hash.
lookups = 0
slug = Hash.new do |cache, title|
  lookups += 1
  cache[title] = title.downcase.tr(" ", "-")
end
slug["Shadow of the Colossus"] # => "shadow-of-the-colossus"
slug["Shadow of the Colossus"] # => "shadow-of-the-colossus"
p lookups # => 1

# Merge nested settings recursively.
def deep_merge(base, extra)
  base.merge(extra) do |_key, old, new|
    old.is_a?(Hash) && new.is_a?(Hash) ? deep_merge(old, new) : new
  end
end

defaults = { loan: { days: 14, renew: true }, store: :memory }
overrides = { loan: { days: 7 }, store: :disk }
deep_merge(defaults, overrides) # => {loan: {days: 7, renew: true}, store: :disk}

# frozen_string_literal: true

filter = { author: "Ueda" }
book = { title: "Ico", author: "Ueda", year: 2001 }
p(filter <= book) # => true
p(filter < book) # => true
p(book >= filter) # => true
twin = book.dup
p(book > twin) # => false
p(book >= twin) # => true
p(book >= { author: "Bach" }) # => false
p(book >= {}) # => true
p(book >= { year: 2001.0 }) # => true
p(book == { year: 2001, author: "Ueda", title: "Ico" }) # => true
p({ a: 1 } == { a: 1.0 }) # => true
p({ a: 1 }.eql?({ a: 1.0 })) # => false
p({ a: 1 }.hash == { a: 1 }.hash) # rubocop:disable Lint/BinaryOperatorWithIdenticalOperands
# => true

matches = [book, { title: "Bach", author: "Bach" }].select { |candidate| filter <= candidate }
matches.map { it[:title] } # => ["Ico"]

# frozen_string_literal: true

book = { title: "Ico", "isbn" => "97801", 3 => nil, nil => [1, 2], [1] => { a: :b } }
book.inspect # => "{title: \"Ico\", \"isbn\" => \"97801\", 3 => nil, nil => [1, 2], [1] => {a: :b}}"
p(book.to_s == book.inspect) # => true
puts book
odd = {
  "my key": 1, :"a-b" => 2, a?: 3, b!: 4, C: 5, "9x": 6,
  :[] => 7, :+ => 8, :a= => 9, :@iv => 10, :$g => 11, nil: 12
}
puts odd.inspect
puts({}.inspect)
puts({ a: 1 }.to_a.inspect)
puts :"my key".inspect
entry = { a: 1 }
puts "hash: #{entry}"

loop_hash = { name: "loop" }
loop_hash[:self] = loop_hash
puts loop_hash.inspect

long = { title: "A very long title that goes on", author: "Somebody Else", isbn: "9780134685991", copies: 3 }
pp long
puts long.pretty_inspect.lines.size

true
{title: "Ico", "isbn" => "97801", 3 => nil, nil => [1, 2], [1] => {a: :b}}
{"my key": 1, "a-b": 2, a?: 3, b!: 4, C: 5, "9x": 6, "[]": 7, "+": 8, "a=": 9, "@iv": 10, "$g": 11, nil: 12}
{}
[[:a, 1]]
:"my key"
hash: {a: 1}
{name: "loop", self: {...}}
{title: "A very long title that goes on",
 author: "Somebody Else",
 isbn: "9780134685991",
 copies: 3}
4

# frozen_string_literal: true

def lend(isbn, days: 14, renew: false) = "#{isbn} for #{days} days#{', renewable' if renew}"

options = { days: 7, renew: true }
lend("9780134685991", **options) # => "9780134685991 for 7 days, renewable"
lend("9780134685991", **options, days: 3) # => "9780134685991 for 3 days, renewable"

begin
  lend("9780134685991", "days" => 7)
rescue ArgumentError => e
  e.message # => "unknown keyword: \"days\""
end

begin
  lend("9780134685991", options)
rescue ArgumentError => e
  e.message # => "wrong number of arguments (given 2, expected 1)"
end

def settings(**config) = config
settings("days" => 7, :renew => true) # => {"days" => 7, renew: true}
table = { "days" => 7 }
settings(**table) # => {"days" => 7}
settings(**{}) # => {}
settings(**nil) # => {}

def legacy(options = {}) = options
legacy(days: 7) # => {days: 7}
legacy({ days: 7 }) # => {days: 7}
legacy(**options.slice(:days)) # => {days: 7}

def rest(*args) = args
rest(days: 7) # => [{days: 7}]
rest(**{}) # => []
rest(*[], **{}) # => []

def either(positional = :none, **keywords) = [positional, keywords]
either({ days: 7 }) # => [{days: 7}, {}]
either(days: 7) # => [:none, {days: 7}]

def opts_then_block(options, &block) = block ? block.call(options) : options
opts_then_block(days: 7) # => {days: 7}

days = 7
renew = true
{ days:, renew: } # => {days: 7, renew: true}
settings(days:, renew:) # => {days: 7, renew: true}

class Settings
  def initialize(**config) = @config = config
  def to_h = @config.dup
  def to_hash = to_h
end

settings(**Settings.new(days: 3)) # => {days: 3}
settings(**options, **{ days: 1 }.compact) # => {days: 1, renew: true}

# frozen_string_literal: true

event = { type: "loan", book: { isbn: "9780134685991", title: "Ico" }, days: 14 }

summary = case event
          in { type: "loan", book: { title: }, days: Integer => days }
            "#{title} lent for #{days} days"
          end
p summary # => "Ico lent for 14 days"

event => { book: { isbn: } }
p isbn # => "9780134685991"

event in { type: "return" } # => false
event in { type: String } # => true
event in { days: 1.. } # => true

extra = { type: "loan", extra: 1 }
kind = case extra
       in { type: "loan", **nil } then :exact
       in { type: "loan", **rest } then rest
       end
p kind # => {extra: 1}

begin
  event => { missing: _field }
rescue NoMatchingPatternKeyError => e
  e.message # => "{type: \"loan\", book: {isbn: \"9780134685991\", title: \"Ico\"}, days: 14}: key not found: :missing"
  e.key # => :missing
end

# A custom class takes part by defining deconstruct_keys.
class Point
  attr_reader :x_pos, :y_pos

  def initialize(x_pos, y_pos)
    @x_pos = x_pos
    @y_pos = y_pos
  end

  def deconstruct_keys(keys) = { x: x_pos, y: y_pos }.slice(*(keys || %i[x y]))
end

case Point.new(1, 2)
in { x:, y: } then [x, y] # => [1, 2]
end

# frozen_string_literal: true

original = { title: "Ico", tags: ["game"], stats: Hash.new(0) }
shallow = original.dup
shallow[:title] = "Changed"
shallow[:tags] << "ps2"
original[:title] # => "Ico"
original[:tags] # => ["game", "ps2"]
shallow[:stats]["x"] # => 0
shallow.default_proc # => nil
shallow.equal?(original) # => false
shallow[:tags].equal?(original[:tags]) # => true

deep = Marshal.load(Marshal.dump({ title: "Ico", tags: ["game"] }))
deep[:tags] << "extra"
p deep # => {title: "Ico", tags: ["game", "extra"]}

counting = Hash.new(7)
counting.dup[:missing] # => 7
counting.clone.default # => 7
counting.merge({}).default # => 7
counting.select { true }.default # => nil
counting.to_h.default # => 7
counting.to_h { |k, v| [k, v] }.default # => nil

locked = { tags: ["game"] }.freeze
locked.dup.frozen? # => false
locked.clone.frozen? # => true
locked.clone(freeze: false).frozen? # => false
locked[:tags] << "still mutable"
p locked # => {tags: ["game", "still mutable"]}

nested = { a: { b: 1 } }
frozen_all = Ractor.make_shareable(nested)
frozen_all.frozen? # => true
frozen_all[:a].frozen? # => true
nested.equal?(frozen_all) # => true

# frozen_string_literal: true

require "json"

payload = '{"title":"Ico","copies":3,"tags":["game"],"author":{"name":"Ueda"}}'
JSON.parse(payload) # => {"title" => "Ico", "copies" => 3, "tags" => ["game"], "author" => {"name" => "Ueda"}}
data = JSON.parse(payload, symbolize_names: true)
p data # => {title: "Ico", copies: 3, tags: ["game"], author: {name: "Ueda"}}
data.dig(:author, :name) # => "Ueda"
JSON.generate(data) # => "{\"title\":\"Ico\",\"copies\":3,\"tags\":[\"game\"],\"author\":{\"name\":\"Ueda\"}}"
p(data.to_json == JSON.generate(data)) # => true
{ 1 => :a, nil => :b, [1] => :c }.to_json # => "{\"1\":\"a\",\"\":\"b\",\"[1]\":\"c\"}"
JSON.parse(JSON.generate({ a: 1 })) # => {"a" => 1}
JSON.pretty_generate({ a: { b: [1, 2] } }).lines.size # => 8

# frozen_string_literal: true

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

failure { Hash[1, 2, 3] } # rubocop:disable Style/HashConversion
# => "ArgumentError: odd number of arguments for Hash"
failure { [[1, 2, 3]].to_h } # => "ArgumentError: wrong array length at 0 (expected 2, was 3)"
failure { [1].to_h } # => "TypeError: wrong element type Integer at 0 (expected array)"
failure { { a: 1 }.fetch(:b) } # => "KeyError: key not found: :b"
failure { { a: 1 }.fetch_values(:a, :b) } # => "KeyError: key not found: :b"
failure { { a: 1 }.freeze[:b] = 2 } # => "FrozenError: can't modify frozen Hash: {a: 1}"
shelf = { a: 1 }
failure { shelf.each { shelf[:b] = 2 } } # => "RuntimeError: can't add a new key into hash during iteration"
failure { { a: 1 }[:a][:b] } # => "TypeError: no implicit conversion of Symbol into Integer"
failure { { a: nil }[:a][:b] } # => "NoMethodError: undefined method '[]' for nil"
failure { { a: 1 }.dig(:a, :b) } # => "TypeError: Integer does not have #dig method"
failure { { a: 1 }.merge(1) } # => "TypeError: no implicit conversion of Integer into Hash"
failure { Hash.new(1, 2) } # => "ArgumentError: wrong number of arguments (given 2, expected 0..1)"
failure { { a: 1 }.transform_keys(1) } # => "TypeError: no implicit conversion of Integer into Hash"
failure { { a: 1, "b" => 2 }.keys.sort } # => "ArgumentError: comparison of Symbol with String failed"
failure { { a: 1 }.sum } # => "TypeError: Array can't be coerced into Integer"

# frozen_string_literal: true

# Deliberate mistakes: run with `ruby -w` to see the warnings.
stock = { "Ico" => 3, "Ico" => 4, ico: 1, ico: 2 } # rubocop:disable Lint/DuplicateHashKey
p stock
p({ a: 1 }.fetch(:a, 0) { 99 }) # rubocop:disable Lint/UselessDefaultValueArgument

{"Ico" => 4, ico: 2}
1
e19.rb:4: warning: key "Ico" is duplicated and overwritten on line 4
e19.rb:4: warning: key :ico is duplicated and overwritten on line 4
e19.rb:6: warning: block supersedes default value argument