Refinements in Ruby — Monkey patching for friendly monkeys
timeless.judofyr.net
timeless.judofyr.net
In scala, you could write an "implicit function" that converts Foos to Bars. If and only if you imported the function, you could then (1) pass an instance of Foo to a function accepting Bars and (2) call methods of Bar on a Foo.
For example, if you defined an implicit mapping from Int to IntWithTimeMethods, you could then call something like 1.seconds_from_now, and get a Time back. You can see something like this at work in https://github.com/robey/xrayspecs/blob/master/src/main/scal...
In scala, it's not required that the class you convert to is a subclass of the original, but it's a really common use case. This "refine" behavior gives you this same ability, but just with an anonymous subclass.
FWIW, I like Scala's implicit conversions. Usually, I see them with things like 1.seconds, or object.toJson, and then you just look among the imports for something referencing time or json. I guess people could think up absurd uses, but then, those people were writing bad code anyways.
As with the .append_features hack, I think it is only good that refinement in no way implies inclusion. It will probably be better to keep the two types of modules explicitly separate.
It's good because you gain an ability to scope your monkey patches.
It's bad because it incentivizes monkey-patches.
IMO, this is the justified cost of flexibility provided by monkey-patching.
(Please note I don't even mean that as a criticism of OO per se. Like everything else, it has costs and benefits, and that is, well, actually a bit of both. Things being hidden from you is annoying, but if you switch to something like Haskell you'll find that everything being shown isn't always entirely cool either.)
As dangerous as they are, there is a reason people monkey patch. Refinements will just help remove the downsides.
(They might still be "dangerous" but you've moved them out of the "suicidal" territory I believe non-scoped monkeypatches live in.)
Incidentally, Perl has been able to do this for a long time. I've gotten a lot of mileage out of:
local *{'Some::Module::method'} = sub { ... };
my $thing = new Some::Module();
...
$thing->method(...);
...