# W1037 Expressions and Operators

## Prerequisites[edit]

- W1031 Positive Integers
- W1032 Negative Integers
- W1033 Character Encoding
- W1038 L-Values and R-Values

## Introduction[edit]

An **expression** is a finite series of symbols that is well-formed according to agreed upon rules. The symbols may include **constants**, **variables**, **operators**, and **brackets**. A valid expression will yield a value of a specific type according to the rules of the language.

## Type Inference[edit]

### Integers[edit]

All expressions, when evaluated, yield a particular **type**. For example, in the expression:

```
let x = 3
```

*x* will be of type **Int**, which is an integer whose size depends on the size of the underlying platform. (On 32-bit platforms, Int will be equivalent to **Int32**, and on 64-bit platforms, Int will be equivalent to **Int64**.) On the other hand, in the expression:

```
let y = 3.0
```

*y* will be of type **Double**, which is a double-precision, floating-point type. **Because Swift is a type-safe language, all expressions will always have a specific type**. Type-safety enables the compiler to warn us when we make a mistake, such as by using an Int when we intended a Double.
Like many other type-safe languages, we're able to

*explicitly*specify the type of a constant of variable:

```
let x : Int = 3
```

We're able to use explicit typing to ensure that we're evaluating the expression as the desired type as in the example above. However, in most cases, Swift allows us to be more brief, and rely on **type inference**. Type inference will rely on the literal value(s) or named value(s) to determine the type. Let's look at a few examples:

```
let maximumClassCount = 8
// maximumClassCount will be of type Int
let maximumGPA = 5.0
// maximumGPA will be of type Double
```

In addition to decimal, literal integer expressions Swift will also infer the Int type from binary, octal, and hexadecimal:

```
let n = 0b101 // An integer formed from a binary, literal constant
let m = 0o17 // An integer formed from an octal, literal constant
let p = 0x2F // An integer formed from a hexadecimal, literal constant
```

### Floating Points[edit]

Floating point numbers may be specified in decimal or in hexadecimal. Decimal numbers may have an optional exponent (indicated by **e** or **E**), which means that the base number is multiplied by .

```
let f = 1.23e5 // f is a Double of value 123,000
```

Hexadecimal numbers may also have an optional exponent (indicated by **p** or **P**), which means that the base number is multiplied by .

```
let g = 0xFp3 // g is a Double of value 120
```

Note that for *literal constants*, Swift will interpret the expression as a Double if any of the component expressions evaluate to a Double. ⚠ This does not apply to named constants.

### Readability[edit]

Both integers and floating point numbers may have leading zeroes and embedded underscores for easier reading (by humans).

```
let oneBillion = 1_000_000_000
let tenBillion = 010_000_000_000
```

### Strings[edit]

A series of characters embedded within quotes will be inferred to be of type String:

```
let name = "Captain Picard"
```

Coming Soon | |

String length |

## Operators[edit]

In programming, **operators** provide us with the ability to write many expressions in a manner generally familiar to us from algebra. *Operators* can be grouped by **arity**, that is, the number of
**operands** on which the operator will function. For example, the expression 4+5 makes use of a binary operator (addition) which takes two operands, in this case a 4 and a 5. (An arity of one is often called **unary** while an arity of two is often called **binary**.)

Some common operators are listed in the table below:

Name | Symbol (Swift) | Arity | Type |
---|---|---|---|

Assignment | = | 2 | General |

Unary Plus (Positive) | + | 1 | Arithmetic |

Unary Minus (Negative) | - | 1 | Arithmetic |

Addition | + | 2 | Arithmetic |

Subtraction | - | 2 | Arithmetic |

Multiplication | * | 2 | Arithmetic |

Division | / | 2 | Arithmetic |

Remainder | % | 2 | Arithmetic |

Logical NOT | ! | 1 | Boolean |

Logical AND | && | 2 | Boolean |

Logical OR | || | 2 | Boolean |

Equal to | == | 2 | Comparison |

Not equal to | != | 2 | Comparison |

Greater than | > | 2 | Comparison |

Greater than or equal to | >= | 2 | Comparison |

Less than | < | 2 | Comparison |

Less than or equal to | <= | 2 | Comparison |

Concatenation | + | 2 | String |

Some languages also support **compound assignment** operators, that is, they perform an operation on an L-Value and then store the result in the same L-Value. For example, the statements:

var x = 9 x += 2

assign the integer value of 9 to "x", and then increment "x" by 2, resulting in a new value for "x" of 11. This is exactly equivalent to:

var x = 9 x=x+2

## Expressions with Operators[edit]

We can use one or more operators with appropriate operands to form more complex expressions and assign the resultant value to a constant or variable:

```
let areaOfRectangle = 4.0 * 5.2
let radius = 2.7
let areaOfCircle = Double.pi * radius * radius
```

The **concatenation** operator can be used to form more complex strings from simpler strings:

```
let firstName = "William"
let lastName = "Riker"
let fullName = firstName + " " + lastName
```

Coming Soon | |

Additional examples of expressions using operators |

## Key Concepts[edit]

- An
**expression**is a finite series of symbols that is well-formed according to agreed upon rules - A valid expression will yield a value of a specific type according to the rules of the language
- All expressions, when evaluated, yield a particular type
- On 32-bit platforms,
**Int**will be equivalent to**Int32** - On 64-bit platforms,
**Int**will be equivalent to**Int64** - Swift is a
**type-safe language**, all expressions will always have a specific type- Type-safety enables the compiler to warn us when we make a mistake, such as by using an Int when we intended a Double
- We're able to use explicit typing to ensure that we're evaluating the expression as the desired type

- In most cases, Swift allows us to be more brief, and rely on
**type inference**- Type inference will rely on the literal value(s) or named value(s) to determine the type

- Integers may be specified in decimal, binary, octal, or hexadecimal
- Floating point numbers may be specified in decimal or hexadecimal
- Exponents may be specified by using
**e**for decimal numbers and**p**for hexadecimal numbers

- Exponents may be specified by using
- Both integers and floating point numbers may have leading zeroes and embedded underscores
- A series of characters embedded within quotes will be inferred to be of type
**String**- The concatenation operator can be used to form more complex strings from simpler strings

- We can use one or more operators with appropriate operands to form more complex expressions

## Exercises[edit]

After completing Printing and String Interpolation:

- M1037-10 Complete Merlin Mission Manager Mission M1037-10.

## References[edit]

- Expressions (Wikipedia.org)
- Expressions (Swift.org)