Как ссылаться на функцию в Ruby?

Ruby не имеет функций. Он имеет только методы (которые не являются первоклассными) и ProcС первого класса, но не связаны с каким-либо объектом.

Итак, это метод:

def foo(bar) puts bar end

foo('Hello')
# Hello

О, И да, это is a реальные метод, а не функция или процедура или что-то. Методы, определенные на верхнем уровне, заканчиваются как частные (!) методы экземпляра в Object класс:

Object.private_instance_methods(false) # => [:foo]

это Proc:

foo = -> bar { puts bar }

foo.('Hello')
# Hello

обратите внимание, что Procs вызываются иначе, чем методы:

foo('Hello')  # method
foo.('Hello') # Proc

на foo.(bar) синтаксис-это просто синтаксический сахар для foo.call(bar) (который для Procs и Methods также имеет псевдоним foo[bar]). Реализации call метод на вашем объекте, а затем вызов его с помощью .() это самое близкое, что вы получите к Python в __call__ables.

обратите внимание, что важное различие между Ruby Procs и Python lambdas разве что ограничений нет: в Python лямбда может содержать только один оператор, но Ruby не есть различие между утверждениями и выражениями (все это выражение), и поэтому данное ограничение просто не существует, поэтому во многих случаях, когда вы нужно чтобы передать именованную функцию в качестве аргумента в Python, потому что вы не можете выразить логику в одном операторе, вы бы в Ruby просто передали Proc или a блок вместо этого, так что проблема уродливого синтаксиса для ссылок на методы даже не возникает.

вы можете wrap метод Method объект (который по существу duck-types Proc) путем вызова Object#method метод на объекте (который даст вам Method чей self привязан к этому конкретному объекту):

foo_bound = self.method(:foo)

foo_bound.('Hello')
# Hello

вы также можете использовать один из методов в Module#instance_method семья, чтобы получить UnboundMethod из модуля (или класса, очевидно, так как класс-это модуль), который вы можете тогда UnboundMethod#bind к определенному объекту и вызову. (Я думаю, что Python имеет те же понятия, хотя и с другой реализацией: несвязанный метод просто принимает аргумент self явно, так же, как он объявлен.)

foo_unbound = Object.instance_method(:foo) # this is an UnboundMethod

foo_unbound.('Hello')
# NoMethodError: undefined method `call' for #<UnboundMethod: Object#foo>

foo_rebound = foo_unbound.bind(self)       # this is a Method

foo_rebound.('Hello')
# Hello

обратите внимание, что вы можете только привязать UnboundMethod к объекту, который является экземпляром модуля, из которого вы взяли метод. Вы не можете использовать UnboundMethods для" трансплантации " поведения между несвязанными модули:

bar = module Foo; def bar; puts 'Bye' end; self end.instance_method(:bar)
module Foo; def bar; puts 'Hello' end end

obj = Object.new
bar.bind(obj)
# TypeError: bind argument must be an instance of Foo

obj.extend(Foo)
bar.bind(obj).()
# Bye
obj.bar
# Hello

обратите внимание, однако, что оба Method и UnboundMethod are фантики вокруг метода, не сам метод. Методы не объекты в Ruby. (Вопреки тому, что я написал в других ответах, кстати. Мне действительно нужно вернуться и исправить их.) Вы можете wrap их в объектах, но они не объекты, и вы можете видеть это, потому что вы по существу получаете все те же проблемы вы всегда получить с обертками: идентичность и состояние. Если вы позвоните method несколько раз для одного и того же метода, вы получите другой