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'''.[[Category:Simple]],

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.

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.

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

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.

<langpre>no

#<unspecified></langpre>

<langpre>less

equal</langpre>

<langpre>composite

consonant</langpre>

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: