Evaluation strategies |
---|
Short-circuit evaluation, minimal evaluation, or McCarthy evaluation (after John McCarthy) is the semantics of some Boolean operators in some programming languages in which the second argument is executed or evaluated only if the first argument does not suffice to determine the value of the expression: when the first argument of the AND
function evaluates to false
, the overall value must be false
; and when the first argument of the OR
function evaluates to true
, the overall value must be true
.
In programming languages with lazy evaluation (Lisp, Perl, Haskell), the usual Boolean operators short-circuit. In others (Ada, Java, Delphi), both short-circuit and standard Boolean operators are available. For some Boolean operations, like exclusive or (XOR), it is impossible to short-circuit, because both operands are always needed to determine a result.
Short-circuit operators are, in effect, control structures rather than simple arithmetic operators, as they are not strict. In imperative language terms (notably C and C++), where side effects are important, short-circuit operators introduce a sequence point: they completely evaluate the first argument, including any side effects, before (optionally) processing the second argument. ALGOL 68 used proceduring to achieve user-defined short-circuit operators and procedures.
The use of short-circuit operators has been criticized as problematic:
The conditional connectives — "cand" and "cor" for short — are ... less innocent than they might seem at first sight. For instance, cor does not distribute over cand: compare
- (A cand B) cor C with (A cor C) cand (B cor C);
in the case ¬A ∧ C , the second expression requires B to be defined, the first one does not. Because the conditional connectives thus complicate the formal reasoning about programs, they are better avoided.
Definition
[edit]In any programming language that implements short-circuit evaluation, the expression x and y
is equivalent to the conditional expression if x then y else x
, and the expression x or y
is equivalent to if x then x else y
. In either case, x is only evaluated once.
The generalized definition above accommodates loosely typed languages that have more than the two truth-values True
and False
, where short-circuit operators may return the last evaluated subexpression. This is called "last value" in the table below. For a strictly-typed language, the expression is simplified to if x then y else false
and if x then true else y
respectively for the boolean case.
Precedence
[edit]Although AND
takes precedence over OR
in many languages, this is not a universal property of short-circuit evaluation. An example of the two operators taking the same precedence and being left-associative with each other is POSIX shell's command-list syntax.[2]: §2.9.3
The following simple left-to-right evaluator enforces a precedence of AND
over OR
by a continue
:
function short-circuit-eval (operators, values) let result := True for each (op, val) in (operators, values): if op = "AND" && result = False continue else if op = "OR" && result = True return result else result := val return result
Formalization
[edit]Short-circuit logic, with or without side-effects, have been formalized based on Hoare's conditional. A result is that non-short-circuiting operators can be defined out of short-circuit logic to have the same sequence of evaluation.[3]
Support in common programming and scripting languages
[edit]As you look at the table below, keep in mind that bitwise operators often do not behave exactly like logical operators, even if both arguments are of 0
, 1
or Boolean type.
Examples:
- In JavaScript, each of the following 3 expressions evaluates to
false
:(true & true) === (true && true)
,(false | false) === (false || false)
,(1 & 2) === (1 && 2)
. - In PHP, each of the following 3 expressions evaluates to
false
:(true & true) === (true && true)
,(0 | 0) === (0 || 0)
,(1 & 2) === (1 && 2)
.
Language | Eager operators | Short-circuit operators | Result type |
---|---|---|---|
Advanced Business Application Programming (ABAP) | none | and , or
|
Boolean[a] |
Ada | and , or
|
and then , or else
|
Boolean |
ALGOL 68 | and, &, ∧ ; or, ∨ | andf , orf (both user defined) | Boolean |
APL | ∧ , ∨ , ⍲ (nand), ⍱ (nor), etc.
|
:AndIf , :OrIf
|
Boolean[a] |
awk | none | && , ||
|
Boolean |
Bash | none | && , ||
|
Boolean |
C, Objective-C | & , | [b]
|
&& , || , ? [5]
|
int (& , | , && ,|| ), opnd-dependent (? )
|
C++[c] | none | && , || , ? [6]
|
Boolean (&& ,|| ), opnd-dependent (? )
|
C# | & , |
|
&& , || , ? , ??
|
Boolean (&& ,|| ), opnd-dependent (? , ?? )
|
ColdFusion Markup Language (CFML) | none | AND , OR , && , ||
|
Boolean |
D[d] | & , |
|
&& , || , ?
|
Boolean (&& ,|| ), opnd-dependent (? )
|
Eiffel | and , or
|
and then , or else
|
Boolean |
Erlang | and , or
|
andalso , orelse
|
Boolean |
Fortran[e] | .and. , .or.
|
.and. , .or.
|
Boolean |
Go, Haskell, OCaml | none | && , ||
|
Boolean |
Java, MATLAB, R, Swift | & , |
|
&& , ||
|
Boolean |
JavaScript | none | && , &&= , || , ||=
|
Last value |
Julia | none | && , ||
|
Last value |
Lasso | none | and , or , && , ||
|
Last value |
Kotlin | and , or
|
&& , ||
|
Boolean |
Lisp, Lua, Scheme | none | and , or
|
Last value |
MUMPS (M) | & , !
|
none | Numeric |
Modula-2 | none | AND , OR
|
Boolean |
Oberon | none | & , OR
|
Boolean |
OCaml | land , lor [7]
|
&& , ||
|
Boolean |
Pascal | and , or [f][g]
|
and_then , or_else [g]
|
Boolean |
Perl | & , |
|
&& , and , || , or
|
Last value |
PHP | none | && , and , || , or
|
Boolean |
POSIX shell (command list) | none | && , ||
|
Last value (exit) |
PowerShell Scripting Language | none | -and , -or
|
Boolean |
Python | & , |
|
and , or
|
Last value |
Ruby | & , |
|
&& , and , || , or [8]
|
Last value |
Rust | & , |
|
&& , || [9]
|
Boolean |
Smalltalk | & , |
|
and: , or: [h]
|
Boolean |
Standard ML | Unknown | andalso , orelse
|
Boolean |
TTCN-3 | none | and , or [10]
|
Boolean |
Beckhoff TwinCAT® (IEC 61131-3)[i] | AND , OR
|
AND_THEN ,[11] OR_ELSE [12]
|
Boolean |
Visual Basic .NET | And , Or
|
AndAlso , OrElse
|
Boolean |
Visual Basic, Visual Basic for Applications (VBA) | And , Or
|
Select Case [j]
|
Numeric |
Wolfram Language | And @@ {...} , Or @@ {...}
|
And , Or , && , ||
|
Boolean |
ZTT | & , |
|
none | Boolean |
- ^ a b ABAP and APL have no distinct boolean type.
- ^ The bitwise operators behave like boolean operators when both arguments are of type
bool
or take only the values0
or1
.[4] - ^ When overloaded, the operators
&&
and||
are eager and can return any type. - ^ This only applies to runtime-evaluated expressions,
static if
andstatic assert
. Expressions in static initializers or manifest constants use eager evaluation. - ^ Fortran operators are neither short-circuit nor eager: the language specification allows the compiler to select the method for optimization.
- ^ ISO/IEC 10206:1990 Extended Pascal allows, but does not require, short-circuiting.
- ^ a b Delphi and Free Pascal default to short circuit evaluation. This may be changed by compiler options but does not seem to be used widely.
- ^ Smalltalk uses short-circuit semantics as long as the argument to
and:
is a block (e.g.,false and: [Transcript show: 'Wont see me']
). - ^ The norm IEC 61131-3 doesn't actually define if
AND
andOR
use short-circuit evaluation and it doesn't define the operatorsAND_THEN
andOR_ELSE
. The entries in the table show how it works for Beckhoff TwinCAT®. - ^ BASIC languages that supported CASE statements did so by using the conditional evaluation system, rather than as jump tables limited to fixed labels.
Common use
[edit]Avoiding undesired side effects of the second argument
[edit]Usual example, using a C-based language:
int denom = 0;
if (denom != 0 && num / denom)
{
... // ensures that calculating num/denom never results in divide-by-zero error
}
Consider the following example:
int a = 0;
if (a != 0 && myfunc(b))
{
do_something();
}
In this example, short-circuit evaluation guarantees that myfunc(b)
is never called. This is because a != 0
evaluates to false. This feature permits two useful programming constructs.
- If the first sub-expression checks whether an expensive computation is needed and the check evaluates to false, one can eliminate expensive computation in the second argument.
- It permits a construct where the first expression guarantees a condition without which the second expression may cause a run-time error.
Both are illustrated in the following C snippet where minimal evaluation prevents both null pointer dereference and excess memory fetches:
bool is_first_char_valid_alpha_unsafe(const char *p)
{
return isalpha(p[0]); // SEGFAULT highly possible with p == NULL
}
bool is_first_char_valid_alpha(const char *p)
{
return p != NULL && isalpha(p[0]); // 1) no unneeded isalpha() execution with p == NULL, 2) no SEGFAULT risk
}
Idiomatic conditional construct
[edit]Since minimal evaluation is part of an operator's semantic definition and not an optional optimization, a number of coding idioms rely on it as a succinct conditional construct. Examples include:
Perl idioms:
some_condition or die; # Abort execution if some_condition is false
some_condition and die; # Abort execution if some_condition is true
POSIX shell idioms:[13]
modprobe -q some_module && echo "some_module installed" || echo "some_module not installed"
This idiom presumes that echo
cannot fail.
Possible problems
[edit]Untested second condition leads to unperformed side effect
[edit]Despite these benefits, minimal evaluation may cause problems for programmers who do not realize (or forget) it is happening. For example, in the code
if (expressionA && myfunc(b)) {
do_something();
}
if myfunc(b)
is supposed to perform some required operation regardless of whether do_something()
is executed, such as allocating system resources, and expressionA
evaluates as false, then myfunc(b)
will not execute, which could cause problems. Some programming languages, such as Java, have two operators, one that employs minimal evaluation and one that does not, to avoid this problem.
Problems with unperformed side effect statements can be easily solved with proper programming style, i.e., not using side effects in boolean statements, as using values with side effects in evaluations tends to generally make the code opaque and error-prone.[14]
Reduced efficiency due to constraining optimizations
[edit]Short-circuiting can lead to errors in branch prediction on modern central processing units (CPUs), and dramatically reduce performance. A notable example is highly optimized ray with axis aligned box intersection code in ray tracing.[clarification needed] Some compilers can detect such cases and emit faster code, but programming language semantics may constrain such optimizations.[citation needed]
An example of a compiler unable to optimize for such a case is Java's Hotspot virtual machine (VM) as of 2012.[15]
See also
[edit]References
[edit]- ^ Edsger W. Dijkstra "On a somewhat disappointing correspondence", EWD1009-0, 25 May 1987 full text
- ^ "Shell Command Language". pubs.opengroup.org.
- ^ Bergstra, Jan A.; Ponse, A.; Staudt, D.J.C. (2010). "Short-circuit logic". arXiv:1010.3674 [cs.LO].
- ^ ISO/IEC 9899 standard, sections 6.2.5, 6.3.1.2, 6.5 and 7.16.
- ^ ISO/IEC 9899 standard, section 6.5.13
- ^ ISO/IEC IS 14882 draft.
- ^ "OCaml - the OCaml language".
- ^ "operators - Documentation for Ruby 3.3". docs.ruby-lang.org. Retrieved 2024-04-02.
- ^ "std::ops - Rust". doc.rust-lang.org. Retrieved 2019-02-12.
- ^ ETSI ES 201 873-1 V4.10.1, section 7.1.4
- ^ "Beckhoff Information System - English". infosys.beckhoff.com. Retrieved 2021-08-16.
- ^ "Beckhoff Information System - English". infosys.beckhoff.com. Retrieved 2021-08-16.
- ^ "What does || mean in bash?". stackexchange.com. Retrieved 2019-01-09.
- ^ "Referential Transparency, Definiteness and Unfoldability" (PDF). Itu.dk. Retrieved 2013-08-24.
- ^ Wasserman, Louis (11 July 2012). "Java: What are the cases in which it is better to use unconditional AND (& instead of &&)". Stack Overflow.
Well, that’s interesting to know that Psilotum nudum are known as whisk ferns. Psilotum nudum is the commoner species of the two. While the P. flaccidum is a rare species and is found in the tropical islands. Both the species are usually epiphytic in habit and grow upon tree ferns. These species may also be terrestrial and grow in humus or in the crevices of the rocks.
View the detailed Guide of Psilotum nudum: Detailed Study Of Psilotum Nudum (Whisk Fern), Classification, Anatomy, Reproduction