I recently discovered a feature of Ruby that surprised me. Really, I was surprised that I hadn't heard of it before (for as long as I have been a fan of the language).
module_function
can be used to make one or more Module methods accessible as type-scoped methods (in the same way that declaring them as self
methods would). For example:
In this form, the methods of the module must be declared before the line containing module_function
. You can pass one or more method names (as symbols) in the call. In fact, you can even re-write this as follows:
This form makes all methods declared after module_function
behave as type-scoped functions (callable in the form of: Foo.bar
or Foo::bar
). You can "turn-off" the behavior of what is given type-scoped calling access by declaring a visibility modifier after the last method you want to expose in this way.
Now the Foo functions can be called either as type-scoped functions or Foo can be included in a class or added to an object.
One thing you now can't do, though, is refer to the module_function
scoped methods as instance methods of classes or objects into which the Foo
module is included. IOW, trying to call: Something.new.foo
in the above sample code blows up with a warning about trying to access a 'private' scoped variable.
1 comment:
I got surprised by module_function recently too. Embarrassingly, it was then apprentice Ethan Gunderson who mentioned it to me while we were doing some refactoring. Great little method. :)
Post a Comment