为什么我不能从另一个模块调用实例方法来初始化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的问题是在从最后一个代码的第三复制代码。它可以用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> 

客户端2包括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 

否则你可以unconstantize拉姆达：

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 

其中一期工程（相同的输出）。不幸的是，我无法解释你为什么。很高兴阅读包含解释的答案（随意复制我的代码）。