I often (not always) make those into methods anyway. The advantage is that others can subclass and override them. Now, you may be thinking, "But, these aren't that type of function that should be overridden." My experience says that even these can be overridden to good effect sometimes. For example, if you've pulled out a common sort function into another function, making it a method would mean that someone two years from now could decide they want a different sort order and simply override it. But you probably can't imagine why right now.

Just food for thought ;-)

Treat them like other code. There is no reason not to. In a class, letting the routines be methods rather than functions (or whatever you want to call it) are the idiomatic norm, not the exception.

Consistency is good on a more pragmatic level too. By having all routines being methods, you don't need to keep track of whether $self / $class should be shifted off @_ or not. You don't need to worry about which routines are called in a particular way -- they're all $self->whatever(). I find myself making this specific mistake surprisingly often when some things were made subroutines.

The problem with not passing around $self (i.e. treating them like methods) is that sooner or later you'll need it in a routine in order to call a method on $self, and then you'll need to rewrite all of the things that call this routine, and everything that calls those routines, etc.

If a routine is clearly not related to the object instance ($self), make it a class method (shift off $class, call the method like this: My::Class->whatever() ) instead, because...

You almost certainly will want to override one of them in sub classes sooner or later, for the same reason you might want to override the rest of your methods. If you write a CPAN library, this is even more frustrating for other people who have needs to tweak the code that you didn't anticipate at the time.

/J

If a routine is clearly not related to the object instance ($self), make it a class method (shift off $class, call the method like this: My::Class->whatever() ) instead, because.. You almost certainly will want to override one of them

This is actually really annoying as an interface, because it means that whatever can't be exported. And in my experience, for every time you want to override a class method/function, there are hundreds of times you just want to call one.

Sorry, I don't get it. Call it like this:

my $whatever = My::Class->whatever();
[download]

Is it the verbosity of the class name that bothers you or something else?

/J

Also, there are circumstances whereby a call of the nature &subname; has to be made - I've not yet found a way of achieving that using the method call notation .oO(Maybe that's me demonstrating, yet again, just how little knowledge of this wonderful language I posess).