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 Every Developer Should Meet Ruby: A Friendly Introduction

-
Meet Ruby: The Language That Makes Coding Feel Human A beginner-friendly guide to why Ruby could be your new favorite language. 🧠 What Is Ruby? Ruby is a high-level, interpreted programming language that was designed with one clear goal: developer happiness . If you’ve ever felt like other programming languages are too rigid or robotic — Ruby changes that. It’s simple, expressive, and reads almost like plain English. Ruby lets you focus more on solving problems and less on battling syntax. 📜 A Quick Look Back: Ruby’s Origins Ruby was created in 1995 by Yukihiro “Matz” Matsumoto , a Japanese programmer who wanted a language that blended the best features of Perl, Smalltalk, and Lisp. His philosophy? “ Programming should be fun. ” And Ruby reflects that. It’s designed to be intuitive, elegant, and enjoyable to work with. 🎯 Why Learn Ruby in 2025? Even in a world full of Python, JavaScript, and Go — Ruby holds its own. Here’s why: Readable Syntax – You’ll write cod...
Read more

This is Ruby. And Ruby knows how to block — like a bouncer for bad code. 🔥

-
Image
Ruby Blocks — The Secret Sauce Behind Elegant Code Ruby Blocks — The Secret Sauce Behind Elegant Code Picture this: You're writing Ruby. Things are going well… until you find yourself copying the same chunk of logic again. And again. And… wait, again? 😩 Enter: Ruby Blocks — your new BFF for clean, DRY, and elegant code. If methods are the skeleton of Ruby, blocks are the juicy muscles that flex logic in powerful ways. 🍱 Blocks? Like, Tupperware Blocks? Exactly! Ruby blocks are like code Tupperware — you can pack them with logic, pass them around, and execute them on demand. They're anonymous chunks of code that you can hand over to a method to be called later. 🔍 Syntax: The Two Faces of Ruby Blocks 1. Curly Braces for the Quickies: [1, 2, 3].each { |num| puts num } 2. do...end for Multiline Zen: [1, 2, 3].each do |num| puts "Double trouble: #{num * 2}" end Both are blocks. One's espresso; the other's a cappuccino. ...
Read more

Iterators in Ruby — Think Less Looping, More Logic

-
Image
Ruby Iterators — When Loops Just Aren’t Elegant Enough Ruby Iterators — When Loops Just Aren’t Elegant Enough Published: June 24, 2025 • CodeCraft Diaries #7 "If you've been writing `for` loops in Ruby like it's 1999, this one's for you." Let’s be real: loops are the bread and butter of programming. But in Ruby? You don’t just butter the bread — you toast it, drizzle it with honey, and serve it like a gourmet dev snack. Welcome to the elegant world of Ruby iterators — where looping is expressive, concise, and kinda beautiful. 🚶 Why Not Just Use a Loop? You can, of course: for i in 1..3 puts i end But Ruby gives us cooler tools. Imagine replacing that clunky loop with something like: (1..3).each { |i| puts i } Cleaner. Readable. Ruby-esque. 🔄 Meet Your Iterator Friends 1. each — The Friendly Tour Guide ["coffee", "code", "chai"].each do |item| puts ...
Read more