Address reviewer comments

Author: christiaanb

compiler-user-guide/src/developing-hardware/annotations.md

@@ -7,7 +7,7 @@
   * Use cached versions of generated HDL, i.e., prevent recompilation of (sub)entities that have not changed since the last run.
     Caching is based on a `.manifest` which is generated alongside the HDL; deleting this file means deleting the cache; changing this file will result in *undefined* behavior.
 
-Functions with a 'Synthesize' annotation must adhere to the following restrictions:
+Functions with a `Synthesize` annotation must adhere to the following restrictions:
 
   * Although functions with a `Synthesize` annotation can of course depend on functions with another `Synthesize` annotation, they must not be mutually recursive.
   * Functions with a `Synthesize` annotation must be completely *monomorphic* and *first-order*, and cannot have any *non-representable* arguments or result.

compiler-user-guide/src/developing-hardware/limitations.md

@@ -160,16 +160,16 @@ Here is a list of Haskell features for which the Clash compiler has only _limite
     * `Int` and `Word` are represented by the same number of bits as is native for the architecture of the computer on which the Clash compiler is executed.
       This means that if you are working on a 64-bit machine, `Int` and `Word` will be 64-bit.
       This might be problematic when you are working in a team, and one designer has a 32-bit machine, and the other has a 64-bit machine.
-      In general, you should be avoiding 'Int' in such cases, but as a band-aid solution, you can force the Clash compiler to use a specific bit-width for `Int` and `Word` using the `-fclash-intwidth=N` flag, where _N_ must either be _32_ or _64_.
+      In general, you should be avoiding `Int` in such cases, but as a band-aid solution, you can force the Clash compiler to use a specific bit-width for `Int` and `Word` using the `-fclash-intwidth=N` flag, where _N_ must either be _32_ or _64_.
 
-    * When you use the `-fclash-intwidth=32` flag on a _64-bit_ machine, the 'Word64' and 'Int64' types _cannot_ be translated. This restriction does _not_ apply to the other three combinations of `-fclash-intwidth` flag and machine type.
+    * When you use the `-fclash-intwidth=32` flag on a _64-bit_ machine, the `Word64` and `Int64` types _cannot_ be translated. This restriction does _not_ apply to the other three combinations of `-fclash-intwidth` flag and machine type.
 
-    * The translation of 'Integer' is not meaning-preserving.
-      'Integer' in Haskell is an arbitrary precision integer, something that cannot be represented in a statically known number of bits.
-      In the Clash compiler, we chose to represent 'Integer' by the same number of bits as we do for `Int` and `Word`.
+    * The translation of `Integer` is not meaning-preserving.
+      `Integer` in Haskell is an arbitrary precision integer, something that cannot be represented in a statically known number of bits.
+      In the Clash compiler, we chose to represent `Integer` by the same number of bits as we do for `Int` and `Word`.
       As you have read in a previous bullet point, this number of bits is either 32 or 64, depending on the architecture of the machine the Clash compiler is running on, or the setting of the `-fclash-intwidth` flag.
 
-      Consequently, you should use `Integer` with due diligence; be especially careful when using `fromIntegral` as it does a conversion via 'Integer'.
+      Consequently, you should use `Integer` with due diligence; be especially careful when using `fromIntegral` as it does a conversion via `Integer`.
       For example:
 
       ``` haskell

compiler-user-guide/src/developing-hardware/primitives.md

@@ -1,6 +1,7 @@
 # User-defined primitives
 There are times when you already have an existing piece of IP, or there are times where you need the HDL to have a specific shape so that the HDL synthesis tool can infer a specific component.
-In these specific cases you can resort to defining your own HDL primitives. Actually, most of the primitives in Clash are specified in the same way as you will read about in this section.
+In these specific cases you can resort to defining your own HDL primitives.
+Actually, most of the primitives in Clash are specified in the same way as you will read about in this section.
 There are perhaps 10 (at most) functions which are truly hard-coded into the Clash compiler.
 You can take a look at the files in <https://github.com/clash-lang/clash-compiler/tree/master/clash-lib/prims/vhdl> (or <https://github.com/clash-lang/clash-compiler/tree/master/clash-lib/prims/verilog> for the Verilog primitives or <https://github.com/clash-lang/clash-compiler/tree/master/clash-lib/prims/systemverilog> for the SystemVerilog primitives) if you want to know which functions are defined as "regular" primitives.
 The compiler looks for primitives in four locations:

compiler-user-guide/src/developing-hardware/troubleshooting.md

@@ -5,7 +5,8 @@ A list of often encountered errors and their solutions:
 * __Type error: Couldn't match expected type `Signal dom (a,b)` with actual type `(Signal dom a, Signal dom b)`__:
 
     Signals of product types and product types of signals are __isomorphic__ due to synchronisity principle, but are not (structurally) equal.
-    Tuples are a product type. Use the `bundle` function to convert from a product type to the signal type.
+    Tuples are a product type.
+    Use the `bundle` function to convert from a product type to the signal type.
     So if your code which gives the error looks like:
 
     ``` haskell
@@ -26,7 +27,8 @@ A list of often encountered errors and their solutions:
 * __Type error: Couldn't match expected type `(Signal dom a, Signal dom b)` with actual type `Signal dom (a,b)`__:
 
     Product types of signals and signals of product types are __isomorphic__ due to synchronicity principle, but are not (structurally) equal.
-    Tuples are a product type. Use the `unbundle` function to convert from a signal type to the product type.
+    Tuples are a product type.
+    Use the `unbundle` function to convert from a signal type to the product type.
     So if your code which gives the error looks like:
 
     ``` haskell
@@ -96,7 +98,8 @@ A list of often encountered errors and their solutions:
 
 *  __<*** Exception: <\<loop\>> or "blinking cursor"__
 
-    You are using value-recursion, but one of the `Vec`tor functions that you are using is too *strict* in one of the recursive arguments. For example:
+    You are using value-recursion, but one of the `Vec`tor functions that you are using is too *strict* in one of the recursive arguments.
+    For example:
 
     ``` haskell
     -- Bubble sort for 1 iteration