Design Philosophy and Coming from Other Languages

# frozen_string_literal: true

require "shelf"

p 42.class
p nil.class
p :isbn.class
p (1..3).class
p Shelf::Book.class
p Shelf::Book.class.class
p 42.respond_to?(:+)
p 1.+(2)
p nil.to_a
p nil.to_s
p nil.inspect
p Integer.ancestors.first(4)
p BasicObject.superclass
p Class.superclass
p Module.superclass
p Object.superclass

Integer
NilClass
Symbol
Range
Class
Class
true
3
[]
""
"nil"
[Integer, Numeric, Comparable, Object]
nil
Module
Object
BasicObject

# frozen_string_literal: true

require "shelf"

isbn = Shelf::Isbn.new("978-0-306-40615-7")
author = Shelf::Author.new("Ada")
book = Shelf::Book.new(isbn, "Notes", author)

catalog = Shelf::Catalog.new
catalog.add(book).add(Shelf::Book.new(Shelf::Isbn.new("9780131103627"), "The C Language", Shelf::Author.new("Brian")))

# No return keyword, no parentheses, method chaining.
titles = catalog.map(&:title).sort.map(&:upcase)
p titles
puts catalog.first
p catalog.count
p(catalog.any? { |b| b.title.start_with?("N") })
p catalog.to_a.empty?
p [3, 1, 2].sort!.first

["NOTES", "THE C LANGUAGE"]
Notes by Ada
2
true
false
1

# frozen_string_literal: true

# Things that surprise newcomers.
truthiness = ->(v) { v ? "truthy" : "falsy" }
p [0, "", [], {}].map(&truthiness)
p [nil, false].map(&truthiness)
p 7 / 2
p(-7 / 2)
p 7.fdiv(2)
p "ab" * 3
p [1, 2].join(", ")
p 0.1 + 0.2
a = "x"
b = a
p b.equal?(a)
p "x".equal?("x")
p :x.equal?(:x)
p 1.equal?(1)
nothing = nil
flag = false
puts [1, [2, [nothing, 3]]].inspect
puts nothing.to_s.empty?
puts "#{nothing}|#{flag}|#{[nothing]}"

["truthy", "truthy", "truthy", "truthy"]
["falsy", "falsy"]
3
-4
3.5
"ababab"
"1, 2"
0.30000000000000004
true
true
true
true
[1, [2, [nil, 3]]]
true
|false|[nil]

# frozen_string_literal: true

numbers = [1, 2, 3, 4]

p numbers.sum
p numbers.reduce(:+)
p(numbers.inject { |acc, n| acc + n })
total = 0
numbers.each { |n| total += n }
p total
p numbers.each_with_object([0]) { |n, acc| acc[0] += n }.first

# Several ways to say "the evens, squared".
p(numbers.select(&:even?).map { |n| n**2 })
p(numbers.filter_map { |n| n**2 if n.even? })
p(numbers.each_slice(2).map(&:last).map { it**2 })

10
10
10
10
10
[4, 16]
[4, 16]
[4, 16]

# frozen_string_literal: true

require "shelf"

# Duck typing: anything with #title works, no common ancestor needed.
Pamphlet = Struct.new(:title)

def shout(item)
  item.title.upcase
end

book = Shelf::Book.new(Shelf::Isbn.new("9780306406157"), "Notes", Shelf::Author.new("Ada"))
p shout(book)
p shout(Pamphlet.new("flyer"))

begin
  shout(42)
rescue NoMethodError => e
  puts e.message
  p e.name
  p e.receiver
end

p [book, Pamphlet.new("x"), 42].select { |o| o.respond_to?(:title) }.size

# A role by convention: each + Enumerable.
class Rack
  include Enumerable

  def initialize(*items) = @items = items

  def each(&)
    return enum_for(:each) unless block_given?

    @items.each(&)
  end
end

s = Rack.new(3, 1, 2)
p s.sort
p s.min
p s.include?(2)
p s.each_slice(2).to_a

"NOTES"
"FLYER"
undefined method 'title' for an instance of Integer
:title
42
2
[1, 2, 3]
1
true
[[3, 1], [2]]

# frozen_string_literal: true

require "shelf"

# Open classes: reopening a class adds to it.
module Shelf
  class Author
    def initials = name.split.map { |part| part[0] }.join
  end
end

p Shelf::Author.new("Ada Lovelace").initials
p Shelf::Author.instance_method(:initials).owner

"AL"
Shelf::Author

# frozen_string_literal: true

# Even core classes are open. Convenient, and dangerous.
class Integer
  def double = self * 2
end

p 21.double
p Integer.instance_method(:double).owner
p Integer.instance_method(:double).source_location.last

42
Integer
5

# frozen_string_literal: true

# A refinement limits the change to a lexical scope.
module Shouting
  refine String do
    def shout = "#{upcase}!"
  end
end

begin
  "hi".shout
rescue NoMethodError => e
  puts e.message
end

using Shouting
p "hi".shout

undefined method 'shout' for an instance of String
"HI!"

# frozen_string_literal: true

# def opens a new scope; blocks and lambdas close over the surrounding one.
limit = 3

def uses_outer
  limit
end

begin
  uses_outer
rescue NameError => e
  puts e.message
end

p([1, 2, 3, 4].select { |n| n < limit })
p(-> { limit }.call)
p defined?(limit)
p defined?(undefined_thing)
p defined?(puts)
p defined?(String)
p defined?(@name)

# No declarations: assignment creates the variable, nil is the default for instance variables.
class Tracker
  def peek = @seen
end

p Tracker.new.peek

# for does not create a scope; each does.
for i in 1..2 do end
p i
[1, 2].each { |j| j }
p defined?(j)

# self is always the receiver; there is no rebinding of this.
p self
p self.class

undefined local variable or method 'limit' for main
[1, 2]
3
"local-variable"
nil
"method"
"constant"
nil
nil
2
nil
main
Object

# frozen_string_literal: true

# Ruby is dynamically but strongly typed: no implicit conversions between unrelated types.
prefix = "total: "
count = 3
text = "3"

begin
  prefix + count
rescue TypeError => e
  puts e.message
end

begin
  count + text
rescue TypeError => e
  puts e.message
end

begin
  nil + 1
rescue NoMethodError => e
  puts e.message
end

p "total: #{count}"
p text.to_i + count
p "abc".to_i
p Integer("42")
p "1" == 1
p [1, 2] + [3]
p nil&.length
p nil.to_a
p({ a: 1 }[:b])
p({ a: 1 }.fetch(:a))
begin
  { a: 1 }.fetch(:b)
rescue KeyError => e
  puts e.message
end
p [1, 2][5]
p 2**100
p((2**100) / (2**98))
p 10.0 / 3
p 10 % 3
p(-10 % 3)

no implicit conversion of Integer into String
String can't be coerced into Integer
undefined method '+' for nil
"total: 3"
6
0
42
false
[1, 2, 3]
nil
[]
nil
1
key not found: :b
nil
1267650600228229401496703205376
4
3.3333333333333335
1
2

# frozen_string_literal: true

# The Java "interface" becomes a convention plus a mixin.
module Describable
  def describe = "#{self.class.name.downcase}: #{label}"
end

Magazine = Struct.new(:label) { include Describable }
Poster = Struct.new(:label) { include Describable }

p Magazine.new("monthly").describe
p Poster.new("A2").describe
p Magazine.include?(Describable)
p Magazine.new("x").is_a?(Describable)
p Describable.instance_methods

# The module needs #label, but nothing checks that until it is called.
Broken = Class.new { include Describable }

begin
  Broken.new.describe
rescue NameError => e
  puts e.message
  p e.class
end

# Comparable gives <, <=, ==, >, >= and between? from a single <=>.
Version = Struct.new(:major, :minor) do
  include Comparable

  def <=>(other) = to_a <=> other.to_a
end

p Version.new(1, 2) < Version.new(1, 10)
p Version.new(1, 2).between?(Version.new(1, 0), Version.new(2, 0))
p [Version.new(2, 0), Version.new(1, 5)].min

"magazine: monthly"
"poster: A2"
true
true
[:describe]
undefined local variable or method 'label' for an instance of Broken
NameError
true
true
#<struct Version major=1, minor=5>

# frozen_string_literal: true

require "shelf"

# try/catch/finally becomes begin/rescue/ensure (and an optional else).
def parse_isbn(text)
  Shelf::Isbn.new(text)
rescue ArgumentError => e
  warn "rejected: #{e.message}"
  nil
ensure
  puts "checked #{text.inspect}"
end

p parse_isbn("9780306406157")
p parse_isbn("123")

# A custom exception hierarchy, and retry.
class NotFound < Shelf::Error; end

attempts = 0
begin
  attempts += 1
  raise NotFound, "no such book" if attempts < 3

  puts "found after #{attempts} attempts"
rescue NotFound
  retry
end

# raise with no argument re-raises; exceptions carry a cause.
begin
  begin
    Integer("abc")
  rescue ArgumentError
    raise NotFound, "lookup failed"
  end
rescue Shelf::Error => e
  p e.class
  p e.cause.class
  puts e.cause.message
end

# Many conversions take exception: false instead of raising.
p Integer("x", exception: false)
p Float("1.5", exception: false)

checked "9780306406157"
#<data Shelf::Isbn digits="9780306406157">
rejected: invalid ISBN: 123
checked "123"
nil
found after 3 attempts
NotFound
ArgumentError
invalid value for Integer(): "abc"
nil
1.5

# frozen_string_literal: true

# Blocks, procs and lambdas: closures for lambdas / function values.
double = ->(n) { n * 2 }
p double.call(4)
p double[4]
p double.lambda?
p [1, 2, 3].map(&double)
p [1, 2, 3].map(&:to_s)

compose = double >> ->(n) { n + 1 }
p compose.call(5)

counter = 0
increment = -> { counter += 1 }
3.times { increment.call }
p counter

def adder(step) = ->(n) { n + step }
p adder(10).call(1)

def each_twice(items)
  return to_enum(__method__, items) unless block_given?

  items.each { |i| 2.times { yield i } }
end

each_twice([1, 2]) { |i| print i, " " }
puts
p each_twice([1, 2]).to_a

pr = proc { |a, b| [a, b] }
p pr.call(1)
p pr.call(1, 2, 3)
p pr.call([4, 5])
begin
  double.call
rescue ArgumentError => e
  puts e.message
end
p method(:puts).to_proc.lambda?

8
8
true
[2, 4, 6]
["1", "2", "3"]
11
3
11
1 1 2 2
[1, 1, 2, 2]
[1, nil]
[1, 2]
[4, 5]
wrong number of arguments (given 0, expected 1)
true

# frozen_string_literal: true

# Annotations become class-level method calls ("class macros").
class Settings
  attr_accessor :host
  attr_reader :port

  def initialize
    @host = "localhost"
    @port = 8080
  end

  DEFAULTS = { host: "localhost" }.freeze
  private_constant :DEFAULTS

  def self.deprecated_alias(old, replacement)
    define_method(old) do |*args, &blk|
      warn "#{old} is deprecated, use #{replacement}"
      public_send(replacement, *args, &blk)
    end
  end

  deprecated_alias :legacy_host, :host
end

s = Settings.new
p s.legacy_host
p Settings.instance_methods(false).sort
p Settings.private_instance_methods(false)
begin
  Settings::DEFAULTS
rescue NameError => e
  puts e.message
end
p s.frozen?
p s.freeze.frozen?
begin
  s.host = "x"
rescue FrozenError => e
  p e.class
end

legacy_host is deprecated, use host
"localhost"
[:host, :host=, :legacy_host, :port]
[:initialize]
private constant Settings::DEFAULTS referenced
false
true
FrozenError

# frozen_string_literal: true

# Without generics: containers hold anything, types are checked at use.
mixed = [1, "two", :three, nil, 4.0, [5]]
p mixed.map(&:class)
p mixed.grep(Numeric)

def total(items)
  items.sum
end

p total([1, 2, 3])
p total([1.5, 2])
begin
  total(%w[a b])
rescue TypeError => e
  puts e.message
end
p total([[1], [2]].map(&:first))
p %w[a b].sum("")

[Integer, String, Symbol, NilClass, Float, Array]
[1, 4.0]
6
3.5
String can't be coerced into Integer
3
"ab"

module Shelf
  class Catalog
    include Enumerable[Book]

    def initialize: (?store: Store::Memory) -> void
    def add: (Book book) -> self
    def each: () { (Book) -> void } -> void
            | () -> Enumerator[Book, void]
  end
end

# frozen_string_literal: true

require "shelf"

# Packages become gems (distribution) and modules (namespacing); files are not namespaces.
p Shelf.constants.sort.first(5)
p Shelf::VERSION
p($LOADED_FEATURES.grep(/shelf\.rb/).map { File.basename(it) })
p require("shelf")
p defined?(Shelf::Store::Memory)
p Shelf::Store::Memory.name
module Shelf
  module Store
    p Memory
  end
end
p Set.new([1, 2, 3]).size

[:Author, :Book, :Catalog, :Config, :Error]
"0.1.0"
["shelf.rb"]
false
"constant"
"Shelf::Store::Memory"
Shelf::Store::Memory
3

# frozen_string_literal: true

# Java-style class vs Ruby: fields, accessors, constructors.
class Reader
  attr_reader :name
  attr_accessor :email

  def initialize(name, email: nil)
    @name = name
    @email = email
  end

  def to_s = "#{name} <#{email || 'n/a'}>"
end

r = Reader.new("Ada", email: "ada@example.com")
puts r
r.email = nil
puts r
p r.instance_variables
p r.respond_to?(:name=)

Pair = Struct.new(:left, :right)
Point = Data.define(:x, :y)
p Pair.new(1, 2)
p Point.new(x: 1, y: 2)
p Point.new(1, 2).with(y: 5)
first = Point.new(1, 2)
p first == Point.new(1, 2)
p Reader.new("a").eql?(Reader.new("a"))

Ada <ada@example.com>
Ada <n/a>
[:@name, :@email]
false
#<struct Pair left=1, right=2>
#<data Point x=1, y=2>
#<data Point x=1, y=5>
true
false