Update the-data.md

Author: gvergnaud

01-the-data/the-data.md

@@ -1,16 +1,16 @@
 # The data of type-level programs
 
-Like with every programming language, in Type-Level TypeScript we will write programs that **transform some data** but unlike in other programming languages, the data our programs will transform are **types**!
+Like with every programming language, in Type Level Typescript we will write code that **transform some data**. The only thing that's different from most other languages is that the data our code will transform are **types**! We will write programs that take some types as input and output some other types.
 
-We will write code that take some types as input and output other types. To master this language we will need to start by understanding the different sorts of data we have at our disposal.
+To master this language we will need to start by understanding the different sorts of data we have at our disposal.
 
 ## The three families of types
 
 There are 3 main "families" of data in Type-Level TypeScript (TLTS): primitive types, literal types, and data structure types. Let's explore each of them.
 
 ### Primitive types
 
-You are certainly already familiar with primitive types. We use them a lot to annotate our function arguments and return types in our day to day TypeScript code. Here is the list of primitive types:
+You are certainly already familiar with primitive types. We use them a lot to annotate our variables and functions in our day to day TypeScript code. Here is the list of primitive types:
 
 ```ts
 type Primitives =
@@ -27,7 +27,7 @@ Every JavaScript value at the exception of objects and functions belong to one o
 
 ### Literal types
 
-Literal types are "exact" types, which encompass a **single value**.
+Literal types are "exact" types, which encompass a **single possible value**.
 
 <!-- prettier-ignore -->
 ```ts
@@ -50,39 +50,39 @@ There's an infinite number of literal types and they look just like regular valu
 
 The world of values and the world of types mostly belong to two parallel universes which exist separately but can't "touch" each other and can't be mixed together [(1)](#dependent-types). I think it's helpful to consider literal types as a sort of reflection of values in the world of types, but we need to keep in mind that they are different things.
 
-One notable difference between values and literal types is that you can't write arithmetic expressions at the type-level. For instance `type five = 2 + 3` won't work, even if `const five = 2 + 3` is a perfectly valid value-level expression.
+One notable difference between values and literal types is that you can't write arithmetic expressions at the type-level. For instance `type five = 2 + 3` won't work, even if `const five = 2 + 3` is a perfectly valid piece of value-level code.
 
-Literal types become particarly useful when put in unions to describe variables which can only contain a finite set of possible values, like `let trafficLight: "green" | "orange" | "red";`. We will explore union types in more depths in a bit.
+Literal types become particarly useful when put in unions to describe variables which can only contain a finite set of possible values like `let trafficLight: "green" | "orange" | "red";`. We will explore union types in more depths in a bit.
 
 ### Data structures
 
 In our type-level world, we have four main built-in data structures at our disposal: objects, records, tuples and arrays.
 
 ```ts
 type DataStructures =
-  | { key1: 1; key2: 2 } // objects
+  | { key1: boolean; key2: number } // objects
   | { [key: string]: number } // records
-  | [1, 2] // tuples
+  | [boolean, number] // tuples
   | number[]; // arrays
 ```
 
-- **Object types** describe objects have a finite number of keys, and each of them contain a value of some specific type.
-- **Record types** are like object types, except they describe objects with an unknown number of keys, and every value contained in a record must have the same type. The type `{ [key: string]: number }` tells us that objects of this type contain numbers.
-- **Tuple types** describe arrays with a fixed length. They can contain a value of a different type for each index.
-- **Array types** describe arrays with an unknown length. Every value contained in an array must have the same type.
+- **Object types** describe objects with a finite set of keys, and these keys contain values of potentially different types.
+- **Record types** are similar to object types, except they describe objects with an unknown number of keys, and all values contained in a record share the same type. For example all values in an object of type `{ [key: string]: number }` are numbers.
+- **Tuple types** describe arrays with a fixed length. They can have a different type for each index.
+- **Array types** describe arrays with an unknown length. all values contained in an array type must have the same type.
 
 It makes sense to split those in 2 sub-groups:
 
 - The sub-group of data structures that can contain **several types**: objects and tuples.
 - The sub-group of data structures that contain a **single type**: records and arrays.
 
-At the type-level, we will mostly be using Objects and Tuples. They are the type level equivalent of JavaScript's objects and arrays and they will enable to implement some of the mapping and filtering algorithms you are already familiar with.
+At the type-level, we will mostly be using objects and tuples. They are the type level equivalent of JavaScript's objects and arrays and they will enable us to implement some of the algorithms you are already familiar with.
 
-Since Records and Array types can only contain a single type inside of them, they aren't very useful in the world of types, so we won't use them very much.
+Since records and array types can only contain a single type inside of them, they aren't very useful in type-level programs, so we won't use them very much.
 
 ### Union and Intersections are data structures too!
 
-Everything we have seen so far look somewhat similar to the kind of data we have at the value-level, but unions and intersections are different. They are really specific to the type-level, and building a good mental model of how they work is a little more challenging.
+Everything we have seen so far looks somewhat similar to the kind of data we have at the value-level, but unions and intersections are different. They are really specific to the type-level, and building a good mental model of how they work is a little more challenging.
 
 Here is what they look like:
 
@@ -92,9 +92,9 @@ type Intersections = X & Y;
 type Unions = X | Y;
 ```
 
-We often tend to think of `&` and `|` as operators. They definitely look like operators at first sight because we place them in between two other types, but they actually are data structures.
+We often tend to think of `&` and `|` as operators. They definitely look like operators at first sight because we place them in between two other types, but they actually are data structures too.
 
-In this course, I'll show you how we can loop through each item inside a union type, how to transform each of them or filter some items to create a new union type from an existing one. This clearly means that `X | Y` doesn't destroy `X` and `Y` to create a new opaque type as an operator would. We will still be able to access `X` and `Y` afterwards and `|` is just a way to add them to some kind of "union" data structure.
+In this course, we will see how we can loop through each item inside a union type, how to "map" over a union type to transform each of its items, or how to filter some items out to create a new union type from an existing one. This clearly means that `X | Y` doesn't turn `X` and `Y` into a new opaque type the way an operator would. Since we are still able to access `X` and `Y` afterwards, it looks like `|` is just a way to add them to some kind of "union" data structure.
 
 To get a better grasp at how unions and intersections work, I'll need to take a little detour that is very foundamental to Type-level TypeScript: **all types are Sets**.