From: "matz (Yukihiro Matsumoto)" <matz@...>
Date: 2012-12-06T01:38:41+09:00
Subject: [ruby-core:50585] [ruby-trunk - Feature #7519][Rejected] Module Single Inheritance


Issue #7519 has been updated by matz (Yukihiro Matsumoto).

Status changed from Open to Rejected

I think providing new inheritance system for modules is overkill for allowing module method inheritance.
It would make the role of modules in the language unclear.

If I were you, I'd make a proposal like another version of #include, or adding optional (keyword) argument to #include.

Matz.

----------------------------------------
Feature #7519: Module Single Inheritance
https://bugs.ruby-lang.org/issues/7519#change-34427

Author: trans (Thomas Sawyer)
Status: Rejected
Priority: Normal
Assignee: 
Category: core
Target version: Next Major


A limitation of modules is that they can not gain and augment the qualities of another module in the same manner that a class can of another class. They can use #include, but using #include to carry the behavior of one module into another is limited in that singleton methods are not available to it and also because of the well known Module Include Problem. So it occurs to me that modules could have their own inheritance chain.

For example:

  module M
    def self.foo
      "foo"
    end
    def bar
      "bar"
    end
  end

  module N < M
    def bar
      super + "!"
    end
  end

  N.foo #=> "foo"

  class C
    include N
  end

  C.new.bar  #=> "bar!"

I think it easy to think about in terms of classes being types of "nouns", and modules being types of "adjectives". So just as one "noun" can inherit the behavior of another "noun", so could one "adjective" inherit the behavior of another "adjective".



-- 
http://bugs.ruby-lang.org/