#! perl -w
use strict;
use List::Util qw( reduce );
use Data::Dumper;

#package Sequence;

#sub new {
#	my ($proto, $seq) = @_;
#	bless $seq, $proto;
#}

#sub seqsub(&) {
#	Sequences->new(@_);
#}
    
sub seq {
	my ($i, $elems) = (0, \@_);
	seqsub {
		$i < @$elems
			? ( $elems->[ $i++ ] )
			: do { $i = 0; () };
	}
}

sub enumerate {
	local $Data::Dumper::Terse = 1;
	local $Data::Dumper::Indent = 0;
	my ($i, $seq) = (0, $_[0]);
	while (my @val = $seq->()) {
		@val = map { ref ($_) ? Dumper($_) : $_ } @val;
		printf "%2d => %s\n", $i++, "@val";
	}
	$seq;
}
    
sub seq_prod2 {
	my ($s, $t) = @_;
	my @sval;
	seqsub {
		@sval = $s->() unless @sval;
		my @tval = $t->();
		@tval ? ( @sval, @tval )
			  : do { @sval = $s->();
					 @sval ? ( @sval, $t->() ) : () };
	}
};
    
sub seq_prod {
	reduce { seq_prod2($a,$b) } @_ ;
}


sub seqs {
	map seq(@$_), @_;
}

sub seq_from_spec {
	seq_prod( seqs(@_) );
}

sub seq_foreach {
	my ($seq, $fn) = @_;
	while (my @val = $seq->()) {
		$fn->(@val);
	}
	$seq;
}

sub seq_foreach_from_spec {
	my ($spec, $fn) = @_;
	seq_foreach( seq_from_spec( @$spec ), $fn );
}

sub seq_filter {
	my ($seq, $filter_fn) = @_;
	seqsub {
		my @val;
		1 while @val = $seq->() and !$filter_fn->(@val);
		return @val;
	}
}
    
sub seq_map {
	my ($seq, $fn) = @_;
	seqsub {
		my @val = $seq->();
		@val ? $fn->(@val) : ();
	}
}
    
sub seq_reset {
	my $seq = shift;
	if ($seq) {
		1 while $seq->();
	}
	$seq;
}

sub seq_zip {
	my $seqs = seq( @_ ); # seq of seqs (!)
	my $seq_count = @_;
	seqsub {
		my @outvals;
		while (my $seq = $seqs->()) {
			if (my @val = $seq->()) {
				push @outvals, @val;
			}
			else {
				seq_reset( $seqs->() ) for 1 .. $seq_count;
				seq_reset( $seqs );
				return ();
			}
		}
		return @outvals;
	}
}

my @site1 = qw( AATKKM aatkkm );
my @site2 = qw( GGGGGG gggggg );

my %counts;

seq_foreach_from_spec( [ \(@site1, @site2) ],
	sub {
		seq_foreach(
			seq_zip( ( map seq(split//), @_ ) ),
			sub { $counts{"@_"}++ }
		)
	}
);

print Dumper(\%counts), "\n";