in reply to open and list context (?)

You guys sure write weird open calls. I keep thinking you’re making an easy thing hard.

Here are some examples of mine from recent programs. Those without error checking are operating under the use autodie pragma. 

rename:     unless (open(TTYIN, "</dev/tty") && open(TTYOUT,">/dev/tty
+")) { ... }

tcgrep:     no strict "refs";
tcgrep:     # use same handlename as filehandle for better warn/die me
+ssages
tcgrep:     unless (open($file, $file)) { ... }

unichars:   open(STDOUT, "|- :utf8", $his_pager, @pager_args);

unilook:    # can't do this many arguments in old perls
unilook:    if ($] >= 5.013_000) {
unilook:        open($look_fh, "-| :utf8", $lookpath, $look_word,  $DB
+_Name,   );
unilook:    } else {
unilook:        open($look_fh,            "$lookpath '$look_word' '$DB
+_Name' |");
unilook:        binmode($look_fh, ":utf8");
unilook:    }

unilook:    open(my $raw_db, "< :utf8", $DB_Name);

unilook:    open($agrep_fh, $arg_string);

unilook:    open(STDOUT, "|- :utf8", $his_pager);

uninames~:      my $unistd    = "$Config{privlib}/unicore/NamesList.tx
+t";
uninames~:    my $mode_in   = "< :encoding(Latin-1)",
uninames~:    my $mode_out  =   ":utf8";
uninames~:    open(my $fh, $mode_in, $unistd)     
uninames~:       || die "can't open $mode_in '$unistd': $!";

uninames:   open(STDOUT, "| $pager")
uninames:       || die "can't open STDOUT to $pager pipe: $!";

uniprops:   open(my $pod_fh, "< $unipod")
uniprops:       || die "can't open $unipod: $!";
uniprops:   open(STDOUT, "| $pager")
uniprops:       || die "can't open pipe to $pager: $!";

[download]
Although my favorite has to be this from uniquote: 
    unshift(@ARGV, "-") if @ARGV == 0;
FILE: 
    for my $quasi_filename (@ARGV) {
        # don't let magic open make an output handle
        my $file = $quasi_filename;
        $file = "standard input" if $file eq q(-);

        debug("opening $file");

        $quasi_filename =~ s/^(?=[\h\v]*[>|])/< /;

    # Down the rabbit hole: I'm using filehandle names that match
    # the handles themselves to aid in debugging message. Silly
    # perl thinks this is somehow symbolic dereferencing.

        no strict "refs";
        my $fh = $file;   # is *so* a lexical filehandle!!! 
        unless (open($fh, $quasi_filename)) {
            yuck("couldn't open $quasi_filename: $!");
            next FILE;
        }
        set_encoding($fh, $file) || next FILE;

LINE:   for(;;) {
            my $line = eval {
                use warnings "FATAL" => "all";
                scalar <$fh>;
            };
            if ($@) {
                $@ =~ s/ at \K.*? line \d+.*/$file line $./;
                yuck("read failure: $@");
                if ($. == 0) { last LINE }
                else         { next LINE }
            }

            last LINE unless defined $line;
            last LINE unless length $line;

        ...

[download]

See how easy that is? Why make things so hard on yourselves? Always use parens on you function calls, and you will never go astray. So simple it’s impossible to forget. And no more precedence problems.

--tom

Replies are listed 'Best First'.
Re^2: open and list context (?)
by chromatic (Archbishop) on Jun 13, 2011 at 16:28 UTC
    Always use parens on you function calls...

    I've given that advice too, but what makes open a function call and die not?

[reply]

      Opinions Considered Harmful

      Cᴀᴠᴇᴀᴛ Lᴇᴄᴛᴏʀ:
      If by chance you’re one to be easily bothered by strong opinions, especially those against which you have an irrational, emotional reaction, please do us all a favor and skip reading this posting. 🙈 🙉 🙊

      On Monday, 13 June 2011 at 10:28 ㏂ ᴍᴅᴛ, chromatic in quoting yours truly has done me the honor to write:

      › Always use parens on you[r] function calls…

      I’ve given that advice too, but what makes open a function call and die not?

      Quite so! Rem acū tetigistī!

      Not merely a just question, it would also seem a perfectly straightfoward question as well. The operative term there is seem, as your seemingly simple question comes accompanied by seriously subobvious traps to trouble both the unwary and the hypervigilant alike.

      <Reveal this spoiler or all spoilers in this node or all in this thread>


      To get a feel for how my current Perl coding style lays out on the page, including in particular my use of parentheses on function calls, I encourage you to look through my recent work in my evergrowing Unicode Tool Chest. Whatever style that that code evinces, and I am absolutely certain that it somehow does so, it is not something I have ever managed to explain coherently, and least not well enough to get something like perltidy to come close to reproducing.

      Nevertheless, I do believe that taken as a whole, my personal style is consistent, predictable, readable, and pedagogically useful. I should’t be surprised if it were found to be so idiosyncratically mine that it would prove readily identifiable as tchrist–code by one of those clever machine‐learning program trying to identify plagiarism.

      The fiftyish programs in my Unicode Tool Chest are often a lot more useful, or can be used in many clever ways other than are immediately apparent. Some of those that I use daily or more include:

      There are around 50 programs, modules, and libraries in that directory, almost all having to do with Unicode. Some are one‐shots, some are well‐documented standard tools I use daily, and all I believe have something to say about Perl (and sometimes C and sometimes Java) programming. Some delightful little simpletons are genuine lifesavers, but you’d never know it without playing around with them a bit. And some are just downright hilarious in the extreme.

      You’ll see.

      <Reveal this spoiler>

      ℹ⃝  Ask me, Ask me, Ask me!

      Lastly, I’m happy to entertain questions both public and private about the code.
[reply]
[d/l]
[select]

In Section Seekers of Perl Wisdom