# mruby-proc-ext

This mrbgem extends the functionality of the `Proc` class in mruby, providing additional methods for common operations and introspection.

## Features

This gem adds the following methods to the `Proc` class:

- **`===`**: Alias for `Proc#call`. Allows procs to be used in `case` statements.

  ```ruby
  upcase_proc = ->(s) { s.upcase }
  case "hello"
  when upcase_proc
    # this won't match directly, but demonstrates usage if proc returned boolean
  end
  # More practically:
  is_even = ->(n) { n % 2 == 0 }
  puts "4 is even" if is_even === 4 # => true
  ```

- **`yield`**: Alias for `Proc#call`.

  ```ruby
  add_one = ->(x) { x + 1 }
  puts add_one.yield(5) # => 6
  ```

- **`to_proc`**: Returns `self`. Useful for methods expecting a proc.

  ```ruby
  p = Proc.new { |x| x * 2 }
  [1, 2, 3].map(&p.to_proc) # => [2, 4, 6]
  ```

- **`curry(arity=self.arity)`**: Returns a curried proc.

  ```ruby
  adder = ->(a, b, c) { a + b + c }
  curried_adder = adder.curry
  add5 = curried_adder.call(2, 3)
  puts add5.call(4) # => 9

  mul = ->(x,y) { x * y }
  mul_by_5 = mul.curry.call(5)
  puts mul_by_5.call(3) # => 15
  ```

- **`<< (composition)`**: Returns a new proc that represents the composition of two procs (g << f is g(f(x))).

  ```ruby
  add_one = ->(x) { x + 1 }
  double_it = ->(x) { x * 2 }
  composed_proc = double_it << add_one # double_it(add_one(x))
  puts composed_proc.call(5) # => double_it(6) => 12
  ```

- **`>> (composition)`**: Returns a new proc that represents the composition of two procs (f >> g is g(f(x))).

  ```ruby
  add_one = ->(x) { x + 1 }
  double_it = ->(x) { x * 2 }
  composed_proc = add_one >> double_it # double_it(add_one(x))
  puts composed_proc.call(5) # => double_it(6) => 12
  ```

- **`lambda?`**: Returns `true` if the proc is a lambda, `false` otherwise.

  ```ruby
  my_lambda = -> {}
  my_proc = Proc.new {}
  puts my_lambda.lambda? # => true
  puts my_proc.lambda?  # => false
  ```

- **`source_location`**: Returns an array containing the source filename and line number where the proc was defined, or `nil` if this information is not available.

  ```ruby
  # Assuming this code is in "test.rb" at line 5
  my_proc = Proc.new {}
  p my_proc.source_location # => ["test.rb", 5] (if debug info enabled)
  ```

- **`inspect`**: Returns a string containing a human-readable representation of the proc, including its source location (if available) and whether it's a lambda.

  ```ruby
  my_lambda = ->(x) { x * 2 }
  # Might output: #<Proc:0x... test.rb:1 (lambda)>
  puts my_lambda.inspect
  ```

- **`parameters`**: Returns an array of arrays, describing the parameters accepted by the proc. Each inner array contains the parameter type (`:req`, `:opt`, `:rest`, `:key`, `:keyrest`, `:block`) and its name.

  ```ruby
  prc = ->(a, b=20, *rest, keyparam:, &blk) { }
  p prc.parameters
  # => [[:req, :a], [:opt, :b], [:rest, :rest], [:keyreq, :keyparam], [:block, :blk]]
  ```

This gem also adds:

- **`Kernel#proc`**: Creates a new proc from a block. This is similar to `Proc.new` but ensures the created proc is not a lambda.

  ```ruby
  p1 = proc { |a| a }
  puts p1.lambda? # => false
  ```
