recover excercise new pull req

internal/exercises/catalog.yaml

@@ -192,12 +192,20 @@ projects:
     - Implement MarshalPerson to convert a struct into JSON using json.Marshal.
     - Implement UnmarshalPerson to convert a JSON string into a struct using json.Unmarshal.
     - Handle and return errors properly in both functions.
-
 - slug: 109_epoch
   title: "Epoch Conversion"
-  difficulty: beginner
-  topics: ["time", "epoch", "unix"]
+  test_regex: ".*"
   hints:
     - "Use Go's `time.Unix()` to convert an epoch to time."
     - "Use `t.Unix()` to convert time back to epoch."
     - "Remember Go’s `time.Parse` can help parse date strings."
+- slug: 110_recover
+  title: Safe Panic Recovery
+  test_regex: ".*"
+  hints:
+    - hint_type: concept
+      text: The `recover()` function is ONLY useful inside a function that is executed by a `defer` statement. Outside of a deferred function, `recover` will return `nil` and have no effect.
+    - hint_type: structure
+      text: You must place a `defer` statement at the beginning of the `Run` function. The function passed to `defer` is where you should call `recover()`.
+    - hint_type: solution
+      text: "The core logic of the deferred function should look like this: `if r := recover(); r != nil { recoveredValue = r }`"

internal/exercises/exercises.go

@@ -124,6 +124,15 @@ func Get(slug string) (Exercise, error) {
 			return ex, nil
 		}
 	}
+	// Fallback: if an embedded template or solution exists, synthesize an Exercise entry
+	if templateExists(slug) || SolutionExists(slug) {
+		return Exercise{
+			Slug:      slug,
+			Title:     slug,
+			TestRegex: ".*",
+			Hints:     nil,
+		}, nil
+	}
 	return Exercise{}, fmt.Errorf("exercise not found: %s", slug)
 }
 

internal/exercises/solutions/110_recover/recover.go

@@ -0,0 +1,33 @@
+package recover_exercise
+
+// DoWork simulates a function that might panic if the input is negative.
+//
+// It is designed to be called by Run, which should demonstrate
+// how to safely handle the panic using recover().
+func DoWork(n int) {
+	if n < 0 {
+		// A panic occurs if n is negative
+		panic("input cannot be negative")
+	}
+	// Normal, non-panicking code path...
+}
+
+// Run calls DoWork and uses defer/recover to safely handle any panic.
+// It returns the recovered panic value or nil if no panic occurred.
+func Run(n int) (recoveredValue interface{}) {
+	// The deferred function is executed just before Run returns.
+	defer func() {
+		// Call recover() to check if a panic has occurred.
+		if r := recover(); r != nil {
+			// If recover() returns a non-nil value (a panic occurred),
+			// assign it to the named return variable 'recoveredValue'.
+			recoveredValue = r
+		}
+	}()
+
+	DoWork(n)
+
+	// 'recoveredValue' is returned. It will be the panic value if
+	// a panic occurred and was recovered, or nil otherwise.
+	return recoveredValue
+}

internal/exercises/templates/110_recover/recover.go

@@ -0,0 +1,25 @@
+package recover_exercise
+
+// DoWork simulates a function that might panic if the input is negative.
+func DoWork(n int) {
+	if n < 0 {
+		// A panic occurs if n is negative
+		panic("input cannot be negative")
+	}
+	// Normal, non-panicking code path...
+}
+
+// Run should call DoWork and safely recover from any panic
+// that occurs during its execution, returning the recovered value.
+// It should return nil if no panic occurred.
+func Run(n int) (recoveredValue interface{}) {
+	// 1. Add your 'defer' statement here.
+	// 2. The deferred function should call recover() and assign the result
+	//    to 'recoveredValue' if it is not nil.
+
+	// Your code here:
+
+	DoWork(n)
+
+	return recoveredValue
+}

internal/exercises/templates/110_recover/recover_test.go

@@ -0,0 +1,28 @@
+package recover_exercise
+
+import (
+	"testing"
+)
+
+func TestRun_NoPanic(t *testing.T) {
+	t.Parallel()
+	result := Run(10)
+	if result != nil {
+		t.Errorf("Run(10) should not panic and should return nil. Got: %v", result)
+	}
+}
+
+func TestRun_WithPanic(t *testing.T) {
+	t.Parallel()
+	expectedPanicValue := "input cannot be negative"
+	result := Run(-5)
+
+	if result == nil {
+		t.Errorf("Run(-5) should panic and recover, returning the panic value. Got nil")
+	}
+
+	// Check if the recovered value is what we expected
+	if resultAsString, ok := result.(string); !ok || resultAsString != expectedPanicValue {
+		t.Errorf("Run(-5) recovered with unexpected value. Expected: %q, Got: %v (%T)", expectedPanicValue, result, result)
+	}
+}