Meet Ruby’s Secret Siblings: Procs & Lambdas Made Fun

-
Procs and Lambdas in Ruby — The Cousins You Need to Know

Procs and Lambdas in Ruby — The Cousins You Need to Know

Published on June 09, 2025 • CodeCraft Diaries #6

"If methods are the parents and blocks are the kids, then Procs and Lambdas are the cool cousins who show up late but save the day with reusable logic."

🔍 Wait... Blocks Have Relatives?

Yes, they do. Blocks are amazing, but sometimes you want to reuse them, store them in variables, or pass them around like a tray of samosas at a tech meetup.

That’s where Procs and Lambdas come in — Ruby’s way of giving blocks a full-time job.

👶 Quick Recap: What’s a Block?

def greet
  yield
end

greet { puts "Hello from the block!" }

Blocks are anonymous chunks of code you can pass to methods. But blocks can’t live on their own — Procs and Lambdas can.

🧑‍🤝‍🧑 Meet Proc and Lambda

📦 What is a Proc?

A Proc is like a block with a backpack — you can carry it around and call it whenever you want.

say_hi = Proc.new { puts "Hi there!" }

say_hi.call  # Hi there!

🦸 What is a Lambda?

Lambdas are like Procs... but with manners.

say_bye = lambda { puts "Goodbye!" }

say_bye.call  # Goodbye!

You can also use the arrow syntax:

say_hello = -> { puts "Hello!" }
say_hello.call

⚖️ Proc vs Lambda — Spot the Differences

  • Return behavior: Procs return from the enclosing method, Lambdas return from themselves.
  • Argument check: Lambdas care about the number of arguments. Procs don’t.

🔁 Return Example:

def test_proc
  my_proc = Proc.new { return "Returned from Proc" }
  my_proc.call
  "Returned from method"
end

puts test_proc  # Output: Returned from Proc

def test_lambda
  my_lambda = -> { return "Returned from Lambda" }
  my_lambda.call
  "Returned from method"
end

puts test_lambda  # Output: Returned from method

🔧 Use Cases — Why Even Bother?

  • Reusable callbacks
  • Validation logic
  • Cleaner control flows

🧪 Mini Code Challenge

Write a method that accepts a lambda and calls it.

def perform_action(action)
  puts "Starting..."
  action.call
  puts "Done!"
end

shout = -> { puts "💥 Boom!" }

perform_action(shout)

🚨 Common Mistakes

  • Using return inside a Proc and wondering why the method exits
  • Passing wrong arguments to Lambdas
  • Confusing blocks, Procs, and Lambdas as “the same”

💡 Quick Recap

  • Block: Can’t be saved, passed anonymously to methods
  • Proc: Can be saved and reused, flexible but loose
  • Lambda: Like Proc but strict and polite

🐦 Tweet-sized Summary

Procs and Lambdas in Ruby: Reusable blocks that let you DRY up code, add elegance, and get strict if needed. Don’t fear them — master them. 💻

🧭 Read Previous Diaries

🚀 Coming Up Next

CodeCraft Diaries #7: “Modules & Mixins in Ruby — Sharing is Caring (But Make It Clean)”

Comments

Post a Comment

Popular posts from this blog

Why Your Ruby Scripts Keep Breaking Files (and How to Fix Them)

-
File Handling in Ruby — Reading, Writing, and What Could Go Wrong File Handling in Ruby — Reading, Writing, and What Could Go Wrong CodeCraft Diaries #9 • For Freshers, Students & Curious Developers “If you’ve never accidentally deleted a file while testing your script, are you even a developer?” Working with files is one of the first real-world things you’ll do in any programming language. Whether it's reading a config, logging errors, or saving user data — file I/O is everywhere. And Ruby? Ruby makes it refreshingly simple. Until you forget to close the file... 💀 📖 Reading from a File Let’s say we have a file called data.txt . File.open("data.txt", "r") do |file| puts file.read end What’s happening here? "r" means “read mode” file.read grabs the entire content The block auto-closes the file (thank you, Ruby!) ✍️ Writing to a File File.open("log....
Read more

Ruby Mixins: Reuse Code Like a Pro (Without Inheritance Headaches)

-
Image
Modules & Mixins in Ruby — Sharing is Caring (Without the Mess) Modules & Mixins in Ruby — Sharing is Caring (Without the Mess) CodeCraft Diaries #8 • For Ruby Freshers, Students & Developers "Code duplication is like wearing the same socks three days in a row — it gets smelly fast." Ever copy-pasted a method from one class to another and thought: “I’ll clean this later...” Spoiler: You won’t. 🙃 That’s where **Modules** and **Mixins** come in — Ruby’s way of letting you *share code like a pro*, without inheritance spaghetti or duplicate soup. 🤝 What Is a Module? Think of a module as a toolbox . It’s not a class. You can’t make objects out of it. But you can pack it with reusable methods and include it wherever needed. module Greetings def hello puts "Hello, Rubyist!" end end Now you’ve got a method... just chilling inside a module, waiting to be mixed in. 🧪 Using Modules...
Read more

Error Handling in Ruby — Don’t Panic, Rescue!

-
Error Handling in Ruby — Don’t Panic, Rescue! 🚨 Error Handling in Ruby — Don’t Panic, Rescue! 🚀 For students, freshers, and curious devs who want to survive Ruby's "uh-oh" moments. Let’s face it — coding without errors is like making Maggi without spilling a little masala. Impossible! 😜 So instead of throwing your laptop out of the window when Ruby screams at you, let’s learn to *rescue* our code like true heroes. Mini Story: Imagine you’re writing the next big Ruby app. Everything is going fine until suddenly… undefined method `sizee' for nil:NilClass (NoMethodError) That’s Ruby’s polite way of saying: “Yo, you messed up.” But instead of crying, we’ll put on our superhero cape and *rescue* the situation. 1. Meet begin and rescue — Your New Besties 🤝 Ruby gives us the begin … rescue block to handle errors like a pro. Think of it as Ruby saying: “Try this. ...
Read more