From bf0d91a2683c229fc2cc2d2d9b96313a3b8b2618 Mon Sep 17 00:00:00 2001
From: Boyan <boyan@confest.im>
Date: Fri, 21 Mar 2025 18:03:31 +0100
Subject: [PATCH] answered questions

---
 haskell/sessions/16_03/notes.md | 46 ++++++++++++++++++++++++++++++---
 1 file changed, 42 insertions(+), 4 deletions(-)

diff --git a/haskell/sessions/16_03/notes.md b/haskell/sessions/16_03/notes.md
index 7b53e70..2582f10 100644
--- a/haskell/sessions/16_03/notes.md
+++ b/haskell/sessions/16_03/notes.md
@@ -52,17 +52,55 @@ f = \x y -> x (x (x y))
 ```
 
 ## Questions
-> How does one do the equations?
-
 > CLI is functional?
+Not really. It fits the functional mindset.
+Commands are:
+- pure, input leads to output
+- composable with the pipe, kinda like `(.)`
+- They can be composed like higher order functions, i.e. one command can be the input to another command
 
-> Lazy and singly-linked lists, what's the relation?
+In reality though, they are not functional. Their main goal is to interact with the system (a.k.a. a mutable state), which obviously breaks the functional paradigm.
 
 > Y combinator?
+A function, which allows us to define recursive functions without giving them a name. It gives us a fixed point of a function, i.e. a function that doesn't change when you apply it to itself.
+
+In other words, finds a value $x$ such that $f(x) = x$.
+
+```hs
+y f = f (y f) -- this is the Y combinator
+```
+
+Example:
+```hs
+fact = \f n -> if n == 0 then 1 else n * f (n-1) -- n! = f(n) = n * f(n-1) = n * (n-1) * f(n-2) = ...
+```
+
+If we were to not use the Y combinator, we would have to define the function as:
+```hs
+fact = \n -> if n == 0 then 1 else n * fact (n-1)
+```
+
+> In which cases would it be impossible to not use the Y combinator?
+Whenever we are working with a system that has no named functions, but we still want recursion.
+
+In the context of Haskell, using the Y combinator (in the classical lambda calculus way) is elegant, yet not necessary.
+Rewriting our factorial function using `where`:
+
+```hs
+fact :: Int -> Int
+fact n = f n
+    where
+        f 0 = 1
+        f n = n * f (n-1)
+```
+
+is way more readable and intuitive.
+
 
 
 ## Resources
 - [course](https://www.cis.upenn.edu/~cis1940/spring15/lectures.html)
 - [standard list](https://hackage.haskell.org/package/base-4.21.0.0/docs/Data-List.html)
 
-[^1]: need to find the actual rigorous way of doing this
\ No newline at end of file
+[^1]: need to find the actual rigorous way of doing this
+[^2]: Referential transparency 
\ No newline at end of file