My first thought was to simply require traits to have a @PROVIDES array that lists which traits it provides (and I can possibly provide some sugar using attributes). However, traits can be composed of other traits and I'd need to ensure that those traits have their functions reexported into the class using the composed traits. My first thought is to do something like this:

package Trait::Foo;
 
use Class::Trait 'base';
 
# the following adds their methods to @Trait::Foo::INHERITED_PROVIDES
use Class::Trait qw(Trait1 Trait2);
 
our @PROVIDES = qw/method1 method2/;
 
# and in the Class::Trait::Base class:
 
sub methods {
  my $class = shift;
  no strict 'refs';
  return @{"${class}::PROVIDES"}, @{"${class}::INHERITED_PROVIDES"};
}
[download]

That can work and now each trait merely needs to declare the methods in the @PROVIDES array, but I was wondering if there was a cleaner way of going about this. If I stumble across a function in a symbol table, I don't suppose there's any way to know where it came from, is there? (short of using PPI, for example)

I suppose I can grab those trait methods as soon as use Class::Trait 'base'; is called, but this does require that programmer remembers to declare this prior to using any other module which might export something. I hate adding arbitrary restrictions like that, but it seems the simplest way. (Er, no. Those methods won't be defined yet so I'd have to parse the code. Bad idea.)