Every Ruby method can implicitly accept ONE block; you do not declare it in the parameter list. Inside the method body, yield value calls the block with value; block_given? lets you behave differently when the caller did not pass one. Returning enum_for(:method_name, ...) when there is no block is the canonical pattern: it lets callers either consume the iterator inline OR get back an Enumerator they can chain with .lazy.map.first(...). This is exactly how built-in methods like Array#map behave.

Capturing the block with &block materialises it as a Proc you can store, pass to another method, or call later. The reverse direction, m(&proc_obj), passes a proc back AS the block. The &:method form is the special case for symbols: Ruby calls Symbol#to_proc to produce a one-arg proc that sends the named method. Use this whenever the block body is { |x| x.method }. Capturing with &block is slightly slower than yield because it allocates the proc; reach for yield when you do not need to forward the block.

Procs and lambdas are both Proc instances but behave differently in two important ways. First, lambdas check argument arity strictly and raise ArgumentError on mismatch, while procs silently fill missing args with nil and drop extras. Second, return inside a proc returns from the enclosing method (because procs are 'inline' continuations of the caller), while return inside a lambda only exits the lambda. Default to lambdas for anything that gets stored or passed around as a value; reach for procs only when you specifically want the looser arity or the return-from-method behaviour. Blocks are arity-lenient like procs but cannot be reified without &.