Fix typos and issues

Author: MarekSuchanek

tutorials/01_fp-env.md

@@ -114,7 +114,7 @@ Haskell does not require a specific editor or IDE. You can use any editor you ar
 
 Common choices include:
 
-* **Vim** with [Haskell plugins](https://wiki.haskell.org/Vim) for command-line enthusiasts
+* **Vim** with [Haskell plugins](https://wiki.haskell.org/Vim) for command-line enthusiasts
 * **Visual Studio Code** with [Haskell extension](https://marketplace.visualstudio.com/items?itemName=haskell.haskell) for a modern and user-friendly experience
 * **IntelliJ IDEA** with [Haskell LSP](https://plugins.jetbrains.com/plugin/24123-haskell-lsp) for those who prefer JetBrains IDEs
 * **Emacs** with [Haskell mods](https://wiki.haskell.org/Emacs) for Emacs lovers

tutorials/02_functions-types.md

@@ -11,7 +11,7 @@ In this tutorial, we build on that foundation and make the picture more concrete
 
 * how functions are written and typed,
 * how Haskell represents data, and
-* how syntax reflects the underlying functional and mathematical model.
+* how syntax reflects the underlying functional and mathematical model.
 
 Before diving into functions and data types themselves, it is useful to clarify some basic syntactic rules and naming conventions that appear throughout Haskell code. This part is not meant to be memorized — it is a reference that will become familiar as we encounter these constructs in practice.
 
@@ -144,7 +144,7 @@ z = (x + 7) :: Integer
 Haskell uses static typing:
 
 * every expression has exactly one type,
-* the type is determined at compile time, and
+* the type is determined at compile time, and
 * it cannot change during execution.
 
 Because of **type inference**, type signatures are not always required, but they are **strongly recommended for clarity and documentation**.
@@ -324,7 +324,7 @@ Haskell provides a small set of basic data types that are used throughout the st
 * `Double` = double-precision floating point
 * `Word` = unsigned integer
 * `Char` = Unicode character
-* `Bool` = logical value (`True¨ or `False`)
+* `Bool` = logical value (`True` or `False`)
 * `String` = type synonym for `[Char]` (list of characters)
 
 You have already encountered most of these in GHCi examples. More specialized data structures (maps, sets, sequences, text) live in libraries and will be introduced when needed.
@@ -393,7 +393,7 @@ data Pet = Pet
 
 There are several ways to address this:
 
-* use more specific field names (personName, petName),
+* use more specific field names (`personName`, `petName`),
 * use modules to separate namespaces,
 * or enable language extensions such as `DuplicateRecordFields`.
 
@@ -521,7 +521,7 @@ addFirstTwo (x, y, _) = x + y
 
 #### Tuples as product types
 
-Conceptually, tuples are **product types*. A tuple `(a, b)` contains both an `a` and a `b`.
+Conceptually, tuples are **product types**. A tuple `(a, b)` contains both an `a` and a `b`.
 
 You can model tuples explicitly using `data`:
 

tutorials/04_containers-functions.md

@@ -203,8 +203,8 @@ You can think of it as a *better list* in situations where you need:
 
 Compared to lists:
 
-* lists are optimized for prepending (x : xs)
-* sequences are optimized for both ends (<| and |>)
+* lists are optimized for prepending (`x : xs`)
+* sequences are optimized for both ends (`<|` and `|>`)
 
 ```
 ghci> import Data.Sequence
@@ -544,6 +544,9 @@ This is not metaphorical. It is literally mathematical **function composition**
 
 ```math
 f: A \to B
+```
+
+```math
 g: B \to C
 ```
 

tutorials/05_typeclasses.md

@@ -204,9 +204,9 @@ This defines structural equality. Minimal requirement for custom instances: defi
 
 **Laws** (that are expected but not enforced by the compiler), for all `x`, `y`, `z`:
 
-* Reflexivity: `x == x`
-* Symmetry: `x == y  ⇒  y == x`
-* Transitivity: `(x == y && y == z) ⇒ x == z`
+* Reflexivity: `x == x`
+* Symmetry: `x == y  ⇒  y == x`
+* Transitivity: `(x == y && y == z) ⇒ x == z`
 
 Example of custom instance:
 
@@ -447,7 +447,7 @@ A typeclass defines:
 
 * a **set of types**
 * that provide certain **operations**
-* and obey certain *laws**
+* and obey certain **laws**
 
 In mathematical language: