print unless $should_not_print++;
print if !$seen++;
[download]

tie my $first, "Trueonce";
while (<DATA>) {
    print if !$first;
}
[download]

This is just a quick heads up regarding bugs in the implementation of TIE. While I dont think the known bugs with it would be an issue for you, it is something to keep in mind. Take a look at warning: tied vars may evaluate twice in logical expressions

Yves / DeMerphq
--
This space for rent.

while (...){ 
  print",\n" unless $should_not_print++; 
  # munging ...
}
[download]

sub Trueonce::TIESCALAR {
        my $s=1;
        bless \$s, $_[0];
}
sub Trueonce::FETCH {
        my($self)=@_;
        local $_=$$self;
        $$self=0;
        return $_;
}
sub Trueonce::STORE {}
[download]

tie $f, "Trueonce";
print $f, "\n";   # 1
print $f, "\n";   # 0 
print $f, "\n";   # 0
print $f, "\n";   # 0
[download]

my @values = ();
while($whatever){
  my $value = $got_from_somewhere;
  push @values, $value;
}

my $query = "INSERT INTO somewhere VALUES (";
$query .= join(" ,", @values);
$query .= ")";
[download]

my @a=qw(random brilliant braindead); print $a[rand(@a)];

use strict;

my $bool = TrueOnce->new();

print $bool->value(), "\n" for (0..4);

package TrueOnce;

sub new { bless { true=>1 }, shift }

sub value {
   my $self = shift;
   my $val  = $self->{'true'};
   $self->{'true'} = 0;
   return $val;
}
[download]

jeffa

L-LL-L--L-LL-L--L-LL-L--
-R--R-RR-R--R-RR-R--R-RR
F--F--F--F--F--F--F--F--
(the triplet paradiddle)

while (<FOO>) {
  print if !$seen++;
  # ...
}
[download]

_____________________________________________________
Jeff[japhy]Pinyan: Perl, regex, and perl hacker.
s++=END;++y(;-P)}y js++=;shajsj<++y(p-q)}?print:??;

use strict;
my $n = do{ my $x=0; sub{$x++} };

print "[".join("][", &$n, &$n, &$n)."]\n
[download]

my @a=qw(random brilliant braindead); print $a[rand(@a)];

Perl doesn't have a "true-once" variable, however there are many ways to get the behaviour you want --- and several have been mentioned, including the most pertinent one: namely that an algorithm with join is probably your best option.

That said, there are a few ways to get the 'once-only' behaviour you are looking in your case without creating new synthetic variables. First you can use the flip-flop operator:

    #!/usr/bin/perl -w
    use strict;
    while(<DATA>){
        chomp;
        print ",\n" unless 1..1;
        print;
    }
    __DATA__
    foo
    bar
    blah
[download]

In scalar context the range .. op is the flip-flop, and when using constant expressions on either side, they are automatically compared to the builtin $. variable. So the above flip-flop is only true for the first record read. This of course leads to the more explicit and only slightly longer direct comparison with $. itself:

    #!/usr/bin/perl -w
    use strict;
    while(<DATA>){
        chomp;
        print ",\n" unless $. == 1;
        print;
    }
    __DATA__
    foo
    bar
    blah
[download]

But the idea of "once-only" can also be expressed by using the special ?? delimiters for a regex: with such delimiters, the regex will match only once --- so, using an expression that will succeed will also get you what you want:

    #!/usr/bin/perl -w
    use strict;
    while(<DATA>){
        chomp;
        print ",\n" unless ?^?;
        print;
    }
    __DATA__
    foo
    bar
    blah
[download]

In my opinion the ?^? trick is a bit too much of... a trick.

First of all, one should always do reset() after a use of ??. But the status of ?? is package scoped, so you might get scary side-effects if you use a function that uses ?? inside a loop where you used the first ??.

For instance, say that you modify your last snippet:

    sub prettify {
        # Just code that uses ??.
    }
    while(<DATA>){
        chomp;
        print ",\n" unless ?^?;
        print prettify($_);
    }
    __DATA__
    foo
    bar
    blah
[download]

Evil indeed.

This is the same problem as with not localized usage of $_, e.g. when people do while (<FOO>) {} without an explicit local() on $_. (I know no way to localize the status of ??.)

-Anomo

sub with_no_map {
    my @lines;
    while <DATA> {
        chomp;                # removes trailing newline
        next unless /\S/;     # skips blank lines
        @values = split /;/;  # gets individual records
        @values = map {quotrim($_)} @values; # quote vals

        # normalize number of values by padding with NULL
        if (scalar(@values) == 3) {
            splice(@values, 2, 0, 'NULL');
        }
        my $values_group = '(NULL, ' .
          join(',', @values) . ')';
        push @lines, $values_group;
    }
    return join(",\n", @lines);
}
[download]

Well, *I* never use it, because I have to run  man perlop every time I see one, but...

In scalar context, ``..'' returns a boolean value. The operator is bistable, like a flip-flop ... It can test the right operand and become false on the same evaluation it became true (as in awk), but it still returns true once.

Anybody who can get it to work, though? I can't get what I expect from, e.g.

Rhandom is right, revising the algorithm is likely the way to go, but I'd like to learn how to use this as a cool way to write "the first time..."

This is derived from an example in the Perl Developer's Dictionary and it's a cool trick if you can stomach it.

$a=0;
$_=0;
while($_++<10) {
        if (! $a..(!$a)) {
                print "True!\n";
        } else {
                print "False!\n";
        }
        $a++;
}
[download]

The if with the .. operator there returns true exactly once (so long as $a isn't externally modified) for the entire life of the program.

You can make the example a bit more concise using this:

$a=0;
$_=0;

while($_++<10) {
        if (! $a..(!$a++)) {
                print "True!\n";
        } else {
                print "False!\n";
        }
}
[download]

But using an auto-increment in an expression where the target variable appears twice makes me nauseous. Probably indigestion from my C days.

my $do = 1;
for (0...9) {
    stuff_to_do_always();
    if ($do) {
        stuff_to_do_first_time();
    }
    else {
        stuff_to_do_other_times();
    }
    $do = 0;
}
[download]

use DBI;
my $dbh = DBI->connect("DBI:mysql:database=chess", "usr", "pwd");  # o
+r whatever

my @line;
my $sth;
while (<DATA>) {
# your parsing:
    chomp;
    next if /^\s*$/;
    @line = split /;/;
# these lines deal with the only variation in 
# your data I can see - there may be others:
    if (@line == 3) {
        push @line, $line[2];
        $line[2] = 'NULL';
    }
# and finally, DBI takes the strain:
    $sth = $dbh->prepare("INSERT INTO eco_class (eco_id,eco,opening,va
+riation,moves) VALUES (NULL,?,?,?,?)") or die $dbh->errstr;
    $sth->execute(@line) or die $dbh->errstr;
}
[download]

while (<DATA>){
  chomp;              # removes trailing newline
  next if /^\s*$/;    # skips blank lines
  @x=map {quotrim($_)} split /;/;
  push @line, \@x;    # gets individual records
}
 
print join ",\n", map { "( ${\(join ',', @$_)} )" } @line;
print ";\n";
[download]

Heh

$| = 0;
sub true_once {
    not $|++;
}
[download]