Short-circuit evaluation: Difference between revisions
m
→{{header|Wren}}: Changed to Wren S/H
(Added Quackery.) |
m (→{{header|Wren}}: Changed to Wren S/H) |
||
(15 intermediate revisions by 10 users not shown) | |||
Line 506:
{{true, false, false, false}, {true, true, true, false}}
</pre>
=={{header|Arturo}}==
<syntaxhighlight lang="arturo">a: function [v][
print ["called function A with:" v]
v
]
b: function [v][
print ["called function B with:" v]
v
]
loop @[true false] 'i ->
loop @[true false] 'j ->
print ["\tThe result of A(i) AND B(j) is:" and? -> a i -> b j]
print ""
loop @[true false] 'i ->
loop @[true false] 'j ->
print ["\tThe result of A(i) OR B(j) is:" or? -> a i -> b j]</syntaxhighlight>
{{out}}
<pre>called function A with: true
called function B with: true
The result of A(i) AND B(j) is: true
called function A with: true
called function B with: false
The result of A(i) AND B(j) is: false
called function A with: false
The result of A(i) AND B(j) is: false
called function A with: false
The result of A(i) AND B(j) is: false
called function A with: true
The result of A(i) OR B(j) is: true
called function A with: true
The result of A(i) OR B(j) is: true
called function A with: false
called function B with: true
The result of A(i) OR B(j) is: true
called function A with: false
called function B with: false
The result of A(i) OR B(j) is: false</pre>
=={{header|AutoHotkey}}==
Line 583 ⟶ 629:
Return</syntaxhighlight>
=={{header|
==={{header|BaCon}}===
BaCon supports short-circuit evaluation.
Line 632 ⟶ 679:
=={{header|Batch File}}==
{{trans|Liberty BASIC}}
<syntaxhighlight lang="dos">%=== Batch Files have no booleans
%=== I will instead use 1 as true and 0 as false. ===%
Line 1,179 ⟶ 1,226:
<syntaxhighlight lang="e">def x := a(i) && (def funky := b(j))</syntaxhighlight>
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|EasyLang}}==
<syntaxhighlight lang=easylang>
func a x .
print "->a: " & x
return x
.
func b x .
print "->b: " & x
return x
.
print "1 and 1"
if a 1 = 1 and b 1 = 1
print "-> true"
.
print ""
print "1 or 1"
if a 1 = 1 or b 1 = 1
print "-> true"
.
print ""
print "0 and 1"
if a 0 = 1 and b 1 = 1
print "-> true"
.
print ""
print "0 or 1"
if a 0 = 1 or b 1 = 1
print "-> true"
.
</syntaxhighlight>
=={{header|Ecstasy}}==
Similar to Java, Ecstasy uses the <span style="background-color: #e5e4e2"> && </tt></span> and <span style="background-color: #e5e4e2"><tt> || </tt></span> operators for short-circuiting logic, and <span style="background-color: #e5e4e2"><tt> & </tt></span> and <span style="background-color: #e5e4e2"><tt> | </tt></span> are the normal (non-short-circuiting) forms.
<syntaxhighlight lang="java">
module test {
@Inject Console console;
static Boolean show(String name, Boolean value) {
console.print($"{name}()={value}");
return value;
}
void run() {
val a = show("a", _);
val b = show("b", _);
for (Boolean v1 : False..True) {
for (Boolean v2 : False..True) {
console.print($"a({v1}) && b({v2}) == {a(v1) && b(v2)}");
console.print();
console.print($"a({v1}) || b({v2}) == {a(v1) || b(v2)}");
console.print();
}
}
}
}
</syntaxhighlight>
{{out}}
<pre>
a()=False
a(False) && b(False) == False
a()=False
b()=False
a(False) || b(False) == False
a()=False
a(False) && b(True) == False
a()=False
b()=True
a(False) || b(True) == True
a()=True
b()=False
a(True) && b(False) == False
a()=True
a(True) || b(False) == True
a()=True
b()=True
a(True) && b(True) == True
a()=True
a(True) || b(True) == True
</pre>
=={{header|Elena}}==
ELENA
<syntaxhighlight lang="elena">import system'routines;
import extensions;
Func<bool, bool> a = (bool x){ console.writeLine
Func<bool, bool> b = (bool x){ console.writeLine
const bool[] boolValues = new bool[]{ false, true };
Line 1,193 ⟶ 1,330:
public program()
{
boolValues.forEach::(bool i)
{
boolValues.forEach::(bool j)
{
console.printLine(i," and ",j," = ",a(i) && b(j));
Line 1,629 ⟶ 1,766:
=={{header|Fōrmulæ}}==
{{FormulaeEntry|page=https://formulae.org/?script=examples/Short-circuit_evaluation}}
'''Solution'''
[[File:Fōrmulæ - Short-circuit evaluation 01.png]]
[[File:Fōrmulæ - Short-circuit evaluation 02.png]]
=={{header|Go}}==
Line 1,852 ⟶ 1,991:
Shortcircuit.icn: 16 | true returned &null
i,j := procedure true, procedure true</pre>
=={{header|Insitux}}==
{{trans|Clojure}}
<syntaxhighlight lang="insitux">
(let a (fn (print-str "a ") %)
b (fn (print-str "b ") %)
f (pad-right " " 6))
(for i [true false] j [true false]
(print-str (f i) "OR " (f j) " = ")
(print (or (a i) (b j)))
(print-str (f i) "AND " (f j) " = ")
(print (and (a i) (b j))))
</syntaxhighlight>
{{out}}
<pre>
true OR true = a true
true AND true = a b true
true OR false = a true
true AND false = a b false
false OR true = a b true
false AND true = a false
false OR false = a b false
false AND false = a false
</pre>
=={{header|Io}}==
Line 2,324 ⟶ 2,488:
x = a(i) and b(i); print ""
y = a(i) or b(i)</syntaxhighlight>
=={{header|M2000 Interpreter}}==
<syntaxhighlight lang="m2000 interpreter">
Module Short_circuit_evaluation {
function a(a as boolean) {
=a
doc$<=format$(" Called function a({0}) -> {0}", a)+{
}
}
function b(b as boolean) {
=b
doc$<=format$(" Called function b({0}) -> {0}", b)+{
}
}
boolean T=true, F, iv, jv
variant L=(F, T), i, j
i=each(L)
global doc$ : document doc$
while i
j=each(L)
while j
(iv, jv)=(array(i), array(j))
doc$<=format$("Calculating x = a({0}) and b({1}) -> {2}", iv, jv, iv and jv)+{
}
x=if(a(iv)->b(jv), F)
doc$<=format$("x={0}", x)+{
}+ format$("Calculating y = a({0}) or b({1}) -> {2}", iv, jv, iv or jv)+{
}
y=if(a(iv)->T, b(jv))
doc$<=format$("y={0}", y)+{
}
end while
end while
clipboard doc$
report doc$
}
Short_circuit_evaluation
</syntaxhighlight>
{{out}}
<pre>
Calculating x = a(False) and b(False) -> False
Called function a(False) -> False
x=False
Calculating y = a(False) or b(False) -> False
Called function a(False) -> False
Called function b(False) -> False
y=False
Calculating x = a(False) and b(True) -> False
Called function a(False) -> False
x=False
Calculating y = a(False) or b(True) -> True
Called function a(False) -> False
Called function b(True) -> True
y=True
Calculating x = a(True) and b(False) -> False
Called function a(True) -> True
Called function b(False) -> False
x=False
Calculating y = a(True) or b(False) -> True
Called function a(True) -> True
y=True
Calculating x = a(True) and b(True) -> True
Called function a(True) -> True
Called function b(True) -> True
x=True
Calculating y = a(True) or b(True) -> True
Called function a(True) -> True
y=True
</pre>
=={{header|Maple}}==
Line 4,835 ⟶ 5,073:
T F OR T a()
T T OR T a()
</pre>
=={{header|V (Vlang)}}==
<syntaxhighlight lang="Zig">
fn main() {
test_me(false, false)
test_me(false, true)
test_me(true, false)
test_me(true, true)
}
fn a(v bool) bool {
print("a")
return v
}
fn b(v bool) bool {
print("b")
return v
}
fn test_me(i bool, j bool) {
println("Testing a(${i}) && b(${j})")
print("Trace: ")
println("\nResult: ${a(i) && b(j)}")
println("Testing a(${i})} || b(${j})")
print("Trace: ")
println("\nResult: ${a(i) || b(j)}")
println("")
}
</syntaxhighlight>
{{out}}
<pre>
Testing a(false) && b(false)
Trace: a
Result: false
Testing a(false)} || b(false)
Trace: ab
Result: false
Testing a(false) && b(true)
Trace: a
Result: false
Testing a(false)} || b(true)
Trace: ab
Result: true
Testing a(true) && b(false)
Trace: ab
Result: false
Testing a(true)} || b(false)
Trace: a
Result: true
Testing a(true) && b(true)
Trace: ab
Result: true
Testing a(true)} || b(true)
Trace: a
Result: true
</pre>
=={{header|Wren}}==
Wren has the '''&&''' and '''||''' short-circuiting operators found in many C family languages.
<syntaxhighlight lang="
System.print(" a called")
return bool
|