Re: Text Analysis: given(){when(){}} block throws a 'useless use of private variable...etc' error

[TomDLux]

Do you suppose the backslash at the end of line 1 has anything to do with it?

Update: There's a closing curly missing at the end of the main line, before the first subroutine. And what's the '+' after 'size2' in the declaration line? That was caused by PerlMonks line-wrapping.

update 2: SOLVED! given() takes a single variable or value, and assigns it to $_, so that in the various when() clauses, you can test $_ with various values / regex / routines. I'm quessing $_ is the private variable which is not used.

You don't need to assign empty strings to the variables, nor do you need to compare against an empty string, undef or empty string are both 'false' in a boolean concept, that's a design feature, not an accident. Also, When reading a file, just read into a buffer variable, the read operation assigns undef to the buffer, ending the loop. I chomp the line when read, and skip empty lines, because I was getting an empty line at the end of the data file. Also, I use ||= to assign 'missed' to $snp if it doesn't have a string value.

I'm not a biologist, but 'homo' means 'the same', 'hetero' means 'different'. So I'm thinking when allele1 and allele2 are both set, it should be 'homo', and 'hetero' should apply when only one is set.

while ( my $line = <FH> ) {
    chomp $line;
    next unless length $line;
    my ( $file, $patientName, $panel, $snp, $allele1, $allele2, $size1
+,
         $size2 ) = split "\t", $line;
    $snp ||= 'missed';
    if ( $allele1 && $allele2 ) {
            constructHetero( $snp, $patientName, $allele1, $allele2 )
        }
    elsif ( $allele1 && not $allele2 ) {
        constructHomo( 'type1', $snp, $patientName, 'allele1', $allele
+1 )
    }
    elsif ( not $allele1 && $allele2 ) {
        constructHomo( 'type2', $snp, $patientName, 'allele2', $allele
+2 )
    }
    elsif ( not $allele1 && not $allele2) {
        constructUnclassified( $snp, $patientName )
    }
}

update 3 : Changed from '!' to 'not' for negation, better visibility.

[biohisham]

I don't suppose so for the following reasons:
1. The code is a boil down from a larger code that displayed the same behavior.
2. The Perl path at the top of this line doesn't really matter here because I am using an editor on an XP machine so the path in the first line isn't really looked into upon compiling.
The +s you see are because of a line overlap, if you hit on the download button at the left bottom of the code area you can have the entire code displayed without these +s..

UPDATE: added the missing curly and removed the backslash pointed out, that should've been a pasting mistake of my code snippet, other than that, this code works and does show the behavior mentioned in the original post

[biohisham]

You provided some very interesting clues to inspire me

I'm quessing $_ is the private variable which is not used.

If given takes a single variable or value and yet quite interesting still, it actually works with two values, even with three values as I tried it in the following demo, that means it is a very strong function that we probably need to develop more for us to avail of its full capacity in Perl 5.

Thinking about if we can have an embedded given(){when(){}} to make it accept two arguments is out of the question since that may lead to a labyrinth of brain-damaging curlies but maybe just keeping track of the arguments passed to given in @_ may provide a path to beat if that can be possible...

use strict;
use warnings;
use feature qw(switch);

my $foo = 'foo';
my $bar = 'bar';
my $baz = 'baz';


given($foo, $bar, $baz){
                  when($foo eq 'check' and $bar eq 'treck'){print "nei
+ther is standard\n";}
                  when($foo eq 'foo' and $bar eq 'treck'){print "$foo 
+is standard\n";}
                  when($foo eq 'check' and $bar eq 'bar'){print "$bar 
+is standard\n";}
                  when($foo eq 'foo' and $bar eq 'bar' and $baz eq 'ba
+z'){print "All are standard\n";}
                  when($foo eq 'foo' and $bar eq 'bar'){print "both ar
+e standard\n";}

        }

Notice that the last 2 when blocks are both true however, the first one in order which evaluates to true is the one that gets its print statement executed and the second one is totally ignored, perambulation of the when blocks can testify to that...

The reason I used a switch statement is because I wanted to clean up my code from the if else pollution in a quick way and the switch is a very neat way to do so, also, the values assigned to '' are going to be needed in another extension to the original code ergo the $var ||= '' statement.

Checking perlsyn for clues..

[TomDLux]

In my opinion, you're abusing the "given/when" construct. Yes, it works, because you have a boolean expression in the when() clauses. But you could put anything in the given part, and it would work just the same.

The point of "given/when", is that the value in the given clause is assigned to $_, and then you can use invisible default $_ in all the when() tests. From "perldoc perlsyn":

   given($_) {
      when (/^abc/) { $abc = 1; }
      when (/^def/) { $def = 1; }
      when (/^xyz/) { $xyz = 1; }
      default { $nothing = 1; }
   }
# and similarly
   given($foo) {
      when (undef) {
         say '$foo is undefined';
      }
      when ("foo") {
         say '$foo is the string "foo"';
      }
      when ([1,3,5,7,9]) {
         say '$foo is an odd digit';
         continue; # Fall through
      }
      when ($_ < 100) {
         say '$foo is numerically less than 100';
      }
      when (\&complicated_check) {
         say 'a complicated check for $foo is true';
      }
      default {
         die q(I don't know what to do with $foo);
      }
   }

As far as I can see, you're using a given/when block to produce an if/elsif block with an extra level of indentation.

If you modify your foo/bar/baz example so that each print block has a new statement after it: pritn "\$_ is $_.\n";. That will print out what the value of $_ is, no matter which path you take. You will see that $_ is 'baz'. Your ($foo, $bar, $baz) evaluates the sequence of expressions and uses the last one as the chosen value. The earlier ones are evaluated only for their side-effect. Of course, $foo does not have a side-effect, but it could equally be $foo++, or $foo->(). That's why you're getting the message about "useless use of a private variable", because only the last one gets assigned to $_.