Merge branch 'master' of https://github.com/tgdwyer/tgdwyer.github.io

Author: tgdwyer

_chapters/haskell0.md

@@ -197,6 +197,8 @@ stack config set snapshot lts-23.25
 
 ## Troubleshooting
 
+For further issues, see [GHCup’s Troubleshooting page](https://www.haskell.org/ghcup/guide/#troubleshooting).
+
 ### Windows Issues
 
 #### `invalid argument (invalid character)`
@@ -243,6 +245,10 @@ Add the following line to the bottom of the file:
 local-programs-path: C:\stack-programs
 ```
 
+#### Script immediately exits
+
+If the script exits without installing anything, you might need to disable any third-party antivirus software.
+
 ### macOS Issues
 
 If you get an error that looks something like `fatal error: 'ffi.h'`, it may be because you do not have the Xcode command line tools installed.  (These are a collection of command line utilities and other developer tools that many programs rely on.) You can install them by running the following command in your terminal:

_chapters/haskell3.md

@@ -372,11 +372,13 @@ We can formalise the definition of Functor with two laws:
 
 The law of ***identity***
 
-∀ x: (id <$> x) ≡ x
+∀ x: (id <\\$> x) ≡ x
 
 The law of ***composition***
 
-∀ f, g, x: (f ∘ g <$> x) ≡ (f <$> (g <$> x))
+∀ f, g, x: (f ∘ g <\\$> x) ≡ (f <\\$> (g <\\$> x))
+
+(∘ has higher precedence than <\\$>, so f ∘ g <\\$> x is equal to (f ∘ g) <\\$> x.)
 
 Note that these laws are not enforced by the compiler when you create your own instances of `Functor`.  You’ll need to test them for yourself.  Following these laws guarantees that general code (e.g. algorithms) using `fmap` will also work for your own instances of `Functor`.
 
@@ -433,7 +435,7 @@ Node (Node (Leaf 1) 2 (Leaf 3)) 4 (Node (Leaf 5) 6 (Leaf 7))
 Law of Composition:
 
 ```haskell
-> (+1) <$> (*2) <$> tree
+> (+1) <$> ((*2) <$> tree)
 Node (Node (Leaf 3) 5 (Leaf 7)) 9 (Node (Leaf 11) 13 (Leaf 15))
 > (+1).(*2) <$> tree
 Node (Node (Leaf 3) 5 (Leaf 7)) 9 (Node (Leaf 11) 13 (Leaf 15))

_data/glossary.yml

@@ -35,7 +35,7 @@
   definition: The processes a computer follows when executing a program in a given language.
   first_appeared: levelsofabstraction
 - term: Imperative
-  definition: Imperative programs are a sequence of statements that change a program’s state.  This is probably the dominant paradigm for programming languages today.  Languages from Assembler to Python are built around this concept and most modern languages still allow you to program in this style.
+  definition: Imperative programs are a sequence of statements that change a program’s state.  This is probably the dominant paradigm for programming languages today.  Languages from Assembly to Python are built around this concept and most modern languages still allow you to program in this style.
   first_appeared: levelsofabstraction
 - term: Procedural
   definition: Procedural languages are basically *imperative* in nature, but add the concept of named *procedures*, i.e. named subroutines that may be invoked from elsewhere in the program, with parameterised variables that may be passed in.
@@ -146,7 +146,7 @@
   definition: A TypeScript construct that allows a variable to hold values of multiple specified types, separated by the `|` symbol.
   first_appeared: typescript1
 - term: Functor
-  definition: A type class in Haskell that represents types that can be mapped over. Instances of Functor must define the fmap function, which applies a function to every element in a structure.
+  definition: A type class in Haskell that represents types that can be mapped over. Instances of [Functor](/assets/WhatTheFunctor.mp3) must define the fmap function, which applies a function to every element in a structure.
   first_appeared: haskell3
 - term: Applicative
   definition: A type class in Haskell that extends Functor, allowing functions that are within a context to be applied to values that are also within a context. Applicative defines the functions pure and (<*>).
@@ -184,6 +184,15 @@
 - term: Lazy Evaluation
   definition: A strategy where expressions are not evaluated until their values are needed, allowing for the creation of infinite sequences and delayed computations.
   first_appeared: lazyevaluation
+- term: Callback
+  definition: A function passed as an argument to another function, to be executed after some event or action has occurred.
+  first_appeared: functionaljavascript
+- term: Chained Functions
+  definition: A programming pattern where multiple function calls are made sequentially, with each function returning an object that allows the next function to be called.
+  first_appeared: functionaljavascript
+- term: Fluent Interface
+  definition: A method chaining pattern where a sequence of method calls is made on the same object, with each method returning the object itself or another chainable object.
+  first_appeared: functionaljavascript
 - term: Operator Sectioning
   definition: The process of partially applying an infix operator in Haskell by specifying one of its arguments. For example, (+1) is a section of the addition operator with 1 as the second argument.
   first_appeared: haskell3
@@ -223,8 +232,8 @@
 - term: K-combinator
   definition: A combinator that takes two arguments and returns the first one.
   first_appeared: higherorderfunctions
-- term: Algebraic Data Types (or ADTs)
-  definition: Custom data types in Haskell defined using the data keyword, allowing the combination of different types into one composite type using the \| operator.
+- term: Algebraic Data Types
+  definition: (or ADTs) Custom data types in Haskell defined using the data keyword, allowing the combination of different types into one composite type using the \| operator.
   first_appeared: haskell2
 - term: Record Syntax
   definition: An alternate way to define data structures in Haskell with named fields, automatically creating accessor functions for those fields.

_plugins/glossary.rb

@@ -28,7 +28,7 @@ def generate(site)
 
       site.data.glossary.each do |entry|
         term = entry['term'].downcase
-        definition = Kramdown::Document.new(entry['definition']).to_html.gsub(/<\/?p>/, '')
+        definition = Kramdown::Document.new(entry['definition']).to_html.gsub(/<\/?p>/, '').gsub(/<a.*?>(.+?)<\/a>/, '$1')
         first_appeared = entry['first_appeared']
 
         @@glossary_terms[term] = [definition, first_appeared]