Study of Procs Best Used With the Seeing is Believing Gem

procs_study.rb

# Procs are just closures:
def my_method_1
  counter = 0            # => 0
  proc { counter += 1 }  # => #<Proc:0x007fadc9244ec8@/Users/durrellchamorro/code/scratch.rb:4>
end                      # => :my_method_1

my_proc = my_method_1  # => #<Proc:0x007fadc9244ec8@/Users/durrellchamorro/code/scratch.rb:4>

my_proc.call  # => 1
my_proc.call  # => 2
my_proc.call  # => 3
# counter       # ~> NameError: undefined local variable or method `counter' for main:Object

# Procs don't enforce arity, but lambdas do:

# my_lambda = lambda { |n, k| n + k }  # => #<Proc:0x007fadc92443b0@/Users/durrellchamorro/code/scratch.rb:15 (lambda)>

# my_lambda.call(1, 1, 3) # ~> ArgumentError: wrong number of arguments (given 3, expected 2)
# my_lambda.call(2, 2, 3) # ~> ArgumentError: wrong number of arguments (given 3, expected 2)

my_proc = proc { |n, k| n + k }  # => #<Proc:0x007fadc92441a8@/Users/durrellchamorro/code/scratch.rb:20>
my_proc.call(1, 1, 3, 4, 5, 6)   # => 2

# Practical examples:

# csv_string = File.read("path/to/file.csv")
#
# CSV.parse(
#   csv_string,
#   headers: true,
#   header_converters: lambda { |f| f.strip },
#   converters: lambda { |f| f ? f.strip : nil }
# ) do |row|
#   # do something with the row
# end

# Different ways to *call methods in ruby:
1.to_s         # => "1"
1.send(:to_s)  # => "1"

"123".gsub('1', '0')         # => "023"
"123".send(:gsub, '1', '0')  # => "023"

# *Technically you send methods(messages) to objects and you call procs/blocks.
# def foo!(array, index, &block)
#   block.call array, index
# end
# my_proc.call(1)

# Instead of:
[1].map { |n| n.to_s }  # => ["1"]
# you can use this syntactic sugar:
[1].map(&:to_s)         # => ["1"]

[1].map { |obj, *args| obj.send(:to_s, *args) }  # => ["1"]

# The Symbol class defines #to_proc like so:

# class Symbol
#   def to_proc
#     Proc.new { |obj, *args| obj.send(self, *args) }
#   end
# end

# This works because in the context of a method call, putting an ampersand in front of the last argument
# tells Ruby to convert whatever is immediately to the right of the ampersand
# to a proc if it isn't a proc already and then use that proc as the method’s block.
# *Technically speaking, Ruby does not consider the ampersand followed by a proc (or in this case a symbol being
# converted to a proc) to be an argument for the method. If it did, then I would get a wrong number of arguments (1 for 0)
# error since #map doesn't take any arguments. 

a_proc = :to_s.to_proc  # => #<Proc:0x007fadc923e0c8(&:to_s)>

# since a_proc is already a proc, the & doesn't need to call #to_proc on it.
# Instead it will just make sure the proc is used as the method's block:
[1].map(&a_proc)  # => ["1"]

# Write your own methods that yield to blocks/procs
def foo!(array, index)
  yield array, index    # => 1, 1
end                     # => :foo!

my_array = [1, 2]  # => [1, 2]

# Instead of using a proc as the method's block we use a plain old block:
foo!(my_array, 0) { |obj, index| obj.delete_at(index) }  # => 1

my_array  # => [2]

# Example of  a custom method yielding to a proc/block (the & must be in the last argument!):
my_array = [1, 2]  # => [1, 2]

foo!(my_array, 0, &:delete_at)  # => 1

# The proc created above by the Symbol class:
# Proc.new { |my_array, index| my_array.send(:delete_at, index) }

# Under the hood the proc above is being used as #foo!'s block like this:
# foo!(my_array, 0) { |my_array, index| my_array.send(:delete_at, index) }  # => 1
my_array  # => [2]

# Using procs to Dry Up Ruby Code (More practical example in my Blog):

def generic_method(array_of_anything, some_proc)
  array_of_anything.each(&some_proc)                      # => ["string is an animal", "cat is an animal", "dog is an animal"]
  array_of_anything[0..1].each { |object| yield object }  # => ["string is not an animal", "cat is an animal"]
end                                                       # => :generic_method

user_input_1 = ["string", "cat", "dog"]  # => ["string", "cat", "dog"]
user_input_2 = [1, 2, 3]                 # => [1, 2, 3]

add_string = proc { |string| string << " is an animal" }  # => #<Proc:0x007fadc92365a8@/Users/durrellchamorro/code/scratch.rb:112>

generic_method(user_input_1, add_string) do |string|
  string.gsub!("is", "is not") if string[0..5] == "string"  # => "string is not an animal", nil
end                                                         # => ["string is not an animal", "cat is an animal"]

user_input_1  # => ["string is not an animal", "cat is an animal", "dog is an animal"]