From 8754d3537a106630464939e4e1075543532a5ba7 Mon Sep 17 00:00:00 2001
From: Boyan <boyan@confest.im>
Date: Fri, 21 Mar 2025 17:50:36 +0100
Subject: [PATCH] Answered questions

---
 haskell/README.md | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/haskell/README.md b/haskell/README.md
index c7a3c4a..dc1d54a 100644
--- a/haskell/README.md
+++ b/haskell/README.md
@@ -16,6 +16,7 @@ This is the larger, more general README, which will house the main takeaways/rev
   - [ToC](#toc)
 - [Books and resources](#books-and-resources)
   - [13th of March - Introduction](#13th-of-march---introduction)
+  - [\[16th of March - Deriving types\]](#16th-of-march---deriving-types)
 
 # Books and resources
 - [Haskell Programming from first principles](http://haskellbook.com/)
@@ -41,6 +42,36 @@ The tree is simply too complex. Linked lists are easy.
 ## [16th of March - Deriving types]
 
 > How does one do this systematically?
+**Eyeball method:**
+Looking at the function definition:
+
+1. Each parameter - what is the type of each parameter?
+2. Return type - what is the type of the return value?
+3. If the function calls another function, look at the type of that function.
+4. Replace concrete types with type variables (a, b, c, etc.)
+  
+**Formal method[^2]:**
+(on paper)
+
+1. Write down the type of each argument and subexpression.
+2. Generate equations for how types relate to each other and apply transitivity (if needed).
+e.g.
+$$
+\begin{align*}
+f &:: a \to b \to c \\
+g &:: c \to e \\
+
+\implies f \circ g &:: a \to b \to e
+\end{align*}
+$$
+3. Solve the equations for the most general type.
+
+
 
 > Lazy and singly-linked lists, what's the relation?
+A lazy list doesn’t compute all elements at once; it only computes elements as you need them.
+A singly-linked list is naturally great for lazy, because each element points to the next, with the next being a thunk (actual fucking term, meaning a computation that hasn't been evaluated yet[^1]).
 
+
+[^1]: More generally, a thunk is a subroutine used to inject computation into another subroutine. They delay computation until it is needed. It canonically originates from the verb *think* lmao.
+[^2]: [Hindley–Milner type inference](https://en.wikipedia.org/wiki/Hindley%E2%80%93Milner_type_system)
\ No newline at end of file