Programming Expressions

Expressions

• Expressions are fundamental for directing computations in programming.
• Understanding expression evaluation requires familiarity with operator and operand evaluation order.
• Assignment statements play a dominant role in imperative languages.

Arithmetic Expressions

• Arithmetic evaluation was a primary motivation for early programming languages.
• Arithmetic expressions consist of operators, operands, parentheses, and function calls.

Arithmetic Operators

• A unary operator requires one operand (e.g., a++).
• A binary operator requires two operands (e.g., a/b).
• A ternary operator requires three operands (e.g., condition ? value_if_true : value_if_false).

Arithmetic Expression Design Issues

• Key design considerations include operator precedence and associativity rules.
• Order of operand evaluation and potential side effects during operand evaluation are important.
• Operator overloading and type mixing in expressions should also be considered.

Expression Notation

• Notation determines whether a function name appears before, among, or after its arguments.
• Infix operators are positioned between operands (e.g., 1 + 2).
• Prefix operators precede operands (e.g., (+ 1 2) in Polish notation).
• Postfix operators follow operands (e.g., (1 2 3 * +) in reverse Polish notation).
• Most imperative languages use infix notation for binary operators and prefix notation for unary operators.
• Lisp uses prefix notation for all functions.
• Prolog uses infix notation in the UI and prefix notation internally.

Operator Precedence Rules

• Operator precedence rules dictate the evaluation order of operators with different precedence levels.
• Typical precedence levels include parentheses, unary operators, exponents, multiplication/division, then addition/subtraction.
• PEMDAS (Parentheses, Exponents, Multiplication, Division, Addition, Subtraction) is a common mnemonic in the United States for remembering operator precedence.

Operator Associativity Rules

• Operator associativity rules determine the evaluation order of operators with the same precedence level.
• Left-to-right associativity is typical, except for exponentiation (**), which is right-to-left.
• Rules can be overridden with parentheses.

Arithmetic Expressions: Examples

• Associativity defines the grouping of equal-precedence operators (right or left).
• Summation associates left-to-right, for example 9 - 3 - 2 is (9–3)–2=4, not 8.
• Exponentiation operator (**) associates right-to-left, For example, 4**3**2 is 4**(3**2) = 262,144, not 4**(3**2) = 4,096.
• Assignment operation is right associative: x = y = z assigns the value of z to y and then to x as x = (y = z).
• Using parentheses is crucial for clarifying expression semantics.

Conditional Expressions

• Conditional expressions exist in C-based languages (e.g., C, C++).
• They provide a way to express if-else logic in a compact form.

Operand Evaluation Order

• Variables require fetching values from memory.
• Constants may be fetched from memory or be part of a machine language instruction.
• Parenthesized expressions are evaluated first.
• Function calls represent a unique case for operand evaluation.

Potential Side Effects in Function Evaluation

• Functional side effects occur when a function alters a two-way parameter or a non-local variable.
• Functional side effects can cause issues where a function changes an operand in an expression.

Dealing with Functional Side Effects

• Possible solutions: disallow functional side effects by eliminating two-way parameters and non-local references, or demand a fixed order of operand evaluation (limits compiler optimizations).
• Rust vs Python vs C

Overloaded Operators

• Operator overloading is using an operator for multiple purposes.
• Overloading * in C cause potential troubles, as it is used as multiplication, and indirection or Dereferencing when used with pointers
• Overloading can lead to a loss of compiler error detection if an operand is omitted.

User-Defined Overloaded Operators

• Sensibly used user-defined operators can improve readability.
• Example: Overloading + and * for matrix operations.
• Nonsense operations, and reduced readability are potential problems.

Type Conversions

• A narrowing conversion changes an object to a type that cannot accommodate all original values.
• A widening conversion changes an object to a type that includes approximations to all original values.

Type Conversions: Mixed Mode

• Mixed-mode expressions contain operands of different types.
• Coercion is implicit type conversion.
• Coercions can reduce the type error detection ability of the compiler.
• Most imperative languages coerce numeric types in expressions using widening conversions.
• Rust avoids implicit type conversions in most cases due to its strict type system.

Explicit Type Conversions

• Explicit type conversion is called casting in C-based languages.
• Example in C: (int)angle.
• Example in Rust: let integer = pi as i32;

Errors in Expressions

• Errors can arise from arithmetic limitations (e.g., division by zero).
• Computer arithmetic limitations include overflow.
• Often, errors are ignored by the runtime system, but some languages offer Exceptions and handling.

Relational and Boolean Expressions

• Relational expressions use relational operators with operands of various types and evaluates to a Boolean Representation.
• Note that operator symbols vary somewhat among languages.
• Boolean expressions have operands that are Boolean that return a Boolean value.
• C89 lacks a Boolean type and uses int (0 for false, nonzero for true).

Short Circuit Evaluation

• Short-circuit evaluation determines the result without evaluating all operands and/or operators.
• In C and Rust, && and || use short-circuit evaluation; & and \ do not.
• Python uses and and or for logical operations.
• Logical operators are short-circuit, while bitwise operators are not.
• Rust's strong type system ensures that bitwise operators are used in appropriate types, this reduces confusion.
• Side effects in expressions can be exposed by short-circuit evaluation.