G'day symgryph,

"I have read a lot about NOT using the 'switch' statement of yore, ..."

You need to be a bit careful with terminology. Perl does not have nor, as far as I know, has ever had a 'switch' statement. It does have "The 'switch' feature". There is a CPAN Switch module which provides a 'switch' function. I'm going to assume that you're talking about the Switch module.

The BUGS and LIMITATIONS sections of Switch both provide a number of reasons to avoid it. I would strongly recommend against using it in production code.

"... but saw some comments on using 'when' instead."

I'll assume that's from the Switch BUGS section: "In general, use given/when instead.".

When that was written, it was probably an entirely reasonable statement; however, in 5.18.0 'given', 'when, and the associated '~~' operator, were made experimental: "perl5180delta: The smartmatch family of features are now experimental". At 5.34.0 they remain experimental:

$ perl -v | head -2 | tail -1
This is perl 5, version 34, subversion 0 (v5.34.0) built for cygwin-th
+read-multi

$ perl -E 'say 1~~2 ? "yes" : "no"'
Smartmatch is experimental at -e line 1.
no

$ perl -E 'my $x = 1; given ($x) { when (2) { say "yes" } default { sa
+y "no" } }'
given is experimental at -e line 1.
when is experimental at -e line 1.
no
[download]

Again, I would not use these in production code.

"Is there a modern howto on doing a case like construct in perl 5.34?"

• There are a couple of (5.34.0) examples in "perlsyn: Basic BLOCKs".
• There are some older but still valid (5.6.0) examples in "(5.6.0) perlsyn: Basic BLOCKs and Switch Statements".
• There's a variant of one of the 5.6.0 examples that I use from time to time. See 'sub orient_matrix {...}' in "Creating X BitMap (XBM) images with directional gradients". There is some discussion about this in the remainder of the thread.

At 5.34.0 they remain experimental

And not for no reason. The design of smartmatch is considered fundamentally broken. They want to abandon this experiment, or at least redesign smart matching. The removal of smartmatching is being held back, at least for now, by the number of users of the experimental feature.

Seeking work! You can reach me at ikegami@adaelis.com

"The removal of smartmatching is being held back, at least for now, by the number of users of the experimental feature."

Yes. Many, including myself, used smartmatch when it was first introduced in 5.10 (when it was not experimental). When it was made experimental in 5.18, many (again, including myself) simply followed the workaround provided in perl5180delta:

no if $] >= 5.018, warnings => "experimental::smartmatch";
[download]

This removed the copious "experimental" warnings and the code continued to run, without any problems, as it had done previously.

The result is that now there is a large body of code in CPAN, as well as commercial and private libraries, that use smartmatch. I certainly have private code, still in current use, that uses it; it's entirely possible that commercial code which I wrote prior to 5.18 also included it.

I suppose the lesson to be learnt here is to make all new features experimental until substantial in-the-field testing indicates no problems. This does seem to be the case for many features (e.g. try/catch in 5.34) but not all (e.g. chained comparisons in 5.32).

— Ken

The removal of smartmatching is being held back, at least for now, by the number of users of the experimental feature

Perhaps that shows how useful in demand the feature is.

see also How do I create a switch or case statement?

Seems like you are referring to use Switch which is a source filter and strongly discouraged.

> but saw some comments on using when instead.

This is most likely referring to given/when activated with use feature "switch" or use 5.10

see https://perldoc.perl.org/perlsyn#Switch-Statements

but also the limitations listed in

https://perldoc.perl.org/perlsyn#Experimental-Details-on-given-and-when

Short version

You can use given/when as long as you stick to the simple to predict patterns. Because when is based on ~~ Smartmatch-Operator (which is already too smart) unless it is not (sigh)

workarounds

Most ppl I know - me included - prefer simpler workarounds depending on the use case like:

a) For multiple tests till it fits

• chained boolean tests
  • if/elsif/else
  • && do {} patterns with explicit last or next to break out °

b) For faster direct lookup of the case (i.e. the comparison operation is always equality eq or == )

• hashes for values
• hash-dispatch tables for code
• goto CASE_LABEL (plus explicit last or next to break out °)

As you can see is switch trying to be overly clever and to cover a multitude of cases and optimizations.

It would really help to know your explicit use case.

°) I originally wrote "explicit break", but as Athanasius msged me are "break statement only for given/when constructs". Thanks Athanasius++ :)

NB:

• the choice of subnames is open to debate
• This is very beta and not heavily tested against all edge cases
• once this is stable for all edge cases it can be improved for performance

• using for as a topicalizer
• a routine once {} like do {} but breaking out
• a routine check {} to explicitly define the criteria (in contrast to smartmatch)
• routines case() and break {} for syntactic sugar

use v5.12;
use warnings;
use subs qw/break/;

#use Data::Dump qw/pp dd/;
#use diagnostics;


say "========= IMPLEMENTATION";

{

    my $check;


    sub check(&) {
        $check = shift;
    }

    sub case {
        my $code;
        if (ref $_[-1] eq "my_break") {
            #warn "my break";
            $code = pop @_;
        }

        my $do;
        for my $val (@_) {
            $do ||= $check->($val);
        }

        if ($do){
            if ($code) {
                once($code) 
            } else {
                return $do
            }
        }
        return;
    }

    no warnings 'exiting';
    sub once (&) {
        (shift)->();
        next;
    }

    sub break(&) {
        return bless shift, "my_break"
    }
}


say "========= TESTS";


say "--- with basic logic";

for ( 0 .. 5 ) {
    $_< 1 and
      once { print "$_ smaller 1"};

    $_< 3 and
      once { print "$_ smaller 3"};

    $_ > 3  && $_ < 5 and
      once { print "$_ between 3 and 5"};

    print "$_ has no match";    # else

} continue {
    print "\n";
}


say "--- with some syntactic sugar";

for ( 0 .. 5 ) {
    check { $_ < shift };

    case 1
      and once { print "$_ smaller 1"};
    case 3
      and once { print "$_ smaller 3"};

    case 4,5
      and once { print "$_ smaller 4 or 5"};

    print "$_ has no match";            # else

} continue {
    print "\n";
}


say "--- with even MORE syntactic sugar";

for ( 0 .. 5 ) {
    check { $_ < shift };

    case 1
      => break { print "$_ smaller 1"};

    case 3
      => break { print "$_ smaller 3"};

    case 4,5
      => break { print "$_ smaller 4 or 5"};

    print "$_ has no match";

} continue {
    print "\n";
}
[download]

C:/Strawberry/perl/bin\perl.exe -w d:/tmp/pm/do_once.pl 
========= IMPLEMENTATION
========= TESTS
--- with basic logic
0 smaller 1
1 smaller 3
2 smaller 3
3 has no match
4 between 3 and 5
5 has no match
--- with some syntactic sugar
0 smaller 1
1 smaller 3
2 smaller 3
3 smaller 4 or 5
4 smaller 4 or 5
5 has no match
--- with even MORE syntactic sugar
0 smaller 1
1 smaller 3
2 smaller 3
3 smaller 4 or 5
4 smaller 4 or 5
5 has no match

Compilation finished at Sat Jul  3 18:15:36
[download]

Switch::Plain is perhaps a contender. I am not aware of any negative opinions of it.

You might consider to jump to a label as goto can be a different thing in Perl.

I just don't know that problem that you are trying to solve

It is possible that the OP is not trying to solve a problem but simply trying to learn from others.

But, like you say, it is easier to provide that help with some example code...