How to Use Hashes to Store methods in Ruby?

Question

I was wondering if anyone could explain to me why I can't use my Hash($player_x_command_list) to access my player_x_move(position) method? What's the correct way of doing this?

What I am trying to do is, create a Hash that lets the user enter input and it reflecting back to my methods in my class.

I have tried various ways of altering so that the code could work correctly but nothing works.

I'm getting the error:

undefined method `player_x_move' for Game:Class (NoMethodError)

Does that mean hashes can't store methods?

Here's my code:

#Tic Tac Toe Game
#The format is the below: where index 0 represents top left and index 8 represents bottom right
#goes 0,1,2
#     3,4,5
#     6,7,8
#"e" is for empty. "x" is for Player X moves and "o" is for Player O moves



class Game
  @@player_x_win_count = 0
  @@player_o_win_count = 0

  def initialize
    @board = Array.new(9, "e")
    @move_number = 0
  end

  def get_names
  puts "Hi Welcome to my Tic Tac Toe Game. The board looks like this:

  |TL|TM|TR|
  |ML|MM|MR|
  |BL|BM|BR|

  Each position of the Tic Tac Toe board is represented by two letters. To \"X\" or \"O\" a position, just input the two letters in CAPS like \"MM\"


  The command list is as follows:
  TL = top left
  TM = top mid
  TR = top right
  ML = mid left
  MM = mid mid
  MR = mid right
  BL = bottom left
  BM = bottom mid
  BR = bottom right
  board = to view the board
  new game = to clean the board and create a new game (note that this command should only be used when you don't want to continue on the current game. The game automatically creates a new game if a winner, loser, or draw is declared)
   "
    puts "Please Enter PlayerX's name. He/she will be using X's to mark the board."
    @player_x = gets.chomp

    puts "Please Enter PlayerO's name. He/she will be using O's to mark the board."
    @player_o = gets.chomp

    self.new_round
  end

$player_x_command_list = {"TL" => self.player_x_move(0), "TM" => self.player_x_move(1), "TR" => self.player_x_move(2), "ML" => self.player_x_move(3), "MM" => self.player_x_move(4), 
    "MR" => self.player_x_move(5), "BL" => self.player_x_move(6), "BM" => self.player_x_move(7), "BR" => self.player_x_move(8), "board" => self.board, "new game" => self.clean_board, 
    "win count" => self.win_count}

$player_o_command_list = {"TL" => self.player_o_move(0), "TM" => self.player_o_move(1), "TR" => self.player_o_move(2), "ML" => self.player_o_move(3), "MM" => self.player_o_move(4), 
    "MR" => self.player_o_move(5), "BL" => self.player_o_move(6), "BM" => self.player_o_move(7), "BR" => self.player_o_move(8), "board" => self.board, "new game" => self.clean_board, 
    "win count" => self.win_count}


  def enter_command_player_x
    puts "Please input your command, #{@player_x} aka PlayerX"
    command = gets.chomp
    $player_x_command_list[command]
  end

  def enter_command_player_o
    puts "Please input your command, #{@player_o} aka PlayerY. Type \"help\" to see a full list of commands"
    command = gets.chomp
    $player_o_command_list[command]
  end


  def new_round
    puts "So who wants to go first this round"
    went_first_this_round = gets.chomp
    if went_first_this_round == @player_x
      self.enter_command_player_x
    elsif went_first_this_round == @player_o
      self.enter_command_player_o
    else
      puts "Not a valid name. Please enter one of the player's names"
    end
  end

  def board
    print "|#{@board[0]}|#{@board[1]}|#{@board[2]}|\n|#{@board[3]}|#{@board[4]}|#{@board[5]}|\n|#{@board[6]}|#{@board[7]}|#{@board[8]}|"
  end

  def player_x_move(position)
    if @board[position] == "x" || @board[position] == "o"  
      return "That move was invalid as someone has already moved there. Please enter a valid move"
    end
    @board[position] = "x"
    @move_number += 1
    puts "That was move number #{@move_number} and the current board looks like: " 
    self.board
    self.check_game
    puts "Now it is #{player_o}'s turn. #{player_o} please input your next command."
    self.enter_command_player_o
  end

  def player_o_move(position)
    if @board[position] == "x" || @board[position] == "o"     
      return "That move was invalid as someone has already moved there. Please enter a valid move"
    end
    @board[position] = "o"
    @move_number += 1
    puts "That was move number #{@move_number} and the current board looks like: "
    self.board
    self.check_game
    puts "Now it is #{player_x}'s turn. #{player_x} please input your next command"
    self.enter_command_player_x
  end

  def check_game
    triple_x = "xxx"
    triple_o = "ooo"
    if @move_number == 9
      @move_number = 0
      self.clean_board
      return "The board is completely filled up. Looks like this is a draw. This is Game Over. Make a new game by setting any variable = to new.Game and using that variable to play"
    elsif @board[0] + @board[1] + @board[2] == triple_x
      @@player_x_win_count += 1
      @move_number = 0
      self.clean_board
      return "Player X Wins"
    elsif @board[3] + @board[4] + @board[5] == triple_x
      @@player_x_win_count += 1
      @move_number = 0
      self.clean_board
      return "Player X Wins"
    elsif @board[6] + @board[7] + @board[8] == triple_x
      @@player_x_win_count += 1
      @move_number = 0
      self.clean_board
      return "Player X Wins"
    elsif @board[0] + @board[3] + @board[6] == triple_x
      @@player_x_win_count += 1
      @move_number = 0
      self.clean_board
      return "Player X Wins"
    elsif @board[1] + @board[4] + @board[7] == triple_x
      @@player_x_win_count += 1
      @move_number = 0
      self.clean_board
      return "Player X Wins"
    elsif @board[2] + @board[5] + @board[8] == triple_x
      @@player_x_win_count += 1
      @move_number = 0
      self.clean_board
      return "Player X Wins"
    elsif @board[0] + @board[4] + @board[8] == triple_x
      @@player_x_win_count += 1
      @move_number = 0
      self.clean_board
      return "Player X Wins"
    elsif @board[2] + @board[4] + @board[6] == triple_x
      @@player_x_win_count += 1
      @move_number = 0
      self.clean_board
      return "Player X Wins"
    #now check if Player O Wins
    elsif @board[0] + @board[1] + @board[2] == triple_o
      @@player_y_win_count += 1
      @move_number = 0
      self.clean_board
      return "Player O Wins"
    elsif @board[3] + @board[4] + @board[5] == triple_o
      @@player_y_win_count += 1
      @move_number = 0
      self.clean_board
      return "Player O Wins"   
    elsif @board[6] + @board[7] + @board[8] == triple_o
      @@player_y_win_count += 1
      @move_number = 0
      self.clean_board
      return "Player O Wins"   
    elsif @board[0] + @board[3] + @board[6] == triple_o
      @@player_y_win_count += 1
      @move_number = 0
      self.clean_board
      return "Player O Wins"    
    elsif @board[1] + @board[4] + @board[7] == triple_o
      @@player_y_win_count += 1
      @move_number = 0
      self.clean_board
      return "Player O Wins"   
    elsif @board[2] + @board[5] + @board[8] == triple_o
      @@player_y_win_count += 1
      @move_number = 0
      self.clean_board
      return "Player O Wins"  
    elsif @board[0] + @board[4] + @board[8] == triple_o
      @@player_y_win_count += 1
      @move_number = 0
      self.clean_board
      return "Player O Wins" 
    elsif @board[2] + @board[4] + @board[6] == triple_o
      @@player_y_win_count += 1
      @move_number = 0
      self.clean_board
      return "Player O Wins"   
    else
      return "no one has WON YET! Continue your GAME!!"
    end
  end

  def clean_board
    @board = Array.new(9, "e")
  end

  def win_count
    puts "So far Player X has won #{@@player_x_win_count} times and Player O has won #{@@player_o_win_count} times."
  end

end

a = Game.new
a.get_names

Answer 1

You have a few things wrong here:

1. Your scope is wrong. When defining the hash, self is the class, not the instance of the class that you want to operate on.
2. When you create the hash, the value of the hash is going to be return value of the player_x_move etc method at the time it was defined.

You can simplify this a lot by using case.

def enter_command
  puts "Please input your command, #{@player_x} aka PlayerX"
  command = gets.chomp
  case command
  when "TL"
    player_x_move(0)
  when "TM"
    player_x_move(1)
  # etc
  else
    puts "#{command} is not a valid command."
  end
end

You can also simplify your code further by creating methods that accept parameters like enter_command, player_move, and then passing the player to operate on to them. This prevents you from having to duplicate each of your methods for each player.

Something else you could consider is just looking up the index of the move based on the command given:

COMMAND_POSITIONS = %w(TL TM TR ML MM MR BL BM BR)
def enter_command(player)
  puts "Please input your command, #{player}"
  command = gets.chomp
  case command
  when *COMMAND_POSITIONS
    player_move player, COMMAND_POSITIONS.index(command)
  when "board"
    board
  when "new game"
    clean_board
  when "win count"
    win_count
  else
    puts "#{command}" is not a valid command
  end
end

Answer 2

Hashes can not store methods. Methods aren't objects, but can be converted to Procs. Method definitions return nil^{changed since this writing}. However, you can store a Proc or a lambda. You can also store the return (evaluation) of a method.

Here is an example of how you can store a Proc to a Hash that was derived from a method.

>> def hello(name)
>>   "Hello #{name}!"
>> end
=> nil
>> my_stored_methods = {:hello => method(:hello).to_proc} 
=> {:hello=>#<Proc:0x816f604 (lambda)>}
>> my_stored_methods[:hello].call("World")
=> "Hello World!"

Do not let the stroop effect of me calling the hash "my_stored_methods" lead you to believe that there is actually a real method stored there. It is lambda (a specialized Proc) stored in the hash, and used as appropriate. Indeed, had I not used .to_proc there, it would hold a Method instance.

Also, this solution does not grow with the development of the open method, if the method were to change, the Proc stored in the hash would continue to work as the method did at the point when the method was stored as a Proc.

As @AndrewMarshall reminds me, I could have left it as a Method instance. This still will not "store" the method itself, as when the method changes, the result will still be the historical behavior of the source method as it was when stored. It also provides for a stronger "Stroop effect" in that you may mistakenly think that an actual method is stored there. It simply is not.

---