the def each(&block) method

I think I solved my own question. What happens is that the class Game has Enumerable and by defining each to take a block and run players.each(&block) is that the instance or (object) game1 = Game.new can have any of the methods ie. any? or find run on the block defined in the def each(&block) method. So for example game1.any?{|player| player.score > 80} what happens is that the method def each(&block) in the Game class runs on the block {|player| player.score > 80} in other words def each({|player| player.score > 80}, players.each{|player| player.score > 80}, end and the any? method from Enumerables can then be used. Example to that shed more light on this came from http://awaxman11.github.io/blog/2013/08/05/what-is-the-difference-between-a-block/ [1] pry(main)> p = Proc.new {|x| puts x * 2} => #<Proc:0xb03fe34@(pry):1> [2] pry(main)> [1, 2, 3].each(&p) 2 4 6 => [1, 2, 3]

So this is a example of passing in a block into a method:

def run_block(&block)
    yield block  # Call the block
end

run_block { puts "Hello!" }

Hope that explains it!

Thank you Alexander. Unfortunately that does not explain what I enquiring about. The method I am discussing comes from the programme enumerable.rb and as you can see in the code below the method def each(&block) is not using a yield or block.call and that is what I am trying to understand.

class Player
  include Comparable
  attr_accessor :name, :score

  def <=>(other_player)
    score <=> other_player.score
  end

  def initialize(name, score)
    @name, @score = name, score
  end
end

class Game
  include Enumerable

  attr_accessor :players

  def each(&block)                      
    players.each(&block)       
  end

  def initialize
    @players = []
  end

  def add_player(player)
    players.push(player)
  end

  def score
    score = 0
    players.each do |player|
      score += player.score
    end
    score
  end

        def name
                players.each do |player|
                        players[] << player.name
                end
                players
        end
end

player1 = Player.new("Jason", 100)
player2 = Player.new("Kenneth", 80)
player3 = Player.new("Nick", 95)
player4 = Player.new("Craig", 20)

game1 = Game.new
game1.add_player(player1)
game1.add_player(player2)

game2 = Game.new
game2.add_player(player3)
game2.add_player(player4)

puts game1.inspect

puts game1.any?{|player| player.name == "Nick"}
puts game1.any?{|player| player.name == "Jason"}
puts game1.any?{|player| player.score > 80}

players = game1.find{|player| player.score > 80}
puts "Players with a score > 80", players.inspect

[MOD: edited code block. sh]

Sure. I was specifically refering to this method.

def each(&block)                      
    players.each(&block)       
  end

[MOD: edited code block. sh]

I understand it in that context but the &block is a proc and how is it being called. You normally need to run call method on proc to get a return on the proc object.

Should I understand that &block remains a block and not a proc?

I checked and the &block returns Proc

def each(&block)
    players.each(&block)
    puts block.class   # returns Proc
end

[MOD: edited code block. sh]

Yes. This is something I am trying to understand as I have studied blocks, lambda and procs but I don't know if the enumerable class methods are able to implicitly call methods on procs. I hope somebody can shed light on this.