I noodled around with this. So, the best I can tell, this makes iterating over files a two step process. First I have to create the iterator and then I have to loop over it? Something like this:

  my $iterator = $fc->scan_blah_files;
  while ($iterator->next_file) {
    my $file = $iterator->selected_file;
    print $file . "\n";
  }
}
[download]

I rewrote it a bit to keep the get/next terminology:

sub AUTOLOAD {
  our $AUTOLOAD;
  my $s = shift;
  $AUTOLOAD  =~ /.*::get(_next)*(_\w+)*_files*$/ or
    croak "No such method: $AUTOLOAD";
  my ($next, $type) = ($1, $2);

  if ($next) {                                      # create an iterat
+or
    my $class = ref($s) . '::Iterator';
    if (!$type) {                                   
      return $class->new($s->get_files);            # iterator for all
+ files
    } else {
      return $class->new(@{$s->{$type.'_files'}});  # iterator for fil
+e subset
    }
  } else {                                        
    return @{$s->{$type.'_files'}};                 # return file subs
+et
  }
}
[download]

Ok, I spent a lot more time on this. I got it back to a one step process while using your idea to create iterator objects AND can do multiple iterators now. Woot!

sub AUTOLOAD {
  our $AUTOLOAD;
  my $s = shift;
  $AUTOLOAD  =~ /.*::get(_next)*(_\w+)_files*$/ or
    croak "No such method: $AUTOLOAD";
  my ($next, $type) = ($1, $2);

  # Handle edge case when get_next_file() method is called
  if (!$next && $type eq '_next') {
    $next = 1;
    $type = '';
  }

  # return the requested list of files
  if (!$next) {
    my $attr = "${type}_files";
    my @files = @{$s->{$attr}};
    return @files;
  }

  # get a single file from an iterator
  if ($s->{"_iterator_$type"}) {
    my $file = $s->{"_iterator_$type"}->next_file;
    $s->{_last_iterator_file} = $file;
    undef $s->{"_iterator_$type"} if (!$file);
    return $file;
  } else {
    my @files = $type ? @{$s->{"${type}_files"}} : $s->get_files;
    return '' if !@files;
    my $class = ref($s) . '::Iterator';
    $s->{"_iterator_$type"} = $class->new(@files);
    $s->{_last_iterator_file} = $s->{"_iterator_$type"}->selected_file
+;
    return $s->{"_iterator_$type"}->selected_file;
  }
}

sub selected_file {
  my $s = shift;
  return $s->{_last_iterator_file};
}
[download]

Now I can do nested loops:

  while ($fp->get_next_file) {
    print $fp->selected_file . "\n";
    while ($fp->get_next_nonparseable_file) {
      print $fp->selected_file . "\n";
    }
  }
[download]

Building on your previous suggestion, now I'm thinking I could do something like this:

 $AUTOLOAD  =~ /.*::(get|bundle)(_next)*(_\w+)_files*$/
[download]

The bundle mode would also create an object that's just a list of files except you would perform operations on. So instead of:

while ($s->get_next_blah_file) {
  $s->delete($s->selected_file);
}
[download]

You would just do:

my $bundle = $s->bundle_blah_files;
$bundle->delete;
[download]

$PM = "Perl Monk's";
$MCF = "Most Clueless Friar Abbot Bishop Pontiff Deacon Curate Priest Vicar";
$nysus = $PM . ' ' . $MCF;
Click here if you love Perl Monks

The key motivation for independent iterator objects is that they allow the program to have multiple iterators even on the same category by removing the need for the File::Collector object to track the iterators.

These "bundles" look a lot like independent iterators, and you could easily introduce an ->all method that returns a special object like so:

(in File::Collector::Iterator)

sub all {
  my $self = shift;
  bless \ $self, 'File::Collector::Iterator::All';
}

{
  package File::Collector::Iterator::All;

  sub AUTOLOAD {
    our $AUTOLOAD;
    my $self = shift;

    $$self->$AUTOLOAD(@_) while ($$self->next_file);
  }
}
[download]

This allows subclasses of File::Collector::Iterator to define their own "bundle actions" invokable as $iterator->all->$action. For example, a subclass that adds a delete action could contain simply:

sub delete { unlink (shift)->selected_file }
[download]