Analyzing method and proc in Ruby

Ruby is simple in appearance, but is very complex inside, just like our human body. — Matz https://www.ruby-lang.org/en/about

Ruby And Python、Scala similar , Everything is an object （Seeing Everything as an Object） On the basis of , Support functional programming , This means that the function is a first-class member , It can be passed in as a parameter , It can also be returned as a function value .

however ,Ruby Functions in are not as simple as those in other dynamic languages , It provides Method And Proc Two classes to represent the concept of function , For the difference between these two classes, whether it is official documents or Stackoverflow On the problem , The explanations are very vague . In other languages, functions are often used in Ruby But it doesn't work , The reason is still unclear about the difference between these two classes , I hope this article can help you understand Ruby Medium “ function ” Concept , Make it simple , Integrate with other functional languages .

Block-oriented Programming

Ruby The most common form of code block in is neither Proc Neither Method, It is block. such as ：

#  Traverse  Range/Array  etc. 
(0..10).each do |num|
    puts num
end

#   Read the file 
File.foreach('README.md').with_index do |line, line_num|
  puts "#{line_num}: #{line}"
end
#   Traversal file 
Dir.glob('*.rb') {|ruby_src| puts "found #{ruby_src}"}

Copy

The above example demonstrates block Two literal quantities of （literal） form , Very convenient and concise . But there's one thing to note ,block just Ruby A grammar icing provided , It is not assigned to a variable . If the custom function needs to call the passed block, Need to adopt yield The way .

#  stay  Array  Class 
class Array
  def my_each
    0.upto(size) do |i|
      yield self[i]
    end
  end
end

%w(a b c).my_each do |item|
  puts item
end

Copy

Function oriented Proc

block The advantage of is simplicity , But one drawback is that it cannot be reused , Because it doesn't exist block type . But in other languages , Function names can be passed freely , Here's an example Python Example ：

def myinc(x):
    return x + 1

map(myinc, [1,2,3]) # => [2, 3, 4]
map(myinc, [4,5,6])    # => [5, 6, 7]

Copy

Ruby What corresponds to it is The process （Proc）, Equivalent to the above functions Ruby The code is ：

myinc = Proc.new {|num| num + 1}
#  Or the following two ways 
# myinc = proc {|num| num + 1}
# myinc = lambda {|num| num + 1}

[1,2,3].map(&myinc)

Copy

The key of the above code is &myinc Medium &, because map A function can be followed by block, So we need to Proc To block.

When & When the symbol appears in the function parameter list , The following parameters will be changed to Proc, And take the converted parameters as block Passed to the caller . http://stackoverflow.com/a/9429972/2163429

I have a better understanding here, you can refer to ：

& stay C In language, it is an address character ,Ruby Function parameters in can be followed by block, Because of this block Not part of the parameter , So there is no name , It is quite natural that block Understood as a memory address ,block_given? Function can check this block Whether there is .&myinc It can be understood as taking Proc Send the address of to map function .

[1,2,3].map(myinc)
#  This way of writing will report the following errors 
# in `map': wrong number of arguments (given 1, expected 0) (ArgumentError)

Copy

therefore ,Ruby Medium Proc It is equivalent to the functions of other dynamic languages , Here is another example to illustrate

def myfilter(arr, validator)
  arr.each do |item|
    if validator.call(item)
      puts item
    end
  end
end

myfilter([1,2,3,4], lambda {|num| num > 3})  #  Output  4

#  Besides ,  You can also define  myfilter  when , utilize  &  Will the last  block  To  Proc

def myfilter(arr, &validator)
  arr.each do |item|
    if validator.call(item)
      puts item
    end
  end
end

myfilter([1,2,3,4]) {|num| num > 3}
#  Output  4

Copy

proc vs. lambda

As mentioned above ,Proc There are two literal forms ：

myinc = proc {|num| num + 1}   #  And  Proc.new  Equivalent 
myinc = lambda {|num| num + 1}

Copy

These two forms of Proc There are two differences ：

proc The form does not limit the number of parameters ; and lambda The form is strict and consistent

proc Medium return Statement is valid for the caller ; and lambda It only works on itself

Object oriented Method

Ruby Use in def Defined “ function ” by Method type , Designed for object-oriented features , More generally, object-oriented is messaging , By sending different messages to an object , Objects make different responses , This is related to SICP The third chapter The content of coincides .

class Rectangle
  def initialize(width, height)
    @width = width
    @height = height
  end
  def area
    @width * @height
  end
end

rect = Rectangle.new 10, 20
#  The traditional way 
puts rect.area
#  Message delivery mode 
puts rect.send :area

Copy

because Ruby The Chinese legal name means to invoke , Therefore, it can generally be used with the same name as the method Symbol To express .

puts rect.method(:area)

#<Method: Rectangle#area>

Copy

Can pass Method Of to_proc Method can Method Turn to functionally equivalent Proc. such as ：

def myinc(num)
  num + 1
end

[1,2,3].map(&method(:myinc))  
# => [2,3,4]
#  stay  Ruby  The functions defined at the top level of the source file belong to  Object  object , So the above call is equivalent to ：
# [1,2,3].map(&Object.method(:myinc))

Copy

summary

• block by Proc Grammar icing of , For single use
• Proc Designed for functional programming , Equivalent to functions of other dynamic languages
• Method Designed for object-oriented , The first parameter of message passing

clarify Method And Proc After the difference , I have to enjoy Ruby Clever language design , Both functional and object-oriented essence . It is really a necessary weapon for programmers .

Reference resources

• https://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Method_Calls