OK, here's a massively generalized version of the above:

use 5.010;
use strict;
use warnings;

BEGIN {
    package Trait::Attribute::Derived;
    
    no thanks;
    use MooseX::Role::Parameterized;
    use List::MoreUtils 'any';
    use namespace::autoclean;
    
    use base do {
        package Trait::Attribute::Derived::__CLASS_METHODS__;
        use Sub::Install 'install_sub';
        use namespace::autoclean;
        
        my @saved;
        sub make_trait {
            my ($pkg, %args) = @_;
            push @saved, $pkg->meta->generate_role(parameters => \%arg
+s);
            return $saved[-1]->name;
        }
        
        sub import {
            my $pkg    = shift;
            my $caller = caller;
            while (@_)
            {
                my $name  = shift;
                my $trait = $pkg->make_trait(%{+shift});
                install_sub {
                    into => $caller,
                    as   => $name,
                    code => sub () { $trait },
                }
            }
        }
        
        __PACKAGE__;
    };
    
    parameter processor  => (is => 'ro', required => 1,   isa => 'Code
+Ref');
    parameter fields     => (is => 'ro', required => 1,   isa => 'Hash
+Ref');
    parameter is         => (is => 'ro', default => 'ro', isa => 'Str'
+);
    parameter source     => (is => 'ro', required => 1,   isa => 'Str'
+);
    
    role {
        my $p      = shift;
        my @fields = keys %{ $p->fields };
        
        has postprocessor => (is => 'ro', isa => 'CodeRef');
        
        for my $attr (@fields) {
            has $attr => (is => 'ro', isa => $p->fields->{$attr});
        }
        
        before _process_options => sub
        {
            my ($meta, $name, $spec) = @_;
            $spec->{is}      //= $p->is;
            $spec->{lazy}    //= 1;
            $spec->{builder} //= "_build_$name";
        };
        
        after attach_to_class => sub
        {
            my $attr   = shift;
            my $class  = $attr->associated_class;
            return if $class->has_method($attr->builder);
            
            my $source      = $p->source;
            my $processor   = $p->processor;
            my $postprocess = $attr->postprocessor;
            my %data        = map { ; $_ => $attr->$_ } @fields;
            
            $class->add_method($attr->builder, sub
            {
                my $self = shift;
                local %_ = %data;
                local $_ = $self->$source;
                $_ =   $self->$processor($_, +{%data});
                return $_ unless $postprocess;
                return $self->$postprocess($_, +{%data});
            });
        };
    };
};

{
    package Person;
    
    use Moose;
    use Trait::Attribute::Derived Split => {
        source    => 'full_name',
        fields    => { segment => 'Num' },
        processor => sub { (split)[$_{segment}] },
    };
    
    has full_name  => (is => 'ro', isa => 'Str');
    has first_name => (traits => [Split], segment => +0);
    has initial    => (traits => [Split], segment => +0, postprocessor
+ => sub { substr $_, 0, 1 });
    has last_name  => (traits => [Split], segment => -1);
}

my $bob = Person->new(full_name => 'Robert Redford');
say $bob->first_name;
say $bob->initial;
say $bob->last_name;
[download]

If you can understand that and how to apply it to your problem, then you're a true metahacker! :-)

Update: this is now on CPAN as Trait::Attribute::Derived.