perlop: Add detail about xor

Fixes Perl#18565

Author: khwilliamson

pod/perlop.pod

@@ -987,9 +987,13 @@ C<"experimental::bitwise"> category.
 X<operator, bitwise, or> X<bitwise or> X<|> X<operator, bitwise, xor>
 X<bitwise xor> X<^>
 
-Binary C<"|"> returns its operands ORed together bit by bit.
+Binary C<"|"> returns its operands ORed together bit by bit.  If both
+corresponding bits are 0, the resulting bit is 0; if either is 1, the result is
+1.
 
-Binary C<"^"> returns its operands XORed together bit by bit.
+Binary C<"^"> returns its operands XORed together bit by bit.  If both
+corresponding bits are 0 or both are 1, the resulting bit is 0; if just
+one is 1, the result is 1.
 
 Although no warning is currently raised, the results are not well
 defined when these operations are performed on operands that aren't either
@@ -1488,14 +1492,12 @@ expressions.  It's equivalent to C<&&> except for the very low
 precedence.  This means that it short-circuits: the right
 expression is evaluated only if the left expression is true.
 
-=head2 Logical or and Exclusive Or
-X<operator, logical, or> X<operator, logical, xor>
-X<operator, logical, exclusive or>
-X<or> X<xor>
+=head2 Logical Or
+X<operator, logical, or> X<or>
 
 Binary C<"or"> returns the logical disjunction of the two surrounding
-expressions.  It's equivalent to C<||> except for the very low precedence.
-This makes it useful for control flow:
+expressions.  It's equivalent to C<||> except for it having very low
+precedence.  This makes it useful for control flow:
 
     print FH $data              or die "Can't write to FH: $!";
 
@@ -1517,11 +1519,22 @@ takes higher precedence.
 
 Then again, you could always use parentheses.
 
-Binary C<"xor"> returns the exclusive-OR of the two surrounding expressions.
-It cannot short-circuit (of course).
-
 There is no low precedence operator for defined-OR.
 
+=head2 Logical Exclusive Or
+X<operator, logical, xor> X<operator, logical, exclusive or> X<xor>
+
+Binary C<"xor"> returns the logical disjunction of the two surrounding
+expressions.  That means it returns 1 if either, but not both, are true.
+It's equivalent to C<^> except for it having very low precedence.  It
+tends to be used to verify that two mutually-exclusive conditions are
+actually mutually exclusive.  For example, in Perl's test suite, we
+might want to test that a regular expression pattern can't both match
+and not match, for otherwise it would be a bug in our pattern matching
+code.
+
+ ($a =~ /$pat/ xor $a !~ /$pat/) or die;
+
 =head2 C Operators Missing From Perl
 X<operator, missing from perl> X<&> X<*>
 X<typecasting> X<(TYPE)>