Alberto Simões

sum, max and min are useful to have, yes, but we do already have them in List::Util which has been in core since 5.8. Maybe it would be nice if they were fully-built in, but the problem with adding new built-ins (at least alphanumeric ones) is that they can conflict with function names that people are already using in their code. So as a result, there needs to be pragmas to explicitly enable them, a la use feature qw(say state switch). So if we're going to need a pragma to enable them, how is that any easier than use List::Util qw(max min sum)?

blessed seems to make more sense. It seems to be something that genuinely should have been part of Perl 5 from the start. Introducing bless without blessed (or at least a version of ref that makes it easy to differentiate between blessed and unblessed references) seems like an oversight.

in on the other hand seems like it would be just replicating part of what smart match already does. Why introduce a more limited version of a feature that already exists? Should there be a new version of last that only acts on while loops and not foreach etc? It's true that smart match has its detractors, but who's to say in would far any better?

 use Acme::Pythonic; # this semicolon yet needed

 sub delete_edges:

     my $G = shift

     while my ($u, $v) = splice(@_, 0, 2):

         if defined $v:

             $G->delete_edge($u, $v)

         else:

             my @e = $G->edges($u)

             while ($u, $v) = splice(@e, 0, 2):

                 $G->delete_edge($u, $v)

    for my $n in 1..100:

        while $n != 1:

            if $n % 2:

                $n = 3*$n + 1

            else:

                $n /= 2

I really like the idea of 'in' in all actuality I spent a day (not even known it was in another language) looking for 'in' because it makes so much damn sense (linguistically especially).

I like the idea, "in" as an explicit "return true if scalar is found in list" would be nice. One could use List::Util any { }, but that doesn't get across the intent of the code as quickly as "if $var in ('one', 'two', 'three')" does.

Yes, you could use smartmatch, but a few people have already pointed out why smart match may not have been the best idea: https://blogs.perl.org/users/brian_d_foy/2011/07/rethinking-smart-matching.html "in" wouldn't suffer from the magic. One side is a scalar, the other side is a list. Smart match, unless its inputs are sanitized, can do unexpected things. Breaking smart match's features into multiple operators could solve its problems by removing the need to cover those cases in smart match.

On the topic of stealing things from other languages, I'd really, really like to see an "is" operator. "if $var is HASH", "if $var is Class::Something". Doing "if ( blessed $var && $var->isa( 'Class::Something' ) )" or "if ( ref $var eq 'HASH' )" is less clear.

to be clear, Perl already has a `in` when you are talking about a list iterator, its `for my $item (@list) { #do stuff }`, but I really like the `if` form idea. Something like `$something->do() if $item in @list`!

I support 'in'. Checking if something is in a set is a very common operation and it is atomic to my mind. This is the way my mind works and when I need to write a grep or use a library for this it introduces a mismatch between thinking and the code. Smartmatch is overdone and having something more specialized makes sense for me - just like having a 'method' keyword indicating that a sub is a method - it is a step into self-documenting code.

While I generally would like an 'in' comparison operator, the example you've shown compares string equality. What about numbers?

The 'in' iteration syntax seems to be just a shorthand so you can omit the parenthesis, so I don't see the point. Plus, things like

for my $foo in $bar { ...

Does that use a scalar $bar or a hash %bar?

Well, sort does string sorting by default and takes an optional subroutine reference (with the magical variables $a and $b) to allow for a custom sort. How about an "in" operator that does string comparison (ie "eq") by default but can take a subroutine reference--again with the magic variables $a and $b--that tells the operator when two elements are equal (so, you would have "$foo in{$a$b} @bar" as a stand-in for part of smart matching).

@Jack Maney: How is that solution different from grep?

Perl's smartmatch operator *is* its "in" operator (given a scalar-array comparison). To want for a Pythonic "in" is to want for Python's type system in place of Perl's:

>>> 1 in [1]
True
>>> 1 in ["1"]
False
>>> 1 in [True]
True
>>> "1" in [True]
False

Which may be nicer depending on your temperament, and can be achieved in Perl by using smart match in conjunction with wrapper classes to delineate between scalar subtypes.

I think I would also like to be able to do


if keys %hash in @array


meaning if any key in in the hash matches an element of the array..., I currently find that hard to express, or at least hard to remember how to express.