Sure, this is possible. Here's a quick-and-dirty solution where each processor_ subroutine is called on the same data sequentially:

#!/usr/bin/perl

use Modern::Perl '2014';
use List::MoreUtils qw/minmax/;
use Data::Dumper;

# count odd/even elements
sub process_1(@) {
    my %result = ();

    foreach my $element (@_) {
        my $type = ($element % 2) ? "odd" : "even";
        $result{$type}++;
    }

    return \%result;
}

# find minimum/maximum value
sub process_2(@) {
    my @minmax = minmax(@_);
    return \@minmax;
}

sub compose {
    my @subs = @_;

    return sub {
        my @results = ();

        # apply each sub in turn and save the result
        foreach my $sub (@subs) {
            push @results, &$sub(@_);
        }

        return \@results;
    }
}

# sample data
my @data        = (1, 6, 813, 472, 134, 48, 99, 1398, 47);

# compose subroutines
my $process_all = compose(\&process_1, \&process_2);

# apply all subroutines
my $result      = &$process_all(@data);

say Dumper $result;
[download]

Is this what you're looking for?

BTW, you may also be interested in Dominus's Higher-Order Perl (also available as a PDF here).