Conditional (computer programming)

Many programming languages (such as C) have distinct conditional statements and expressions. In pure functional programming, a conditional expression does not have side-effects, many functional programming languages with conditional expressions (such as Lisp) support side-effects.

Conditional statement

If-then-else statement

Although the syntax of an if-then-else statement varies by language, the general syntax is shown as pseudocode below. The part represented by the condition placeholder is an expression that evaluates to either true or false. If true, control passes to consequent and when complete to after end if. If false, control passes to alternative and when complete to after end if. As the else clause is optional, the else alternative part can be omitted. Typically, both consequent and alternative can be either a single statement or a block of statements.

<span id="mwLA"></span><span class="kr" id="mwLQ">if</span><span class="w" id="mwLg"> </span><span class="nv" id="mwLw">condition</span><span class="w" id="mwMA"> </span><span class="kr" id="mwMQ">then</span> <span class="w" id="mwMg"> </span><span class="nv" id="mwMw">consequent</span> <span class="kr" id="mwNA">else</span> <span class="w" id="mwNQ"> </span><span class="nv" id="mwNg">alternative</span> <span class="kr" id="mwNw">end</span><span class="w" id="mwOA"> </span><span class="kr" id="mwOQ">if</span>

The following example, also in pseudocode, replaces placeholders with example logic.

<span id="mwPQ"></span><span class="kr" id="mwPg">if</span><span class="w" id="mwPw"> </span><span class="nv" id="mwQA">stock</span><span class="w" id="mwQQ"> </span><span class="o" id="mwQg">=</span><span class="w" id="mwQw"> </span><span class="mi" id="mwRA">0</span><span class="w" id="mwRQ"> </span><span class="kr" id="mwRg">then</span> <span class="w" id="mwRw"> </span><span class="nv" id="mwSA">message</span><span class="w" id="mwSQ"> </span><span class="o" id="mwSg">=</span><span class="w" id="mwSw"> </span><span class="s1" id="mwTA">'order new stock'</span> <span class="kr" id="mwTQ">else</span> <span class="w" id="mwTg"> </span><span class="nv" id="mwTw">message</span><span class="w" id="mwUA"> </span><span class="o" id="mwUQ">=</span><span class="w" id="mwUg"> </span><span class="s1" id="mwUw">'there is stock'</span> <span class="kr" id="mwVA">end</span><span class="w" id="mwVQ"> </span><span class="kr" id="mwVg">if</span>

History and development

In early programming languages, especially dialects of BASIC, an if–then-else statement could only contain goto statements but this tended to result in hard-to-read spaghetti code. As a result, structured programming, which supports control flow via code blocks, gained in popularity, until it became the norm in most BASIC variants and all languages. Such mechanisms and principles were based on the ALGOL family of languages, including Pascal and Modula-2. While it is possible to use goto in a structured way, structured programming makes this easier. A structured if–then–else statement is one of the key elements of structured programming, and it is present in most popular languages such as C, Java, JavaScript and Visual Basic.

Dangling else

The convention is that an else clause, like the then clause, responds to the nearest preceding if clause. However, the semantics of nested conditionals in some early languages such as ALGOL 60 were less than clear; the syntax was inadequate to always specify the same predicate if clause. Thus, the parser might randomly pair the else with any one of the perhaps manifold if clauses in the intended nested hierarchy.

For example, take the statement:

<span id="mwdA"></span><span class="kr" id="mwdQ">if</span><span class="w" id="mwdg"> </span><span class="nv" id="mwdw">A</span><span class="w" id="mweA"> </span><span class="kr" id="mweQ">then</span><span class="w" id="mweg"> </span><span class="kr" id="mwew">if</span><span class="w" id="mwfA"> </span><span class="nv" id="mwfQ">B</span><span class="w" id="mwfg"> </span><span class="kr" id="mwfw">then</span><span class="w" id="mwgA"> </span><span class="nv" id="mwgQ">S</span><span class="w" id="mwgg"> </span><span class="kr" id="mwgw">else</span><span class="w" id="mwhA"> </span><span class="nv" id="mwhQ">S2</span>

or the same statement but indented for clarity:

<span id="mwiA"></span><span class="kr" id="mwiQ">if</span><span class="w" id="mwig"> </span><span class="nv" id="mwiw">A</span><span class="w" id="mwjA"> </span><span class="kr" id="mwjQ">then</span> <span class="w" id="mwjg"> </span><span class="kr" id="mwjw">if</span><span class="w" id="mwkA"> </span><span class="nv" id="mwkQ">B</span><span class="w" id="mwkg"> </span><span class="kr" id="mwkw">then</span> <span class="w" id="mwlA"> </span><span class="nv" id="mwlQ">S</span> <span class="w" id="mwlg"> </span><span class="kr" id="mwlw">else</span><span class="w" id="mwmA"> </span> <span class="w" id="mwmQ"> </span><span class="nv" id="mwmg">S2</span>

may be parsed either as meaning:

<span id="mwoQ"></span><span class="kr" id="mwog">if</span><span class="w" id="mwow"> </span><span class="nv" id="mwpA">A</span><span class="w" id="mwpQ"> </span><span class="kr" id="mwpg">then</span><span class="w" id="mwpw"> </span><span class="p" id="mwqA">(</span><span class="kr" id="mwqQ">if</span><span class="w" id="mwqg"> </span><span class="nv" id="mwqw">B</span><span class="w" id="mwrA"> </span><span class="kr" id="mwrQ">then</span><span class="w" id="mwrg"> </span><span class="nv" id="mwrw">S</span><span class="p" id="mwsA">)</span><span class="w" id="mwsQ"> </span><span class="kr" id="mwsg">else</span><span class="w" id="mwsw"> </span><span class="nv" id="mwtA">S2</span><span class="w" id="mwtQ"> </span><span class="kr" id="mwtg">end</span>

<span id="mwuQ"></span><span class="kr" id="mwug">if</span><span class="w" id="mwuw"> </span><span class="nv" id="mwvA">A</span><span class="w" id="mwvQ"> </span><span class="kr" id="mwvg">then</span> <span class="w" id="mwvw"> </span><span class="p" id="mwwA">(</span><span class="kr" id="mwwQ">if</span><span class="w" id="mwwg"> </span><span class="nv" id="mwww">B</span><span class="w" id="mwxA"> </span><span class="kr" id="mwxQ">then</span><span class="w" id="mwxg"> </span><span class="nv" id="mwxw">S</span><span class="p" id="mwyA">)</span> <span class="kr" id="mwyQ">else</span><span class="w" id="mwyg"> </span> <span class="w" id="mwyw"> </span><span class="nv" id="mwzA">S2</span> <span class="kr" id="mwzQ">end</span>

or as meaning:

<span id="mw0w"></span><span class="kr" id="mw1A">if</span><span class="w" id="mw1Q"> </span><span class="nv" id="mw1g">A</span><span class="w" id="mw1w"> </span><span class="kr" id="mw2A">then</span><span class="w" id="mw2Q"> </span><span class="p" id="mw2g">(</span><span class="kr" id="mw2w">if</span><span class="w" id="mw3A"> </span><span class="nv" id="mw3Q">B</span><span class="w" id="mw3g"> </span><span class="kr" id="mw3w">then</span><span class="w" id="mw4A"> </span><span class="nv" id="mw4Q">S</span><span class="w" id="mw4g"> </span><span class="kr" id="mw4w">else</span><span class="w" id="mw5A"> </span><span class="nv" id="mw5Q">S2</span><span class="p" id="mw5g">)</span>

<span id="mw6Q"></span><span class="kr" id="mw6g">if</span><span class="w" id="mw6w"> </span><span class="nv" id="mw7A">A</span><span class="w" id="mw7Q"> </span><span class="kr" id="mw7g">then</span> <span class="w" id="mw7w"> </span><span class="p" id="mw8A">(</span><span class="kr" id="mw8Q">if</span><span class="w" id="mw8g"> </span><span class="nv" id="mw8w">B</span><span class="w" id="mw9A"> </span><span class="kr" id="mw9Q">then</span><span class="w" id="mw9g"> </span><span class="nv" id="mw9w">S</span><span class="w" id="mw-A"> </span><span class="kr" id="mw-Q">else</span><span class="w" id="mw-g"> </span><span class="nv" id="mw-w">S2</span><span class="p" id="mw_A">)</span> <span class="kr" id="mw_Q">end</span>

This is known as the dangling else problem. It is resolved in various ways, depending on the language (in some, by means of explicit block-ending syntax (such as end if ) or a block enclosure, such as curly brackets ( {⋯} ).

Chaining

Chaining conditionals is often provided in a language via an else-if construct. Only the statements following the first condition that is true are executed. Other statements are skipped. In placeholder pseudocode:

<span id="mwAQc"></span><span class="kr" id="mwAQg">if</span><span class="w" id="mwAQk"> </span><span class="nv" id="mwAQo">condition1</span><span class="w" id="mwAQs"> </span><span class="kr" id="mwAQw">then</span><span class="w" id="mwAQ0"> </span> <span class="w" id="mwAQ4"> </span><span class="nv" id="mwAQ8">block1</span> <span class="kr" id="mwARA">else</span><span class="w" id="mwARE"> </span><span class="kr" id="mwARI">if</span><span class="w" id="mwARM"> </span><span class="nv" id="mwARQ">condition2</span><span class="w" id="mwARU"> </span><span class="kr" id="mwARY">then</span><span class="w" id="mwARc"> </span> <span class="w" id="mwARg"> </span><span class="nv" id="mwARk">block2</span> <span class="kr" id="mwARo">else</span><span class="w" id="mwARs"> </span><span class="kr" id="mwARw">if</span><span class="w" id="mwAR0"> </span><span class="nv" id="mwAR4">condition3</span><span class="w" id="mwAR8"> </span><span class="kr" id="mwASA">then</span><span class="w" id="mwASE"> </span> <span class="w" id="mwASI"> </span><span class="nv" id="mwASM">block3</span> <span class="w" id="mwASQ"> </span><span class="o" id="mwASU">..</span><span class="p" id="mwASY">.</span> <span class="kr" id="mwASc">else</span> <span class="w" id="mwASg"> </span><span class="nv" id="mwASk">block4</span> <span class="kr" id="mwASo">end</span><span class="w" id="mwASs"> </span><span class="kr" id="mwASw">if</span>

In the following pseudocode, a shop offers as much as a 30% discount for an item. If the discount is 10%, then the first if statement is true and "you have to pay $30" is printed. All other statements below that first if statement are skipped.

<span id="mwATE"></span><span class="kr" id="mwATI">if</span><span class="w" id="mwATM"> </span><span class="nv" id="mwATQ">discount</span><span class="w" id="mwATU"> </span><span class="o" id="mwATY"><</span><span class="w" id="mwATc"> </span><span class="mi" id="mwATg">11</span><span class="o" id="mwATk">%</span><span class="w" id="mwATo"> </span><span class="kr" id="mwATs">then</span><span class="w" id="mwATw"> </span> <span class="w" id="mwAT0"> </span><span class="nb" id="mwAT4">print</span><span class="w" id="mwAT8"> </span><span class="s2" id="mwAUA">"You have to pay $30."</span> <span class="kr" id="mwAUE">else</span><span class="w" id="mwAUI"> </span><span class="kr" id="mwAUM">if</span><span class="w" id="mwAUQ"> </span><span class="nv" id="mwAUU">discount</span><span class="w" id="mwAUY"> </span><span class="o" id="mwAUc"><</span><span class="w" id="mwAUg"> </span><span class="mi" id="mwAUk">21</span><span class="o" id="mwAUo">%</span><span class="w" id="mwAUs"> </span><span class="kr" id="mwAUw">then</span><span class="w" id="mwAU0"> </span> <span class="w" id="mwAU4"> </span><span class="nb" id="mwAU8">print</span><span class="w" id="mwAVA"> </span><span class="s2" id="mwAVE">"You have to pay $20."</span> <span class="kr" id="mwAVI">else</span><span class="w" id="mwAVM"> </span><span class="kr" id="mwAVQ">if</span><span class="w" id="mwAVU"> </span><span class="nv" id="mwAVY">discount</span><span class="w" id="mwAVc"> </span><span class="o" id="mwAVg"><</span><span class="w" id="mwAVk"> </span><span class="mi" id="mwAVo">31</span><span class="o" id="mwAVs">%</span><span class="w" id="mwAVw"> </span><span class="kr" id="mwAV0">then</span><span class="w" id="mwAV4"> </span> <span class="w" id="mwAV8"> </span><span class="nb" id="mwAWA">print</span><span class="w" id="mwAWE"> </span><span class="s2" id="mwAWI">"You have to pay $10."</span> <span class="kr" id="mwAWM">end</span><span class="w" id="mwAWQ"> </span><span class="kr" id="mwAWU">if</span>

Only one end if is needed if one uses else if instead of else followed by if.

In ALGOL 68, the 1968 “Draft Report” (circulated as a supplement to ALGOL Bulletin no. 26) still used the bold keyword elsf in “contracted” conditionals. The spelling elif was then standardized in the “Revised Report on the Algorithmic Language ALGOL 68” (1973), which lists both the bold words if ~ then ~ elif ~ else ~ fi and their “brief” symbols, where elif corresponds to |: in the compact form ( ~ | ~ |: ~ | ~ | ~ ).

In Ada, the elseif keyword is syntactic sugar for the two words else if. PHP also supports an elseif keyword both for its curly brackets or colon syntaxes. Perl and Ruby provide the keyword elsif to avoid the large number of braces that would be required by multiple if and else statements. Python uses the special keyword elif because structure is denoted by indentation rather than braces, so a repeated use of else and if would require increased indentation after every condition. Visual Basic, supports ElseIf. Similarly, the earlier UNIX shells (later gathered up to the POSIX shell syntax) use elif too, but giving the choice of delimiting with spaces, line breaks, or both.

However, in many languages more directly descended from Algol, such as Simula, Pascal, BCPL and C, this special syntax for the else if construct is not present, nor is it present in the many syntactical derivatives of C, such as Java, ECMAScript, and so on. This works because in these languages, any single statement (in this case if cond...) can follow a conditional without being enclosed in a block.

If all terms in the sequence of conditionals are testing the value of a single expression (e.g., if x = 0, else if x = 1, else if x = 2 ...), an alternative is the switch statement. In a language that does not have a switch statement, these can be encoded as a chained if-then-else.

Switch statement

A switch statement supports multiway branching, often comparing the value of an expression with constant values and transferring control to the code of the first match. There is usually a provision for a default action if no match is found. An optimizing compiler may use a control table to implement the logic of a switch statement. In a dynamic language, the cases may not be limited to constant expressions, and might extend to pattern matching, as in the shell script example on the right, where the '*)' implements the default case as a regular expression matching any string.

Guarded conditional

The Guarded Command Language (GCL) of Edsger Dijkstra supports conditional execution as a list of commands consisting of a Boolean-valued guard (corresponding to a condition) and its corresponding statement. In GCL, exactly one of the statements whose guards is true is evaluated, but which one is arbitrary. In this code

<b id="mwAdU">if</b> G0 → S0 □ G1 → S1 ... □ Gn → Sn <b id="mwAdY">fi</b>

the G_i's are the guards and the S_i's are the statements. If none of the guards is true, the program's behavior is undefined.

GCL is intended primarily for reasoning about programs, but similar notations have been implemented in Concurrent Pascal and occam.

Arithmetic if

The earliest conditional statement in Fortran, up to Fortran 77, was the arithmetic if statement which jumped to one of three labels depending on whether a value (of type integer, real, or double precision) is <0, 0, or >0.

In the following code, control passes to one of the labels based on the value of e.

<span id="mwAeo"></span><span class="w" id="mwAes"> </span><span class="k" id="mwAew">IF</span><span class="w" id="mwAe0"> </span><span class="p" id="mwAe4">(</span><span class="n" id="mwAe8">e</span><span class="p" id="mwAfA">)</span><span class="w" id="mwAfE"> </span><span class="n" id="mwAfI">label1</span><span class="p" id="mwAfM">,</span><span class="w" id="mwAfQ"> </span><span class="n" id="mwAfU">label2</span><span class="p" id="mwAfY">,</span><span class="w" id="mwAfc"> </span><span class="n" id="mwAfg">label3</span>

This is equivalent to the following sequence.

<span id="mwAfw"></span><span class="w" id="mwAf0"> </span><span class="n" id="mwAf4">e_temp</span><span class="w" id="mwAf8"> </span><span class="o" id="mwAgA">=</span><span class="w" id="mwAgE"> </span><span class="n" id="mwAgI">e</span> <span class="w" id="mwAgM"> </span><span class="k" id="mwAgQ">IF</span><span class="w" id="mwAgU"> </span><span class="p" id="mwAgY">(</span><span class="n" id="mwAgc">e_temp</span><span class="w" id="mwAgg"> </span><span class="p" id="mwAgk">.</span><span class="n" id="mwAgo">LT</span><span class="p" id="mwAgs">.</span><span class="w" id="mwAgw"> </span><span class="mi" id="mwAg0">0</span><span class="p" id="mwAg4">)</span><span class="w" id="mwAg8"> </span><span class="k" id="mwAhA">GOTO</span><span class="w" id="mwAhE"> </span><span class="n" id="mwAhI">label1</span> <span class="w" id="mwAhM"> </span><span class="k" id="mwAhQ">IF</span><span class="w" id="mwAhU"> </span><span class="p" id="mwAhY">(</span><span class="n" id="mwAhc">e_temp</span><span class="w" id="mwAhg"> </span><span class="p" id="mwAhk">.</span><span class="n" id="mwAho">EQ</span><span class="p" id="mwAhs">.</span><span class="w" id="mwAhw"> </span><span class="mi" id="mwAh0">0</span><span class="p" id="mwAh4">)</span><span class="w" id="mwAh8"> </span><span class="k" id="mwAiA">GOTO</span><span class="w" id="mwAiE"> </span><span class="n" id="mwAiI">label2</span> <span class="w" id="mwAiM"> </span><span class="k" id="mwAiQ">GOTO</span><span class="w" id="mwAiU"> </span><span class="n" id="mwAiY">label3</span>

As it acts like goto, arithmetic if is unstructured, not structured, programming. It was the only conditional statement in the original implementation of Fortran on the IBM 704 computer. On that computer, the test-and-branch op-code had three addresses for those three states. Other computers would have "flag" registers such as positive, zero, negative, even, overflow, carry, associated with the last arithmetic operations and would use instructions such as 'Branch if accumulator negative' then 'Branch if accumulator zero' or similar. Note that the expression is evaluated once only, and in cases such as integer arithmetic where overflow may occur, the overflow or carry flags would be considered also.

The Arithmetic IF statement was listed as obsolescent starting with the Fortran 90 Standard. It was deleted from the Fortran 2018 Standard. Nonetheless, most compilers continue to support it for compatibility with legacy codes.

In Smalltalk

In contrast to other languages, in Smalltalk the conditional statement is not a language construct but defined in the class Boolean as an abstract method that takes two parameters, both closures. Boolean has two subclasses, True and False, which both define the method, True executing the first closure only, False executing the second closure only.

<span id="mwAj4"></span><span class="nv" id="mwAj8">var</span> <span class="nf" id="mwAkA">=</span> <span class="nv" id="mwAkE">condition</span> <span class="nb" id="mwAkI">ifTrue:</span> [ <span class="s" id="mwAkM">'foo'</span> ] <span class="nb" id="mwAkQ">ifFalse:</span> [ <span class="s" id="mwAkU">'bar'</span> ]

In JavaScript

JavaScript supports if-else statements similar to C syntax. The following example has conditional Math.random() < 0.5 which is true if the random float (value between 0 and 1) is greater than 0.5. The statement uses it to randomly choose between outputting You got Heads! or You got Tails!.

<span id="mwAlc"></span><span class="k" id="mwAlg">if</span><span class="w" id="mwAlk"> </span><span class="p" id="mwAlo">(</span><span class="nb" id="mwAls">Math</span><span class="p" id="mwAlw">.</span><span class="nx" id="mwAl0">random</span><span class="p" id="mwAl4">()</span><span class="w" id="mwAl8"> </span><span class="o" id="mwAmA"><</span><span class="w" id="mwAmE"> </span><span class="mf" id="mwAmI">0.5</span><span class="p" id="mwAmM">)</span><span class="w" id="mwAmQ"> </span><span class="p" id="mwAmU">{</span> <span class="w" id="mwAmY"> </span><span class="nx" id="mwAmc">console</span><span class="p" id="mwAmg">.</span><span class="nx" id="mwAmk">log</span><span class="p" id="mwAmo">(</span><span class="s2" id="mwAms">"You got Heads!"</span><span class="p" id="mwAmw">);</span> <span class="p" id="mwAm0">}</span><span class="w" id="mwAm4"> </span><span class="k" id="mwAm8">else</span><span class="w" id="mwAnA"> </span><span class="p" id="mwAnE">{</span> <span class="w" id="mwAnI"> </span><span class="nx" id="mwAnM">console</span><span class="p" id="mwAnQ">.</span><span class="nx" id="mwAnU">log</span><span class="p" id="mwAnY">(</span><span class="s2" id="mwAnc">"You got Tails!"</span><span class="p" id="mwAng">);</span> <span class="p" id="mwAnk">}</span>

Conditionals can be chained as shown below:

<span id="mwAn0"></span><span class="kd" id="mwAn4">var</span><span class="w" id="mwAn8"> </span><span class="nx" id="mwAoA">x</span><span class="w" id="mwAoE"> </span><span class="o" id="mwAoI">=</span><span class="w" id="mwAoM"> </span><span class="nb" id="mwAoQ">Math</span><span class="p" id="mwAoU">.</span><span class="nx" id="mwAoY">random</span><span class="p" id="mwAoc">();</span> <span class="k" id="mwAog">if</span><span class="w" id="mwAok"> </span><span class="p" id="mwAoo">(</span><span class="nx" id="mwAos">x</span><span class="w" id="mwAow"> </span><span class="o" id="mwAo0"><</span><span class="w" id="mwAo4"> </span><span class="mf" id="mwAo8">1</span><span class="o" id="mwApA">/</span><span class="mf" id="mwApE">3</span><span class="p" id="mwApI">)</span><span class="w" id="mwApM"> </span><span class="p" id="mwApQ">{</span> <span class="w" id="mwApU"> </span><span class="nx" id="mwApY">console</span><span class="p" id="mwApc">.</span><span class="nx" id="mwApg">log</span><span class="p" id="mwApk">(</span><span class="s2" id="mwApo">"One person won!"</span><span class="p" id="mwAps">);</span> <span class="p" id="mwApw">}</span><span class="w" id="mwAp0"> </span><span class="k" id="mwAp4">else</span><span class="w" id="mwAp8"> </span><span class="k" id="mwAqA">if</span><span class="w" id="mwAqE"> </span><span class="p" id="mwAqI">(</span><span class="nx" id="mwAqM">x</span><span class="w" id="mwAqQ"> </span><span class="o" id="mwAqU"><</span><span class="w" id="mwAqY"> </span><span class="mf" id="mwAqc">2</span><span class="o" id="mwAqg">/</span><span class="mf" id="mwAqk">3</span><span class="p" id="mwAqo">)</span><span class="w" id="mwAqs"> </span><span class="p" id="mwAqw">{</span> <span class="w" id="mwAq0"> </span><span class="nx" id="mwAq4">console</span><span class="p" id="mwAq8">.</span><span class="nx" id="mwArA">log</span><span class="p" id="mwArE">(</span><span class="s2" id="mwArI">"Two people won!"</span><span class="p" id="mwArM">);</span> <span class="p" id="mwArQ">}</span><span class="w" id="mwArU"> </span><span class="k" id="mwArY">else</span><span class="w" id="mwArc"> </span><span class="p" id="mwArg">{</span> <span class="w" id="mwArk"> </span><span class="nx" id="mwAro">console</span><span class="p" id="mwArs">.</span><span class="nx" id="mwArw">log</span><span class="p" id="mwAr0">(</span><span class="s2" id="mwAr4">"It's a three-way tie!"</span><span class="p" id="mwAr8">);</span> <span class="p" id="mwAsA">}</span>

Lambda calculus

In Lambda calculus, the concept of an if-then-else conditional can be expressed using the following expressions:

true = λx. λy. x false = λx. λy. y ifThenElse = (λc. λx. λy. (c x y))

true takes up to two arguments and once both are provided (see currying), it returns the first argument given.
false takes up to two arguments and once both are provided(see currying), it returns the second argument given.
ifThenElse takes up to three arguments and once all are provided, it passes both second and third argument to the first argument(which is a function that given two arguments, and produces a result). We expect ifThenElse to only take true or false as an argument, both of which project the given two arguments to their preferred single argument, which is then returned.

Note: if ifThenElse is passed two functions as the left and right conditionals; it is necessary to also pass an empty tuple () to the result of ifThenElse in order to actually call the chosen function, otherwise ifThenElse will just return the function object without getting called.

In a system where numbers can be used without definition (like Lisp, Traditional paper math, so on), the above can be expressed as a single closure below:

<span id="mwAuE"></span><span class="p" id="mwAuI">((</span><span class="nv" id="mwAuM">λtrue.</span><span class="w" id="mwAuQ"> </span><span class="nv" id="mwAuU">λfalse.</span><span class="w" id="mwAuY"> </span><span class="nv" id="mwAuc">λifThenElse.</span> <span class="w" id="mwAug"> </span><span class="p" id="mwAuk">(</span><span class="nv" id="mwAuo">ifThenElse</span><span class="w" id="mwAus"> </span><span class="nv" id="mwAuw">true</span><span class="w" id="mwAu0"> </span><span class="mi" id="mwAu4">2</span><span class="w" id="mwAu8"> </span><span class="mi" id="mwAvA">3</span><span class="p" id="mwAvE">)</span> <span class="p" id="mwAvI">)(</span><span class="nv" id="mwAvM">λx.</span><span class="w" id="mwAvQ"> </span><span class="nv" id="mwAvU">λy.</span><span class="w" id="mwAvY"> </span><span class="nv" id="mwAvc">x</span><span class="p" id="mwAvg">)(</span><span class="nv" id="mwAvk">λx.</span><span class="w" id="mwAvo"> </span><span class="nv" id="mwAvs">λy.</span><span class="w" id="mwAvw"> </span><span class="nv" id="mwAv0">y</span><span class="p" id="mwAv4">)(</span><span class="nv" id="mwAv8">λc.</span><span class="w" id="mwAwA"> </span><span class="nv" id="mwAwE">λl.</span><span class="w" id="mwAwI"> </span><span class="nv" id="mwAwM">λr.</span><span class="w" id="mwAwQ"> </span><span class="nv" id="mwAwU">c</span><span class="w" id="mwAwY"> </span><span class="nv" id="mwAwc">l</span><span class="w" id="mwAwg"> </span><span class="nv" id="mwAwk">r</span><span class="p" id="mwAwo">))</span>

Here, true, false, and ifThenElse are bound to their respective definitions which are passed to their scope at the end of their block.

A working JavaScript analogy(using only functions of single variable for rigor) to this is as follows:

<span id="mwAxM"></span><span class="kd" id="mwAxQ">var</span><span class="w" id="mwAxU"> </span><span class="nx" id="mwAxY">computationResult</span><span class="w" id="mwAxc"> </span><span class="o" id="mwAxg">=</span><span class="w" id="mwAxk"> </span><span class="p" id="mwAxo">((</span><span class="nx" id="mwAxs">_true</span><span class="w" id="mwAxw"> </span><span class="p" id="mwAx0">=></span><span class="w" id="mwAx4"> </span><span class="nx" id="mwAx8">_false</span><span class="w" id="mwAyA"> </span><span class="p" id="mwAyE">=></span><span class="w" id="mwAyI"> </span><span class="nx" id="mwAyM">_ifThenElse</span><span class="w" id="mwAyQ"> </span><span class="p" id="mwAyU">=></span><span class="w" id="mwAyY"> </span> <span class="w" id="mwAyc"> </span><span class="nx" id="mwAyg">_ifThenElse</span><span class="p" id="mwAyk">(</span><span class="nx" id="mwAyo">_true</span><span class="p" id="mwAys">)(</span><span class="mf" id="mwAyw">2</span><span class="p" id="mwAy0">)(</span><span class="mf" id="mwAy4">3</span><span class="p" id="mwAy8">)</span><span class="w" id="mwAzA"> </span> <span class="p" id="mwAzE">)(</span><span class="nx" id="mwAzI">x</span><span class="w" id="mwAzM"> </span><span class="p" id="mwAzQ">=></span><span class="w" id="mwAzU"> </span><span class="nx" id="mwAzY">y</span><span class="w" id="mwAzc"> </span><span class="p" id="mwAzg">=></span><span class="w" id="mwAzk"> </span><span class="nx" id="mwAzo">x</span><span class="p" id="mwAzs">)(</span><span class="nx" id="mwAzw">x</span><span class="w" id="mwAz0"> </span><span class="p" id="mwAz4">=></span><span class="w" id="mwAz8"> </span><span class="nx" id="mwA0A">y</span><span class="w" id="mwA0E"> </span><span class="p" id="mwA0I">=></span><span class="w" id="mwA0M"> </span><span class="nx" id="mwA0Q">y</span><span class="p" id="mwA0U">)(</span><span class="nx" id="mwA0Y">c</span><span class="w" id="mwA0c"> </span><span class="p" id="mwA0g">=></span><span class="w" id="mwA0k"> </span><span class="nx" id="mwA0o">x</span><span class="w" id="mwA0s"> </span><span class="p" id="mwA0w">=></span><span class="w" id="mwA00"> </span><span class="nx" id="mwA04">y</span><span class="w" id="mwA08"> </span><span class="p" id="mwA1A">=></span><span class="w" id="mwA1E"> </span><span class="nx" id="mwA1I">c</span><span class="p" id="mwA1M">(</span><span class="nx" id="mwA1Q">x</span><span class="p" id="mwA1U">)(</span><span class="nx" id="mwA1Y">y</span><span class="p" id="mwA1c">)));</span>

The code above with multivariable functions looks like this:

<span id="mwA1s"></span><span class="kd" id="mwA1w">var</span><span class="w" id="mwA10"> </span><span class="nx" id="mwA14">computationResult</span><span class="w" id="mwA18"> </span><span class="o" id="mwA2A">=</span><span class="w" id="mwA2E"> </span><span class="p" id="mwA2I">((</span><span class="nx" id="mwA2M">_true</span><span class="p" id="mwA2Q">,</span><span class="w" id="mwA2U"> </span><span class="nx" id="mwA2Y">_false</span><span class="p" id="mwA2c">,</span><span class="w" id="mwA2g"> </span><span class="nx" id="mwA2k">_ifThenElse</span><span class="p" id="mwA2o">)</span><span class="w" id="mwA2s"> </span><span class="p" id="mwA2w">=></span> <span class="w" id="mwA20"> </span><span class="nx" id="mwA24">_ifThenElse</span><span class="p" id="mwA28">(</span><span class="nx" id="mwA3A">_true</span><span class="p" id="mwA3E">,</span><span class="w" id="mwA3I"> </span><span class="mf" id="mwA3M">2</span><span class="p" id="mwA3Q">,</span><span class="w" id="mwA3U"> </span><span class="mf" id="mwA3Y">3</span><span class="p" id="mwA3c">)</span> <span class="p" id="mwA3g">)((</span><span class="nx" id="mwA3k">x</span><span class="p" id="mwA3o">,</span><span class="w" id="mwA3s"> </span><span class="nx" id="mwA3w">y</span><span class="p" id="mwA30">)</span><span class="w" id="mwA34"> </span><span class="p" id="mwA38">=></span><span class="w" id="mwA4A"> </span><span class="nx" id="mwA4E">x</span><span class="p" id="mwA4I">,</span><span class="w" id="mwA4M"> </span><span class="p" id="mwA4Q">(</span><span class="nx" id="mwA4U">x</span><span class="p" id="mwA4Y">,</span><span class="w" id="mwA4c"> </span><span class="nx" id="mwA4g">y</span><span class="p" id="mwA4k">)</span><span class="w" id="mwA4o"> </span><span class="p" id="mwA4s">=></span><span class="w" id="mwA4w"> </span><span class="nx" id="mwA40">y</span><span class="p" id="mwA44">,</span><span class="w" id="mwA48"> </span><span class="p" id="mwA5A">(</span><span class="nx" id="mwA5E">c</span><span class="p" id="mwA5I">,</span><span class="w" id="mwA5M"> </span><span class="nx" id="mwA5Q">x</span><span class="p" id="mwA5U">,</span><span class="w" id="mwA5Y"> </span><span class="nx" id="mwA5c">y</span><span class="p" id="mwA5g">)</span><span class="w" id="mwA5k"> </span><span class="p" id="mwA5o">=></span><span class="w" id="mwA5s"> </span><span class="nx" id="mwA5w">c</span><span class="p" id="mwA50">(</span><span class="nx" id="mwA54">x</span><span class="p" id="mwA58">,</span><span class="w" id="mwA6A"> </span><span class="nx" id="mwA6E">y</span><span class="p" id="mwA6I">));</span>

Another version of the earlier example without a system where numbers are assumed is below.

The first example shows the first branch being taken, while second example shows the second branch being taken.

<span id="mwA6c"></span><span class="p" id="mwA6g">((</span><span class="nv" id="mwA6k">λtrue.</span><span class="w" id="mwA6o"> </span><span class="nv" id="mwA6s">λfalse.</span><span class="w" id="mwA6w"> </span><span class="nv" id="mwA60">λifThenElse.</span> <span class="w" id="mwA64"> </span><span class="p" id="mwA68">(</span><span class="nv" id="mwA7A">ifThenElse</span><span class="w" id="mwA7E"> </span><span class="nv" id="mwA7I">true</span><span class="w" id="mwA7M"> </span><span class="p" id="mwA7Q">(</span><span class="nv" id="mwA7U">λFirstBranch.</span><span class="w" id="mwA7Y"> </span><span class="nv" id="mwA7c">FirstBranch</span><span class="p" id="mwA7g">)</span><span class="w" id="mwA7k"> </span><span class="p" id="mwA7o">(</span><span class="nv" id="mwA7s">λSecondBranch.</span><span class="w" id="mwA7w"> </span><span class="nv" id="mwA70">SecondBranch</span><span class="p" id="mwA74">))</span> <span class="p" id="mwA78">)(</span><span class="nv" id="mwA8A">λx.</span><span class="w" id="mwA8E"> </span><span class="nv" id="mwA8I">λy.</span><span class="w" id="mwA8M"> </span><span class="nv" id="mwA8Q">x</span><span class="p" id="mwA8U">)(</span><span class="nv" id="mwA8Y">λx.</span><span class="w" id="mwA8c"> </span><span class="nv" id="mwA8g">λy.</span><span class="w" id="mwA8k"> </span><span class="nv" id="mwA8o">y</span><span class="p" id="mwA8s">)(</span><span class="nv" id="mwA8w">λc.</span><span class="w" id="mwA80"> </span><span class="nv" id="mwA84">λl.</span><span class="w" id="mwA88"> </span><span class="nv" id="mwA9A">λr.</span><span class="w" id="mwA9E"> </span><span class="nv" id="mwA9I">c</span><span class="w" id="mwA9M"> </span><span class="nv" id="mwA9Q">l</span><span class="w" id="mwA9U"> </span><span class="nv" id="mwA9Y">r</span><span class="p" id="mwA9c">))</span> <span class="p" id="mwA9g">((</span><span class="nv" id="mwA9k">λtrue.</span><span class="w" id="mwA9o"> </span><span class="nv" id="mwA9s">λfalse.</span><span class="w" id="mwA9w"> </span><span class="nv" id="mwA90">λifThenElse.</span> <span class="w" id="mwA94"> </span><span class="p" id="mwA98">(</span><span class="nv" id="mwA-A">ifThenElse</span><span class="w" id="mwA-E"> </span><span class="nv" id="mwA-I">false</span><span class="w" id="mwA-M"> </span><span class="p" id="mwA-Q">(</span><span class="nv" id="mwA-U">λFirstBranch.</span><span class="w" id="mwA-Y"> </span><span class="nv" id="mwA-c">FirstBranch</span><span class="p" id="mwA-g">)</span><span class="w" id="mwA-k"> </span><span class="p" id="mwA-o">(</span><span class="nv" id="mwA-s">λSecondBranch.</span><span class="w" id="mwA-w"> </span><span class="nv" id="mwA-0">SecondBranch</span><span class="p" id="mwA-4">))</span> <span class="p" id="mwA-8">)(</span><span class="nv" id="mwA_A">λx.</span><span class="w" id="mwA_E"> </span><span class="nv" id="mwA_I">λy.</span><span class="w" id="mwA_M"> </span><span class="nv" id="mwA_Q">x</span><span class="p" id="mwA_U">)(</span><span class="nv" id="mwA_Y">λx.</span><span class="w" id="mwA_c"> </span><span class="nv" id="mwA_g">λy.</span><span class="w" id="mwA_k"> </span><span class="nv" id="mwA_o">y</span><span class="p" id="mwA_s">)(</span><span class="nv" id="mwA_w">λc.</span><span class="w" id="mwA_0"> </span><span class="nv" id="mwA_4">λl.</span><span class="w" id="mwA_8"> </span><span class="nv" id="mwBAA">λr.</span><span class="w" id="mwBAE"> </span><span class="nv" id="mwBAI">c</span><span class="w" id="mwBAM"> </span><span class="nv" id="mwBAQ">l</span><span class="w" id="mwBAU"> </span><span class="nv" id="mwBAY">r</span><span class="p" id="mwBAc">))</span>

Smalltalk uses a similar idea for its true and false representations, with True and False being singleton objects that respond to messages ifTrue/ifFalse differently.

Haskell used to use this exact model for its Boolean type, but at the time of writing, most Haskell programs use syntactic sugar if a then b else c construct which unlike ifThenElse does not compose unless either wrapped in another function or re-implemented as shown in The Haskell section of this page.

5 more chapters are free with a Lably account.

Conditional expression

Many languages support a conditional expression, which unlike a statement evaluates to a value instead of controlling control flow. The concept of conditional expression was first developed by John McCarthy during his research into symbolic processing and LISP in the late 1950s.

Examples

Algol

ALGOL 60 and some other members of the ALGOL family allow if–then–else as an expression. The idea of including conditional expressions was suggested by John McCarthy, though the ALGOL committee decided to use English words rather than McCarthy's mathematical syntax:

<span id="mwBC4"></span><span class="n" id="mwBC8">myvariable</span><span class="w" id="mwBDA"> </span><span class="o" id="mwBDE">:=</span><span class="w" id="mwBDI"> </span><span class="k" id="mwBDM">if</span><span class="w" id="mwBDQ"> </span><span class="n" id="mwBDU">x</span><span class="w" id="mwBDY"> </span><span class="o" id="mwBDc">></span><span class="w" id="mwBDg"> </span><span class="mi" id="mwBDk">20</span><span class="w" id="mwBDo"> </span><span class="k" id="mwBDs">then</span><span class="w" id="mwBDw"> </span><span class="mi" id="mwBD0">1</span><span class="w" id="mwBD4"> </span><span class="k" id="mwBD8">else</span><span class="w" id="mwBEA"> </span><span class="mi" id="mwBEE">2</span>

ALGOL 68

Compound statements are all terminated (guarded) by distinctive closing brackets:

IF choice clauses:

<b id="mwBEk">IF</b> condition <b id="mwBEo">THEN</b> statements [ <b id="mwBEs">ELSE</b> statements ] <b id="mwBEw">FI</b> "brief" form: ( condition | statements | statements )

<b id="mwBE4">IF</b> condition1 <b id="mwBE8">THEN</b> statements <b id="mwBFA">ELIF</b> condition2 <b id="mwBFE">THEN</b> statements [ <b id="mwBFI">ELSE</b> statements ] <b id="mwBFM">FI</b> "brief" form: ( condition1 | statements |: condition2 | statements | statements )

This scheme not only avoids the dangling else problem but also avoids having to use BEGIN and END in embedded statement sequences.

CASE choice clauses:

<b id="mwBF8">CASE</b> switch <b id="mwBGA">IN</b> statements, statements,... [ <b id="mwBGE">OUT</b> statements ] <b id="mwBGI">ESAC</b> "brief" form: ( switch | statements,statements,... | statements )

<b id="mwBGQ">CASE</b> switch1 <b id="mwBGU">IN</b> statements, statements,... <b id="mwBGY">OUSE</b> switch2 <b id="mwBGc">IN</b> statements, statements,... [ <b id="mwBGg">OUT</b> statements ] <b id="mwBGk">ESAC</b> "brief" form of <b id="mwBGo">CASE</b> statement: ( switch1 | statements,statements,... |: switch2 | statements,statements,... | statements )

Choice clause example with Brief symbols:

<b id="mwBG4">PROC</b> days in month = (<b id="mwBG8">INT</b> year, month)<b id="mwBHA">INT</b>: (month| 31, (year÷×4=0 ∧ year÷×100≠0 ∨ year÷×400=0 | 29 | 28 ), 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 );

Lisp

Conditional expressions have always been a fundamental part of Lisp . In pure LISP, the COND function is used. In dialects such as Scheme, Racket and Common Lisp :

<span id="mwBHw"></span><span class="c1" id="mwBH0">;; Scheme</span> <span class="p" id="mwBH4">(</span><span class="k" id="mwBH8">define</span><span class="w" id="mwBIA"> </span><span class="p" id="mwBIE">(</span><span class="nf" id="mwBII">myvariable</span><span class="w" id="mwBIM"> </span><span class="nv" id="mwBIQ">x</span><span class="p" id="mwBIU">)</span><span class="w" id="mwBIY"> </span><span class="p" id="mwBIc">(</span><span class="k" id="mwBIg">if</span><span class="w" id="mwBIk"> </span><span class="p" id="mwBIo">(</span><span class="nb" id="mwBIs">></span><span class="w" id="mwBIw"> </span><span class="nv" id="mwBI0">x</span><span class="w" id="mwBI4"> </span><span class="mi" id="mwBI8">12</span><span class="p" id="mwBJA">)</span><span class="w" id="mwBJE"> </span><span class="mi" id="mwBJI">1</span><span class="w" id="mwBJM"> </span><span class="mi" id="mwBJQ">2</span><span class="p" id="mwBJU">))</span><span class="w" id="mwBJY"> </span><span class="c1" id="mwBJc">; Assigns 'myvariable' to 1 or 2, depending on the value of 'x'</span>

<span id="mwBJo"></span><span class="c1" id="mwBJs">;; Common Lisp</span> <span class="p" id="mwBJw">(</span><span class="k" id="mwBJ0">let</span><span class="w" id="mwBJ4"> </span><span class="p" id="mwBJ8">((</span><span class="nv" id="mwBKA">x</span><span class="w" id="mwBKE"> </span><span class="mi" id="mwBKI">10</span><span class="p" id="mwBKM">))</span> <span class="w" id="mwBKQ"> </span><span class="p" id="mwBKU">(</span><span class="k" id="mwBKY">setq</span><span class="w" id="mwBKc"> </span><span class="nv" id="mwBKg">myvariable</span><span class="w" id="mwBKk"> </span><span class="p" id="mwBKo">(</span><span class="k" id="mwBKs">if</span><span class="w" id="mwBKw"> </span><span class="p" id="mwBK0">(</span><span class="nb" id="mwBK4">></span><span class="w" id="mwBK8"> </span><span class="nv" id="mwBLA">x</span><span class="w" id="mwBLE"> </span><span class="mi" id="mwBLI">12</span><span class="p" id="mwBLM">)</span><span class="w" id="mwBLQ"> </span><span class="mi" id="mwBLU">2</span><span class="w" id="mwBLY"> </span><span class="mi" id="mwBLc">4</span><span class="p" id="mwBLg">)))</span><span class="w" id="mwBLk"> </span><span class="c1" id="mwBLo">; Assigns 'myvariable' to 2</span>

Haskell

In Haskell 98, there is only an if expression, no if statement, and the else part is compulsory, as every expression must have some value. Logic that would be expressed with conditionals in other languages is usually expressed with pattern matching in recursive functions.

Because Haskell is lazy, it is possible to write control structures, such as if, as ordinary expressions; the lazy evaluation means that an if function can evaluate only the condition and proper branch (where a strict language would evaluate all three). It can be written like this:

<span id="mwBNQ"></span><span class="nf" id="mwBNU">if'</span><span class="w" id="mwBNY"> </span><span class="ow" id="mwBNc">::</span><span class="w" id="mwBNg"> </span><span class="kt" id="mwBNk">Bool</span><span class="w" id="mwBNo"> </span><span class="ow" id="mwBNs">-></span><span class="w" id="mwBNw"> </span><span class="n" id="mwBN0">a</span><span class="w" id="mwBN4"> </span><span class="ow" id="mwBN8">-></span><span class="w" id="mwBOA"> </span><span class="n" id="mwBOE">a</span><span class="w" id="mwBOI"> </span><span class="ow" id="mwBOM">-></span><span class="w" id="mwBOQ"> </span><span class="n" id="mwBOU">a</span> <span class="nf" id="mwBOY">if'</span><span class="w" id="mwBOc"> </span><span class="kt" id="mwBOg">True</span><span class="w" id="mwBOk"> </span><span class="n" id="mwBOo">x</span><span class="w" id="mwBOs"> </span><span class="kr" id="mwBOw">_</span><span class="w" id="mwBO0"> </span><span class="ow" id="mwBO4">=</span><span class="w" id="mwBO8"> </span><span class="n" id="mwBPA">x</span> <span class="nf" id="mwBPE">if'</span><span class="w" id="mwBPI"> </span><span class="kt" id="mwBPM">False</span><span class="w" id="mwBPQ"> </span><span class="kr" id="mwBPU">_</span><span class="w" id="mwBPY"> </span><span class="n" id="mwBPc">y</span><span class="w" id="mwBPg"> </span><span class="ow" id="mwBPk">=</span><span class="w" id="mwBPo"> </span><span class="n" id="mwBPs">y</span>

C-like languages

C and related languages support a ternary operator that provides for conditional expressions like:

<i id="mwBQE">condition</i> ? <i id="mwBQI">true-value</i> : <i id="mwBQM">false-value</i>

If condition is true, then the expression evaluates to true-value; otherwise to false-value. In the following code, r is assigned to "foo" if x > 10, and to "bar" if not.

<span id="mwBQo"></span><span class="n" id="mwBQs">r</span><span class="w" id="mwBQw"> </span><span class="o" id="mwBQ0">=</span><span class="w" id="mwBQ4"> </span><span class="n" id="mwBQ8">x</span><span class="w" id="mwBRA"> </span><span class="o" id="mwBRE">></span><span class="w" id="mwBRI"> </span><span class="mi" id="mwBRM">10</span><span class="w" id="mwBRQ"> </span><span class="o" id="mwBRU">?</span><span class="w" id="mwBRY"> </span><span class="s" id="mwBRc">"foo"</span><span class="w" id="mwBRg"> </span><span class="o" id="mwBRk">:</span><span class="w" id="mwBRo"> </span><span class="s" id="mwBRs">"bar"</span><span class="p" id="mwBRw">;</span>

To accomplish the same using an if-statement, this would take more than one statement, and require mentioning r twice:

<span id="mwBSE"></span><span class="k" id="mwBSI">if</span><span class="w" id="mwBSM"> </span><span class="p" id="mwBSQ">(</span><span class="n" id="mwBSU">x</span><span class="w" id="mwBSY"> </span><span class="o" id="mwBSc">></span><span class="w" id="mwBSg"> </span><span class="mi" id="mwBSk">10</span><span class="p" id="mwBSo">)</span> <span class="w" id="mwBSs"> </span><span class="n" id="mwBSw">r</span><span class="w" id="mwBS0"> </span><span class="o" id="mwBS4">=</span><span class="w" id="mwBS8"> </span><span class="s" id="mwBTA">"foo"</span><span class="p" id="mwBTE">;</span> <span class="k" id="mwBTI">else</span> <span class="w" id="mwBTM"> </span><span class="n" id="mwBTQ">r</span><span class="w" id="mwBTU"> </span><span class="o" id="mwBTY">=</span><span class="w" id="mwBTc"> </span><span class="s" id="mwBTg">"bar"</span><span class="p" id="mwBTk">;</span>

Some argue that the explicit if-then statement is easier to read and that it may compile to more efficient code than the ternary operator, while others argue that concise expressions are easier to read and better since they have less repeated clauses.

Visual Basic

In Visual Basic and some other languages, a function called IIf is provided, which can be used as a conditional expression. However, it does not behave like a true conditional expression, because both the true and false branches are always evaluated; it is just that the result of one of them is thrown away, while the result of the other is returned by the IIf function.

Tcl

In Tcl if is not a keyword but a function (in Tcl known as command or proc). For example

<span id="mwBU8"></span><span class="k" id="mwBVA">if</span><span class="w" id="mwBVE"> </span><span class="k" id="mwBVI">{</span><span class="nv" id="mwBVM">$x</span><span class="w" id="mwBVQ"> </span><span class="o" id="mwBVU">></span><span class="w" id="mwBVY"> </span><span class="nv" id="mwBVc">10</span><span class="k" id="mwBVg">}</span><span class="w" id="mwBVk"> </span><span class="k" id="mwBVo">{</span> <span class="w" id="mwBVs"> </span><span class="nb" id="mwBVw">puts</span><span class="w" id="mwBV0"> </span><span class="s2" id="mwBV4">"Foo!"</span> <span class="k" id="mwBV8">}</span>

invokes a function named if passing 2 arguments: The first one being the condition and the second one being the true branch. Both arguments are passed as strings (in Tcl everything within curly brackets is a string).

In the above example the condition is not evaluated before calling the function. Instead, the implementation of the if function receives the condition as a string value and is responsible to evaluate this string as an expression in the callers scope.

Such a behavior is possible by using uplevel and expr commands. Uplevel makes it possible to implement new control constructs as Tcl procedures (for example, uplevel could be used to implement the while construct as a Tcl procedure).

Because if is actually a function it also returns a value. The return value from the command is the result of the body script that was executed, or an empty string if none of the expressions was non-zero and there was no bodyN.

Rust

In Rust, if is always an expression. It evaluates to the value of whichever branch is executed, or to the unit type () if no branch is executed. If a branch does not provide a return value, it evaluates to () by default. To ensure the if expression's type is known at compile time, each branch must evaluate to a value of the same type. For this reason, an else branch is effectively compulsory unless the other branches evaluate to (), because an if without an else can always evaluate to () by default.

The following assigns r to 1 or 2 depending on the value of x.

<span id="mwBY0"></span><span class="kd" id="mwBY4">let</span><span class="w" id="mwBY8"> </span><span class="n" id="mwBZA">r</span><span class="w" id="mwBZE"> </span><span class="o" id="mwBZI">=</span><span class="w" id="mwBZM"> </span><span class="k" id="mwBZQ">if</span><span class="w" id="mwBZU"> </span><span class="n" id="mwBZY">x</span><span class="w" id="mwBZc"> </span><span class="o" id="mwBZg">></span><span class="w" id="mwBZk"> </span><span class="mi" id="mwBZo">20</span><span class="w" id="mwBZs"> </span><span class="p" id="mwBZw">{</span> <span class="w" id="mwBZ0"> </span><span class="mi" id="mwBZ4">1</span> <span class="p" id="mwBZ8">}</span><span class="w" id="mwBaA"> </span><span class="k" id="mwBaE">else</span><span class="w" id="mwBaI"> </span><span class="p" id="mwBaM">{</span> <span class="w" id="mwBaQ"> </span><span class="mi" id="mwBaU">2</span> <span class="p" id="mwBaY">};</span>

Values can be omitted when not needed.

<span id="mwBao"></span><span class="k" id="mwBas">if</span><span class="w" id="mwBaw"> </span><span class="n" id="mwBa0">x</span><span class="w" id="mwBa4"> </span><span class="o" id="mwBa8">></span><span class="w" id="mwBbA"> </span><span class="mi" id="mwBbE">20</span><span class="w" id="mwBbI"> </span><span class="p" id="mwBbM">{</span> <span class="w" id="mwBbQ"> </span><span class="fm" id="mwBbU">println!</span><span class="p" id="mwBbY">(</span><span class="s" id="mwBbc">"x is greater than 20"</span><span class="p" id="mwBbg">);</span> <span class="p" id="mwBbk">}</span>

Pattern matching

Pattern matching is an alternative to conditional statements (such as if–then–else and switch). It is available in many languages with functional programming features, such as Wolfram Language, ML and many others. Here is a simple example written in the OCaml language:

<span id="mwBcI"></span><span class="k" id="mwBcM">match</span> <span class="n" id="mwBcQ">fruit</span> <span class="k" id="mwBcU">with</span> <span class="o" id="mwBcY">|</span> <span class="s2" id="mwBcc">"apple"</span> <span class="o" id="mwBcg">-></span> <span class="n" id="mwBck">cook</span> <span class="n" id="mwBco">pie</span> <span class="o" id="mwBcs">|</span> <span class="s2" id="mwBcw">"coconut"</span> <span class="o" id="mwBc0">-></span> <span class="n" id="mwBc4">cook</span> <span class="n" id="mwBc8">dango_mochi</span> <span class="o" id="mwBdA">|</span> <span class="s2" id="mwBdE">"banana"</span> <span class="o" id="mwBdI">-></span> <span class="n" id="mwBdM">mix</span><span class="o" id="mwBdQ">;;</span>

The power of pattern matching is the ability to concisely match not only actions but also values to patterns of data. Here is an example written in Haskell which illustrates both of these features:

<span id="mwBds"></span><span class="nf" id="mwBdw">map</span><span class="w" id="mwBd0"> </span><span class="kr" id="mwBd4">_</span><span class="w" id="mwBd8"> </span><span class="kt" id="mwBeA">[]</span><span class="w" id="mwBeE"> </span><span class="ow" id="mwBeI">=</span><span class="w" id="mwBeM"> </span><span class="kt" id="mwBeQ">[]</span> <span class="nf" id="mwBeU">map</span><span class="w" id="mwBeY"> </span><span class="n" id="mwBec">f</span><span class="w" id="mwBeg"> </span><span class="p" id="mwBek">(</span><span class="n" id="mwBeo">h</span><span class="w" id="mwBes"> </span><span class="kt" id="mwBew">:</span><span class="w" id="mwBe0"> </span><span class="n" id="mwBe4">t</span><span class="p" id="mwBe8">)</span><span class="w" id="mwBfA"> </span><span class="ow" id="mwBfE">=</span><span class="w" id="mwBfI"> </span><span class="n" id="mwBfM">f</span><span class="w" id="mwBfQ"> </span><span class="n" id="mwBfU">h</span><span class="w" id="mwBfY"> </span><span class="kt" id="mwBfc">:</span><span class="w" id="mwBfg"> </span><span class="n" id="mwBfk">map</span><span class="w" id="mwBfo"> </span><span class="n" id="mwBfs">f</span><span class="w" id="mwBfw"> </span><span class="n" id="mwBf0">t</span>

This code defines a function map, which applies the first argument (a function) to each of the elements of the second argument (a list), and returns the resulting list. The two lines are the two definitions of the function for the two kinds of arguments possible in this case – one where the list is empty (just return an empty list) and the other case where the list is not empty.

Pattern matching is not strictly speaking always a choice construct, because it is possible in Haskell to write only one alternative, which is guaranteed to always be matched – in this situation, it is not being used as a choice construct, but simply as a way to bind names to values. However, it is frequently used as a choice construct in the languages in which it is available.

Map-based conditionals

In programming languages that have associative arrays or comparable data structures, such as Python, Perl, PHP or Objective-C, it is idiomatic to use them to implement conditional assignment.

<span id="mwBg8"></span><span class="n" id="mwBhA">pet</span> <span class="o" id="mwBhE">=</span> <span class="nb" id="mwBhI">input</span><span class="p" id="mwBhM">(</span><span class="s2" id="mwBhQ">"Enter the type of pet you want to name: "</span><span class="p" id="mwBhU">)</span> <span class="n" id="mwBhY">known_pets</span> <span class="o" id="mwBhc">=</span> <span class="p" id="mwBhg">{</span> <span class="s2" id="mwBhk">"Dog"</span><span class="p" id="mwBho">:</span> <span class="s2" id="mwBhs">"Fido"</span><span class="p" id="mwBhw">,</span> <span class="s2" id="mwBh0">"Cat"</span><span class="p" id="mwBh4">:</span> <span class="s2" id="mwBh8">"Meowsles"</span><span class="p" id="mwBiA">,</span> <span class="s2" id="mwBiE">"Bird"</span><span class="p" id="mwBiI">:</span> <span class="s2" id="mwBiM">"Tweety"</span><span class="p" id="mwBiQ">,</span> <span class="p" id="mwBiU">}</span> <span class="n" id="mwBiY">my_name</span> <span class="o" id="mwBic">=</span> <span class="n" id="mwBig">known_pets</span><span class="p" id="mwBik">[</span><span class="n" id="mwBio">pet</span><span class="p" id="mwBis">]</span>

In languages that have anonymous functions or that allow a programmer to assign a named function to a variable reference, conditional flow can be implemented by using a dictionary as a dispatch table.

Branch predication

An alternative to conditional branch instructions is branch predication. Predication is an architectural feature that enables instructions to be conditionally executed instead of modifying the control flow.

Choice system cross reference

This table refers to the most recent language specification of each language. For languages that do not have a specification, the latest officially released implementation is referred to.

^{^} This refers to pattern matching as a distinct conditional construct in the programming language – as opposed to mere string pattern matching support, such as regular expression support.
¹ ² An #ELIF directive is used in the preprocessor sub-language that is used to modify the code before compilation; and to include other files.
¹ ² ³ ⁴ ⁵ ⁶ The often-encountered else if in the C family of languages, and in COBOL and Haskell, is not a language feature but a set of nested and independent if then else statements combined with a particular source code layout. However, this also means that a distinct else–if construct is not really needed in these languages.
¹ ² ³ Case-expressions in Haskell and match-expressions in F# and Haskell allow both switch-case and pattern matching usage.
^{^} In a Ruby case construct, regular expression matching is among the conditional flow-control alternatives available. For an example, see this Stack Overflow question.
¹ ² SQL has two similar constructs that fulfill both roles, both introduced in SQL-92. A "searched CASE" expression CASE WHEN cond1 THEN expr1 WHEN cond2 THEN expr2 [...] ELSE exprDflt END works like if ... else if ... else, whereas a "simple CASE" expression: CASE expr WHEN val1 THEN expr1 [...] ELSE exprDflt END works like a switch statement. For details and examples see Case (SQL).
^{^} Fortran 90 added the MERGE intrinsic. Fortran 2023 added the C-like ternary operator.
^{^} Pattern matching was added in Ruby 3.0. Some pattern matching constructs are still experimental.
^{^} Arithmetic if was marked as obsolescent in Fortran 90. It was deleted as of the Fortran 2018 Standard.