What `map(&:name)` Means in Ruby

By the end of this page, you will understand why map(&:name) is a short Ruby way to call the name method on every item in a collection. You will also learn how the & operator and symbols work together, how this compares to a normal block, and when this shorthand is useful in real Ruby and Rails code.

In Ruby, map loops through a collection and returns a new array containing the result of running something on each element.

For example:

[1, 2, 3].map { |n| n * 2 }
# => [2, 4, 6]

When you write:

tags.map(&:name)

Ruby is using a shorthand for a very common pattern:

tags.map { |tag| tag.name }

What the pieces mean

• :name is a symbol representing the method name name
• & tells Ruby to convert that symbol into something usable as a block
• map then calls that method on each element

So if tags is a collection of tag objects, map(&:name) means:

• take each tag
• call tag.name

Think of map as a worker on an assembly line.

• The collection is a line of items moving past
• map applies the same action to each item
• &:name is like giving the worker a small instruction card that says: for each item, ask for its name

So instead of saying:

map { |item| item.name }

you hand Ruby a shortcut card:

map(&:name)

Same job, shorter instruction.

Basic 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: "Liam"),
  OpenStruct.new(name: "Noah")
]

users.map(&:name)
# => ["Ava", "Liam", "Noah"]

This calls name on each user object.

Example 2: Convert strings to uppercase

words = ["ruby", "rails", "api"]
words.map(&:upcase)
# => ["RUBY", "RAILS", "API"]

This calls upcase on each string.

Example 3: Compare with block syntax

tags.map(&)

Consider this code:

words = ["ruby", "rails", "api"]
result = words.map(&:upcase)

Here is what happens step by step:

1. words is an array with three strings:

   • "ruby"
   • "rails"
   • "api"

2. map starts looping through the array.

3. &:upcase tells Ruby: for each element, call the upcase method.

4. Ruby processes each item:

   • "ruby".upcase → "RUBY"
   • "rails".upcase → "RAILS"
   • "api".upcase → "API"

5. map collects the results into a new array.

map(&:method_name) is common when you want one value from each object in a collection.

Common practical uses

• Rails views: get names or titles for display

  @posts.map(&:title)
  

• Building API responses: extract IDs or fields

  users.map(&:id)
  

• Data cleanup: transform strings

  emails.map(&:downcase)
  

• Admin dashboards: list labels from objects

  categories.map(&:name)
  

• Form helpers: prepare selected values

  roles.map(&:name).join(", ")
  

Why developers like it

• short and readable for simple method calls
• avoids unnecessary block variables
• works well in chains with map, select, and

In real Ruby and Rails projects, this shorthand is often used when the block only calls one method with no extra logic.

Typical patterns

Extracting attributes

user_ids = users.map(&:id)
post_titles = posts.map(&:title)

Preparing display strings

tag_list = tags.map(&:name).join(", ")

Working with associations in Rails

@article.comments.map(&:body)
@order.line_items.map(&:price)

Combining with other enumerable methods

users.select(&:active?).map(&:email)

This means:

1. keep only active users
2. get each user's email

When developers avoid it

If the logic is more than a simple method call, a normal block is usually clearer:

users.map { |user| "#{user.first_name} #{user.last_name}" }

1. Thinking &:name is special syntax only for map

It is not limited to map. It can be used with other methods that accept a block, such as select, reject, and any?.

users.select(&:active?)

2. Using it when the method needs arguments

This does not work for methods that require extra arguments in this form.

Broken example:

words.map(&:gsub)

Why it fails:

• gsub needs arguments
• &:gsub only says "call gsub"
• it does not provide the required parameters

Use a block instead:

words.map { |word| word.gsub("a", "@") }

3. Using it when the method may not exist

Broken example:

map(&:name) vs block syntax

map vs each

Quick reference

Basic form

collection.map(&:method_name)

Equivalent to:

collection.map { |item| item.method_name }

Common examples

users.map(&:name)
posts.map(&:title)
words.map(&:upcase)
users.select(&:active?)

What & does

• converts an object into a block if possible
• with symbols, Ruby uses to_proc

What :name is

• a symbol representing the method name name

Good use cases

• calling one method on each element
• short, clear collection transformations

Avoid when

• the method needs arguments
• you need multiple steps
• the shorthand hurts readability

Related equivalent

What does map(&:name) mean in Ruby?

It means: loop through the collection, call name on each item, and return the results in a new array.

Is map(&:name) the same as map { |x| x.name }?

Yes. For this case, they are equivalent.

What does the & do in &:name?

It tells Ruby to convert the symbol into a block-like callable object.

Why is a symbol used instead of a string?

Ruby supports converting symbols like :name into procs for this shorthand. Strings do not work the same way here.

Can I use &:name with methods other than map?

Yes. Any method that accepts a block may be able to use this style, such as select, reject, or any?.

Does map(&:name) work if the method takes arguments?

Usually no. If arguments are needed, use a normal block.

Is map(&:name) always better than a block?

Symbols

Symbols like :name are a key part of this syntax because Ruby converts them into procs.

Blocks

map(&:name) is shorthand for passing a block, so understanding blocks makes this syntax much clearer.

Procs

The & operator works with objects that can become procs, which is why Symbol#to_proc matters here.

Enumerables

map is part of Ruby's enumerable tools for transforming and filtering collections.

each

each is often learned alongside map, and the difference between iteration and transformation is important.

select

Like map, select often appears with shorthand such as select(&:active?).

ActiveRecord pluck

In Rails, pluck is related because it can retrieve attribute values directly from the database without loading full objects.