Short-circuit evaluation: Difference between revisions

{{task|Programming language concepts}}

{{Control Structures}}

 

 

Similarly, if we needed to compute the disjunction (<code>or</code>):

 

 

 

=={{header|Ada}}==

Ada has built-in short-circuit operations '''and then''' and '''or else''':

 

procedure Test_Short_Circuit is

end loop;

end loop;

{{out|Sample output}}

<pre>

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d]}}

Note: The "brief" ''conditional clause'' ( ~ | ~ | ~ ) is a the standard's ''shorthand'' for enforcing ''short-circuit evaluation''. Moreover, the coder is able to define their own '''proc'''[edures] and '''op'''[erators] that implement ''short-circuit evaluation'' by using Algol68's ''proceduring''.

OP ORELSE = (BOOL a, PROC BOOL b)BOOL: ( a | a | b ),

ANDTHEN = (BOOL a, PROC BOOL b)BOOL: ( a | b | a );

print(("T ANDTHEN T = ", a(TRUE) ANDTHEN (BOOL:b(TRUE)), new line))

 

{{out}}

<pre>

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d]}}

 

PROC a = (BOOL a)BOOL: ( print(("a=",a,", ")); a),

END CO

 

{{out}}

<pre>

a=T, b=T, T ANDTH T = T

</pre>

 

=={{header|AutoHotkey}}==

In AutoHotkey, the boolean operators, '''and''', '''or''', and ternaries, short-circuit:

j = 1

x := a(i) and b(j)

MsgBox, b() was called with the parameter "%p%".

Return, p

 

=={{header|AWK}}==

Short-circuit evalation is done in logical AND (&&) and logical OR (||) operators:

BEGIN {

print (a(1) && b(1))

print " y:"y

return y

{{out}}

<pre>

y:1

1

</pre>

 

=={{header|BBC BASIC}}==

Short-circuit operators aren't implemented directly, but short-circuit AND can be simulated using cascaded IFs. Short-circuit OR can be converted into a short-circuit AND using De Morgan's laws.

FOR i% = TRUE TO FALSE

FOR j% = TRUE TO FALSE

DEFFNboolstring(bool%)

This gives the results shown below:

<pre>For x=a(TRUE) AND b(TRUE)

Function A used; Function B used; y is FALSE

</pre>

=={{header|Bracmat}}==

Bracmat has no booleans. The closest thing is the success or failure of an expression. A function is not called if the argument fails, so we have to use a trick to pass 'failure' to a function. Here it is accomplished by an extra level of indirection: two == in the definition of 'false' (and 'true', for symmetry) and two !! when evaluating the argument in the functions a and b. The backtick is another hack. This prefix tells Bracmat to look the other way if the backticked expression fails and to continue as if the expression succeeded. A neater way is to introduce an extra OR operator. That solution would have obscured the core of the current task.

Short-circuit evaluation is heavily used in Bracmat code. Although not required, it is a good habit to exclusively use AND (&) and OR (|) operators to separate expressions, as the code below exemplifies.

& (b=.out$"I'm b"&!!arg)

& (false==~)

& done

);

Output:

<pre>Testing false AND false

=={{header|C}}==

Boolean operators <nowiki>&&</nowiki> and || are shortcircuit operators.

#include <stdbool.h>

 

 

return 0;

 

=={{header|C sharp|C#}}==

 

class Program

}

}

{{out}}

False and False = False

 

 

a

 

=={{header|Clojure}}==

The print/println stuff in the doseq is kinda gross, but if you include them all in a single print, then the function traces are printed before the rest (since it has to evaluate them before calling print).

(b [bool] (print "(b)") bool)]

(doseq [i [true false] j [true false]]

(println (or (a i) (b j)))

(print i "AND" j " = ")

{{out}}

<pre>true OR true = (a)true

 

=={{header|Common Lisp}}==

(print 'a)

F )

(and (a (car x)) (b (car(cdr x))))

(format t "~%(or ~S)" x)

{{out}}

(and (NIL NIL))

=={{header|D}}==

{{trans|Python}}

 

T a(T)(T answer) {

immutable r2 = a(x) || b(y);

}

{{out}}

<pre>

=={{header|Delphi}}==

Delphi supports short circuit evaluation by default. It can be turned off using the {$BOOLEVAL OFF} compiler directive.

 

{$APPTYPE CONSOLE}

end;

end;

 

=={{header|E}}==

E defines <code>&amp;&amp;</code> and <code>||</code> in the usual short-circuiting fashion.

def b(v) { println("b"); return v }

 

def x := a(i) && b(j)

Unusually, E is an expression-oriented language, and variable bindings (which are expressions) are in scope until the end of the nearest enclosing <code>{ ... }</code> block. The combination of these features means that some semantics must be given to a binding occurring inside of a short-circuited alternative.

The choice we make is that <code>funky</code> is ordinary if the right-side expression was evaluated, and otherwise is <em>ruined</em>; attempts to access the variable give an error.

 

=={{header|Erlang}}==

-module( short_circuit_evaluation ).

 

io:fwrite( "~p orelse ~p~n", [Boolean1, Boolean2] ),

io:fwrite( "=> ~p~n", [a(Boolean1) orelse b(Boolean2)] ).

{{out}}

<pre>

=> false

</pre>

 

=={{header|F_Sharp|F#}}==

let b (x : bool) = printf "(b)"; x

 

|> List.iter (fun (x, y) ->

printfn "%b AND %b = %b" x y ((a x) && (b y))

Output

<pre>(a)(b)true AND true = true

(a)false AND false = false

(a)(b)false OR false = false</pre>

 

=={{header|Fantom}}==

{

static Bool a (Bool value)

}

}

{{out}}

<pre>

 

=={{header|Forth}}==

: ENDIF postpone THEN ; immediate

 

I A IF J B IF 1 ELSE END-PRIOR-IF 0 ENDIF ." ANDIF=" .bool CR

I A 0= IF J B IF END-PRIOR-IF 1 ELSE 0 ENDIF ." ORELSE=" .bool CR

{{out}}

<pre>A=true B=true ANDIF=true

{{works with|Fortran|90 and later}}

Using an <code>IF .. THEN .. ELSE</code> construct

implicit none

 

write(*, "(a,l1,a)") "Called function b(", value, ")"

end function

{{out}}

<pre>Calculating x = a(F) and b(F)

Called function a(T)

y = T</pre>

 

=={{header|Go}}==

Short circuit operators are <nowiki>&&</nowiki> and ||.

 

import "fmt"

test(true, false)

test(true, true)

{{out}}

<pre>Testing a(false) && b(false)

=={{header|Groovy}}==

Like all C-based languages (of which I am aware), Groovy short-circuits the logical and (<nowiki>&&</nowiki>) and logical or (||) operations, but not the bitwise and (<nowiki>&</nowiki>) and bitwise or (|) operations.

def g = { printf ('%5d ', it); it > 50 }

 

assert g(2) || f('sss')

assert ! (g(1) && f('sss'))

{{out}}

<pre>bitwise

=={{header|Haskell}}==

[[Lazy evaluation]] makes it possible for user-defined functions to be short-circuited. An expression will not be evaluated as long as it is not [[pattern matching|pattern matched]]:

 

import Prelude hiding ((&&), (||))

 

main = mapM_ print ( [ a p || b q | p <- [False, True], q <- [False, True] ]

{{out}}

<pre>

</pre>

One can force the right-hand arguemnt to be evaluated first be using the alternate definitions:

False && True = False

_ && _ = True

_ || True = True

True || False = True

{{out}}

<pre>

</pre>

The order of evaluation (in this case the original order again) can be seen in a more explicit form by [[syntactic sugar|desugaring]] the pattern matching:

False -> False

_ -> case q of

_ -> case q of

True -> True

 

=={{header|Icon}} and {{header|Unicon}}==

* Rather than have the tasks print their own name, we will just utilize built-in tracing which will be more informative.

This use of procedures as values is somewhat contrived but serves us well for demonstration purposes. In practice this approach would be strained since failure results aren't re-captured as values (and can't easily be).

&trace := -1 # ensures functions print their names

 

procedure false() #: fails always

fail # for clarity but not needed as running into end has the same effect

Sample output for a single case:<pre>i,j := procedure true, procedure false

i & j:

Shortcircuit.icn: 16 | true returned &null

i,j := procedure true, procedure true</pre>

 

=={{header|J}}==

See the J wiki entry on [[j:Essays/Short Circuit Boolean|short circuit booleans]].

A=: 'A ' labeled

B=: 'B ' labeled

and=: ^:

{{out|Example}}

B 1

A 1

B 0

A 0

Note that J evaluates right-to-left.

 

=={{header|Java}}==

In Java the boolean operators <code>&&</code> and <code>||</code> are short circuit operators. The eager operator counterparts are <code>&</code> and <code>|</code>.

public static void main(String[] args){

System.out.println("F and F = " + (a(false) && b(false)) + "\n");

return b;

}

{{out}}

<pre>a

a

T or T = true</pre>

 

=={{header|jq}}==

jq's 'and' and 'or' are short-circuit operators. The following demonstration, which follows the "awk" example above, requires a version of jq with the built-in filter 'stderr'.

 

def b(y): " b(\(y))" | stderr | y;

"or:", (a(true) or b(true)),

"and:", (a(false) and b(true)),

{{out}}

and:

" a(true)"

" a(false)"

" b(true)"

 

=={{header|Julia}}==

Julia does have short-circuit evaluation, which works just as you expect it to:

 

b(x) = (println("\t# Called b($x)"); return x)

 

println("\nCalculating: y = a($i) || b($j)"); y = a(i) || b(j)

println("\tResult: y = $y")

{{out}}

<pre>Calculating: x = a(true) && b(true)

# Called b(false)

Result: y = false</pre>

 

=={{header|Liberty BASIC}}==

LB does not have short-circuit evaluation. Implemented with IFs.

for i = 0 to 1

for j = 0 to 1

for i = 0 to 1

for j = 0 to 1

res =a( i) 'call always

if res = 0 then 'short circuit if <>0

print ,"calls func b"

b = t

{{out}}

calls func a

calls func a

calls func a

calls func b

calls func a

calls func b

calls func a

calls func b

calls func a

calls func b

calls func a

calls func a

 

=={{header|Logo}}==

The <code>AND</code> and <code>OR</code> predicates may take either expressions which are all evaluated beforehand, or lists which are short-circuit evaluated from left to right only until the overall value of the expression can be determined.

 

=={{header|Lua}}==

print "Function a(i) called."

return i

i = false

x = a(i) and b(i); print ""

 

Mathematica has built-in short-circuit evaluation of logical expressions.

b[in_] := (Print["b"]; in)

a[False] && b[True]

Evaluation of the preceding code gives:

False

a

Whereas evaluating this:

Gives:

b

 

=={{header|MATLAB}} / {{header|Octave}}==

Short-circuit evalation is done in logical AND (&&) and logical OR (||) operators:

printf('a: %i\n',x);

end;

a(0) && b(1)

a(1) || b(1)

{{out}}

a: 1

b: 1

> a(0) || b(1);

a: 0

 

=={{header|MUMPS}}==

MUMPS evaluates every expression it encounters, so we have to use conditional statements to do a short circuiting of the expensive second task.

WRITE !,?10,$STACK($STACK,"PLACE")

QUIT IN

WRITE !,$SELECT(Z:"TRUE",1:"FALSE")

KILL Z

{{out}}

<pre>USER>D SSEVAL3^ROSETTA

SSEVAL2+1^ROSETTA +3

TRUE</pre>

 

=={{header|Nemerle}}==

 

class ShortCircuit

WriteLine("False || False: {0}", a(f) || b(f));

}

{{out}}

b

True && True : True

a

b

 

=={{header|NetRexx}}==

{{trans|ooRexx}}

Like [[OoRexx]], [[NetRexx]] allows a list of expressions in the condition part of <tt>If</tt> and <tt>When</tt>. Evaluation ends with the first of these expressions resulting in <tt>boolean true</tt>.

options replace format comments java crossref symbols nobinary

 

Say '--b returns' state

Return state

{{out}}

<pre>

 

=={{header|Nim}}==

echo "a called"

result = x

proc b(x): bool =

echo "b called"

 

let x = a(false) and b(true) # echoes "a called"

 

=={{header|Objeck}}==

In Objeck the Boolean operators <code>&</code> and <code>|</code> short circuit.

function : a(a : Bool) ~ Bool {

"a"->PrintLine();

"T or T = {$result}"->PrintLine();

}

 

=={{header|OCaml}}==

let b r = print_endline " > function b called"; r

 

print_endline "==== Testing or ====";

test_this test_or;

{{out}}

==== Testing and ====

> function a called

> function b called

 

=={{header|ooRexx}}==

ooRexx allows a list of expressions in the condition part of If and When.

Say 'Version='v

If a() | b() Then Say 'a and b are true'

a: Say 'a returns .true'; Return .true

b: Say 'b returns 1'; Return 1

{{out}}

<pre>Version=REXX-ooRexx_4.2.0(MT)_32-bit 6.04 22 Feb 2014

=={{header|Oz}}==

Oz' <code>andthen</code> and <code>orelse</code> operators are short-circuiting, as indicated by their name. The library functions <code>Bool.and</code> and <code>Bool.or</code> are not short-circuiting, on the other hand.

fun {A Answer}

AnswerS = {Value.toVirtualString Answer 1 1}

Y = {A I} orelse {B J}

end

{{out}}

% Called function {A false} -> false

Calculating: Y = {A I} orelse {B J}

% Called function {B true} -> true

Calculating: Y = {A I} orelse {B J}

 

=={{header|PARI/GP}}==

Note that <code>|</code> and <code>&</code> are deprecated versions of the GP short-circuit operators.

print(a"("n")");

a

and(A,B)={

a(A) && b(B)

 

=={{header|Pascal}}==

===Standard Pascal===

Standard Pascal doesn't have native short-circuit evaluation.

 

function a(value: boolean): boolean;

scandor(true, false);

scandor(true, true);

 

===Turbo Pascal===

Turbo Pascal allows short circuit evaluation with a compiler switch:

 

function a(value: boolean): boolean;

scandor(true, false);

scandor(true, true);

===Extended Pascal===

The extended Pascal standard introduces the operators <code>and_then</code> and <code>or_else</code> for short-circuit evaluation.

 

function a(value: boolean): boolean;

scandor(true, false);

scandor(true, true);

Note: GNU Pascal allows <code>and then</code> and <code>or else</code> as alternatives to <code>and_then</code> and <code>or_else</code>.

 

=={{header|Perl}}==

Perl uses short-circuit boolean evaluation.

sub b { print 'B'; return $_[0] }

 

 

# Test and display

{{out}}

<pre>a(1) && b(1): AB

a(0) || b(0): AB</pre>

 

 

=={{header|PicoLisp}}==

(msg 'a)

F )

(println I Op J '-> (Op (a I) (b J))) ) )

'(NIL NIL T T)

{{out}}

<pre>a

 

=={{header|Pike}}==

{

write(" a\n");

write(" %d || %d\n", @args);

a(args[0]) || b(args[1]);

{{out}}

<pre>

 

=={{header|PL/I}}==

procedure options (main);

declare (true initial ('1'b), false initial ('0'b) ) bit (1);

end;

end;

{{out|Results}}

<pre>

Y='0'B;

</pre>

 

=={{header|Prolog}}==

Prolog has not functions but predicats succeed of fail.

Tested with SWI-Prolog. Should work with other dialects.

( a_or_b(true, true) -> writeln('==> true'); writeln('==> false')) , nl,

( a_or_b(true, false)-> writeln('==> true'); writeln('==> false')) , nl,

b(X) :-

format('b(~w)~n', [X]),

{{out}}

a(true) or b(true)

a(true)

==> false

 

 

=={{header|PureBasic}}==

Logical '''And''' &amp; '''Or''' operators will not evaluate their right-hand expression if the outcome can be determined from the value of the left-hand expression.

PrintN(" # Called function a("+Str(arg)+")")

ProcedureReturn arg

Next

Next

{{out}}

<pre>Calculating: x = a(0) And b(0)

=={{header|Python}}==

Pythons '''and''' and '''or''' binary, infix, boolean operators will not evaluate their right-hand expression if the outcome can be determined from the value of the left-hand expression.

print(" # Called function a(%r) -> %r" % (answer, answer))

return answer

# Called function b(True) -> True

Calculating: y = a(i) or b(j)

Pythons if ''expression'' can also be used to the same ends (but probably should not):

for j in (False, True):

print ("\nCalculating: x = a(i) and b(j) using x = b(j) if a(i) else False")

# Called function b(True) -> True

Calculating: y = a(i) or b(j) using y = b(j) if not a(i) else True

 

=={{header|R}}==

The builtins <tt><nowiki>&&</nowiki></tt> and <tt>||</tt> will short circuit:

{{trans|Perl}}

b <- function(x) {cat("b called\n"); x}

 

call <- substitute(op(a(x),b(y)), row)

cat(deparse(call), "->", eval(call), "\n\n")

{{out}}

a(1) || b(1) -> TRUE

 

 

a called

Because R waits until function arguments are needed before evaluating them, user-defined functions can also short circuit.

if(s < 0) x || y

else if (s > 0) x && y

else xor(x, y)

{{out}}

a called

[1] TRUE

a called

b called

 

=={{header|Racket}}==

(define (a x)

(display (~a "a:" x " "))

(displayln `(or (a ,x) (b ,y)))

(or (a x) (b y))

{{out}}

<pre>

</pre>

 

 

{{out}}

<pre>

</pre>

 

=={{header|Ruby}}==

Binary operators are short-circuiting. Demonstration code:

puts "a( #{bool} ) called"

bool

puts

end

{{out}}

<pre>

a( false ) or b( false ) is false.

</pre>

=={{header|Run BASIC}}==

ao$ = word$("AND,OR",k,",")

print "========= ";ao$;" =============="

print chr$(9);"calls func b"

b = t

<pre>========= AND ==============

a(0) AND b(0)

a(1) OR b(1)

calls func a</pre>

 

=={{header|Sather}}==

a(v:BOOL):BOOL is

#OUT + "executing a\n";

#OUT + "F or T = " + x + "\n\n";

end;

 

=={{header|Scala}}==

def a(b:Boolean)={print("Called A=%5b".format(b));b}

def b(b:Boolean)={print(" -> B=%5b".format(b));b}

println

}

{{out}}

<pre>Testing A=false AND B=false -> Called A=false

 

=={{header|Scheme}}==

(display "a\n")

x)

a

b

 

=={{header|Seed7}}==

const func boolean: a (in boolean: aBool) is func

test(TRUE, FALSE);

test(TRUE, TRUE);

{{out}}

<pre>

 

=={{header|Sidef}}==

# Test-driver

func test() {

# Test and display

{{out}}

<pre>a(1) && b(1): AB

a(0) || b(1): AB

a(0) || b(0): AB</pre>

 

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

The <code>and:</code> <code>or:</code> selectors are shortcircuit selectors but in order to avoid evaluation of the second operand, it must be a block: <code>a and: [ code ]</code> will evaluate the code only if a is true. On the other hand, <code>a and: b</code>, where b is an expression (not a block), behaves like the non-shortcircuit and (&amp;). (Same speech for or |)

Smalltalk at: #b put: nil.

 

('true and false = %1' %

{ (a value: true) and: [ b value: false ] })

 

=={{header|SNOBOL4}}==

 

The test statements below use a pattern constructed from the functions a( ) and b( ) and match it to the null string with deferred evaluation. This idiom allows the functions to self-report the expected short-circuit patterns.

a out = 'A '

eq(val,1) :s(return)f(freturn)

out = 'F or T: '; null ? *a(0) | *b(1); nl()

out = 'F or F: '; null ? *a(0) | *b(0); nl()

{{out}}

<pre>T and T: A B

=={{header|Standard ML}}==

{{trans|OCaml}}

fun b r = ( print " > function b called\n"; r )

 

test_this test_and;

print "==== Testing or ====\n";

{{out}}

==== Testing and ====

> function a called

> function b called

 

=={{header|Swift}}==

Short circuit operators are <nowiki>&&</nowiki> and ||.

print("a")

return v

test(false, true)

test(true, false)

{{out}}

<pre>

=={{header|Tcl}}==

The <code>&&</code> and <code>||</code> in the <code>expr</code> command support short-circuit evaluation. It is recommended that you always put expressions in braces so that and command or variable substitutions are applied at the right time rather than before the expression is evaluated at all. (Indeed, it is recommended that you do that anyway as unbraced expressions cannot be efficiently compiled.)

proc tcl::mathfunc::a boolean {

puts "a($boolean) called"

puts ""; # Blank line for clarity

}

{{out}}Note that booleans may be written out words or numeric:

<pre>

 

=={{header|TXR}}==

@ (output)

a (@x) called

@(short_circuit_demo "0" "1")

@(short_circuit_demo "1" "0")

{{out|Run}}

<pre>$ txr short-circuit-bool.txr

The ''&&'' and ''||'' operators use the exit status of each command. The ''true'' and ''false'' commands convert a string to an exit status; our code ''&& x=true || x=false'' converts an exit status to a string.

{{works with|Bourne Shell}}

echo "Called a $1"

"$1"

echo " $i || $j is $y"

done

The output reveals that <nowiki>&&</nowiki> and || have short-circuit evaluation.

<pre>Called a false

==={{header|C Shell}}===

Between commands, ''&&'' and ''||'' have short-circuit evaluation. (The aliases for ''a'' and ''b'' must expand to a single command; these aliases expand to an ''eval'' command.)

alias b eval \''echo "Called b \!:1"; "\!:1"'\'

 

echo " $i || $j is $x"

end

Inside expressions, ''&&'' and ''||'' can short circuit some commands, but cannot prevent substitutions.

if ( 1 || { echo This command never runs. } ) echo ok

 

 

# Prints "error", then "ok".

 

=={{header|zkl}}==

{{out}}

<pre>