Ruby &: Symbol-to-Proc Shortcut Explained

By the end of this page, you will understand how Ruby's & operator works with blocks, how a Symbol like :foo becomes a callable object through to_proc, and why some_objects.map(&:name) is a real language feature rather than a random special case. You will also see when this shortcut is helpful and when a normal block is clearer.

In Ruby, the &:method_name pattern is based on two language features working together:

1. & in a method call means: convert this object into a block.
2. Symbol#to_proc lets a symbol such as :foo turn into a Proc.

So when Ruby sees this:

some_objects.each(&:foo)

it roughly interprets it like this:

some_objects.each(&(:foo.to_proc))

And :foo.to_proc produces a proc that calls foo on whatever object it receives.

Conceptually, it behaves like:

proc { |obj| obj.foo }

That is why it works with iterator methods such as each, map, select, and similar methods that accept blocks.

Why this matters

Think of & as a block adapter.

A method like each wants a block. But instead of giving it a normal block directly, you hand Ruby an object.

some_objects.each(&:foo)

Ruby says:

• “I need a block here.”
• “You gave me :foo with an &.”
• “Let me ask :foo to turn itself into a proc by calling to_proc.”
• “Now I can use that proc as the block.”

A symbol like :foo is therefore acting like a label for a method name. Ruby converts that label into a callable block that says:

• “When I receive an object, call foo on it.”

So you can imagine &:foo as a little remote control button labeled foo. Each object in the collection gets the same button pressed on it.

Core syntax

collection.map(&:method_name)

This is shorthand for:

collection.map { |item| item.method_name }

Example 1: Extract names

users = [
  OpenStruct.new(name: "Ava"),
  OpenStruct.new(name: "Ben"),
  OpenStruct.new(name: "Cara")
]

names = users.map(&:name)
puts names.inspect

Output:

["Ava", "Ben", "Cara"]

Explanation:

• map loops through each user
• &:name becomes a proc
• that proc calls name on each user
• map collects the returned names into a new array

Example 2: Convert strings to integers

Consider this code:

words = ["cat", "dog", "bird"]
lengths = words.map(&:length)
puts lengths.inspect

Here is what happens step by step:

1. words is an array containing three strings.
2. map starts iterating through each element.
3. Ruby sees &:length and knows map expects a block.
4. Ruby calls to_proc on :length.
5. That creates a proc that behaves roughly like:

proc { |item| item.length }

1. map calls that proc for each item:
   • for "cat" → "cat".length → 3
   • for "dog" → "dog".length → 3

Common places you will see &:symbol

Transforming arrays

products.map(&:price)
orders.map(&:id)
messages.map(&:strip)

Used when you want one property or one method result from every object.

Cleaning input data

params[:tags].map(&:strip).reject(&:empty?)

Useful for removing extra spaces and blank values.

Working with API or database results

users.map(&:email)
records.map(&:attributes)

Developers often extract fields from collections of model objects.

Type conversion

csv_row.map(&:to_s)
values.map(&:to_i)

Helpful when normalizing incoming data.

Boolean-style filtering

items.select(&:valid?)

This keeps only items for which valid? returns true.

In real Ruby projects, &:symbol appears most often in collection pipelines.

Common patterns

Simple mapping

user_names = users.map(&:name)

Validation and filtering

valid_orders = orders.select(&:valid?)

Cleanup chains

tags = raw_tags.map(&:strip).reject(&:empty?).uniq

Guarding readability

Developers often avoid &:symbol if the expression becomes harder to understand.

# Clear
users.map(&:name)

# Often clearer as a block
users.map { |user| user.profile.display_name }

How it relates to other Ruby patterns

• Guard clauses: not directly related, but both aim to keep code concise and readable.
• Validation: select(&:valid?) is common when filtering objects by a predicate method.
• Error handling: if some objects may not respond to the method, developers usually avoid unless they are sure the method exists.

1. Thinking &:foo is magic syntax only for symbols

It is not a one-off exception. & means “convert this object to a proc for use as a block.” Symbols work because Symbol defines to_proc.

2. Using it when the method needs extra logic

Broken for readability:

users.map(&:name.downcase)

This does not mean “call name.downcase on each user.”

Write this instead:

users.map { |user| user.name.downcase }

3. Using it on objects that do not respond to the method

items = ["a", 1, nil]
items.map(&:upcase)

This will fail because 1 and nil do not have upcase.

Safer alternative:

items.filter_map { || item.upcase  item.respond_to?() }

&:symbol vs explicit block

map(&:foo) vs each(&:foo)

Quick reference

Basic form

collection.map(&:method_name)

Equivalent to:

collection.map { |item| item.method_name }

Why it works

• & tells Ruby to treat something as a block
• Ruby calls to_proc on the object after &
• Symbol#to_proc turns :name into a proc that calls name

Common examples

users.map(&:name)
strings.map(&:upcase)
values.map(&:to_i)
orders.select(&:paid?)

Good use cases

• one short method call per item
• readable collection transformations
• simple predicate filtering

Avoid when

• you need chained logic like user.name.downcase
• you need conditionals

What does &:name mean in Ruby?

It means Ruby converts the symbol :name into a proc and uses it as the block. In practice, it calls name on each item.

Is &:symbol exactly the same as { |x| x.foo }?

For common usage, yes, that is the right mental model. Internally, Ruby uses Symbol#to_proc to create the proc.

Why does the ampersand work here?

In a method call, & tells Ruby to convert an object into a block by calling to_proc on it.

Is this only for symbols?

No. Any object that implements to_proc can be used with & in a method call.

When should I avoid &:symbol?

Avoid it when the logic is more than one simple method call, or when the shorter syntax makes the code harder to read.

Does each(&:foo) return the results of foo?

Usually no. each typically returns the original collection. If you want collected results, use .

Blocks

Blocks are the foundation of methods like each and map, and &:symbol is ultimately a way to provide a block.

Proc objects

&:symbol works because Ruby converts a symbol into a Proc.

to_proc

This method is the key mechanism Ruby uses when converting an object with & into a block.

Symbols

The shortcut uses a symbol such as :name, so understanding symbols helps explain the syntax.

Enumerables

Methods like map, each, select, and reject are where this pattern is used most often.

map vs each

These are commonly confused by beginners, and &:symbol often appears with both.

Predicate methods