Here we have a JavaScript function that takes an input array and then invokes sort and reverse. To return a reverse sorted array, we create an array of five numbers stored in a start variable. Then we invoke this reverse sorted function and then store the result in a result variable. Now at this point, our result is exactly what we expected it to be. It is the five numbers in reverse sorted order. However, sadly, the reverse sorted function has also mutated our input array. This is a very common mistake to make when beginning JavaScript development.

And the reason is that the sort and the reverse methods, in addition to returning the results, also mutate the original array. Fortunately, with TypeScript, instead of declaring the input as a number array, we can declare it as a read only number array, and now any mutating methods will no longer be available on input. So if you want to use the sort and the reverse methods, the first thing that we will need to do is to create a copy of the input array using the built-in slice method. This creates a new non read only array, which can then be safely sorted

and reversed and then returned. And now when we invoke this reverse sorted method on the start variable, the start variable is no longer mutated, which is very, very cool. Now, you might remember that for JavaScript arrays, TypeScript has a needs syntax, which we prefer as well as a more verbose array generic syntax. The same is true for read only arrays. We prefer the needs syntax, as you saw us already use that for the input parameter, but there is an equivalent read only array generic interface. Now, TypeScript also supports read only couples,

and we've mentioned this before, that couples are simply erased with fixed length. So let's look at a topple example. Here we have a topple representing a point in two dimensional space with two members, both of type number. We create this utility move function that accepts a given point and the distance to move in the X and Y dimensions, and then updates the values in the input double, and then returns the modified double. So if we create a point with X and Y zero and move it by amount 10 and 10 in the x and Y dimensions, we do get the moved point with 10 10.

However, this results in a side effect of mutating our input point also to 10 10, which makes us set. Now just like a arrays, we can annotate a couple as read only by using the read only modifier before the double declaration. And now any attempts to modify any given point we'll result in a compiler error. For example, here you can see that we cannot mutate the Y value. So now we can fix this error by replacing our mutating implementation with an implementation that returns a new double created from the existing double plus the moves in the X and Y dimensions.

So now when we invoke the move method on an existing point, we no longer mutate the original point, which replaces our sad tears with tears of joy.