1. Support in common programming languages

2. Common use
    Avoiding undesired side effects of the second argument 

3. Possible problems
     Untested second condition leads to unperformed side effect   Code efficiency 

4. References

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 some programming languages (Lisp, Perl, Haskell because of lazy evaluation), the usual Boolean operators are 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 not possible to short-circuit, because both operands are always required to determine the result.

The short-circuit expression x and y is equivalent to the

(True if y else False) if x else False; the expression

x or y is equivalent to

True if x else True if y else False.

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.

In loosely typed languages that have more than the two truth-values

True and False, short-circuit operators may return the

last evaluated subexpression. The expression x and y is

equivalent to y if x else x; the expression

x or y is equivalent to

twice). This is called "last value" in the table below.

In languages that use lazy evaluation by default (like Haskell), all functions are effectively short-circuit, and special short-circuit operators are not needed.

The use of short-circuit operators has been criticized as problematic:

(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.

Support in common programming languages

Common use

Avoiding undesired side effects of the second argument

Usual example, using a C-based language:

int denom = 0;

if (denom != 0 && num / denom)

}

Consider the following example:

int a = 0;

if (a != 0 && myfunc(b))

}

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.

1. 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.
2. 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)

}

bool is_first_char_valid_alpha(const char *p)

}

Possible problems

Untested second condition leads to unperformed side effect

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)) {

}

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.^[7]

Since minimal evaluation is part of an operator's semantic definition and not an (optional) optimization, many coding patterns{{Which|date=July 2010}} have come to rely on it as a succinct (if idiomatic) 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

BASH (UNIX shell script) idioms^[8]:

modprobe -q some_module && echo "some_module installed" || echo "some_module not installed"

Code efficiency

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.{{clarify|date=November 2010}} Some compilers can detect such cases and emit faster code, but programming language semantics may constrain such optimizations.{{cn|date=October 2016}}

References

• Scottish Football League 1899–00
• Scottish Football League 1900–01
• Scottish Football League 1901–02
• Scottish Football League 1902–03
• Scottish Football League 1903–04
• Scottish Football League 1904–05
• Scottish Football League 1905–06
• Scottish Football League 1906–07
• Scottish Football League 1907–08
• Scottish Football League 1908–09
• Scottish Football League 1909–10
• Scottish Football League 1910–11
• Scottish Football League 1911–12
• Scottish Football League 1912–13
• Scottish Football League 1913–14
• Scottish Football League 1914–15
• Scottish Football League 1915–16
• Scottish Football League 1916–17
• Scottish Football League 1917–18
• Scottish Football League 1918–19
• Scottish Football League 1919–20
• Scottish Football League 1920–21
• Scottish Football League 1921–22
• Scottish Football League 1922–23
• Scottish Football League 1923–24