The Tower of Hanoi is a classic algorithmic problem that can be solved using recursive techniques. We can apply the concepts of procs and lambdas to implement a solution for the Tower of Hanoi problem in Ruby. Here's an example:

def tower_of_hanoi(n, source, destination, auxiliary, move_callback)
  if n == 1
    move_callback.call(source, destination)
  else
    tower_of_hanoi(n-1, source, auxiliary, destination, move_callback)
    move_callback.call(source, destination)
    tower_of_hanoi(n-1, auxiliary, destination, source, move_callback)
  end
end

move_proc = lambda { |source, destination| puts "Move disk from #{source} to #{destination}" }

tower_of_hanoi(3, 'A', 'C', 'B', move_proc)

In this implementation, the tower_of_hanoi method takes the number of disks (n), names of the source (source), destination (destination), and auxiliary (auxiliary) towers, as well as a move_callback proc as arguments.

The tower_of_hanoi method follows the recursive algorithm for solving the Tower of Hanoi problem. If n is 1, it simply calls the move callback to move the disk from the source to the destination tower. Otherwise, it recursively solves the problem for n-1 disks by moving them from the source tower to the auxiliary tower, then moves the largest disk from the source to the destination, and finally solves the problem for n-1 disks by moving them from the auxiliary tower to the destination tower.

We define a move_proc lambda that prints the move operations. You can pass any other proc or lambda with a different behavior to customize how the moves are handled.

Finally, we call the tower_of_hanoi method with n = 3, source tower 'A', destination tower 'C', auxiliary tower 'B', and the move_proc lambda as the move callback.

When you run this code, it will print the sequence of moves required to solve the Tower of Hanoi problem with 3 disks. You can adjust the value of n and the tower names to solve the problem for different numbers of disks or with different tower names.