The set of [tcl::mathop] commands does not include commands corresponding to the `[&&]` or `[||]` operators for reasons that are, well, reasonable.  You can still (easily) fake them on lists of values that are a subset of the general set of boolean values, namely 0 (falsity) and all non-zero numerical values (truth).  (You can also fake them on general boolean values that aren't numeric, such as `yes` or `false`, but not as easily or conveniently: I show commands that do just that at the bottom of the page.)

Limiting the boolean domain to this sub-domain is actually quite natural in Tcl. Any boolean expression already does evaluate to a value in this sub-domain, or can be trivially converted to a value in it by applying the logical negation (NOT, `!`) twice:

======
set foo [list true 1 [expr {5 > 2}]]
# => true 1 1
set bar [lmap elem $foo { expr {!!$elem} }]
# => 1 1 1
======

Because the definition is that 0 means false and non-zero means true, we can use `tcl::mathop::*` to perform a multi-argument AND operation on these values:

======
::tcl::mathop::* {*}$bar
# => 1
::tcl::mathop::* [expr {5 > 2}] [expr {5 > 4}] [expr {5 > 7}]
# => 0
======

since the semantics of multiplication corresponds to the semantics of conjunction (AND) when the domain of boolean values is defined this way.  Even in the case where there are no arguments provided the semantics are a fit, since the multiplicative and the conjunctive identities are both 1.

An important caveat is that there is no short-circuit evaluation: every argument is evaluated.

Multi-argument OR can also be faked along similar lines:

======
::tcl::mathop::+ [expr {5 > 2}] [expr {5 > 4}] [expr {5 > 7}]
# => 2
# (and 2 is logically true!)
::tcl::mathop::+ [expr {5 > 12}] [expr {5 > 14}] [expr {5 > 7}]
# => 0
======

since the semantics of addition corresponds to the semantics of inclusive disjunction (OR) when the domain of boolean values is defined this way.  Even in the case where there are no arguments provided the semantics are a fit, since the additive and the disjunctive identities are both 0.

An important caveat is (as above) that there is no short-circuit evaluation: every argument is evaluated.Commands can be implemented for these operations in this way (but again, for every set of boolean values that aren't the boolean literals `on`, `true`, etc, the `tcl::mathop::*` and `+` commands are sufficient):

======
proc listAnd args {
    # Performs serial logical conjunction without short-circuit evaluation.
    # Every argument shall be a pre-evaluated boolean value.
    # If given at least one false value, returns 0, otherwise (including if given no values) returns 1.
    ::tcl::mathop::* {*}[lmap arg $args { expr {!!$arg} }]
}

proc listOr args {
    # Performs serial logical inclusive disjunction without short-circuit evaluation.
    # Every argument shall be a pre-evaluated boolean value.
    # If given at least one true value, returns 1, otherwise (including if given no values) returns 0.
    expr {[::tcl::mathop::+ {*}[lmap arg $args { expr {!!$arg} }]] > 0}
}

% listOr [expr {5 > 12}] [expr {5 > 14}] [expr {5 > 7}]
# => 0
% listOr [expr {5 > 12}] [expr {5 > 4}] [expr {5 > 7}]
# => 1
% listAnd [expr {5 > 2}] [expr {5 > 4}] [expr {5 > 7}]
# => 0
% listAnd [expr {5 > 2}] [expr {5 > 4}]
# => 1
======

See also

   * [tcl::mathop]
   * [Math Operators as Commands]


<<categories>> Command | Syntax