conditional operator (idea)

The '?:' syntax of C like languages comes as a borrowed concept from functional languages (such as Lisp, Scheme, and ML).

In Lisp everything returns something. This is even true of the 'if' function. With common lisp, 'if' has the structure:
if test then [else] => result
In an actual lisp session, this would look like:

(if t 1 2) => 1
(if nil 1 2) => 2

In the above example, the return value of the if is displayed to the right. Thats correct, return value of the if statement. Within procedural languages, the concept of a return value for every instruction and block of code is a bit foreign. Blocks may certainly return a value, but are not legal on the right hand side of assignment operator.

And yet, the return value from an if is such a useful idea, especially when it is properly understood by all parties and not abused to make the code difficult to read. Consider the following code from perl (just happens to be what I'm thinking in now)

# var         does it exist               use it       default
$opt_test  = (defined $options{'test'})?  $options{'test'}  :0;
$opt_log   = (defined $options{'log'})?   $options{'log'}   :1;
$opt_force = (defined $options{'force'})? $options{'force'} :0;
$opt_debug = (defined $options{'debug'})? $options{'debug'} :0;

The separation between statements and expressions is an important one within procedural languages and its offspring of object oriented languages (most of which come from a procedural background). Most notably is the rigidity with how these languages handle types compared to that of functional languages. The type of an expression is known at compile time and fairly easy to figure out. Consider the difficulty in attempting to figure out the 'type' of an anonymous block of code (which is itself a 'statement') or a statement.

In most cases, while it would be 'neat' to have a 'while' loop or a 'for' loop (or any other structure) return a value, this is rarely needed (or desired). Instead, it would add needless complexity to the language that would rarely be used, and in essence, violates the ideals of a procedural language. (The only procedural language to do such a thing was a variant of Algol, however it applied only to the 'if' keyword and its positioning relative to parentheses as an indicator if it was to be an expression or statement. Realize that Algol did a number of other 'interesting' things to its syntax (to say the least).) It turns out that separating the expression 'if' from the control structure 'if' makes it easier on the complier and leads to less likelyhood of confusion on the part of the programmer (such as the confusion with a '=' instead of a '==' within an expression in C).

The one exception to this, is the 'if' expression which has the syntax of '?:'. Hidden within other expressions or simply shorthand for a conditional. While quite simple, picture the 'if' form of the following:

foo = (bar?bar:1)/(qux?qux:1);

If 'bar' is true (not 0), then use it, otherwise use '1'. This is then divided by qux, which has the same applied to it.

The '?:' expression is found in most any language that is derived from BCPL (the predecessor of B, the predecessor of C) or one of its descendants. From the reference manual found at:
http://cm.bell-labs.com/cm/cs/who/dmr/bcpl.html (page 15) dated July 21, 1967.

5.5 Conditional Expressions

Syntactic form: E1 -> E2, E3

E1, E2 and E3 may be any logical expressions or expressions of greater binding power. E2 and E3 may, in addition be conditional expressions.

Semantics:

The value of the conditional expression E1 -> E2, E3 is the Rvalue of E2 or E3 depending on whether the value of E1 represents true or false respectively. In either case only one alternative is evaluated. If the value of E1 does not represent either true or false than the result of the conditional expression is undefined.

While it was never fully implemented, CPL (the language that lead to BCPL) had a similar structure. The language definition can be found in pages 136-137 of "The main features of CPL" by Barron, D. W., Buxton, J. N., Hartley, D. F., Nixon, E., Strachey, C. as part of Computer Journal, volume 6 (1963) which is online at http://www3.oup.co.uk/computer_journal/hdb/Volume_06/Issue_02/ (many thanks to jrn who dug up the refrence).

The '?:' syntax was first seen as part of B:
(from http://cm.bell-labs.com/cm/cs/who/dmr/kbman.html)

rvalue ::=
    ( rvalue )
    lvalue
    constant
    lvalue assign rvalue
    inc-dec lvalue
    lvalue inc-dec
    unary rvalue
    & lvalue
    rvalue binary rvalue
    rvalue ? rvalue : rvalue
    rvalue ( {rvalue {, rvalue} } )