[ADD] panic, defer, recover

Author: ineelhere

codes/defer.go

@@ -0,0 +1,38 @@
+package main
+
+import (
+	"fmt"
+	"os"
+)
+
+func main() {
+
+	f := createFile("/tmp/defer.txt")
+	defer closeFile(f)
+	writeFile(f)
+}
+
+func createFile(p string) *os.File {
+	fmt.Println("creating")
+	f, err := os.Create(p)
+	if err != nil {
+		panic(err)
+	}
+	return f
+}
+
+func writeFile(f *os.File) {
+	fmt.Println("writing")
+	fmt.Fprintln(f, "data")
+
+}
+
+func closeFile(f *os.File) {
+	fmt.Println("closing")
+	err := f.Close()
+
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "error: %v\n", err)
+		os.Exit(1)
+	}
+}

codes/panic.go

@@ -0,0 +1,13 @@
+package main
+
+import "os"
+
+func main() {
+
+	panic("a problem")
+
+	_, err := os.Create("/tmp/file")
+	if err != nil {
+		panic(err)
+	}
+}

codes/recover.go

@@ -0,0 +1,21 @@
+package main
+
+import "fmt"
+
+func mayPanic() {
+	panic("a problem")
+}
+
+func main() {
+
+	defer func() {
+		if r := recover(); r != nil {
+
+			fmt.Println("Recovered. Error:\n", r)
+		}
+	}()
+
+	mayPanic()
+
+	fmt.Println("After mayPanic()")
+}

codes/sorting-by-functions.go

@@ -0,0 +1,35 @@
+package main
+
+import (
+	"cmp"
+	"fmt"
+	"slices"
+)
+
+func main() {
+	fruits := []string{"peach", "banana", "kiwi"}
+
+	lenCmp := func(a, b string) int {
+		return cmp.Compare(len(a), len(b))
+	}
+
+	slices.SortFunc(fruits, lenCmp)
+	fmt.Println(fruits)
+
+	type Person struct {
+		name string
+		age  int
+	}
+
+	people := []Person{
+		Person{name: "Jax", age: 37},
+		Person{name: "TJ", age: 25},
+		Person{name: "Alex", age: 72},
+	}
+
+	slices.SortFunc(people,
+		func(a, b Person) int {
+			return cmp.Compare(a.age, b.age)
+		})
+	fmt.Println(people)
+}

documentation/44-sorting-by-functions.md

@@ -0,0 +1,68 @@
+This Go code showcases the use of a custom sorting package named "slices" along with a comparison package "cmp" to perform sorting on slices. It demonstrates the flexibility of custom sorting by providing a comparison function. 
+
+Let's go through the code with inline comments and explanations:
+
+```go
+// Importing necessary packages.
+package main
+
+import (
+	"cmp"     // Custom comparison package
+	"fmt"
+	"slices"  // Custom slices package for sorting
+)
+
+// The main function, where the execution of the program begins.
+func main() {
+	// Example with a slice of strings
+	fruits := []string{"peach", "banana", "kiwi"}
+
+	// Defining a custom comparison function for sorting based on string length
+	lenCmp := func(a, b string) int {
+		return cmp.Compare(len(a), len(b))
+	}
+
+	// Using the SortFunc function from the slices package to sort the string slice using the custom comparison function.
+	slices.SortFunc(fruits, lenCmp)
+
+	// Printing the sorted string slice.
+	fmt.Println(fruits)
+
+	// Example with a slice of custom type (Person)
+	type Person struct {
+		name string
+		age  int
+	}
+
+	// Creating a slice of Person instances
+	people := []Person{
+		{name: "Jax", age: 37},
+		{name: "TJ", age: 25},
+		{name: "Alex", age: 72},
+	}
+
+	// Using the SortFunc function from the slices package to sort the Person slice using a custom comparison function.
+	slices.SortFunc(people,
+		func(a, b Person) int {
+			return cmp.Compare(a.age, b.age)
+		})
+
+	// Printing the sorted Person slice.
+	fmt.Println(people)
+}
+```
+### Output
+```
+[kiwi peach banana]
+[{TJ 25} {Jax 37} {Alex 72}]
+```
+Now, let's discuss the `slices` package and the use of `SortFunc`:
+
+#### `slices.SortFunc(slice interface{}, less func(i, j int) int)`
+   - This function takes a slice of any type (interface{}) and a custom comparison function `less`.
+   - The comparison function is used to determine the order of elements in the slice.
+   - The sorting is performed in-place, modifying the original slice.
+
+The `main` function demonstrates the use of `SortFunc` with both a string slice (`fruits`) and a slice of custom type (`people`). It shows how to provide a custom comparison function (`lenCmp` for strings and an anonymous function for `Person` instances) to achieve sorting based on specific criteria.
+
+Make sure that the `slices` and `cmp` packages are implemented correctly and are available in the same directory or in the Go module path for this program to work. The `import "slices"` and `import "cmp"` statements assume that there are files named `slices.go` and `cmp.go` containing the respective packages in the same directory as your main program.

documentation/45-panic.md

@@ -0,0 +1,47 @@
+This Go code demonstrates the use of the `panic` function, which is used to terminate the normal execution flow of a program and initiate a panic. Let's go through the code with inline comments and explanations:
+
+```go
+// Importing necessary package.
+import "os"
+
+// The main function, where the execution of the program begins.
+func main() {
+    // Initiating a panic with a custom error message.
+    panic("a problem")
+
+    // The code below this line will not be executed due to the preceding panic.
+
+    // Attempting to create a file (this code will not be reached).
+    _, err := os.Create("/tmp/file")
+
+    // Checking if an error occurred during file creation (this code will not be reached).
+    if err != nil {
+        // Initiating a panic with the error message if an error is present.
+        panic(err)
+    }
+}
+```
+### Output
+```
+panic: a problem
+
+goroutine 1 [running]:
+main.main()
+        ..:/...../..../..../panic.go:7 +0x25
+exit status 2
+```
+Explanation:
+
+1. **`panic("a problem")`:**
+   - This line explicitly triggers a panic with the message "a problem."
+   - When a panic occurs, the normal flow of the program is halted, and the program terminates abruptly.
+
+2. **`_, err := os.Create("/tmp/file")`:**
+   - This line attempts to create a file in the "/tmp" directory.
+   - Note that this line and the subsequent lines will not be executed if a panic occurs earlier in the code.
+
+3. **`if err != nil { panic(err) }`:**
+   - This code checks if an error occurred during the file creation process (which will not happen in this example due to the preceding panic).
+   - If an error is present, it triggers another panic with the error message.
+
+It's important to note that initiating a panic is typically used in exceptional situations where the program cannot continue normal execution. In general, using panics should be done judiciously, and it's often preferable to handle errors in a more controlled manner using error values and other error-handling techniques.

documentation/46-defer.md

@@ -0,0 +1,82 @@
+This Go code illustrates the use of `defer` statements to ensure that certain actions, like closing a file, are performed even if an error occurs. Let's go through the code with inline comments and explanations:
+
+```go
+// Importing necessary packages.
+import (
+	"fmt"
+	"os"
+)
+
+// The main function, where the execution of the program begins.
+func main() {
+	// Creating a file and deferring the closing of the file until the surrounding function returns.
+	f := createFile("/tmp/defer.txt")
+	defer closeFile(f)
+
+	// Writing data to the file.
+	writeFile(f)
+}
+
+// createFile function creates a file and returns a pointer to the os.File.
+func createFile(p string) *os.File {
+	fmt.Println("creating")
+	// Attempting to create the file.
+	f, err := os.Create(p)
+	if err != nil {
+		// If an error occurs during file creation, the program panics.
+		panic(err)
+	}
+	return f
+}
+
+// writeFile function writes data to the provided os.File.
+func writeFile(f *os.File) {
+	fmt.Println("writing")
+	// Writing the data to the file.
+	fmt.Fprintln(f, "data")
+}
+
+// closeFile function closes the provided os.File, handling errors.
+func closeFile(f *os.File) {
+	fmt.Println("closing")
+	// Closing the file and checking for errors.
+	err := f.Close()
+
+	// Handling errors if the file cannot be closed successfully.
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "error: %v\n", err)
+		os.Exit(1)
+	}
+}
+```
+### Output
+```
+creating
+panic: open /tmp/defer.txt: The system cannot find the path specified.
+
+goroutine 1 [running]:
+main.createFile({0x622f83, 0xe})
+       ..:/...../..../..../defer.go:19 +0x93
+main.main()
+       ..:/...../..../..../defer.go:10 +0x2b
+exit status 2
+```
+Explanation:
+
+1. **`createFile(p string) *os.File`:**
+   - This function creates a file at the specified path `p`.
+   - If an error occurs during file creation, the function panics with the error message.
+   - The created file is returned as a pointer to `os.File`.
+
+2. **`writeFile(f *os.File)`:**
+   - This function writes the string "data" to the provided file (`os.File`).
+
+3. **`closeFile(f *os.File)`:**
+   - This function closes the provided file (`os.File`).
+   - If an error occurs during file closing, it prints an error message to `os.Stderr` and exits the program.
+
+4. **`defer closeFile(f)`:**
+   - The `defer` statement ensures that the `closeFile` function is called when the surrounding function (`main` in this case) returns, regardless of whether it returns normally or panics.
+   - In this example, it ensures that the file is closed even if an error occurs during the execution of `main`.
+
+Using `defer` is a convenient way to ensure that cleanup actions are performed, especially when dealing with resources like files, to avoid resource leaks.

documentation/48-recover.md

@@ -0,0 +1,56 @@
+This Go code demonstrates the use of the `recover` function to catch and handle panics within a deferred function. Let's go through the code with inline comments and explanations:
+
+```go
+// Importing necessary package.
+import "fmt"
+
+// mayPanic function deliberately panics with a custom error message.
+func mayPanic() {
+    panic("a problem")
+}
+
+// The main function, where the execution of the program begins.
+func main() {
+    // Using a deferred anonymous function to recover from panics.
+    defer func() {
+        // The recover function is used to catch a panic.
+        if r := recover(); r != nil {
+            // Handling the panic by printing the recovered error message.
+            fmt.Println("Recovered. Error:\n", r)
+        }
+    }()
+
+    // Calling the mayPanic function, which panics intentionally.
+    mayPanic()
+
+    // This line will be reached only if there is no panic in the mayPanic function.
+    fmt.Println("After mayPanic()")
+}
+```
+### output
+```
+Recovered. Error:
+ a problem
+```
+
+Explanation:
+
+1. **`mayPanic()`:**
+   - This function deliberately panics with the custom error message "a problem."
+
+2. **`defer func() { ... }()`:**
+   - The `defer` statement is used to schedule the execution of an anonymous function to be performed when the surrounding function (`main` in this case) exits.
+   - The anonymous function includes a `recover()` call, which returns `nil` if there is no panic or the value passed to `panic` if a panic occurred.
+
+3. **`if r := recover(); r != nil { ... }`:**
+   - Inside the deferred function, the `recover` function is used to catch a panic.
+   - If a panic occurred, the recovered value (error message in this case) is printed.
+
+4. **`mayPanic()`:**
+   - This line calls the `mayPanic` function, which intentionally panics.
+
+5. **`fmt.Println("After mayPanic()")`:**
+   - If there was no panic or if the panic was recovered successfully, this line will be executed.
+   - If a panic occurred and was caught by the deferred function, the program will continue executing from this point.
+
+Using `recover` in a deferred function is a common pattern for handling panics and performing cleanup or logging operations before the program exits. It allows you to gracefully recover from unexpected errors and continue with the execution of the program.

documentation/SUMMARY.md

@@ -43,4 +43,8 @@
 * [Atomic Counters](40-atomic-conters.md)
 * [Mutexes](41-mutexes.md)
 * [Stateful Goroutines](42-stateful-goroutines.md)
-* [Sorting](43-sorting.md)
+* [Sorting](43-sorting.md)
+* [Sorting by Functions](44-sorting-by-functions.md)
+* [Panic](45-panic.md)
+* [Defer](46-defer.md)
+* [Recover](47-recover.md)