Apply suggestions from code review

Co-authored-by: Christine Rose <christinerose@users.noreply.github.com>

Author: 2 people

data/tutorials/language/3ds_03_set.md

@@ -22,26 +22,26 @@ pay attention to the case; you need to type `Set.Make(String)` and not
 `Set.Make(string)`. The reason behind this is explained in the
 "Technical Details" section at the bottom.
 
-Doing this in the OCaml's top level will yield a lot of output:
+Doing this in the OCaml's toplevel will yield a lot of output:
 
 ```ocamltop
 module SS = Set.Make(String);;
 ```
 
-What happened here is that after assigning your newly created module to the name
-`SS`, OCaml's top level then displayed the module, which in this case contains
+What happened here is that after assigning your newly-created module to the name
+`SS`, OCaml's toplevel displayed the module, which in this case contains
 a large number of convenience functions for working with sets (for example `is_empty`
-for checking if you set is empty, `add` to add an element to your set, `remove` to
+to check if your set is empty, `add` to add an element to your set, `remove` to
 remove an element from your set, and so on).
 
-Note also that this module defines two types: `type elt = String.t` representing
-the type of the elements, and `type t = Set.Make(String).t` representing the type of
-the set itself. It's important to note this, because these types are used in the
+Note also that this module defines two types: `type elt = String.t`, representing
+the type of the elements, and `type t = Set.Make(String).t`, representing the type of
+the set itself. It's important to note this because these types are used in the
 signatures of many of the functions defined in this module.
 
 For example, the `add` function has the signature `elt -> t -> t`, which means
 that it expects an element (a String), and a set of strings, and will return to you
-a set of strings. As you gain more experience in OCaml and other function languages,
+a set of strings. As you gain more experience in OCaml and other functional languages,
 the type signature of functions are often the most convenient form of documentation
 on how to use those functions.
 
@@ -54,30 +54,30 @@ find what function or value you should use to do this, but this is an excellent
 opportunity to practice reading the type signatures and inferring the answer from them.
 
 You want to create a new set (as opposed to modifying an existing set). So you should
-look for functions whose return result has type `t` (the type representing the set),
+look for functions whose return result has type `t` (the type representing the set)
 and which *does not* require a parameter of type `t`.
 
 Skimming through the list of functions in the module, there's only a handful of functions
 that match that criteria: `empty: t`, `singleton : elt -> t`, `of_list : elt list -> t`
 and `of_seq : elt Seq.t -> t`.
 
 Perhaps you already know how to work with lists and sequences in OCaml or
-perhaps you don't. For now, let's assume you don't know, and so we'll focus
+perhaps you don't. For now, let's assume you don't know, so we'll focus
 our attention on the first two functions in that list: `empty` and `singleton`.
 
-The type signature for `empty` says that it simply returns `t`, i.e. an instance
+The type signature for `empty` says that it simply returns `t`, i.e., an instance
 of our set, without requiring any parameters at all. By intuition, you might
 guess that the only reasonable set that a library function could return when
 given zero parameters is the empty set. And the fact that the function is named
 `empty` reinforces this theory.
 
-Is there a way to test this theory? Perhaps if we had a function which
+Is there a way to test this theory? Perhaps if we had a function that
 could print out the size of a set, then we could check if the set we get
 from `empty` has a size of zero. In other words, we want a function which
-receives a set as a parameter, and returns an integer as a result. Again,
+receives a set as a parameter and returns an integer as a result. Again,
 skimming through the list of functions in the module, we see there is a
 function which matches this signature: `cardinal : t -> int`. If you're
-not familiar with the word "cardinal", you can look it up on Wikipedia
+not familiar with the word "cardinal," you can look it up on Wikipedia
 and notice that it basically refers to the size of sets, so this reinforces
 the idea that this is exactly the function we want.
 
@@ -88,17 +88,17 @@ let s = SS.empty;;
 SS.cardinal s;;
 ```
 
-Excellent, it looks like `SS.empty` does indeed create an empty set,
+Excellent! It looks like `SS.empty` does indeed create an empty set,
 and `SS.cardinal` does indeed print out the size of a set.
 
 What about that other function we saw, `singleton : elt -> t`? Again,
 using our intuition, if we provide the function with a single element,
 and the function returns a set, then probably the function will return
 a set containing that element (or else what else would it do with the
 parameter we gave it?). The name of the function is `singleton`, and
-again if you're unfamiliar with what word, you can look it up on
-Wikipedia and see that the word means "a set with exactly one element".
-It sounds like we're on the right track again. Let's test our theory.
+if you're unfamiliar with what word, you can look it up on
+Wikipedia and see that the word means "a set with exactly one element."
+It sounds like we're on the right track, so let's test our theory.
 
 ```ocamltop
 let s = SS.singleton "hello";;
@@ -110,12 +110,12 @@ It looks like we were right again!
 ## Working with Sets
 
 Now let's say we want to build bigger and more complex sets. Specifically,
-let's say we want to add another element to our existing set. So we're
-looking for a function with two parameters: One of the parameters should
+let's say we want to add another element to our existing set, so we're
+looking for a function with two parameters. One of the parameters should
 be the element we wish to add, and the other parameter should be the set
 that we're adding to. For the return value, we would expect it to either
 return unit (if the function modifies the set in place), or it returns a
-new set representing the result of adding the new element. So we're
+new set representing the result of adding the new element. We're
 looking for signatures that look something like `elt -> t -> unit` or
 `t -> elt -> unit` (since we don't know what order the two parameters
 should appear in), or `elt -> t -> t` or `t -> elt -> t`.
@@ -124,9 +124,9 @@ Skimming through the list, we see 2 functions with matching signatures:
 `add : elt -> t -> t` and `remove : elt -> t -> t`. Based on their names,
 `add` is probably the function we're looking for. `remove` probably removes
 an element from a set, and using our intuition again, it does seem like
-the type signature makes sense: To remove an element from a set, you need
+the type signature makes sense. To remove an element from a set, you need
 to tell it what set you want to perform the removal on and what element
-you want to remove; and the return result will be the resulting set after
+you want to remove. The return result will be the resulting set after
 the removal.
 
 Furthermore, because we see that these functions return `t` and not `unit`,
@@ -163,16 +163,16 @@ comparison instead. To do this, we simply have to change the parameter
 that we pass to the `Set.Make` function.
 
 The `Set.Make` function expects a struct with two fields: a type `t`
-that represents the type of the element, and a function `compare`
+that represents the type of the element and a function `compare`,
 whose signature is `t -> t -> int` and essentially returns 0 if two
 values are equal, and non-zero if they are non-equal. It just so happens
 that the `String` module matches that structure, which is why we could
 directly pass `String` as a parameter to `Set.Make`. Incidentally, many
 other modules also have that structure, including `Int` and `Float`,
-and so they too can be directly passed into `Set.Make` to construct a
-set of integers, or a set of floating point numbers.
+so they too can be directly passed into `Set.Make` to construct a
+set of integers or a set of floating point numbers.
 
-For our use case, we still want our elements to be of type string, but
+For our use case, we still want our elements to be a string, but
 we want to change the comparison function to ignore the case of the
 strings. We can accomplish this by directly passing in a literal struct
 to the `Set.Make` function:
@@ -225,16 +225,16 @@ end);;
 
 ## Technical Details
 
-### Set.Make, types and modules
+### `Set.Make`, Types, and Modules
 
 As mentioned in a previous section, the `Set.Make` function accepts a structure
-with two specific fields, `t` and `compare`. Modules have structure, and thus
+with two specific fields, `t` and `compare`. Modules have structure, so
 it's possible (but not guaranteed) for a module to have the structure that
-`Set.Make` expects. On the other hand, types do not have structure, and so you
+`Set.Make` expects. On the other hand, types do not have structure, so you
 can never pass a type to the `Set.Make` function. In OCaml, modules start with
-an upper case letter and types start with a lower case letter. This is why
+an upper case letter, and types start with a lower case letter. So
 when creating a set of strings, you have to use `Set.Make(String)` (passing in
-the module named `String`), and not `Set.Make(string)` (which would be attempting
+the module named `String`) and not `Set.Make(string)` (which would be attempting
 to pass in the type named `string`, which will not work).
 
 ### Purely Functional Data Structures
@@ -247,7 +247,7 @@ that you create are immutable. The functions like `add` and `remove` do not
 actually modify the set you pass in, but instead return a new set representing
 the results of having performed the corresponding operation.
 
-### Full API documentation
+### Full API Documentation
 
 This tutorial focused on teaching how to quickly find a function that does what
 you want by looking at the type signature. This is often the quickest and most