为什么我不能从另一个模块调用实例方法来初始化 ruby​​ 中的 lambda？

Question

我正在尝试重构现有代码以简化。 最初我是在调用模块方法，就像 java 中的静态实用程序方法一样。

这是新代码：

module Module1
  def mod1() 1; end
end

module Module2
  include Module1
  def mod2
    puts mod1()
    puts 2
  end
  Constant = lambda { mod1() }  # This line fails
end

class Sample
  include Module2
  def go
    mod2
    Constant.call  #  <module:Module2>': undefined method `mod1' for Module2:Module (NoMethodError)
  end
end

Sample.new.go

如果简单地将Module1的代码复制到Module2我就可以使它工作。 有更好的解决方案吗？

编辑：此外，我应该能够从直接包含它的类中调用Module1方法。 例如：

class Sample2
  include Module1
  def go
    puts mod1()
  end
end
Sample2.new.go

实际模块1：

module HtmlUtils
  def wrap(tag = :span, class_names, text)
    %(<#{ tag } class="#{ class_names }">#{ text }</#{ tag }>)
  end
end

实际模块 2问题是从最后一个代码开始的第 3 个中的重复代码。 它可以由 HtmlUtils#wrap 方法替换。

module Markdown
  include HtmlUtils
  BOLD = {
    regexp: /(_{2}|\*{2})(.*?)\1/,
    lambda: ->(token, regexp) { "<b>#{ token[regexp, 2] }</b>" }
  }
  NUMBER = {               
    regexp: /(?<=\s|\()[+-]?(?:[1-9]\d*|0)(?:\.\d+)?(?!-|\.|\d|,\d)/,
    lambda: ->(token, regexp) { %(<span class="num">#{ token }</span>) }  # Redundant Code
  }
end

Client1 包括 Markdown，实际上是 HtmlUtils。

@parser.regexter('bold', BOLD[:regexp], BOLD[:lambda]);
@parser.regexter('numbers', NUMBER[:regexp], NUMBER[:lambda])
puts @parser.parse('some **string** 1')  # => some <b>string</b> <span class="num">1</span>

Client2 包括 HtmlUtils

@parser.regexter('quote', /(?<=)((["']).*?\2)/, ->(token, regexp) { wrap(:quote, token));
puts @parser.parse('s="Hello"')  # => s=<span class="quote">"Hello"</span>

Answer 1

注意尝试回答原始问题（在发布实际代码之前）。

这要看情况。 如果模块自己提供他们需要的一切，你可以让mod1成为一个模块函数并显式调用它（然后不需要包含模块）。 但我担心您实际上需要上下文。

module Module1
  def self.mod1() 1; end
end

module Module2
  def mod2
    puts Module1.mod1()
    puts 2
  end
  Constant = lambda { puts Module1.mod1() }  
end

class Sample
  include Module2
  def go
    mod2
    Constant.call  
  end
end

Sample.new.go

产出

#=>
1
2
1

否则，您可以对 lambda 进行常量化：

module Module1
  def mod1() inmod2 ; end
end

module Module2
  include Module1

  def inmod2
    1
  end

  def mod2
    puts mod1()
    puts 2
  end
  def constant
    lambda { puts self.mod1() }
  end
end

class Sample
  include Module2
  def go
    mod2
    constant.call
  end
end

Sample.new.go

哪个有效（相同的输出）。 不幸的是，我无法向您解释原因。 很高兴阅读包含解释的答案（请随意复制我的代码）。