Arrow Operator and questions related to Path::Class

[kamal]

I have just started to delve into Perl, and going through the following example:

#!/usr/bin/perl
use strict;
use warnings;

use Path::Class;

my $dir = dir('foo','bar'); # foo/bar

# Iterate over the content of foo/bar
while (my $file = $dir->next) {
    
    # See if it is a directory and skip
    next if $file->is_dir();
    
    # Print out the file name and path
    print $file->stringify . "\n";
}

Reading the code....

my $dir = dir ('test1');

# local scalar dir is assigned by dir ('test1')
the dir on the RHS, being possibly from Path::Class (CPAN)
while (This condition hold true)
# Simple While

my $file = $dir->next $dir scalar de-references the function next ? HOW ?
HOW do i guess that next would indeed be written as next and not next(), etc
since there is NO reference/example for "next" in
Class.pm Same goes for stringify, or is_dir()
Now in this case is_dir() seems again to be a function, but how come its called differently

Thanks,
-Kamal.

[choroba]

There are two instances of next in your code. They are very different:
$dir->next calls the method next of the object $dir, while next if ... jumps to the end of the current loop and iterates a next cycle.

[kennethk]

Let's go line by through the code.

use Path::Class;

So, we'll use Path::Class. According to the linked docs, this use statement exports 2 functions: dir and file. So now we know anytime we see the function dir, we are invoking the one from Path::Class. From the docs:

dir

A synonym for Path::Class::Dir->new.

So the correct place to find docs on the object returned by dir is Path::Class::Dir. Let us continue:

# Iterate over the content of foo/bar
while (my $file = $dir->next) {

Now we've invoked the method next via an arrow dereference, so we check the appropriate package for the object for the method documentation. If you didn't realize it what package it was, you can use ref to tell you via the debug statement print ref $dir;.

$dir_or_file = $dir->next()

A convenient way to iterate through directory contents. The first time next() is called, it will open() the directory and read the first item from it, returning the result as a Path::Class::Dir or Path::Class::File object (depending, of course, on its actual type). Each subsequent call to next() will simply iterate over the directory's contents, until there are no more items in the directory, and then the undefined value is returned....

So now we have either a Path::Class::Dir or a Path::Class::File, depending on what the iterator hit. In both cases, methods by the name of stringify and is_dir are available and documented in the appropriate docs. When you get to the line

next if $file->is_dir();

we see next is not associated with a object dereference, so unless Path::Class exports something by that name, it will be a Perl CORE function. So, if we check the docs, either via the web at next or on the command line via perldoc -f next, we see it's a language keyword for flow control.

This is all recoverable if you follow the logical flow of the program.

[nemesdani]

Hey kennethk your wisdom spreads :)

http://stackoverflow.com/questions/12584342/perl-program-explained-line-by-line

[ww]

"HOW do i guess that next would indeed be written as next and not next()...?"

perldoc -f next at your command prompt.

next is an integral flow control function in perl... it's not something special to any particular (non-core) module.

[kamal]

Thanks, and what about $file->stringify ?
I got:
No documentation for perl function `stringify' found
$perldoc -f stringify

[Corion]

You will need to learn about the arrow operator ->, for example in perlop, and/or one of the Perl object tutorials, or maybe the Modern Perl book.

The methods of an object are traditionally documented in the respective class documentation. In your case, that's Path::Class.

[Anonymous Monk]

It is actually fairly common in programming-languages for an identifier (such as "next" or "dir") to have multiple meanings depending on the context in which they are used. Furthermore, the Perl language (again, in a manner typical of its genre) defers many aspects of the name-resolution process to very late, at runtime.