&blk in a parameter list turns a block into a Proc; &proc at a call turns a Proc back into a block.

1. A block is syntax, not an object

A block is the { ... } or do ... end you attach to a method call. It is not a value you can hold by itself.

You can't store a block in a variable — Ruby won't even parse it:

b = { |x| x * 2 }   # SyntaxError
# Ruby reads { } here as a hash, not a block.

A method can carry at most one block:

[1, 2, 3].each { |x| puts x }   # fine — exactly one block
# There is no syntax to attach a second block to the same call.

Inside a method you reach the block with yield:

def run
  yield        # runs whatever block was attached
  yield        # you can run it again
end
run { puts "hi" }   # prints: hi hi

A block is not a normal argument. It rides along separately from the things in the parentheses:

def how_many(*args)
  args.size
end
how_many(1, 2) { puts "ignored" }   # => 2   (the block is NOT counted as an argument)

2. A Proc is an object

A Proc is a real object that holds a chunk of code. You can do anything with it that you do with any object.

Store it in a variable:

doubler = proc { |x| x * 2 } # or Proc.new { |x| x * 2 }
doubler.class      # => Proc

Call it (three equivalent ways):

doubler.call(5)    # => 10
doubler.(5)        # => 10   (.() shorthand)
doubler[5]         # => 10   ([] shorthand)

Put it in an array and pass it around:

jobs = [proc { puts "a" }, proc { puts "b" }]
jobs.each { |job| job.call }   # prints: a b

So the difference is simple: a block is loose syntax attached to one call; a Proc is an object you can keep.

3. & is the bridge between them

& converts a block into a Proc, or a Proc into a block. Which direction happens depends only on where you write the &.

3.a) & in the parameter list → block becomes a Proc

When you write def foo(&blk), the & catches the block the caller attached and gives it to you as a Proc object named blk:

def foo(&blk)
  blk.class      # => Proc    (now it's a real object)
  blk.call(10)   # => 20      (call it like any object)
end
foo { |x| x * 2 }   # the { } block arrives as the Proc `blk`

Without & you'd have no name for the block — you could only use yield. With &blk you can store it, inspect it, or pass it on.

def run
  yield               # the ONLY way to reach the block
  # blk             — there's no such variable to refer to
  # @saved = blk    — can't store it
  # blk.arity       — can't inspect it
  # other(&blk)     — can't pass it on
end
run { puts "hi" }     # prints: hi

3.b) & at a call site → Proc becomes a block

When you already have a Proc in a variable and want a method to use it as its block, put & in front:

doubler = ->(x) { x * 2 }
[1, 2, 3].map(&doubler)    # => [2, 4, 6]

Here doubler is lambda

Without the &, it's treated as a normal argument and map won't use it as the block:

[1, 2, 3].map(doubler)     # ArgumentError
# wrong number of arguments (given 1, expected 0)

lambda is a Proc

The arrow ->(x) { ... } just creates a Proc object that happens to be the "strict" kind. You can check:

doubler = ->(x) { x * 2 }
doubler.class     # => Proc
doubler.lambda?   # => true

So when the text says "a Proc in a variable", a lambda counts — it is a Proc. The word Proc (capital P) is the class; both ways of making one produce an object of that class:

a = ->(x) { x * 2 }       # lambda
b = lambda { |x| x * 2 }  # lambda (same as above)
c = proc { |x| x * 2 }    # plain proc
d = Proc.new { |x| x * 2 }# plain proc

[a, b, c, d].map(&:class)    # => [Proc, Proc, Proc, Proc]
[a, b, c, d].map(&:lambda?)  # => [true, true, false, false]

3.c) Both directions in one method

Capture a block as a Proc, then forward it as a block to another method. Same &, opposite jobs, decided purely by position:

def logged(&blk)          # & in params: block → Proc `blk`
  puts "start"
  [1, 2, 3].each(&blk)    # & at call: Proc `blk` → block for each
  puts "end"
end
logged { |n| puts n }     # prints: start 1 2 3 end

4. The to_proc rule

One extra rule explains everything else: at a call site, if the thing after & is not already a Proc, Ruby first calls .to_proc on it, then turns the result into a block.

A Symbol knows how to become a Proc:

:upcase.to_proc.call("hi") # => "HI"

%w[a b c].map(&:upcase) # `&` runs `:upcase.to_proc`, then uses it as the block
%w[a b c].map { |s| s.upcase } # exactly the same thing
# both => ["A", "B", "C"]

So &:upcase is roughly the same as &->(x) { x.upcase }.

A Method object does too (remember: method(:name) returns an object):

method(:puts).class               # => Method
method(:puts).to_proc.call("hi")  # prints: hi

[1, 2, 3].each(&method(:puts))    # `&` runs the Method's `to_proc`, then uses it
[1, 2, 3].each { |x| puts x }     # exactly the same thing
# both print: 1 2 3

Even your own objects work after &, as long as they define to_proc:

class Multiplier
  def initialize(by) = @by = by
  def to_proc = proc { |x| x * @by }
end

triple = Multiplier.new(3)
[1, 2, 3].map(&triple) # => [3, 6, 9]

5. The whole thing in two lines

• &X at a call means: take X, call .to_proc if it isn't already a Proc, then use it as the block.
• &blk in a parameter list does the reverse — it catches the block and hands it back as a Proc you can hold.