Basically "No method modifiers and I have to write my own constructors? Really?" always drives me away within a few hours.
Basically "No method modifiers and I have to write my own constructors? Really?" always drives me away within a few hours.
As for writing your own constructors, you only need to do so if you actually need to initialize something, and since instance variables can be used without having initialized them in a constructor (they'll just default to nil), I'm curious what you mean here too.
I don't know how to convert this into ruby then without needing to manually gensym a bunch of names:
use Class::Method::Modifiers;
sub foo { 2 }
before foo => sub { warn "before foo 1" };
around foo => sub {
my ($orig, $self) = (shift, shift);
warn "around foo";
(1, $orig->$self(@_), 3);
};
before foo => sub { warn "before foo 2" };
> As for writing your own constructors, you only need to do so if you actually need to initialize somethingWhich is required if you're going to use value objects as much as possible rather than spraying mutable state everywhere.
Sounds like you want something like: https://github.com/nicknovitski/modifiers
> Which is required if you're going to use value objects as much as possible rather than spraying mutable state everywhere.
Using Ruby's Struct class for this often avoids needing explicit constructors.
What I really want is CLOS. But the closest in perl/python/ruby/javascript is Moose/Moo.
There's also, btw, a moosex gem where some rubyists are trying to port the perl stuff - but Moose/Moo are pervasive in modern OO perl whereas most existing ruby code is done the ugly, boilerplate-y way.
The basic idea is this:
module Mst
def self.included(base)
# define a method on base using define_method named :before, which takes an
# argument and a block
# in that method, you grab the method with that name, using .method()
# you then define a new method, named method, which calls the block and
# then calls the original method
end
end
class Foo
include Mst
def test
puts "test"
end
before :test do
puts "before"
end
end
Module named after you. You can see how the logic only changes a bit for after and around. You could then wrap this up as a library, and all you'd need to do is the include.http://api.rubyonrails.org/classes/ActiveSupport/Callbacks/F... has an example, I think.
I hope, however, that you can understand from the POV of somebody who keeps being driven off ruby by ruby being too much work, that "you could make it less work by first porting all the perl5 libraries that make perl5 OO more pleasant" isn't really a convincing solution :)
Sure, I was just addressing the "I don't know how to do that." Rails offer this for models in certain circumstances, for example.
Yeah, I was responding to a post that claimed it was trivial; that's cute but not trivial - although it does demonstrate that using 'alias' to rename isn't necessary, which is nice to know.
I can absolutely see how I'd turn this into a full Class::Method::Modifiers re-implementation, so I'll totally stipulate to 'trivial if' :D
Please do not take this conversation as an affront and throw away what has so far come of it. It has shown you, and Ruby at large, an API that has been proven to be good and useful, and the Ruby community has come up with a way to implement it in a generalized way. I hope to someday be able to learn Ruby and use its OO with similar ease and pleasure as i can use the OO system in Perl 5. So please, do not throw this away. It is a valuable chance to do the same thing Perl has done so many times: Recognize something useful and make it your own.
Pretty sure we'll manage to resolve the confusion shortly.
I've genuinely no idea why you think I was being condescending.
This may be the first time (yeah, English, but do wear a kilt a fair bit) I've ever run into a problem with an American overdetecting sarcasm.
Ruby eventually added `prepend`, which I demonstrated upthread, and is a genuinely generic, in-language solution to the problem you're talking about.
That's cute, but $FOO.
is seen as really condescending here. It's literally diminutive, suggesting that something might be small and pretty, but not worth adult consideration for Real Stuff.Anyway, if that's not how you meant it, I completely understand. Text is hard. No harm, no foul. Sorry for misunderstanding.
On the other hand, the thread started off with "I've already got stuff in perl that does X and it looks like I'd have to write it myself in ruby", then somebody replied with "this already works in ruby, just use alias" then when I provided an example that wouldn't you showed me how to write a library to support said example in ruby.
So I now know much better 'how to write it myself in ruby', and I am genuinely grateful for that, but it still wasn't an answer to the original question so 'cute' seemed like the appropriate compliment.
The actual answer I was looking for seems to be "people who're bad at ruby will always suggest alias, prepend will handle some cases, and then you can write not that much code if you want the other cases, but there's no perl5+Moo quality experience to be had without implementing at least part of it yourself".
Which is totally fine by me, I just need to talk somebody better than me at ruby into implementing it and then try and convince everybody to upgrade :D
(also, if you have a suggestion for a word other than cute that would express "really pretty even though it doesn't answer the question" while seeming positive rather than negative about this fact I'm all ears)
I sat on it for another evening, but I'm not sure of the best word for you, to be honest.