It seems to be something to do with (de)referencing the constant.

Actually, running with perl -MO=Deparse shows that wxID_Yes, wxID_No, and wxID_CANCEL are subroutines:

given ($selection) {
    when (wxID_YES()) {
        print qq[You pressed: "Yes"\n];
    }
    when (wxID_NO()) {
        print qq[You pressed: "No"\n];
    }
    when (wxID_CANCEL()) {
        print qq[You pressed: "Cancel"\n];
    }
}
[download]

And the documentation says that “A user-defined subroutine call or a method invocation” is treated as a boolean, meaning “true” if it returns any non-zero value! (You can easily confirm this by making your own subroutines that return 0 and 1, say, and you will see that the first when clause with the non-zero-returning sub is always successful.)

Update: Here’s the code I used for experimenting:

So, it looks as though this (strange) behaviour is exactly as expected (until changed in a later version of Perl?) In the meantime, either of the workarounds you suggest will get the job done. I haven’t found a “simpler/cleaner syntax.” :-(

Hope that helps,

Indeed. If they were proper constants (e.g. defined by constant) then they'd work with given/when. But they are not. :-(

perl -E'sub Monkey::do{say$_,for@_,do{($monkey=[caller(0)]->[3])=~s{::}{ }and$monkey}}"Monkey say"->Monkey::do'

Its an outstanding issue Bug #58579 for Wx: Compile Wx constants without exporting Wx constants

Try this:

given ($selection) {
  when ([wxID_YES])    { $self->Wx::LogStatus('You pressed: "Yes"'   )
+ }
  when ([wxID_NO])     { $self->Wx::LogStatus('You pressed: "No"'    )
+ }
  when ([wxID_CANCEL]) { $self->Wx::LogStatus('You pressed: "Cancel"')
+ }
}
[download]

PS: if there's any possibility that $selection could potentially contain an arrayref, then my solution might behave a little oddly; you could explicitly protect against arrayrefs:

sub is_arrayref (_) { ref(shift) eq 'ARRAY' }

given ($selection) {
  when (is_arrayref)   { die "unexpected!" }
  when ([wxID_YES])    { $self->Wx::LogStatus('You pressed: "Yes"'   )
+ }
  when ([wxID_NO])     { $self->Wx::LogStatus('You pressed: "No"'    )
+ }
  when ([wxID_CANCEL]) { $self->Wx::LogStatus('You pressed: "Cancel"')
+ }
}
[download]

Of course, probably the code that generates $selection can never generate an arrayref, so you don't need to protect against that possibility.

perl -E'sub Monkey::do{say$_,for@_,do{($monkey=[caller(0)]->[3])=~s{::}{ }and$monkey}}"Monkey say"->Monkey::do'g

The when ([wxID_YES]) {....} also works (why?)

I also wondered that. :-) Here is the answer I came up with:

1. From Experimental Details on given and when, it is clear that this is not one of the “10 exceptional cases” in which the expression is treated as a boolean. Therefore, smartmatching applies.

2. From Smartmatch Operator:

   The smartmatch implicitly dereferences any non-blessed hash or array r
   +eference, so the HASH and ARRAY entries apply in those cases.
   [download]

3. Also from Smartmatch Operator:

   Right operand is an ARRAY:
   
   ...
   
   Any       ARRAY      smartmatch each ARRAY element
                  like: grep { Any ~~ $_ } ARRAY
   [download]

4. and

   Num       nummy       numeric equality
                   like: Num == nummy
   [download]

   where nummy is defined as

   Either an actual number, or a string that looks like one.
   [download]

So,

creates an anonymous array reference, and populates the array with the result of calling wxID_YES() — namely, 5103 — then it dereferences the array reference (1) & (2), and performs a smartmatch on the elements (3), effectively:

grep { $selection ~~ $_ } (5103)
[download]

which (4) reduces to:

$selection == 5103
[download]

which actually succeeds in being DWIM.

All clear now?   ;-)

*   *   *

Also interesting is tobyink’s observation about constant, because

use constant FOO => 42;
[download]

is implemented as a subroutine named FOO. The significant point is that this subroutine is prototyped to take no arguments:

sub FOO() { return 42; }
[download]

which (together with some other requirements) allows Perl to inline it — that is, wherever FOO appears in the code (outside of quotes), it is replaced with the value 42, so smartmatching just works as expected. See Constant Functions.

Precisely.

Smartmatch is easy. (Except when it isn't.)

perl -E'sub Monkey::do{say$_,for@_,do{($monkey=[caller(0)]->[3])=~s{::}{ }and$monkey}}"Monkey say"->Monkey::do'