From d9da49d8b9ec6c83b8554c991f2f999efa714247 Mon Sep 17 00:00:00 2001
From: Semih <3025014@stud.hs-mannheim.de>
Date: Fri, 12 Jun 2026 20:12:09 +0200
Subject: [PATCH] Basics erweitert und README aktualisiert

---
 .../{9-funktionen.rs => 10-funktionen.rs}     | 20 ++++++++++
 B-basics/5-kontrollfluss.rs                   | 32 +++++++++++++++-
 B-basics/7-compounds.rs                       |  4 +-
 B-basics/9-enums.rs                           | 20 ++++++++++
 {F-testing => F-error}/TODO                   |  0
 H-advanced/result.rs                          |  0
 I-homework/Homework.md                        | 38 +------------------
 README.md                                     | 33 ++++++++--------
 8 files changed, 91 insertions(+), 56 deletions(-)
 rename B-basics/{9-funktionen.rs => 10-funktionen.rs} (81%)
 create mode 100644 B-basics/9-enums.rs
 rename {F-testing => F-error}/TODO (100%)
 create mode 100644 H-advanced/result.rs

diff --git a/B-basics/9-funktionen.rs b/B-basics/10-funktionen.rs
similarity index 81%
rename from B-basics/9-funktionen.rs
rename to B-basics/10-funktionen.rs
index 536fcf3..1c3f2bc 100644
--- a/B-basics/9-funktionen.rs
+++ b/B-basics/10-funktionen.rs
@@ -1,3 +1,5 @@
+#[allow(dead_code)]
+
 fn main() {
     // Das ist die Main Funktion
     // Diese Funktion wird beim Aufruf von rust-script und von cargo run ausgeführt
@@ -9,6 +11,11 @@ fn main() {
     let mut r = Rechteck::new(400.0, 20.0);
     r.skalieren(4.0);
     println!("{:?}", r.flaeche());
+
+    use Arbeit::*; // Use dafür, damit man nicht immer Arbeit:: schreiben muss
+    let person = Arbeitnehmer;
+
+    inspect(person);    
 }
 
 // Das ist eine Funktion, die ein Boolean zurückgibt, Parameter können in die Klammern geschrieben werden
@@ -57,3 +64,16 @@ impl Rechteck {
         self.breite *= s;
     }
 }
+
+enum Arbeit {
+    Arbeitnehmer,
+    Arbeitgeber,
+    Selbstaendiger,
+}
+
+fn inspect(person: Arbeit) {
+    match person {
+        Arbeit::Arbeitnehmer => println!("Grrr, Chefs"),
+        _ => println!("Grrr, Steuern"),
+    }
+}
\ No newline at end of file
diff --git a/B-basics/5-kontrollfluss.rs b/B-basics/5-kontrollfluss.rs
index 38a1396..137ff3e 100644
--- a/B-basics/5-kontrollfluss.rs
+++ b/B-basics/5-kontrollfluss.rs
@@ -17,8 +17,8 @@ fn main() {
         x += 1;
     }
 
-    // For Loops sind etwas wilder, die klassische Java for-Loop (for (int i = 0; i <= 100; i++) {}) sehe so aus
-    for i in 0..100 {
+    // For Loops sind etwas wilder, die klassische Java for-Loop (for (int i = 0; i < 10; i++) {}) sehe so aus
+    for i in 0..10 {
         // Das ist quasi der Ternary Operator aus Python
         let gerade = if i % 2 == 0 { true } else { false }; // Semicolon wichtig, da das eine Variableninitialisierung ist
 
@@ -30,4 +30,32 @@ fn main() {
         println!("Endlosschleifeeeee...");
         break; // nicht mehr endlos
     }
+
+    for tag in 1..8 {
+        // Switch Case werden realisiert durch Pattern Matching
+        match tag {
+            1 => println!("Montag :O"),
+            2 => println!("Dienstag >:("),
+            3 => println!("Mittwoch :("),
+            4 => println!("Donnerstag :|"),
+            5 => println!("Freitag :)"),
+            6 => println!("Samstag :D"),
+            7 => println!("Sonntag :D"),
+            _ => println!("Tag unbekannt"), // Default Fall
+        }
+    }
+
+    let punktzahl = 50;
+
+    // Durch match kann ein Wert einer Variable zugeordnet werden, je nachdem, was die Lage ist
+    let note = match punktzahl {
+        0..50 => "Ungenügend",
+        50..67 => "Ausreichend",
+        67..80 => "Befriedigend",
+        80..92 => "Gut",
+        92..101 => "Sehr gut",
+        _ => "Unbekannte Punktzahl",
+    }; // Hier ist ein Semikolon nötig, da es eine Variableninitialisierung ist
+
+    println!("{note}");
 }
diff --git a/B-basics/7-compounds.rs b/B-basics/7-compounds.rs
index ec83fbe..ac3ec94 100644
--- a/B-basics/7-compounds.rs
+++ b/B-basics/7-compounds.rs
@@ -1,7 +1,9 @@
 fn main() {
-    let string: &str = "Das ist ein String.";
+    // Dieser String ist ein String Slice, welcher eine unveränderliche Referenz auf einen bestehenden String ist
+    let string: &str = "Das ist ein String."; 
     println!("{string}");
 
+    // Ein im Heap allokierter, veränderlicher und besitzender String, mehr dazu später
     let string = String::from("Das ist auch ein String.");
     println!("{string}");
 
diff --git a/B-basics/9-enums.rs b/B-basics/9-enums.rs
new file mode 100644
index 0000000..a29dcdf
--- /dev/null
+++ b/B-basics/9-enums.rs
@@ -0,0 +1,20 @@
+#[allow(dead_code)]
+#[allow(unused_variables)]
+
+fn main() {
+    // Beides macht dasselbe
+    let semih = Hochschule::Student;
+    let steger = Hochschule::Professor;
+
+    // Durch Enums kann Pattern Matching in etwas sehr wertvolles umgewandelt werden
+    match semih {
+        Hochschule::Student => println!("Ich bin ein armer Student :("),
+        Hochschule::Professor => println!("Ich bin ein Professor :)")
+    }
+}
+
+// Eine Enumeration wird durch enum eingeleitet, danach folgt die Deklarierung der Enum-Konstanten
+enum Hochschule {
+    Student,
+    Professor,
+}
\ No newline at end of file
diff --git a/F-testing/TODO b/F-error/TODO
similarity index 100%
rename from F-testing/TODO
rename to F-error/TODO
diff --git a/H-advanced/result.rs b/H-advanced/result.rs
new file mode 100644
index 0000000..e69de29
diff --git a/I-homework/Homework.md b/I-homework/Homework.md
index 3898b5f..9979596 100644
--- a/I-homework/Homework.md
+++ b/I-homework/Homework.md
@@ -1,9 +1,6 @@
 # Rust Übungsaufagaben:
-
 ## 1. Ownership & Borrowing:
-
 ### Aufgabe 1:
-
 Erkläre, warum folgender Rust-Code nicht kompiliert:
 
 ```rust
@@ -15,11 +12,8 @@ fn main() {
 }
 ```
 Ändere den Code so, dass ```s1``` und ```s2``` augegeben werden können.
-<br> <br>
-
 
 ### Aufgabe 2:
-
 Warum verbietet Rust folgenden Code?
 
 ```rust
@@ -36,7 +30,6 @@ fn main() {
 Schreibe den Code so um, sodass beide ```println!``` statements funktionieren.
 
 ## 2. Pattern Matching & Enums:
-
 ### Aufgabe 3:
 Gegeben sei folgender Rust Code für eine 3-Phasen Ampel: 
 ```rust
@@ -62,9 +55,7 @@ fn main(){
 Was passiert wenn nicht alle Varainten in ```match ampel_status``` aufgelistet werden?
 
 ## 3. Option & Result Types:
-
 ### Aufgabe 4:
-
 Erkläre, warum folgender Code nicht funktioniert und behebe das Problem:
 
 ```rust
@@ -79,10 +70,7 @@ fn main() {
 
 Verwende `Option` oder eine andere Fehlerbehandlung, um sicher auf den Vektor zuzugreifen. Erkläre die Vorteile dieses Ansatzes gegenüber einem Laufzeitfehler ("panic").
 
-<br>
-
 ### Aufgabe 5:
-
 Schreibe eine Funktion `parse_number`, die einen String nimmt und ein `Result<i32, String>` zurückgibt:
 - Bei erfolgreicher Konvertierung: `Ok(zahl)`
 - Bei Fehler: `Err("Ungültige Eingabe".to_string())`
@@ -102,9 +90,7 @@ fn main() {
 Wie unterscheidet sich `Result` von `Option`? Wann verwendet man welchen Typ?
 
 ## 4. String vs &str und Ownership:
-
 ### Aufgabe 6:
-
 Erkläre den Unterschied zwischen `String` und `&str`. Warum verbietet Rust folgende Funktion zu kompilieren?
 
 ```rust
@@ -123,10 +109,7 @@ fn main() {
 
 Behebe den Fehler und erkläre, warum die Verwendung von `&str` als Parameter flexibler ist.
 
-<br>
-
 ### Aufgabe 7:
-
 Was ist der Unterschied zwischen folgenden zwei Funktionen? Welche ist besser und warum?
 
 ```rust
@@ -144,9 +127,7 @@ fn create_greeting_2(name: &str) -> String {
 Schreibe für beide Varianten ein Beispiel in `main()`, das die Flexibilität von Variante 2 demonstriert.
 
 ## 5. Traits und Polymorphismus:
-
 ### Aufgabe 8:
-
 Gegeben sind folgende Structs und ein Trait:
 
 ```rust
@@ -168,11 +149,8 @@ Implementiere den `Flaeche` Trait für beide Structs. Schreibe dann eine Funktio
 
 Bonus: Erstelle einen Vektor mit verschiedenen Formen und iteriere über sie.
 
-
 ## 6. Mutability und Interior Mutability:
-
 ### Aufgabe 9:
-
 Erkläre, warum folgender Code nicht funktioniert:
 
 ```rust
@@ -202,9 +180,7 @@ fn main() {
 Erkläre die Rolle von `mut`, `&mut` und `*`.
 
 ## 7. Lifetimes:
-
 ### Aufgabe 10:
-
 Warum kompiliert folgender Code nicht und wie behebt man das Problem?
 
 ```rust
@@ -230,10 +206,8 @@ fn main() {
 Erkläre, was Lifetimes sind und warum Rust sie braucht. Behebe den Code mit korrekten Lifetime-Annotationen.
 
 
-## 9. Error Handling und Panic:
-
+## 8. Error Handling und Panic:
 ### Aufgabe 11:
-
 Was ist der Unterschied zwischen `panic!` und `Result`? Wann sollte man welches verwenden?
 
 Schreibe eine Funktion `divide`, die zwei Zahlen dividiert:
@@ -254,13 +228,3 @@ fn main() {
 ```
 
 Erkläre, warum `Result` sicherer ist als ein `panic!` in einer Library-Funktion.
-
-
-
-
-
-
-
-
-
-
diff --git a/README.md b/README.md
index 322124e..2e0ae52 100644
--- a/README.md
+++ b/README.md
@@ -2,20 +2,24 @@
 In diesem Repo sind alle Unterlagen für die Präsentation der Programmiersprache Rust
 Das Repo beinhaltet:
 - Dockerfile
-- Basics (TODO)
+- Basics
 - Ownership und Borrowing
-- Pattern Matching und Enumerationen (TODO)
-- Testing und Debugging (TODO)
-- Advanced Features von Rust (TODO)
+- Pattern Matching und Enumerationen (wurde noch nicht gemacht)
+- Testing und Debugging (wurde noch nicht gemacht)
+- Advanced Features von Rust
 Link zur Präsentation: https://docs.google.com/presentation/d/1vkq-cDprBH-5ya1Vvn4xmCyAN0YgbcioXG6CJkVKWDQ/edit?usp=sharing
+
 # Ablauf
 1. Warum Rust, (welche Apps), welche Entwicklungsumgebung (ca. 10 Minuten)
 2. Ökosystem und Einrichtung (Compiler, Cargo) (ca. 5 Minuten)
 3. Syntax und Basics (ca. 15 Minuten)
     1. HelloWorld Programm
-    2. Variablen
-    3. Kontrollstrukturen
-    4. Types
+    2. Variablen und Konstanten
+    3. Datentypen und Arithmetik
+    4. Kontrollstrukturen
+    5. Print Makro
+    6. Zusammengesetzte Typen (Compounds, Structs und Enums)
+    7. Funktionen
 4. Ownership & Borrowing (Live Coding) (ca. 20 Minuten)
     1. Motivation: Warum Ownership
     2. Prinzip: Ownership
@@ -27,12 +31,13 @@ Link zur Präsentation: https://docs.google.com/presentation/d/1vkq-cDprBH-5ya1V
 
 # Aufgabenbereich
 - Semih Uguz (3025014)
-    - B-basics
-    - C-cargo
+    - Basics
+    - Cargo
     - Präsentieren
     - Organisation des Repos
+    - Teile von Advanced
 - Lukas Müller (3017761)
-    - D-ownership
+    - Ownership
     - Präsentieren
     - Live Coding
 - Oliver Stolle (3024383)
@@ -42,12 +47,8 @@ Link zur Präsentation: https://docs.google.com/presentation/d/1vkq-cDprBH-5ya1V
     - Fakten und Anwendungen von Rust
     - Cheat Sheet
     - Präsentieren
-    - G-advanced
+    - Concurrency
 - Vincent Laux (3019006)
     - Präsentieren
     - Endpräsentation erstellen
-    - G-advanced
-- Dominik Stuck (3018438)
-    - Präsentieren
-    - E-enums
-    - F-testing
+- Dominik Stuck (3018438) (aktuell noch nichts gemacht)