Prepare lecture impure functional programming

Author: s-macke

docs/03-Go-Programming-OOP.slide

@@ -9,26 +9,26 @@ https://www.qaware.de
 
 * Last lecture
 - Types (string, int, bool, float64, ...)
-- weak vs. strong typing
+- weak vs. strong typing, statically vs. dynamically typed.
 - Functions and Control Structures
 - Arrays, Slices and Maps
 - Pointer
 - Unit Tests
-- Preview into interfaces
 
 * Last Exercise
 - Let's look at an example implementation
 
 : Ergebnisse der Übungen zeigen.
 
 * Error Handling
+.image ./img/error_meme.jpg 400 _
 
 * Errors in Go
 
 Go doesn't have try-catch exception based error handling.
 Go distinguishes between recoverable and unrecoverable errors.
 
-Recoverable: e. g. file not found
+_Recoverable_: e. g. file not found
 
 - Go returns the error as one of the return values
 
@@ -37,7 +37,7 @@ Recoverable: e. g. file not found
 		log.Error(err)
 	}
 
-Unrecoverable: array access outside its boundaries, out of memory
+_Unrecoverable_: array access outside its boundaries, out of memory
 
 * Go defer: run code before function exists
 

docs/04-Forth.slide

@@ -8,15 +8,6 @@ Rosenheim Technical University
 Sebastian.Macke@th-rosenheim.de
 https://www.qaware.de
 
-* Plan
-
-- Presentations & Forth
-- Logic programming
-- WebAssembly
-- (Summary) / Clean Code / What language to use for which problem?
-- Presentations
-
-
 * Last lecture
 - Exception Handling. Error return codes vs. Exceptions
 - Dynamic Types in Go
@@ -124,12 +115,13 @@ Evaluate
 .image img/stack1.png 200 _
 
   3  push 3 onto stack
-  9  push 9 onto stack
-  +  pop 9 and 3 and add them and push the result back on the stack
-  4  push 4 onto stack
-  6  push 6 onto stack
-  +  pop 6 and 4 and add them and push the result back on the stack
-  *  pop 9 and 17 and multiply them and push the result back on the stack
+  9 push 9 onto stack
+    + pop 3 and 9 from stack, add them, push result onto stack
+    4 push 4 onto stack
+    6 push 6 onto stack
+      + pop 4 and 6 from stack, add them, push result onto stack
+        * pop 12 and 15 from stack, multiply them, push result onto stack
+
 
 
 * Postfix via a stack machine
@@ -835,3 +827,9 @@ Algorithm:
 
 .link https://github.com/s-macke/concepts-of-programming-languages/blob/master/docs/exercises/Exercise4.md
 
+* Last lecture
+- Prefix, Infix and Post-Notation
+- Stack machine
+- Forth as one of the most simplistic languages
+- Metaprogramming, program new language features while programming
+- Shunting-Yard Algorithm

docs/05-Functional-Programming.slide

@@ -11,14 +11,23 @@ https://www.qaware.de
 : https://www.digicomp.ch/blog/2015/10/20/einfuehrung-in-die-funktionale-programmierung
 
 * Last lecture
-- Prefix, Infix and Post-Notation
-- Stack machine
-- Forth as one of the most simplistic languages
-- Metaprogramming, program new language features while programming
-- Shunting-Yard Algorithm
+- Exception Handling. Error return codes vs. Exceptions
+- Object Oriented Programming without class hierarchy
+- Embedding
+- Implicit satisfied interfaces with Polymorphism
 
 : Ergebnisse der Übungen zeigen.
 
+* The error interface
+
+.play ../src/oop/errors/error.go /START OMIT/,/END OMIT/
+
+The error is just an interface with one method that should return the error message:
+
+    type error interface {
+        Error() string
+    }
+
 * What is Functional programming?
 - Functional programming is a programming paradigm where functions can not only be defined and applied. Like data, functions can be linked together, used as parameters, and occur as function results.
 - In short: Functions are treated as first-class citizens.
@@ -38,7 +47,7 @@ Functional programming is old, but some major languages have adapted them quite
 These types of functional languages support only the functional paradigms and have no state. For example − Haskell.
 
 - *Impure* Functional Languages
-These types of functional languages support the functional paradigms and imperative style programming. For example − LISP and Go.
+These types of functional languages support the functional paradigms and imperative style programming. For example all of the major languages today.
 
 * Impure Functional Languages
 
@@ -106,6 +115,30 @@ Rewrite it, so that the Bubble Sort algorithm takes a comparison function as inp
 
 	BubbleSort(data, func(i, j int) bool {return data[i] > data[j]})
 
+* Closures in JavaScript
+
+    const object1 = {
+        prop: 42,
+
+        func: function () {
+            return this.prop;
+       },
+    };
+
+    console.log(object1.prop)  // 42
+    console.log(object1.func())  // 42  // At creation time, this points to test.prop
+
+    const object2 = {
+        prop: 43,
+        func: object1.func  // take the function defined in object1.
+    }
+
+    console.log(object2.prop)  // 43
+    console.log(object2.func())  // 43. Now "this" points to object2.
+
+: https://onecompiler.com/javascript
+: object1.func = object1.func.bind(object1);
+
 * Pure Functions
 
 * What is a pure function?
@@ -124,23 +157,31 @@ Advantages
 
 * Every Function can be made pure
 
-"An interactive program is a pure function that takes the current 'state of the world' as its arg and produces a modified world as result" - unknown Twitter user
 
-- This one is pure (Go)
+- This one is impure
 
-	var array []int
-	newarray := append(array, 1)
+    var count = 0
+    func increment() {
+        count++
+    }
 
-- This one is not (Java)
+- This one is pure
 
-    List<Integer> array = new ArrayList<Integer>
-    arrlist.add(1);
+    func incrementPure(count int) int {
+        return count + 1 // This function is pure because it does not modify external state
+    }
+
+- Often functions are "pure enough" in the practical sense.
+	var array []int
+	newarray := append(array, 1)
 
 - Question: How to make a pseudo random() function pure?
 - Question: How to make a real random() function pure?
 
+: "An interactive program is a pure function that takes the current 'state of the world' as its arg and produces a modified world as result" - unknown Twitter user
 : Question: How to make a real random() function pure?
 : How to make a quasi-random number pure?
+: newarray := append(array, 1)
 : TODO: separate slide maybe?
 
 * Pure Functional Languages
@@ -213,11 +254,11 @@ Functional programming supports distributed computing
     .... Do something else
     partialApplicatedFunction(3) -> 4
 
-* Currying allows for Partial Application
+: * Currying allows for Partial Application
 
-.play ../src/functional/currying/main.go
+: .play ../src/functional/currying/main.go
 
-- Partial application is used here as a form of a constructor
+: - Partial application is used here as a form of a constructor
 
 * Functional Composition
 Functions can be composed to new functions
@@ -313,6 +354,7 @@ _(λx.x)_ _a_
 : To apply a function
 : (λx.x) 5 = 5
 
+: schlechtes Beispiel
 : (λa.λb.(a+b)) 5 6 = 11
 : ((λa.λb.(a+b)) 5) 6 = 11
 : (λ5.λb.(5+b)) 6 = 11
@@ -321,6 +363,8 @@ _(λx.x)_ _a_
 
 : T := λa.λb.a is the function which takes two parameters and returns the first one
 : F := λa.λb.b is the function which takes two parameters and returns the second one
+: brackets ein zeichnen
+: T 3 5
 : (λx.3) 5 = 3
 : (λa.λb.a) 5 6 = 5
 : (λa.λb.b) 5 6 = 6
@@ -331,15 +375,15 @@ _(λx.x)_ _a_
 : AND True True = True True False = True
 : AND False True = False True False = False
 
-Alternative:
+: Alternative:
 : OR := λa.λb.(a b a)
 : OR := λa.λb.(a a b)
-
-: ifelse = λp.λa.λb.(p a b)
-: ifelse true 42 58 = true 42 58 = 42
 : or = λp.λq.(p p q)
 : alternative for not = λp.λa.λb.(p b a)
 
+: ifelse = λp.λa.λb.(p a b)
+: ifelse T 42 58 = T 42 58 = 42
+
 : Y combinator
 : Y := λf.(λx.f (x x)) (λx.f (x x))
 : Y g = λf.(λx.f (x x)) (λx.f (x x)) g

docs/img/error_meme.jpg

@@ -3,21 +3,21 @@ package main
 import (
 	"flag"
 	"fmt"
-	"io/ioutil"
 	"log"
 	"os"
 	"regexp"
 )
 
 func ListDir(path string, pattern string) {
-	files, err := ioutil.ReadDir(path)
+	files, err := os.ReadDir(path)
 	if err != nil {
 		log.Fatal(err)
 	}
 	for _, f := range files {
 		name := path + string(os.PathSeparator) + f.Name()
 		b, err := regexp.MatchString(pattern, f.Name())
 		if err != nil {
+
 			log.Fatal(err)
 		}
 		if b {

src/basics/find/find.go

@@ -6,7 +6,9 @@ package index
 import "fmt"
 
 // Page contains an array of words.
-type Page []string
+type Page struct {
+	words []string
+}
 
 // Book is an array of pages.
 type Book []Page
@@ -17,8 +19,8 @@ type Index map[string][]int
 // MakeIndex generates an index structure
 func MakeIndex(book Book) Index {
 	idx := make(Index)
-	for i, page := range book {
-		for _, word := range page {
+	for i := range book {
+		for _, word := range book[i].words {
 			pages := idx[word]
 			idx[word] = append(pages, i)
 		}

src/basics/index/index.go

@@ -19,7 +19,8 @@ type B struct {
 
 func (b B) Foo() {
 	fmt.Print("b.foo ")
-	b.Bar() //b.A.Bar()
+	//b.Bar() //b.A.Bar()
+	b.A.Bar()
 }
 
 func (b B) Bar() {
@@ -29,8 +30,8 @@ func (b B) Bar() {
 func main() {
 	a := A{}
 	a.Foo()
-	/*
-		b := B{}
-		b.Foo() // "a.bar" or "b.bar"?
-	*/
+
+	b := B{}
+	b.Foo() // "a.bar" or "b.bar"?
+
 }

src/oop/delegation/delegation.go

@@ -0,0 +1,26 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+)
+
+// START OMIT
+func divide(a, b int) (int, error) {
+	if b == 0 {
+		return 0, errors.New("division by zero")
+	}
+	return a / b, nil
+}
+
+func main() {
+	// Successful division
+	result, err := divide(10, 0)
+	if err != nil {
+		fmt.Println("Error:", err)
+	} else {
+		fmt.Println("Result:", result)
+	}
+}
+
+// END OMIT

src/oop/errors/error.go

@@ -15,11 +15,11 @@ type Rational struct {
 // END1 OMIT
 
 // NewRational constructor function
-func NewRational(numerator int, denominator int) Rational {
+func NewRational(numerator int, denominator int) *Rational {
 	if denominator == 0 {
 		panic("division by zero")
 	}
-	r := Rational{}
+	r := &Rational{}
 	divisor := gcd(numerator, denominator)
 	r.numerator = numerator / divisor
 	r.denominator = denominator / divisor