Methods

def method_name
  # code
end

def greet(name)
  "Hello, #{name}!"
end

def add(a, b)
  a + b
end

def greet(name = "World")
  "Hello, #{name}!"
end

def sum(*numbers)
  numbers.inject(0) { |sum, n| sum + n }
end

sum(1, 2, 3, 4)  # 10

def create_user(name:, age: 18, email: nil)
  # code
end

create_user(name: "John", age: 25)

def user_info(**attributes)
  attributes.each { |key, value| puts "#{key}: #{value}" }
end

def add(a, b)
  a + b  # implicit return
end

def explicit_return
  return "early return"
  "this won't execute"
end

def public_method
  "anyone can call me"
end

private

def private_method
  "only callable within this class"
end

protected

def protected_method
  "callable by instances of same class or subclasses"
end

class MyClass
  def self.class_method
    "I'm a class method"
  end

  def instance_method
    "I'm an instance method"
  end
end

MyClass.class_method    # "I'm a class method"
obj = MyClass.new
obj.instance_method     # "I'm an instance method"

alias old_name new_name

def original_method
  "original"
end

alias :old_method :original_method

class DynamicClass
  def method_missing(name, *args)
    puts "Called #{name} with #{args.inspect}"
  end
end

obj = DynamicClass.new
obj.any_method("arg")  # Called any_method with ["arg"]

def my_method
  yield if block_given?
end

my_method { puts "Block executed" }

my_proc = Proc.new { |x| x * 2 }
my_proc.call(5)  # 10

my_lambda = lambda { |x| x * 2 }
my_lambda.call(5)  # 10

# Or:
my_lambda = ->(x) { x * 2 }

class Calculator
  def add(a, b)
    a + b
  end
end

calc = Calculator.new
method_obj = calc.method(:add)
result = method_obj.call(2, 3)  # 5

class Point
  attr_accessor :x, :y

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

  def +(other)
    Point.new(@x + other.x, @y + other.y)
  end

  def to_s
    "(#{@x}, #{@y})"
  end
end

p1 = Point.new(1, 2)
p2 = Point.new(3, 4)
p3 = p1 + p2  # (4, 6)

obj = "hello"
def obj.shout
  upcase
end

obj.shout  # "HELLO"

class Chainable
  def initialize(value)
    @value = value
  end

  def add(n)
    @value += n
    self  # Return self for chaining
  end

  def multiply(n)
    @value *= n
    self
  end

  def result
    @value
  end
end

result = Chainable.new(5).add(3).multiply(2).result  # 16