answered questions

haskell/sessions/16_03/notes.md

@@ -52,13 +52,50 @@ 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
@@ -66,3 +103,4 @@ f = \x y -> x (x (x y))
 - [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
+[^2]: Referential transparency