Increase consistency and readability a tiny bit

20 files changed, 35 insertions, 35 deletions

diff --git a/src/content/chapter0_basics/lesson03_unqualified_imports/en.html b/src/content/chapter0_basics/lesson03_unqualified_imports/en.html
index 35ea10f..3f15f58 100644
--- a/src/content/chapter0_basics/lesson03_unqualified_imports/en.html
+++ b/src/content/chapter0_basics/lesson03_unqualified_imports/en.html
@@ -7,11 +7,11 @@
   </a>.
 </p>
 <p>
-  It is also possible to specify a list of functions to import from a module in
+  it's also possible to specify a list of functions to import from a module in
   an <em>unqualified</em> fashion, meaning the function name can be used without
   the module <em>qualifier</em> (the name and the dot) before it.
 </p>
 <p>
-  Generally it is best to use qualified imports, as this makes it clear where
-  the function is defined, making the code easier to read.
+  Generally it's best to use qualified imports, as this makes it clear where the
+  function is defined, making the code easier to read.
 </p>
diff --git a/src/content/chapter0_basics/lesson14_type_imports/en.html b/src/content/chapter0_basics/lesson14_type_imports/en.html
index 0f362e5..243bd61 100644
--- a/src/content/chapter0_basics/lesson14_type_imports/en.html
+++ b/src/content/chapter0_basics/lesson14_type_imports/en.html
@@ -17,6 +17,6 @@
   the import statement with the word <code>type</code> before the type name.
 </p>
 <p>
-  It is more common in Gleam code for types to be imported in an unqualified way
+  It's more common in Gleam code for types to be imported in an unqualified way
   than it is for functions to be imported in an unqualified way.
 </p>
diff --git a/src/content/chapter0_basics/lesson15_type_aliases/en.html b/src/content/chapter0_basics/lesson15_type_aliases/en.html
index 9fddd70..9d5cef9 100644
--- a/src/content/chapter0_basics/lesson15_type_aliases/en.html
+++ b/src/content/chapter0_basics/lesson15_type_aliases/en.html
@@ -1,6 +1,6 @@
 <p>
   A type alias can be used to refer to a type by a different name. Giving a type
-  an alias doesn't make a new type, it is still the same type.
+  an alias doesn't make a new type, it's still the same type.
 </p>
 <p>
   A type's name always starts with a capital letter, contrasting to variables
diff --git a/src/content/chapter0_basics/lesson17_lists/en.html b/src/content/chapter0_basics/lesson17_lists/en.html
index 84f88f3..5db7c11 100644
--- a/src/content/chapter0_basics/lesson17_lists/en.html
+++ b/src/content/chapter0_basics/lesson17_lists/en.html
@@ -15,7 +15,7 @@
 </p>
 <p>
   Counting the length of a list or getting elements from other positions in the
-  list is expensive and rarely done. It is rare to write algorithms that index
+  list is expensive and rarely done. It's rare to write algorithms that index
   into sequences in Gleam, but when they are written a list is not the right
   choice of data structure.
 </p>
diff --git a/src/content/chapter1_functions/lesson00_functions/en.html b/src/content/chapter1_functions/lesson00_functions/en.html
index 32d5bed..0ebf281 100644
--- a/src/content/chapter1_functions/lesson00_functions/en.html
+++ b/src/content/chapter1_functions/lesson00_functions/en.html
@@ -9,6 +9,6 @@
 </p>
 <p>
   Like with assignments, type annotations are optional for function arguments
-  and return values. It is considered good practice to use type annotations for
+  and return values. It's considered good practice to use type annotations for
   functions, for clarity and to encourage intentional and thoughtful design.
 </p>
diff --git a/src/content/chapter1_functions/lesson06_generic_functions/en.html b/src/content/chapter1_functions/lesson06_generic_functions/en.html
index e32c860..d5abb55 100644
--- a/src/content/chapter1_functions/lesson06_generic_functions/en.html
+++ b/src/content/chapter1_functions/lesson06_generic_functions/en.html
@@ -10,7 +10,7 @@
   compatible.
 </p>
 <p>
-  To enable this Gleam support <em>generics</em>, also known as
+  To enable this, Gleam supports <em>generics</em>, also known as
   <em>parametric polymorphism</em>.
 </p>
 <p>
diff --git a/src/content/chapter1_functions/lesson08_labelled_arguments/en.html b/src/content/chapter1_functions/lesson08_labelled_arguments/en.html
index b1d771c..869a041 100644
--- a/src/content/chapter1_functions/lesson08_labelled_arguments/en.html
+++ b/src/content/chapter1_functions/lesson08_labelled_arguments/en.html
@@ -16,7 +16,7 @@
   a dictionary or perform any other runtime work.
 </p>
 <p>
-  Labels are optional when calling a function, it is up to the programmer to
+  Labels are optional when calling a function, it's up to the programmer to
   decide what is clearest in their code.
 </p>
 
diff --git a/src/content/chapter1_functions/lesson09_documentation_comments/en.html b/src/content/chapter1_functions/lesson09_documentation_comments/en.html
index c27bac6..b20307e 100644
--- a/src/content/chapter1_functions/lesson09_documentation_comments/en.html
+++ b/src/content/chapter1_functions/lesson09_documentation_comments/en.html
@@ -8,7 +8,7 @@
 </p>
 <p>
   <code>///</code> is used for documenting types and functions, and should be
-  placed immediately before the type or function it is documenting.
+  placed immediately before the type or function it's documenting.
 </p>
 <p>
   <code>////</code> is used for documenting modules, and should be placed
diff --git a/src/content/chapter2_flow_control/lesson07_list_recursion/en.html b/src/content/chapter2_flow_control/lesson07_list_recursion/en.html
index 9f158d8..7f7c735 100644
--- a/src/content/chapter2_flow_control/lesson07_list_recursion/en.html
+++ b/src/content/chapter2_flow_control/lesson07_list_recursion/en.html
@@ -1,5 +1,5 @@
 <p>
-  While it is more common to use functions in the 
+  While it's more common to use functions in the
   <a href="https://hexdocs.pm/gleam_stdlib/gleam/list.html" target="_blank">
     <code>gleam/list</code>
   </a> 
diff --git a/src/content/chapter2_flow_control/lesson08_multiple_subjects/en.html b/src/content/chapter2_flow_control/lesson08_multiple_subjects/en.html
index 23e3722..67a8faa 100644
--- a/src/content/chapter2_flow_control/lesson08_multiple_subjects/en.html
+++ b/src/content/chapter2_flow_control/lesson08_multiple_subjects/en.html
@@ -1,9 +1,9 @@
 <p>
-  Sometimes it is useful to pattern match on multiple values at the same time in
+  Sometimes it's useful to pattern match on multiple values at the same time in
   one case expression.
 </p>
 <p>
-  To do this you can give multiple subjects and multiple patterns, separated by
+  To do this, you can give multiple subjects and multiple patterns, separated by
   commas.
 </p>
 <p>
diff --git a/src/content/chapter2_flow_control/lesson09_alternative_patterns/en.html b/src/content/chapter2_flow_control/lesson09_alternative_patterns/en.html
index 25421f4..0e36b2d 100644
--- a/src/content/chapter2_flow_control/lesson09_alternative_patterns/en.html
+++ b/src/content/chapter2_flow_control/lesson09_alternative_patterns/en.html
@@ -7,6 +7,6 @@
   clause must also define a variable with the same name and same type.
 </p>
 <p>
-  Currently it is not possible to have nested alternative patterns, so the
+  Currently it's not possible to have nested alternative patterns, so the
   pattern <code>[1 | 2 | 3]</code> is not valid.
 </p>
diff --git a/src/content/chapter3_data_types/lesson00_tuples/en.html b/src/content/chapter3_data_types/lesson00_tuples/en.html
index a5c708e..d88053f 100644
--- a/src/content/chapter3_data_types/lesson00_tuples/en.html
+++ b/src/content/chapter3_data_types/lesson00_tuples/en.html
@@ -14,7 +14,7 @@
   and <code>#(1.4, 10, 48)</code> has the type <code>#(Float, Int, Int)</code>.
 </p>
 <p>
-  Tuples are most commonly used to return 2 or 3 values from a function. 
-  Often it is clearer to use a <em>custom type</em> where a tuple could
-  be used, We will cover custom types next.
+  Tuples are most commonly used to return 2 or 3 values from a function. Often
+  it's clearer to use a <em>custom type</em> where a tuple could be used, We
+  will cover custom types next.
 </p>
diff --git a/src/content/chapter3_data_types/lesson01_custom_types/en.html b/src/content/chapter3_data_types/lesson01_custom_types/en.html
index 34e51f2..3ca1f66 100644
--- a/src/content/chapter3_data_types/lesson01_custom_types/en.html
+++ b/src/content/chapter3_data_types/lesson01_custom_types/en.html
@@ -1,6 +1,7 @@
 <p>
-  Gleam has a few built in types such as <code>Int</code>, <code>String</code>,
-  but custom types allow the creation of entirely new types.
+  Gleam has a few built in types such as <code>Int</code> and
+  <code>String</code>, but custom types allow the creation of entirely new
+  types.
 </p>
 <p>
   A custom type is defined with the <code>type</code> keyword followed by the
diff --git a/src/content/chapter3_data_types/lesson02_records/en.html b/src/content/chapter3_data_types/lesson02_records/en.html
index ea46e4d..0c49f67 100644
--- a/src/content/chapter3_data_types/lesson02_records/en.html
+++ b/src/content/chapter3_data_types/lesson02_records/en.html
@@ -8,6 +8,6 @@
   be used for variants that define them.
 </p>
 <p>
-  It is common to have a custom type with one variant that holds data, this is
+  It's common to have a custom type with one variant that holds data, this is
   the Gleam equivalent of a struct or object in other languages.
 </p>
diff --git a/src/content/chapter3_data_types/lesson06_nil/en.html b/src/content/chapter3_data_types/lesson06_nil/en.html
index 9749180..fbb1700 100644
--- a/src/content/chapter3_data_types/lesson06_nil/en.html
+++ b/src/content/chapter3_data_types/lesson06_nil/en.html
@@ -1,12 +1,12 @@
 <p>
-  <code>Nil</code> is Gleam's unit type. It is a value that is returned by
+  <code>Nil</code> is Gleam's unit type. It's a value that is returned by
   functions that have nothing else to return, as all functions must return
   something.
 </p>
 <p>
   <code>Nil</code> is not a valid value of any other types. Therefore, values in
-  Gleam are not nullable. If the type of a value is <code>Nil</code> then it is
-  the value <code>Nil</code>. If it is some other type then the value is not
+  Gleam are not nullable. If the type of a value is <code>Nil</code> then it's
+  the value <code>Nil</code>. If it's some other type then the value is not
   <code>Nil</code>.
 </p>
 <p>
diff --git a/src/content/chapter5_advanced_features/lesson00_opaque_types/en.html b/src/content/chapter5_advanced_features/lesson00_opaque_types/en.html
index dbd362f..f0956fb 100644
--- a/src/content/chapter5_advanced_features/lesson00_opaque_types/en.html
+++ b/src/content/chapter5_advanced_features/lesson00_opaque_types/en.html
@@ -11,7 +11,7 @@
   directly. This can be useful for ensuring that the type is used correctly.
 </p>
 <p>
-  For example, this <code>PositiveInt</code> custom type is opaque, so if other
+  For example, this <code>PositiveInt</code> custom type is opaque. If other
   modules want to construct one they have to use the <code>new</code> function,
   which ensures that the integer is positive.
 </p>
diff --git a/src/content/chapter5_advanced_features/lesson01_use/en.html b/src/content/chapter5_advanced_features/lesson01_use/en.html
index b8e2641..d879aec 100644
--- a/src/content/chapter5_advanced_features/lesson01_use/en.html
+++ b/src/content/chapter5_advanced_features/lesson01_use/en.html
@@ -25,7 +25,6 @@
 </p>
 <p>
   This is a very capable and useful feature, but excessive application of
-  <code>use</code> may result in code that is unclear otherwise, especially to
-  beginners. Often using the regular function call syntax will result in more
-  approachable code!
+  <code>use</code> may result in unclear code, especially to beginners. Usually
+  the regular function call syntax results in more approachable code!
 </p>
diff --git a/src/content/chapter5_advanced_features/lesson04_panic/en.html b/src/content/chapter5_advanced_features/lesson04_panic/en.html
index c54c217..07b1d48 100644
--- a/src/content/chapter5_advanced_features/lesson04_panic/en.html
+++ b/src/content/chapter5_advanced_features/lesson04_panic/en.html
@@ -1,6 +1,6 @@
 <p>
   The <code>panic</code> keyword is similar to the <code>todo</code> keyword,
-  but it is used to crash the program when the program has reached a point that
+  but it's used to crash the program when the program has reached a point that
   should never be reached.
 </p>
 <p>
diff --git a/src/content/chapter5_advanced_features/lesson05_let_assert/en.html b/src/content/chapter5_advanced_features/lesson05_let_assert/en.html
index 29fd06c..0a6d10f 100644
--- a/src/content/chapter5_advanced_features/lesson05_let_assert/en.html
+++ b/src/content/chapter5_advanced_features/lesson05_let_assert/en.html
@@ -1,11 +1,11 @@
 <p>
   <code>let assert</code> is the final way to intentionally crash your Gleam
-  program. It is similar to the <code>panic</code> keyword in that it crashes
+  program. It's similar to the <code>panic</code> keyword in that it crashes
   when the program has reached a point that should never be reached.
 </p>
 <p>
-  <code>let assert</code> is similar to <code>let</code> in that it is a way to
-  assign values to variables, but it is different in that the pattern can be
+  <code>let assert</code> is similar to <code>let</code> in that it's a way to
+  assign values to variables, but it's different in that the pattern can be
   <i>partial</i>. The pattern does not need to match every possible value of the
   type being assigned.
 </p>
diff --git a/src/content/chapter5_advanced_features/lesson07_multi_target_externals/en.html b/src/content/chapter5_advanced_features/lesson07_multi_target_externals/en.html
index 6e02d36..c755ac7 100644
--- a/src/content/chapter5_advanced_features/lesson07_multi_target_externals/en.html
+++ b/src/content/chapter5_advanced_features/lesson07_multi_target_externals/en.html
@@ -11,10 +11,10 @@
   possible due to incompatibilities in how IO and concurreny works in Erlang and
   JavaScript. With Erlang concurrent IO is handled transparently by the runtime,
   while in JavaScript concurrent IO requires the use of promises or callbacks.
-  If your code uses the Erlang style it is typically not possible to implement
-  in JavaScript, while if callbacks are used then it won't be compatible with
-  most Gleam and Erlang code as it forces any code that calls the function to
-  also use callbacks.
+  If your code uses the Erlang style it's typically not possible to implement in
+  JavaScript, while if callbacks are used then it won't be compatible with most
+  Gleam and Erlang code as it forces any code that calls the function to also
+  use callbacks.
 </p>
 <p>
   Libraries that make use of concurrent IO will typically have to decide whether