I hope it's clear that ! is just the logical negation operator.

Double negations are a very common idiom, you will find it in many languages, also in JS.

!!$a is in the same idiomatic niche like 0+$a or "".$a of explicit casting to a certain type without altering the value. Just Boolean now instead of number or string.

Ok, thanks, I wasn't sure. I thought maybe they adopted "!!0" and "!!1" and imbued it with some special meaning beyond double negation.

$PM = "Perl Monk's";
$MC = "Most Clueless Friar Abbot Bishop Pontiff Deacon Curate Priest Vicar Parson";
$nysus = $PM . ' ' . $MC;
Click here if you love Perl Monks

I hadn't heard about the new booleans.

They're not new. They've existed for a very long time. At least since Perl 5.6 in 2000, but probably long before that. What was missing were functions whose sole purpose was to return them. That's what was recently introduced. And that's why we used !!0 and !!1 to produce them before that.

Perl 5.36 does have "new" booleans. Copies of the immortal &PL_sv_yes and &PL_sv_no values are still identifiable as booleans. This means they can be serialized more accurately. The latest versions of JSON::PP, Data::Dumper, and Storable all support this.

Prior to perl 5.36 it was not possible to identify a boolean true value after it had been copied. The exact same SV type, flags, and values could be produced by normal usage of a string "1". A boolean false would be more identifiable as it would never be produced naturally, requiring dualvar to construct.

Prior to perl 5.36 it was not possible to identify a boolean true value after it had been copied

This was done by ensuring that the string buffer (PV) of &PL_sv_yes and &PL_sv_no is shared on assignment.

$ 5.34t/bin/perl -MDevel::Peek -e'Dump(!!1); my $x = !!1; Dump($x);'
SV = PVNV(0x55852a177160) at 0x55852a1753c8
  REFCNT = 2147483644
  FLAGS = (IOK,NOK,POK,READONLY,PROTECT,pIOK,pNOK,pPOK)
  IV = 1
  NV = 1
  PV = 0x558529a84f64 "1"
  CUR = 1
  LEN = 0
SV = PVNV(0x55852a177220) at 0x55852a178770
  REFCNT = 1
  FLAGS = (IOK,NOK,POK,pIOK,pNOK,pPOK)
  IV = 1
  NV = 1
  PV = 0x55852a1b6010 "1"\0
  CUR = 1
  LEN = 10

$ 5.36t/bin/perl -MDevel::Peek -e'Dump(!!1); my $x = !!1; Dump($x);'
SV = PVNV(0x55d55f1be160) at 0x55d55f1bc3c8
  REFCNT = 2147483644
  FLAGS = (IOK,NOK,POK,IsCOW,READONLY,PROTECT,pIOK,pNOK,pPOK)
  IV = 1
  NV = 1
  PV = 0x55d55e89b984 "1" [BOOL PL_Yes]
  CUR = 1
  LEN = 0
SV = PVNV(0x55d55f1be220) at 0x55d55f1bf770
  REFCNT = 1
  FLAGS = (IOK,NOK,POK,IsCOW,pIOK,pNOK,pPOK)
  IV = 1
  NV = 1
  PV = 0x55d55e89b984 "1" [BOOL PL_Yes]
  CUR = 1
  LEN = 0
[download]

is_bool checks if the provided scalar shares a string buffer (PV) with &PL_sv_yes or &PL_sv_no.

Before you had two "levels" of true:

• &PL_sv_yes
• true or false value

After, three:

• &PL_sv_yes
• is_bool
• true or false value

> What was missing is a function whose sole purpose was to return them. That's what was recently introduced. And that's why we used !!0 and !!1 to produce them before that.

Are you referring to builtin::true etc. in builtin? Nobody has mentioned them yet in this thread.

Or are you talking about the internal &PL_sv_yes ?

On a side note: shouldn't it be possible to activate true and false while silencing the warnings with just one pragma?

  
use experimental qw/builtin/;
use builtin qw/true false/;
use Data::Dump;

ddx $];
dd [true,false]

__END__
# bool.pl:6: "5.036000"
[1, ""]
[download]

Cheers Rolf
_{(addicted to the Perl Programming Language :)
see Wikisyntax for the Monastery}

Them, Perl's booleans = &PL_sv_yes and &PL_sv_no.

Recently introduced functions = builtin::true and builtin::false

(Especially as it's mostly internal stuff which could change and the effects are supposed to be DWIM. Like I said most problems arise when converting to other languages, esp. JS)

But you can gather them from various places like perlop or perlglossary .

FWIW and I don't think !!1 used to be dualvar (see Scalar::Util ) prior to 5.36.

FWIW and I don't think !!1 used to be dualvar (see Scalar::Util ) prior to 5.36.

It's actually a triplevar, and it has been so at least as far back as 5.6, but probably a lot further back.

I don't have 5.6, but here's 5.8.9:

$ 5.8.9/bin/perl -MDevel::Peek -e'Dump(!!1)'
SV = PVNV(0x55e2de0d1348) at 0x55e2dd477310
  REFCNT = 2147483647
  FLAGS = (IOK,NOK,POK,READONLY,pIOK,pNOK,pPOK)
  IV = 1
  NV = 1
  PV = 0x55e2de0d2320 "1"\0
  CUR = 1
  LEN = 8

$ 5.8.9/bin/perl -MDevel::Peek -e'Dump(!!0)'
SV = PVNV(0x55aeb71e8320) at 0x55aeb5e05da0
  REFCNT = 2147483647
  FLAGS = (IOK,NOK,POK,READONLY,pIOK,pNOK,pPOK)
  IV = 0
  NV = 0
  PV = 0x55aeb71e8300 ""\0
  CUR = 0
  LEN = 8
[download]

In the case of !!1 it seems to only be just a performance thing, because all values are just 1 , i.e. any later casting would produce the same effect/caching of types.

I was confused because prior to this I only heard of !!0 as dualvar and I'm kinda sure I read it in the perldocs.

Cheers Rolf
_{(addicted to the Perl Programming Language :)
see Wikisyntax for the Monastery}