Являются ли блоки переданными в качестве аргументов?

Question

я могу передать аргументы функции, как это:

func 1, 2, 3 

или я могу использовать скобки, как:

func(1, 2, 3) 

Позже я узнал о функциях как list.each, которые я прохожу (не уверен, если это то, что действительно происходит) блок для работы по каждому элементу:

list.each {|x| puts x} 

Я предположил, что это просто передало блок в качестве аргумента для each функция, но это, кажется, не так, потому что:

list.each({|x| puts x}) 

не работает.

Я понял это, когда показано:

5.upto(9) {|x| puts x} 

Который не имеет смысла, если блок просто аргумент.

Что здесь происходит? Любой ресурс, на который вы можете указать мне, чтобы помочь объяснить это, и, возможно, другие структурные вещи, которые не сразу очевидны?

Answer 1

Блоки действительно немного особенные, но также могут использоваться в качестве аргументов. Рассмотрим эту функцию:

def greet 
    yield "Hello" 
end 

greet{ |greeting| puts "#{greeting} to you" } 

Вы также можете написать одно и то же, как это:

def greet(&block) 
    block.call("Hello") 
end 

greet{ |greeting| puts "#{greeting} to you" } 

# which is equivalent to: 
my_proc = proc{ |greeting| puts "#{greeting}, nice to see you." } 
greet(&my_proc) 

В конце концов, блоки представляют собой особый вид проками со специальным синтаксисом, что делает их более удобными. Но вы все равно можете получить доступ к процессам и передать их.

Answer 2

методы могут принимать ровно один блок, вроде как специальный аргумент.

def foo 
    yield 123 
end 

foo { |x| puts x } 
#=> 123 

Обратите внимание, что этот метод принимает нулевые аргументы, но все же принимает блок. Это потому, что этот синтаксис подвески блока с помощью метода - это особый случай. Любой блок, переданный методу, может быть запущен с ключевым словом yield. И вы даже можете спросить, прошел ли блок с ключевым словом block_given?.

Если вы хотите записать его в локальной переменной, вы можете сделать это с помощью специального синтаксиса.

def foo(a, &block) 
    block.call a 
end 

foo(123) { |x| puts x } 
#=> 123 

В этом случае, вы захватывая аргумент блок в явном виде, с тем & префиксом в списке аргументов. Теперь у вас есть переменная для этого блока, которую вы можете отправить сообщение call для выполнения. Просто знайте, что это должно появиться в конце списка аргументов.

Также обратите внимание на parens. foo(123) { |x| puts x }. Список аргументов останавливается, парсеры закрываются, и прикрепленный блок появляется после. Опять же, потому что это особый случай в синтаксисе.