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

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

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

def foo(bar) puts bar end

foo('Hello')
# Hello

О, И, да, это реальныйметод, а не функция верхнего уровня или процедура или что-то еще. Методы, определенные на верхнем уровне, заканчиваются как частные (!) методы экземпляра в классе 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__.

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

Вы можете оберните метод в объект Method (который по сути является утиным типом 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 являются оболочками вокруг метода, не сам метод. Методы не объекты в Рубине. (Вопреки тому, что я написал в других ответах, кстати. Мне действительно нужно вернуться и ПОЧИНИТЬ ИХ.) Вы можете обернуть их в объекты, но они не являются объектами, и вы можете видеть, что, поскольку вы по существу получаете все те же проблемы, которые вы всегда получаете с оболочками: идентичность и состояние. Если вы вызываете method несколько раз для одного и того же метода, вы каждый раз будете получать другой объект Method. Если вы пытаетесь сохранить некоторое состояние на этом объекте Method (например Строки в стиле Python __doc__, например), это состояние будет закрыто для этого конкретного экземпляра, и если вы попытаетесь снова получить свою строку docstring через method, вы обнаружите, что она исчезла.

В прошлом было несколько предложений использовать оператор разрешения области видимости Ruby :: для доступа к связанным Methodобъектам, подобным этому:

bound_method = obj::foo

Который должен быть идентичен

bound_method = obj.method(:foo)

Проблема заключается в том, что в настоящее время, используя оператор разрешения области для вызова методов фактически поддерживается:

obj.bar
obj::bar
# Hello

И что еще хуже, это фактически используется, так что это было бы обратно несовместимое изменение.