Conditional structures: Difference between revisions

{{Task|Control Structures}}{{Control Structures}}This page lists the conditional structures offered by different programming languages. Common conditional structures are '''if-then-else''' and '''switch'''.

6502 Assembly has 8 conditional branch instructions; each instruction will test the appropriate flag and condition and jump between -128 and 127 bytes. To understand these conditional instructions, it is helpful to remember that the comparison instructions (CMP, CPX, CPY) set the flags as if a subtraction had occurred:

Following these instructions, the accumulator will still hold 10 but the flags are set as if you had instructed the processor to perform 10 - 11. The result is -1, so the sign flag will be set, the zero flag will be cleared, the overflow flag will be cleared, and the carry flag will be set.

This code will loop until X is zero. Most assemblers will figure out the correct offset for you if you use a label in place of the offset after a branch instruction, as in the above example.

When there is no '''when others''' clause, the compiler will complain about any uncovered alternative. This defends against a common reason for bugs in other languages. I.e., the following code is syntactically incorrect:

Select provides conditional acceptance of entry calls. Select can also be used to conditionally call an entry

A selective entry call provides a way to time-out an entry call. Without the time-out the calling task will suspend until the entry call is accepted.

The entry Start on the task My_Task will be called. If My_Task accepts the entry call before the timer expires the timer is canceled. If the timeout expires before the entry call is accepted the entry call is canceled.

The first argument should be a boolean expression. The second and third arguments should be blocks (aka anonymous functions or thunks).

Befunge only has one conditional structure, which comes in two flavors: ''vertical IF'' ( | ) and ''horizontal IF'' ( _ ). Befunge only has two boolean commands, ''greater-than'' ( ` ) and ''not'' ( ! ). These snippets input a number and use the conditional operators to print a "0" if it is zero and an "X" otherwise.

'''#''' is the skip command. It unconditionally skips one character, allowing a little flexibility in flow control.

Bracmat uses & and | for branching. These binary operators are like && and || in C-like languages. Bracmat does not have the notion of Boolean variables, but marks all evaluated expressions as either succeeded or failed. If the left hand side of the & operator has succeeded, Bracmat goes on evaluating the right hand side. Only if both of left and right hand sides succeed, the expression tree headed by the & operator as a whole succeeds. Likewise, only if both of left and right hand sides of an expression tree headed by | fail, the expression tree as a whole fails. Evaluated expressions are just that: expressions. The following expression writes "That's what I thought." to your screen and evaluates to the expression "Right".

Use a patterns with alternations. Note that the match-expression (the tree headed by the : operator) evaluates to the left hand side of the : operator. In the following example, the resulting expression is a single node containing "4".

Brainf*** has two conditional jump instructions, [ and ]. the [ instruction jumps forward to the corresponding ] instruction if the value at the current memory cell is zero, while the ] instruction jumps back if the current memory cell is nonzero. Thus in the following sequence:

There are no ''then'' or ''else'' keyword in Clean. The second argument of <tt>if</tt> is the then-part, the third argument is the else-part.

Similar to if, but body in an implicit do block allowing multiple statements. No facility for providing an else. <code>when</code> is defined as a macro.

The cond macro takes a series of test/result pairs, evaluating each test until one resolves to logical true, then evaluates its result. Returns nil if none of the tests yield true.

The if() and elseif() commands evaluate boolean expressions like ''num GREATER 100''; refer to [http://www.cmake.org/cmake/help/cmake-2-8-docs.html#command:if cmake --help-command if]. The elseif() and else() sections are optional.

The (if ...) construct takes a predicate as its first argument and evaluates it. Should the result be non-nil, it goes on to evaluate and returnm the results of the 'then' part, otherwise, when present, it evaluates and returns the result of the 'else' part. Should there be no 'else' part, it returns nil.

the expressions can contain parenthesis or not, here both options are shown

since if and case do pattern matching if an if or case expression don't match some of the patterns the program will crash

Erlang's conditionals are based on pattern matching and guards. There are several mechanisms for this: case-of, if, function clauses. Pattern matching allows destructuring a term and matches a clause based on the structure. In the case example the term is X and the pattern is {N,M} or _. _ will match anything, while {N,M} will only match tuples of two terms. Though N and M could be any other type (in this case an error will occur if they're non-numeric). Guards allow more specification on the terms from the matched pattern. In the case example comparing N and M are guards.

if expressions match against guards only, without pattern matching. Guards must evaluate to true or false so true is the catch-all clause.

There are many conditional structures in Factor. Here I'll demonstrate the most common ones. A few of these have other variations that abstract common stack shuffle patterns. I will not be demonstrating them.

Output is:

Output:

<lang>no

#<unspecified></lang>

Output:

<lang>less

equal</lang>

Output:

<lang>composite

consonant</lang>

There can be single or multiple statements. An if-statement can have multiple elsif parts.

The <code>cases</code>, <code>all</code> and <code>none</code> directives most resemble control structures because they have short-circuiting behavior. For instance:

If any subclause fails to match, then <code>all</code> stops processing subsequent clauses. There are subtleties though, because an earlier clause can produce variable bindings which are visible to later clauses. If previously bound variable is bound again, it must be to an identical piece of text: