From: 2weiEmu Date: Mon, 9 Feb 2026 11:21:17 +0000 (+0100) Subject: updated: fp notes X-Git-Url: https://git.saalbach.dev/?a=commitdiff_plain;h=a4a325e6bfda22d8f4f0d3e881ed0207ef89f0c5;p=research-obsidian.git updated: fp notes --- diff --git a/.obsidian/workspace.json b/.obsidian/workspace.json index afb540b..9c3ffeb 100644 --- a/.obsidian/workspace.json +++ b/.obsidian/workspace.json @@ -4,16 +4,16 @@ "type": "split", "children": [ { - "id": "226611ae14e85609", + "id": "c663d0c432405846", "type": "tabs", "children": [ { - "id": "3e78d839de43b5f0", + "id": "d08e3f89f9fa8c53", "type": "leaf", "state": { "type": "markdown", "state": { - "file": "4th and 5th Gen Fighters/Grippen and F-35 Deep Dive.md", + "file": "University/Functional Programming/Functional Programming Round 2 Full Notes.md", "mode": "source", "source": false, "backlinks": true, @@ -28,23 +28,10 @@ } }, "icon": "lucide-file", - "title": "Grippen and F-35 Deep Dive" - } - }, - { - "id": "c7759456ba31ed51", - "type": "leaf", - "state": { - "type": "release-notes", - "state": { - "currentVersion": "1.11.4" - }, - "icon": "lucide-book-up", - "title": "Release Notes 1.11.4" + "title": "Functional Programming Round 2 Full Notes" } } - ], - "currentTab": 1 + ] } ], "direction": "vertical" @@ -101,7 +88,8 @@ } ], "direction": "horizontal", - "width": 300 + "width": 300, + "collapsed": true }, "right": { "id": "52c8cd2985704b8e", @@ -187,8 +175,13 @@ "pdf-plus:PDF++: Toggle auto-paste": false } }, - "active": "c7759456ba31ed51", + "active": "d08e3f89f9fa8c53", "lastOpenFiles": [ + "University/Functional Programming/test.hs~", + "University/Functional Programming/test.hs", + "University/Functional Programming/Functional Programming Introduction.md", + "University/Functional Programming/Functional Programming Round 2 Full Notes.md", + "University/Functional Programming/Lecture 2.md", "University/Algorithm Design/Full Notes - Run 2.md", "Robert's Opsec Policy/Robert's Opsec Policy.md", "Robert's Opsec Policy", @@ -206,7 +199,6 @@ "Nebulous Command/ANS/My Fleets/ANS Dedicated/Stat Sheet.md", "Nebulous Command/ANS/My Fleets/ANS Dedicated/Battle Report 2.md", "Nebulous Command/ANS/My Fleets/ANS Dedicated/Battle Report 1.md", - "Nebulous Command/ANS/My Fleets/ANS Dedicated", "List of things to do.md", "Diary and thoughts/Untitled.md", "AI/References on AI.md", @@ -227,10 +219,6 @@ "Blog/Saalbach.dev and experiences writing that software.md", "Blog/sis50.nl Experiences Writing that Software.md", "WT Skins.md", - "University/Machine Learning/Full Notes.md", - "Watchlist & Do List.md", - "Untitled 1.md", - "Untitled.md", "Pasted image 20251106230015.png", "Pasted image 20251106225651.png", "Pasted image 20251106225645.png", diff --git a/Robert's Opsec Policy/Robert's Opsec Policy.md b/Robert's Opsec Policy/Robert's Opsec Policy.md deleted file mode 100644 index e69de29..0000000 diff --git a/University/Functional Programming/Functional Programming Round 2 Full Notes.md b/University/Functional Programming/Functional Programming Round 2 Full Notes.md new file mode 100644 index 0000000..6e36439 --- /dev/null +++ b/University/Functional Programming/Functional Programming Round 2 Full Notes.md @@ -0,0 +1,118 @@ +Programming in Haskell by Graham Hutton + +35% Project +Rest is Exam (open resources, weblab) + +Functional Languages work through the application of _functions_. +Functional code can be: +- shorter +- easier to understand +- easier to refactor +- easier to reason about + +Haskell: +- Statically Typed - means all types are checked at compile time, but are still inferred +- Lazy Evaluation - means inputs are ecaluated on demand +- Purity - functiosn do not have side effects (like modding global vars) + +Hackage and Hoogle, very practical, should use + +:t for type +:l to load file +:q to quit + +# Haskell Syntax + +## Naming Rules +Names of constructors start with a _capital_ letter. (True, False) +Names of functions and variables start with a _small_ letter. (not, length) +Names of concrete types start with a _capital_ letter. (Bool, Int) +Names of type variables start with a _small_ letter. (a, t) + +Comments start with --, or {- -} for multi-line. + +Let Binding: +```haskell +cylinderSurfaceArea r h = + let sideArea = 2 * pi * r * h + topArea = pi * r ^2 + in sideArea + 2 * topArea +``` + +Each definition can have an optional _type_ signature. (`f :: ...`) +A definition consists of one or more _clauses_ (`f x = ...`) +`where` block for helper functions +```haskell +doubleSmallNumber :: Int -> Int +doubleSmallNumber x = + if isSmall x then 2 * x else + where + isSmall = x < 10 +``` + +`where` and `let` mostly interchangeable +`let ... in ...` is just an expression, but `where` always has to be at the top level of the defintion as it has to be attached to a clause. + +Indentation matters! Same level of indentation = same block + +A _type_ is a name for a collection of values +You can write typing `True :: Bool` almost anywhere. + +Basic Types +Bool: True / False +Int: (64 bit integer) +Integer (arb. size integers) +Float: etc. // TODO: on slides + +There is also tuples (a,b) is the type of tuples (x,y) where x :: a, and y :: b + +## Functions with Several Arguments +there are 2 main ways: +```haskell +add1 :: (Int, Int) -> Int -- Uncommon +add2 :: Int -> (Int -> Int) -- More common +add2 :: Int -> Int -> Int -- most common way to write it +``` + +add2 is called "currying", as a convention haskell functions with multiple arguments are usually curried. + +Function arrow -> associates to the right +Int -> Bool -> Char += Int -> (Bool -> Char) + +Function application associates to the left: +f x y = (f x) y + +[t] is the type of (singly-linked) lists [x1, x2, ... , xn] with elements of type t + +```haskell +type String = [Char] +``` + +They can be used interchangeably. ['a'..'z'] will give you the abc. + +List can have any lenght, while a tuple's size is fixed. + +All elements in a list must have the _same_ type. Tuples may have different type elements. +Range syntax: `[i..j]`, will give you first to last (inclusive). If you do `[10..1]` it will give you an empty list. +If you do `[42..42] = [42]`, and then `[10, 8,..1] = [10, 8, 6, 4, 2]` (i.e. if you indicate the jump length) + + +## List Comprehensions +```haskell +[ x * x | x <- [1..5] ] +``` +Create a new list, given an existing list. + +`x <- [1..5]` is a _generator_. You can have multiple generators. + +The order of generators matters! (for the ordering of the resulting list) +Outer vs. inner loop kinda principle. + +Later generators may depend on previous ones. +`[ 10 * x + y | x <- [1..3], y <- [x..3] ]` + +filtering lists also works: +we can select only elements that satisfy a boolean predicate +`[x | x <- [1..10], even x]` + diff --git a/University/Functional Programming/test.hs b/University/Functional Programming/test.hs new file mode 100644 index 0000000..e8c7970 --- /dev/null +++ b/University/Functional Programming/test.hs @@ -0,0 +1,4 @@ +n = a `div` length xs + where + a = 10 + xs = [1,2,3,4,5]