Short-circuit evaluation: Difference between revisions

{{trans|Python}}

 

print(‘ ## Called function a(#.)’.format(v))

R v

V x = a(i) & b(j)

print(‘Calculating: y = a(i) or b(j)’)

 

{{out}}

 

Source Code for the module:

False equ 0

True equ 255

db "A OR B IS TRUE",0

BoolText_A_or_B_False:

 

 

The relevant code for the actual invoking of the functions:

sta z_B

lda #True

jsr Func_A_or_B

 

And finally the output:

 

=={{header|Action!}}==

PrintF(" a(%B)",x)

RETURN (x)

OD

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Short-circuit_evaluation.png Screenshot from Atari 8-bit computer]

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

=={{header|ALGOL W}}==

In Algol W the boolean "and" and "or" operators are short circuit operators.

 

logical procedure a( logical value v ) ; begin write( "a: ", v ); v end ;

write( "---" );

{{out}}

<pre>

(As a statement, rather than an expression, the ''if ... then ... else'' structure does not compose – unlike ''cond'' or ''? :'', it can not be nested inside expressions)

 

map(test, {|and|, |or|})

end map

 

 

 

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

 

=={{header|Axe}}==

TEST(0,1)

TEST(1,0)

Lbl B

r₁

 

=={{header|BaCon}}==

BaCon supports short-circuit evaluation.

 

FUNCTION a(f)

PRINT "FUNCTION a"

PRINT "TRUE or FALSE"

y = a(TRUE) OR b(FALSE)

 

{{out}}

=={{header|Batch File}}==

{{trans|Liberty BASIC}}

%=== I will instead use 1 as true and 0 as false. ===%

 

echo. calls func b

set bool_b=%1

{{Out}}

<pre>AND

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

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|C++}}==

Just like C, boolean operators <nowiki>&&</nowiki> and || are shortcircuit operators.

 

bool a(bool in)

test(true, true);

return 0;

{{out}}

<pre>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|Dyalect}}==

{{trans|Swift}}

 

print(nameof(a), terminator: "")

return v

testMe(false, true)

testMe(true, false)

 

{{out}}

=={{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|Elena}}==

ELENA 5.0 :

import extensions;

}

}

{{out}}

<pre>

 

=={{header|Elixir}}==

defp a(bool) do

IO.puts "a( #{bool} ) called"

end

 

 

{{out}}

 

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

 

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

=={{header|Factor}}==

<code>&&</code> and <code>||</code> perform short-circuit evaluation, while <code>and</code> and <code>or</code> do not. <code>&&</code> and <code>||</code> both expect a sequence of quotations to evaluate in a short-circuit manner. They are smart combinators; that is, they infer the number of arguments taken by the quotations. If you opt not to use the smart combinators, you can also use words like <code>0&&</code> and <code>2||</code> where the arity of the quotations is dictated.

IN: rosetta-code.short-circuit

 

"t || f = " write { [ t a ] [ f b ] } || .

"t && t = " write { [ t a ] [ t b ] } && .

{{out}}

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

 

=={{header|FreeBASIC}}==

 

Function a(p As Boolean) As Boolean

Print

Print "Press any key to quit"

 

{{out}}

=={{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:

=={{header|Io}}==

{{trans|Ruby}}

writeln("a(#{bool}) called." interpolate)

bool

writeln

)

{{output}}

<pre>a(true) called.

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

Short-circuiting evaluation of boolean expressions has been the default since the first versions of JavaScript.

 

'use strict';

 

return [x, y, z];

 

The console log shows that in each case (the binding of all three values), only the left-hand part of the expression (the application of ''a(expr)'') was evaluated – ''b(expr)'' was skipped by logical short-circuiting.

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

 

=={{header|Kotlin}}==

 

fun a(v: Boolean): Boolean {

println()

}

 

{{out}}

Short-circuiting evaluation of boolean expressions has been the default since the first versions of lambdatalk.

{def A {lambda {:bool} :bool}} -> A

{def B {lambda {:bool} :bool}} -> B

{or {A false} {B true}} -> true

{or {A false} {B false}} -> false

 

Some more words about short-circuit evaluation. Lambdatalk comes with the {if "bool" then "one" else "two"} special form where "one" or "two" are not evaluated until "bool" is. This behaviour prevents useless computing and allows recursive processes. For instance, the naïve fibonacci function quickly leads to extensive computings.

 

{def fib

{{P.right {when}}} -> 832040 // after choice using {}

 

 

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

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

for i = 0 to 1

for j = 0 to 1

print ,"calls func b"

b = t

{{out}}

<pre>AND

=={{header|LiveCode}}==

Livecode uses short-circuit evaluation.

function a bool

put "a called with" && bool & cr after outcome

end repeat

put outcome

 

=={{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 ""

 

=={{header|Maple}}==

Built-in short circuit evaluation

printf("a is called->%s\n", bool):

return bool:

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

od:

{{Out|Output}}

<pre>calculating x := a(i) and b(j)

=={{header|Mathematica}}/{{header|Wolfram Language}}==

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:

<pre>a

True</pre>

Whereas evaluating this:

Gives:

<pre>a

=={{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|Modula-2}}==

FROM FormatString IMPORT FormatString;

FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

Print(TRUE,FALSE);

ReadChar

 

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

=={{header|Nanoquery}}==

Nanoquery does not short-circuit by default, so short-circuit logic functions have been implemented by nested ifs.

global a

global b

 

println "T and T = " + short_and(true, true) + "\n"

{{out}}

<pre>a called.

 

=={{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}}==

Nim produces code which uses short-circuit evaluation.

echo "a called"

result = x

 

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 ====

 

=={{header|Ol}}==

(define (a x)

(print " (a) => " x)

'(#t #t #f #f)

'(#t #f #t #f))

{{Out}}

<pre>

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

Evaluation ends with the first of these expressions resulting in .false (or 0).

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

=={{header|Phix}}==

In Phix all expressions are short circuited

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{Out}}

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

=={{header|PowerShell}}==

PowerShell handles this natively.

function a ( [boolean]$J ) { return $J }

( a $True ) -and ( b $False )

( a $True ) -and ( b $True )

{{out}}

<pre>True

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>

(formerly Perl 6)

{{Works with|rakudo|2018.03}}

 

sub a ($p) { print 'a'; $p }

print "\n";

}

{{out}}

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

language specifications that

<br>short-circuiting is '''not''' supported).

parse arg LO HI . /*obtain optional arguments from the CL*/

if LO=='' | LO=="," then LO= -2 /*Not specified? Then use the default.*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

a: say ' A entered with:' arg(1); return abs( arg(1) // 2) /*1=odd, 0=even */

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

 

=={{header|Ring}}==

# Project : Short-circuit evaluation

 

b = t

return b

Output:

<pre>

=={{header|Ruby}}==

Binary operators are short-circuiting. Demonstration code:

puts "a( #{bool} ) called"

bool

puts

end

{{out}}

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

=={{header|Rust}}==

 

println!("a");

foo

}

}

{{out}}

<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}}==

func b(bool) { print 'B'; return bool }

 

 

# Test and display

{{out}}

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

 

=={{header|Simula}}==

 

BOOLEAN PROCEDURE A(BOOL); BOOLEAN BOOL;

TEST;

END.

{{out}}

<pre>

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

Stata always evaluates both arguments of operators & and |. Here is a solution with '''if''' statements.

 

printf(" a")

return(x)

printf("\n")

return((x,y))

 

'''Example'''

 

and: a

or: a b

+---------+

1 | 1 1 |

 

=={{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|VBA}}==

Debug.Print "a: "; i = 1,

a = i

Debug.Print

End Sub

 

a: Onwaar = x

=={{header|Visual Basic .NET}}==

{{trans|c++}}

 

Function A(v As Boolean) As Boolean

End Sub

 

{{out}}

<pre>a

 

=={{header|Visual FoxPro}}==

*!* Visual FoxPro natively supports short circuit evaluation

CLEAR

RETURN v

ENDFUNC

{{out}}

<pre>

=={{header|Wren}}==

Wren has the '''&&''' and '''||''' short-circuiting operators found in many C family languages.

System.print(" a called")

return bool

a.call(bool[0]) || b.call(bool[1])

System.print()

 

{{out}}

 

=={{header|zkl}}==

{{out}}

<pre>