Qual é o propósito de terMethod#unbind eUnboundMethod#bind?

Pelo que entendi, os métodos são objetos que podem ser chamados, como procs e lambdas, exceto que os métodos estão vinculados ao escopo de seu receptor:

class SomeClass
  def a_method; puts "from SomeClass"; end
end

s = SomeClass.new
s.a_method # => "from SomeClass"

eu posso ligara_method se eu estiver dentro do contexto deSomeClass ou se eu tiver um objeto deSomeClass. Eu posso torná-lo um objeto que pode ser chamado, extraindo o método como umMethod objeto, mas ainda está vinculado a um objeto de classeSomeClass neste exemplo:

m = s.method :a_method
m.class # => Method
m.owner # => SomeClass
m.call # => "from SomeClass"

Por que eu iria quererunbind um método do seu receptor? Talvez eu possa passar isso por aí oubind para um objeto diferente, dando-lhe um novo contexto, talvez eu possa ter um objeto completamente diferente para chamar esse método sem herança, mas não posso fazer nada com ele, a menos que o vincule a um objeto de sua classe original ou o converta em umProc objeto (realmente um lambda, já que métodos e lambdas são um pouco semelhantes):

# Module#instance_method gives me an UnboundMethod
ub = SomeClass.instance_method :a_method
ub.class # -> UnboundMethod

# now I can't make any calls 
ub.call # -> NoMethod Error, undefined method 'call'

class AnotherClass; end
a = AnotherClass.new
b = ub.bind(a) # -> TypeError: bind argument must be an instance of SomeClass
b = ub.bind(SomeClass.new).call # -> "from SomeClass"

Eu poderia converter o objeto de método em um proc e talvez fazer algo com ele:

AnotherClass.class_eval do
  # I can access m becausec this block is evaluated in the same 
  # scope it's defined, so I can grab m ;)
  define_method(:method_from_some_class, m.to_proc)
end

AnotherClass.instance_methods(false) # -> [:method_from_some_class]
a.method_from_some_class # -> "from SomeClass"

Qual é o propósito de fazer isso? Quais são as aplicações do mundo real para algo assim?