ruby-blocks-procs-lambdas

Blocks, procs, and lambdas are all closures in Ruby, but they differ in syntax, arity checking, and return behavior. Blocks use do...end or {...}, procs created with Proc.new are lenient with arguments, and lambdas enforce strict arity and return to their enclosing method rather than the caller.

Define a method with a block parameter using yield to invoke it. When you call the method, pass a block with do...end or {...} syntax; yield executes that block within the method's context, enabling callbacks and iteration patterns.

Use lambdas when you need strict argument validation and predictable return behavior; they enforce arity and return only from the lambda itself. Use Procs for flexible callbacks where lenient argument handling and early returns to the enclosing method are acceptable.

Blocks and lambdas capture variables from their enclosing scope, creating closures that retain access to those variables even after the defining scope ends. This enables stateful callbacks, partial application, and higher-order functions.

Symbol-to-proc converts a symbol to a proc using &:method_name syntax in method calls like map(&:upcase). This creates a closure that applies the method to each element, reducing boilerplate when passing simple method calls as blocks.

Yes, both lambdas and Procs support currying through the curry method, which returns a proc that accumulates arguments and fires when arity is satisfied. Partial application locks in some arguments, creating specialized functions for reuse.