**Properties** associate a particular value to **classes**, **structures**, and **enumerations**. Properties can be of two types:

- stored properties
- computed properties

The first are constants or variables defined by the keywords **let** and **var** and can be part of classes and structures. The second are properties obtained from a calculation and can be part of classes, structures, and enumerations.

Properties, both stored and computed, can be **static** in this case they are called **type properties** (see them in the second part).

We are going to define a **structure** with two **stored properties**, one variable and the other constant:

`struct FixedInterval {`

` var startValue: Int`

` let interval: Int`

`}`

`var intervalThree = FixedInterval(startValue: 0, interval: 3)`

`intervalThree.startValue = 6`

When the instance of the **FixedInterval** structure is created, two values are associated with the properties. Only one of these two values can be edited afterwards because it is variable, the value defined by **let** is constant and once initialized it is no longer editable.

It is necessary to make a clarification about variables and constants. If the **FixedInterval** structure is associated with a constant, the internally defined variable is also constant. This is because the structure is a **value type**. The same thing would not be true for a **class** because the class is a **reference type**.

In addition to the **stored properties** where, once the instance is created, values are stored and associated with properties whether they are variable or constant, there are **computed properties** where values are not stored but obtained through a calculation. These properties use the **get** and **set** keyword.

With **get**, I read the value of the **computed property** that is a value obtained from the calculation made on other properties.

With **set**, I write the value in the **computed property** that is equivalent to writing the value of the stored properties indirectly through the calculation.

In the following example, I set two points on the plane, by means of computed properties I return the distance and the travel speed from point A to point B.

`// x and y coordinates at the time t (meters and seconds)`

`struct PointPlane {`

` var x = 0, y = 0`

` var t = 0`

`}`

`struct Route {`

` var start = PointPlane()`

` var arrival = PointPlane()`

` `

` var timeTravel: Int {`

` `

` get {`

` return arrival.t - start.t`

` }`

` `

` set(newT) {`

` start.t = 0`

` arrival.t = newT`

` }`

` }`

` `

` var distance: Double {`

` `

` get {`

` let dX = arrival.x - start.x`

` let dY = arrival.y - start.y`

` let tmp = sqrt(pow(Double(dX), 2) + pow(Double(dY), 2))`

` return tmp`

` }`

` }`

` `

` var speed: Double {`

` `

` get {`

` return distance/Double(timeTravel)`

` }`

` }`

`}`

`let pointA = PointPlane(x: 0, y: 0, t: 0) //I'm setting the starting point`

`let pointB = PointPlane(x: 10, y: 10, t: 10) //I'm setting the arrival point`

`var routeAB = Route(start: pointA, arrival: pointB)`

`routeAB.timeTravel = 8 //I'm changing time for travel`

`let distance = routeAB.distance//I'm reading the computed property = 14,14 m`

`let speed = routeAB.speed//I'm reading the computed property = 1,76 m/sec`

In the structure **Route**, I've created two **stored properties** by creating the **start** and **arrival** variables that are two instances of the **PointPlane** structure. Then I've created the **computed property** **timeTravel** variable. This variable, when I read it, calculates the difference between the start and arrival properties and returns an integer value. This is done through the **get** keyword. Through **set** I can set a new travel time by setting the value **t** of the **start** and **arrival** variables. Two other calculated properties are created: **distance** and **speed**; the method is the same, by means of a calculation and the keyword **get** the variable assumes a precise value when interrogated.

Note that the **set** keyword is followed by the name of a variable (**newT**) that is used to convey the new value in the calculation; you can avoid specifying it and Swift assigns as default name "newValue" that can be used instead of **newT**.

As usual in the perspective of simplification, the two properties of **distance** and **speed** are read-only because of without the "setter"; it is therefore possible to avoid writing **get** and making the code easier to read.

`var speed: Double {`

` return distance/Double(timeTravel)`

`}`