"Starting to grok the code, I 1st wondered why the type constraints do not need to be written in a string. It seems use MooseX::Types::Moose is responsible for being able to do that."

Moose type constraints are not strings, they are instances of Moose::Meta::TypeConstraint. has (and indeed the Moose::Meta::Attribute class that powers has) just gives you a little sugar allowing you to indicate type constraints as strings. But internally it translates those to type constraint objects.

MooseX::Types basically gives you functions defined along these lines:

# It's actually a lot more complex than this, but just
# pretend it's this simple...
#
sub HashRef () {   ### empty prototype
  return Moose::Meta::TypeConstraint->lookup('HashRef');
}
[download]

So that you can use:

    isa => HashRef
[download]

It also plays some fancy tricks overloading bitwise operators so that HashRef | ArrayRef "just works".

So everything I did in the previous example would work without MooseX::Types; you'd just need to do a bit of work with Moose::Meta::TypeConstraint objects, so it wouldn't look as pretty.

"Indicating, that only the 1st one in the inheritance hierarchy gets propagated. So I assume for it to work independent of how many parent classes were passed, one would have to loop over them in _existing_constraint (how?) and buildup the type constraint before returning it."

Multiple inheritance is always going to make things messier. For example, if you're inheriting from classes A and B where:

package A;
has data => (is => 'ro');
package B;
has data => (is => 'rw');
[download]

... what on earth would you expect to happen?!

In cases like this, I'd want the class that's doing the multi-inheritance to define as much of the data attribute as it can, and rely on its base classes' definitions as little as possible.

Moose type constraints are not strings, they are instances of Moose::Meta::TypeConstraint.

Sure, I assumed they have semantics beyond 'being a String'. I just meant from the syntactic perspective, Moose::Manual::Types pretty much makes it look like the types are strings. At least

...
isa => Str | ArrayRef,
...
[download]

doesn't work without MooseX::Types (Bareword "Str" not allowed while "strict subs"...)

Anyway, I tried to make this inherited union constraints "do what I mean" for multiple inheritance and came up with

package ValAtom;

use strict;
use warnings;
use 5.10.1;

use Moose;
use MooseX::Types::Moose -all;

extends 'KeyAtom', 'JustTesting';

has '+data' => (
    isa     => __PACKAGE__->_existing_constraint('data') . ' | ArrayRe
+f | HashRef',
);

sub _existing_constraint {
        my ($class, $attr) = @_;
        return join ' | ', map {
            $_->meta->find_attribute_by_name($attr)->type_constraint
        } $class->meta->superclasses;
    }

1;
[download]

Back to string again - obviously - as I couldn't figure out how to do it otherwise. But this seems to work.

Bye
 PetaMem     All Perl:   MT, NLP, NLU