Can you show another example, then, of how one might implement the "magic" of Dwemthy's Array (http://poignantguide.net/dwemthy/) just using modules? I can never remember how to do this sort of thing, and if modules can make it conceptually simpler it would be most useful.

class Creature

def self.metaclass ; class << self ; self ; end ; end



def self.traits ( * arr )

return @ traits if arr . empty?



attr_accessor ( * arr )



arr . each do | a |

metaclass . instance_eval do

define_method ( a ) do | val |

@ traits ||= {}

@ traits [ a ] = val

end

end

end



class_eval do

define_method ( : initialize ) do

self . class . traits . each do | k , v |

instance_variable_set ( " @ #{ k } " , v )

end

end

end

end

end



class Rabbit < Creature

traits : bombs

bombs 3

end



Rabbit . new . bombs

class Creature

def self.traits ( * arr )

return @ traits if arr . empty?



attr_accessor ( * arr )



mod = Module . new do

arr . each do | a |

define_method ( a ) do | val |

@ traits ||= {}

@ traits [ a ] = val

end

end

end



extend mod



define_method ( : initialize ) do

self . class . traits . each do | k , v |

instance_variable_set ( " @ #{ k } " , v )

end

end

end

end



class Rabbit < Creature

traits : bombs

bombs 3

end



Rabbit . new . bombs

super

Following my blog entry Underuse of Modules , an anonymous commenter asksI'm not sure exactly what magic they were referring to, but I'll assume they mean what allows creature habits to be defined in class definitions. Based on that assumption, I pulled out this code from the example.Note, I removed the comments and added the Rabbit code. The Rabbit is there to ensure the magic continues to function as expected.The version using a module isn't significantly better, but I do slightly prefer it.The above version is a bit clearer to me because it defines methods on a module and then extends the module. I know that if I extend a module from the context of a class definition the methods of that module will become class methods.Conversely, the first example forces me to think about where a method goes if I do an instance_eval on a metaclass. By definition all class methods are instance methods of the metaclass, but there are times when you can be surprised. For example, using def changes based on whether you use instance_eval or class_eval , but define_method behaves the same (change metaclass.instance_eval in the original example to metaclass.class_eval and the behavior doesn't change). This type of thing is an easy concept that becomes a hard to find bug.If you spend enough time with metaclasses it's all clear and easy enough to follow. However, modules are generally straightforward and get you the same behavior without the mental overhead. I'm sure someone will argue that metaclasses are easier to understand, which is fine. Use what works best for you.However, there are other reasons why it might make sense to use modules instead, such as wanting to have an ancestor (and thus the ability to redefine and use).Again, it probably comes down to personal preference.