Proc

A Proc represents a function pointer with an optional context (the closure data). It is typically created with a proc literal:

  1. # A proc without parameters
  2. ->{ 1 } # Proc(Int32)
  4. # A proc with one parameter
  5. ->(x : Int32) { x.to_s } # Proc(Int32, String)
  7. # A proc with two parameters
  8. ->(x : Int32, y : Int32) { x + y } # Proc(Int32, Int32, Int32)

The types of the parameters are mandatory, except when directly sending a proc literal to a lib fun in C bindings.

The return type is inferred from the proc’s body, but can also be provided explicitly:

  1. # A proc returning an Int32 or String
  2. -> : Int32 | String { 1 } # Proc(Int32 | String)
  4. # A proc with one parameter and returning Nil
  5. ->(x : Array(String)) : Nil { x.delete("foo") } # Proc(Array(String), Nil)
  7. # The return type must match the proc's body
  8. ->(x : Int32) : Bool { x.to_s } # Error: expected Proc to return Bool, not String

A new method is provided too, which creates a Proc from a captured block. This form is mainly useful with aliases:

  1. Proc(Int32, String).new { |x| x.to_s } # Proc(Int32, String)
  3. alias Foo = Int32 -> String
  4. Foo.new { |x| x.to_s } # same proc as above

The Proc type

To denote a Proc type you can write:

  1. # A Proc accepting a single Int32 argument and returning a String
  2. Proc(Int32, String)
  4. # A proc accepting no arguments and returning Nil
  5. Proc(Nil)
  7. # A proc accepting two arguments (one Int32 and one String) and returning a Char
  8. Proc(Int32, String, Char)

In type restrictions, generic type arguments and other places where a type is expected, you can use a shorter syntax, as explained in the type:

  1. # An array of Proc(Int32, String, Char)
  2. Array(Int32, String -> Char)

Invoking

To invoke a Proc, you invoke the call method on it. The number of arguments must match the proc’s type:

  1. proc = ->(x : Int32, y : Int32) { x + y }
  2. proc.call(1, 2) # => 3

From methods

A Proc can be created from an existing method:

  1. def one
  2.   1
  3. end
  5. proc = ->one
  6. proc.call # => 1

If the method has parameters, you must specify their types:

  1. def plus_one(x)
  2.   x + 1
  3. end
  5. proc = ->plus_one(Int32)
  6. proc.call(41) # => 42

A proc can optionally specify a receiver:

  1. str = "hello"
  2. proc = ->str.count(Char)
  3. proc.call('e') # => 1
  4. proc.call('l') # => 2