Expressions (chapter 7 of textbook) Semantics of expressions depends on: –operator evaluation order operator precedence operator associativity –operand evaluation order –side effects –short-circuit evaluation

Arithmetic expressions expressions involving arithmetic operators such as +, -, * and / –most are binary only (taking two arguments) –some are unary (taking one argument) most languages write binary arithmetic operators infix (between their operands), as in mathematics: x + y some don’t (e.g. Scheme): (+ x y) Scheme’s operators are of arbitrary arity: ( )  (+ (+ (+ 1 2) 3) 4)  10 ( )  (- (- (- 1 2) 3) 4)  -8 (* )  (* (* (* 1 2) 3) 4)  24 (/ )  (/ (/ (/ 1 2) 3) 4)  1/24

Precedence Without parenthesization, in what order are different operators evaluated? E.g. what is the value of * 3? Is it 9 or 7? Most languages adopt precedence rules of mathematics (e.g. * and / have higher precedence than + and -). Unary operators typically have higher precedence than binary ones (e.g. unary – has higher precedence than binary -). In C-like languages, postfix ++ and -- have higher precedence than unary -. Suppose x has value 2, then -x++ has value -2 (but leaves x with value 3).

Associativity Determines whether unparenthesized expressions involving operators of the same precedence group to the left or to the right: 5 – 3 – 4  (5 – 3) – 4  –2 (left associativity) 5 – 3 – 4  5 – (3 – 4)  6 (right associativity) In most languages +,-,*,/ are left associative. In Scheme the question of associativity does not come up (since all expressions must be fully parenthesized)

Associative operators Some operators are, mathematically speaking, associative. For example, + is mathematically associative, meaning that x+y = y+x. For example, - is not: x-y != y-x (unless x and y are the same). Compilers can take advantage of this to reorder expressions for increased execution speed, but… Operators like + are not generally associative in programming languages due to the limited precision with which numbers are represented. With floating point operations + and * are not associative: … != …

Conditional expressions A conditional expression has a value. In C-like languages the if-statement is not an expression, and has no value: if (count==0) { average = 0; } else { average = sum/count; }

Conditional expressions in C-like languages In C-like languages we cannot write: average = if (count==0) 0; else sum/count; In C-like languages we must write: average = (count==0) ? 0 : sum/count; In functional languages conditionals are expressions: val average = if (count=0)then 0 else sum/count; Orthogonality in language design favors NOT having different syntax for conditional statements and conditional expressions.

Implications of conditional expressions A conditional expression requires that all branches of the conditional: –have a value –have the same type An if-then without an else is semantically incoherent as an expression.

Operand evaluation order In an expression like +, is or evaluated first? Without side-effects or short-circuit evaluation, order is irrelevant. Aside: if an expression has the same value no matter what its context of evaluation, then it is termed referentially transparent.

Side-effects & operand evaluation If expressions have side effects (e.g. mutate variables) then order of evaluation becomes very important. Operators like ++ are side-effecting: ++x is equivalent to x = x + 1.

Short-circuit evaluation and operand evaluation If expression evaluation is short-circuited then order of evaluation also becomes very important. In C-like languages && is typically short- circuiting.

Operator overloading Positives: can make code more clear –in C++ ‘<<’ can be overloaded for different types to handle stream output –in C++ ‘+’ can be overloaded to provide addition of novel types Negatives: can make code less clear –in C ‘&’ is overloaded with unrelated meanings –nothing stops a user from overloading ‘+’ to do something other than addition

unary/binary overloading - is overloaded with unary and binary meanings in most languages In ML - is binary subtraction only, and ~ is unary negation. –Is benefit worth the trouble?

Type coercions and type checking Type coercions weaken type checking.