[operators] &&, ||, //, min, max, item =, =>, not, so

Author: moritz

lib/operators.pod

@@ -806,4 +806,118 @@ Here is an excerpt of built-in smart-matching functionality:
 
 =end table
 
+=head1 Tight AND Precedence
+
+=head2 infix &&
+
+Returns the first argument that evaluates to C<False> in boolean context,
+or otherwise the last argument.
+
+Note that this short-circuits, i.e. if one of the arguments evaluates to a
+false value, the arguments to the right of are never evaluated.
+
+    sub a { 1 }
+    sub b { 0 }
+    sub c { die "never called" };
+    say a() && b() && c();      # 0
+
+=head1 Tight OR Precedence
+
+=head2 infix ||
+
+Returns the first argument that evaluates to C<True> in boolean context,
+or otherwise the last argument.
+
+Note that this short-circuits, i.e. if one of the arguments evaluates to a
+true value, the arguments to the right of are never evaluated.
+
+    sub a { 0 }
+    sub b { 1 }
+    sub c { die "never called" };
+    say a() || b() || c();      # 1
+
+=head2 infix ^^
+
+Returns the first true argument if there is only one, and L<Nil> otherwise.
+Short-circuits as soon as two true arguments are found.
+
+    say 0 ^^ 42;                # 42
+    say 0 ^^ 42 ^^ 1 ^^ die 8;  # (empty line)
+
+=head2 infix //
+
+Defined-or operator. Returns the first defined operand. Short-circuits.
+
+    say Any // 0 // 42;         # 0
+
+=head2 infix min
+
+Returns the smallest of the arguments, as determined by L<cmp> semantics.
+
+=head2 infix max
+
+Returns the largest of the arguments, as determined by L<cmp> semantics.
+
+=head1 Conditional Operator Precedence
+
+=head2 infix ?? !!
+
+Ternary operator, conditional operator.
+
+C<$condition ?? $true !! $false> evaluates and returns the expression from the
+C<$true> branch if C<$condition> is a true value. Otherwise it evaluates and
+returns the C<$false> branch.
+
+# TODO: ff, ^ff, ff^, ^ff^, fff, ^fff, fff^, ^fff^
+
+=head1 Item Assignment Precedence
+
+=head2 infix =
+
+    sub infix:<=>(Mu $a is rw, Mu $b)
+
+Item assignment.
+
+Places the value of the left-hand side into the container on the right-hand
+side.
+
+(Note that item assignment and list assignment have different precedence
+levels, and the syntax of the left-hand side decides whether an equal sign
+C<=> is parsed as item assignment or list assignment operator).
+
+=head2 infix =>
+
+    sub infix:«=>»($key, Mu $value) returns Pair:D
+
+L<Pair> constructor.
+
+Constructs a L<Pair> object with the left-hand side as the key and the
+right-hand side as the value.
+
+Note that the C<< => >> operator is syntactically special-cased, in that
+it allows unquoted identifier on the left-hand side.
+
+    my $p = a => 1;
+    say $p.key;         # a
+    say $p.value;       # 1
+
+A L<Pair> within an argument list with an unquoted identifier on the left
+is interpreted as a named argument.
+
+=head1 Loose Unary Precedence
+
+=head2 prefix not
+
+    multi sub prefix:<not>(Mu $x) returns Bool:D
+
+Evaluates its argument in boolean context (and thus collapses L<Junction>s),
+and negates the result.
+
+=head2 prefix so
+
+    multi sub prefix:<so>(Mu $x) returns Bool:D
+
+Evaluates its argument in boolean context (and thus collapses L<Junction>s),
+and returns the result.
+
 =end pod