Re^3: regex return true instead of false (precedence)

[Marshall]

I prefer to use indenting to make all the parens more clear. Also, this "unless not" syntax can be confusing.
I think I got this right, but it is easy to make a mistake. Consider:

# X is the "default action"

# do X with an exception that when A,B and C are all false
# then don't do X

unless (!A and !B and !C) {X}

# if anybody is true then they all can't be false
# so we do X unless anybody is true (meaning they
# can't all be false)

unless (A or B or C) {X}
-------

unless ( (!($args =~ /\-rs(\s+)(\S+)/)) && 
         (!($args =~ /\-p(\s+)(\S+)/))  && 
         (!($args =~ /\-P(\s+)(\S+)/))     ) 
   {.....

# I figure this is easier to understand:

unless ( $args =~ /\-rs(\s+)(\S+)/ or 
         $args =~ /\-p(\s+)(\S+)/  or 
         $args =~ /\-P(\s+)(\S+)/     ) 
   {....

[GrandFather]

If you break a condition like that over multiple lines (and for a complicated or long condition I recommend it) put the operators at the front of the lines so they don't get "lost" at the back:

if (  $args =~ /\-rs(\s+)(\S+)/
   || $args =~ /\-p(\s+)(\S+)/
   || $args =~ /\-P(\s+)(\S+)/
   )

[Marshall]

Actually, I like that better.
As I remember, a senior Monk yelled at me once when I posted something like that. But yes this is the way that I would do it in my code. I didn't want to get into an argument that detracts from the main point.
Update: As I remember the argument against this was like "injecting spacing like that is bad because it is manually done and IDE's don't do it that way". BS. The compiler doesn't give a darn about spaces. Whitespace is added to help the humans. If it helps the humans, it is a good idea.

[AnomalousMonk]

I agree with your and GrandFather's leftist leaning when it comes to formatting complex logical expressions, but I think it's tangential to the main point made by haukex here: the statements
    if     (    condition  ) {} else {code }
    unless (    condition  )         {code }
    if     ( ! (condition) )         {code }
are all exactly equivalent, so the condition expression within them does not need to change at all.

[rsFalse]

Also you can waste one line of code for making first conditional to have the same line-format as others:

if( not 0
   || $args =~ /\-rs(\s+)(\S+)/x
#  || $args =~ /\-? (\s+)(\S+)/x
   || $args =~ /\-p (\s+)(\S+)/x
   || $args =~ /\-P (\s+)(\S+)/x
   ){ ... }

...or equivalently inside regex:

if( $args !~ / (*FAIL)
   | \-rs(\s+)(\S+) 
#  | \-? (\s+)(\S+)
   | \-P (\s+)(\S+)
   | \-p (\s+)(\S+)
   /x ){ ... }

edit: not equivalently, because there are 8 capturing groups instead of 2 :)

Of course regex can be simplyfied as AnomalousMonk have shown here Re: regex return true instead of false.

[AnomalousMonk]

if( $args !~ / (*FAIL)
   | \-rs(\s+)(\S+) 
#  | \-? (\s+)(\S+)
   | \-P (\s+)(\S+)
   | \-p (\s+)(\S+)
   /x ){ ... }

I don't understand the purpose of the  (*FAIL) operator (see Special Backtracking Control Verbs in perlre in Perl versions 5.10+ (update: see also Backtracking control verbs in perlretut - but that's not actually as extensive as the discussion in perlre)) in the quoted regex. At any position in the  | alternation,  (*FAIL) will simply force the RE to try the next alternation; if it's at the last position, all the preceding pattern matches would have failed and the alternation would fail anyway without (*FAIL).

c:\@Work\Perl\monks>perl -wMstrict -le
"use 5.010;
 ;;
 for my $s (qw(XXX ppp)) {
   print qq{for '$s' string};
   if ($s !~ m{ (*F) | p | q }xms) { print '  with (*F): no match, !~ 
+true' }
   if ($s !~ m{   Z  | p | q }xms) { print '  with Z:    no match, !~ 
+true' }
   if ($s !~ m{        p | q }xms) { print '  no (*F):   no match, !~ 
+true' }
   print '  -------';
   }
"
for 'XXX' string
  with (*F): no match, !~ true
  with Z:    no match, !~ true
  no (*F):   no match, !~ true
  -------
for 'ppp' string
  -------

Note that for all these variations, for string 'XXX' there is never a match (!~ is always true); string 'ppp' always matches (!~ always false).

... not equivalently, because there are 8 capturing groups instead of 2 ...

If you're using  (*FAIL) you must be using Perl version 5.10+, so you also have the  (?|pattern) "branch reset" operator (see Extended Patterns in perlre). This allows you to go back to having two capture groups again!

Update: Changed example code slightly to better reflect discussion.