snake = [[2, 3], [2, 4], [2, 5]] # => [[2, 3], [2, 4], [2, 5]]
grown_snake = snake + [[2, 6]]   # => [[2, 3], [2, 4], [2, 5], [2, 6]]

snake.equal?(snake)              # => true
snake.equal?(grown_snake)        # => false

snake[0]                         # => [2, 3]
grown_snake[0]                   # => [2, 3]
snake[0].equal?(grown_snake[0])  # => true

def something(a, *b, c)
end

def order(drink:, size: 'grande', syrup: nil)
end

pow = lambda { |a, b| a**b }

# Синтаксис
say_hi = lambda { puts 'Hi there!' }
double = lambda { |x| x * 2 }
pow = lambda { |a, b| a**b }

# Симпатичен синтаксис (1.9+)
say_hi = -> { puts 'Hi there' }
double = ->(x) { x * 2 }
pow = ->(a, b) { a**b }

# Извикване
pow.call 2, 3
pow[2, 3]
pow.(2, 3)

def calculate
  result = yield(2)
  "The result for 2 is #{result}"
end

calculate { |x| x**2 } # => "The result for 2 is 4"

is_odd = lambda { |n| n.odd? }

filter([1, 2, 3, 4, 5], &is_odd)
filter([1, 2, 3, 4, 5]) { |n| n.odd? }

def invoke_with(*args, &block)
  block.call(*args)
end

invoke_with(1, 2) { |a, b| puts a + b }

# Валиден код
order drink: 'latte', size: 'grande'
order({drink: 'latte', size: 'grande'})

# Невалиден код
order {drink: 'latte', size: 'grande'}

->(foo:, **opts) { p [opts] }.call foo: 'bar', larodi: 'baz'

double = Proc.new { |x| x * 2 }

double.call(2)
double[2]
double.(2)

lambda { |n| n**2 }   # => #<Proc:0x002ab59a7f7db0@-:1 (lambda)>
Proc.new { |n| n**2 } # => #<Proc:0x002ab59a7f7888@-:2>

def return_in_lambda
  -> { return 42 }.call
  'Hello world'
end

def return_in_proc
  Proc.new { return 42 }.call
  'Hello world'
end

return_in_lambda # => "Hello world"
return_in_proc   # => 42

numbers = [-9, -4, -1, 0, 1, 4, 9]

positive = numbers.select { |n| n >= 0 }
# => [0, 1, 4, 9]
even = numbers.reject { |n| n.odd? }
# => [-4, 0, 4]
squares = numbers.map { |n| n**2 }
# => [81, 16, 1, 0, 1, 16, 81]
roots = numbers.select { |n| n > 0 }.map { |n| n**0.5 }
# => [1.0, 2.0, 3.0]

numbers = [-9, -4, -1, 0, 1, 4, 9]

squares = numbers.collect { |n| n**2 }
# => [81, 16, 1, 0, 1, 16, 81]
positive = numbers.find_all { |n| n >= 0 }
# => [0, 1, 4, 9]

numbers = [1, 2, 3, 4, 5]

numbers.reduce(0) { |a, b| a + b }
# => 15
numbers.reduce(1) { |a, b| a * b }
# => 120

numbers.reduce { |a, b| a + b }
# => 15
numbers.reduce { |a, b| "#{a}, #{b}" }
# => "1, 2, 3, 4, 5"

def reduce(array, initial = nil)
  remaining = array.dup
  buffer    = initial || remaining.shift

  until remaining.empty?
    buffer = yield buffer, remaining.shift
  end

  buffer
end

reduce([1, 2, 3, 4]) { |a, b| a + b }
reduce([1, 2, 3, 4], 0) { |a, b| a + b }

class Array
  def reduce(initial = nil)
    remaining = dup
    buffer    = initial || remaining.shift

    until remaining.empty?
      buffer = yield buffer, remaining.shift
    end

    buffer
  end
end

class Bacon
  def chunky?
    'yes, of course!'
  end
end

bacon = Bacon.new
bacon.chunky?      # => "yes, of course!"

class Vector
  def initialize(x, y)
    @x = x
    @y = y
  end
end

class Vector
  def initialize(x, y)
    @x = x
    @y = y
  end

  def length
    (@x * @x + @y * @y)**0.5
  end
end

vector = Vector.new 2.0, 3.0
vector.length()     # => 3.605551275463989
vector.length       # => 3.605551275463989

class Person
  def soul
    @nothingness
  end
end

person = Person.new
person.soul # nil

class Person
  def initialize(name) @name = name                end
  def say_hi()         puts "My name is #{@name}!" end
  def sound_smart()    puts "1101000 1101001"      end

  def talk
    self.say_hi
    sound_smart
  end
end

mel = Person.new 'Mel'
mel.talk

class Person
  def me
    self
  end
end

person = Person.new
person           # => #<Person:0x002b39374de6a8>
person.me        # => #<Person:0x002b39374de6a8>
person.me.me     # => #<Person:0x002b39374de6a8>

class Person
  def initialize(age)
    @age = age
  end

  def age
    @age
  end

  def set_age(age)
    @age = age
  end
end

person = Person.new(33)
person.age          # => 33
person.set_age 20
person.age          # => 20

class Person
  def age
    @age
  end

  def age=(value)
    @age = value
  end
end

person = Person.new
person.age = 33  # Същото като person.age=(33)

person.age       # => 33

class Person
  attr_accessor :age
end

person = Person.new
person.age = 33

person.age # => 33

class Person
  attr_reader :name
  attr_writer :grade
  attr_accessor :age, :height

  attr :address # като attr_reader
end

person.age()
person.age

class Person
  def name
    'River'
  end
end

class Person
  def say_hi
    "Hi, I am #{name}."
  end
end

Person.new.say_hi # => "Hi, I am River."
Person.new.name   # => "River"

class Someone
  def name
    'Tom Baker'
  end

  def name
    'Colin Baker'
  end
end

Someone.new.name # => 'Colin Baker'

class Something
  a = 1
  b = 2
  a + b # => 3
end

class Object
  if RUBY_VERSION <= '1.8.6'
    def tap
      yield self
      self
    end
  end
end

class Person
  def foo() end
  def bar() end
end

Person.new.methods - Object.new.methods # => [:foo, :bar]

class Vector
  attr_accessor :x, :y

  def initialize(x, y)
    @x, @y = x, y
  end

  def +(other)
    Vector.new(x + other.x, y + other.y)
  end

  def inspect
    "Vector.new(#@x, #@y)"
  end
end

Vector.new(1, 5) + Vector.new(3, 10) # => Vector.new(4, 15)

class Person
  def say_hi
    "Hello! I am #{name}"
  end

  private

  def name
    'the Doctor'
  end
end

person = Person.new
person.say_hi     # => "Hello! I am the Doctor"
person.name       # => error: NoMethodError

class Person
  def say_hi
    "Hello! I am #{self.name}"
  end

  private

  def name
    'the Doctor'
  end
end

person = Person.new
person.say_hi     # => error: NoMethodError

module UselessStuff
  def almost_pi
    3.1415
  end

  def almost_e
    2.71
  end
end

module UselessStuff
  def almost_pi
    3.1415
  end
end

class Something
  include UselessStuff
end

Something.new.almost_pi # => 3.1415

module Introducable
  def introduction
    "Hello, I am #{name}"
  end
end

class Person
  include Introducable
  def name() 'The Doctor' end
end

doctor = Person.new
doctor.introduction # => "Hello, I am The Doctor"

module Includeable
  def name() 'Module' end
end

class Something
  def name() 'Class' end
  include Includeable
end

Something.new.name # => "Class"

module Chunky
  def name() 'chunky' end
end

module Bacon
  def name() 'bacon' end
end

class Something
  include Chunky
  include Bacon
end

Something.new.name # => "bacon"

[1, 2, 3, 4, 5].select { |n| n.odd? }           # => [1, 3, 5]
%w(foo plugh barney).map { |word| word.length } # => [3, 5, 6]
[1, 2, 3, 4, 5].reduce { |a, b| a * b }         # => 120

hash = {2 => 3, 4 => 5}

hash.to_a                                 # => [[2, 3], [4, 5]]
hash.map { |p| p[0] + p[1] }              # => [5, 9]
hash.map { |k, v| k + v }                 # => [5, 9]
hash.reduce(0) { |s, p| s + p[0] * p[1] } # => 26

hash = {2 => 3, 4 => 5, 6 => 7, 8 => 9}

hash.select { |k, v| v > 6 }      # => {6=>7, 8=>9}
hash.to_a.select { |k, v| v > 6 } # => [[6, 7], [8, 9]]

class FibonacciNumbers
  include Enumerable

  def initialize(limit)
    @limit = limit
  end

  def each
    current, previous = 1, 0

    while current < @limit
      yield current
      current, previous = current + previous, current
    end
  end
end

FibonacciNumbers.new(100).to_a # => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

class StepRange
  include Enumerable

  def initialize(first, last, step)
    @first, @last, @step = first, last, step
  end

  def each
    @first.step(@last, @step) { |n| yield n }
  end
end

StepRange.new(1, 10, 2).select { |n| n > 5 } # => [7, 9]

def each_digit
  yield 0; yield 1; yield 2; yield 3; yield 4
  yield 5; yield 6; yield 7; yield 8; yield 9
end

result = []
each_digit do |n|
  result << n
end

result = enum_for(:each_digit).to_a

evens = enum_for(:each_digit).
          select { |digit| digit.event? }

def each_number
  n = 0
  loop do
    n += 1
    yield n
  end
end

enum_for(:each_number).
  lazy.
  select { |x| x.odd? }.
  take(10)