Robust Error Handling with Wrapping in Go

Error wrapping is a crucial technique in Go for providing more context to errors, making debugging and troubleshooting significantly easier. This challenge asks you to implement a function that wraps an existing error with additional information, preserving the original error while adding a descriptive message. This is particularly useful when dealing with layered functions where the root cause of an error might be obscured by intermediate operations.

Problem Description

You are tasked with creating a function WrapError that takes an existing error and a string message as input. The function should return a new error that:

1. Contains the original error as its underlying cause (using fmt.Errorf and %w).
2. Includes the provided message to describe the context in which the original error occurred.
3. The returned error should be of type error.

The goal is to create a chain of errors, where each wrapped error provides more information about the error's journey through your application. This allows for more informative error messages and easier debugging.

Examples

Example 1:

Input: originalError := fmt.Errorf("database connection failed"); message := "Failed to connect to the database server"
Output: WrappedError: Failed to connect to the database server; database connection failed
Explanation: The `WrapError` function takes the original database connection error and the descriptive message. It returns a new error that includes both the message and the original error, allowing for easy identification of the root cause.

Example 2:

Input: originalError := fmt.Errorf("file not found"); message := "Unable to read configuration file"
Output: WrappedError: Unable to read configuration file; file not found
Explanation:  Similar to Example 1, this demonstrates wrapping a "file not found" error with a message indicating the context of the error (configuration file reading).

Example 3: (Edge Case - Nil Error)

Input: originalError := nil; message := "An unexpected error occurred"
Output: WrappedError: An unexpected error occurred
Explanation:  If the original error is `nil`, the function should still return a valid error containing the message.  It should not panic.

Constraints

• The WrapError function must accept an error interface and a string as input.
• The WrapError function must return an error interface.
• The returned error must be a non-nil error.
• The function should handle the case where the input error is nil gracefully.
• The function should use fmt.Errorf with the %w verb to wrap the original error.

Notes

• Consider using fmt.Errorf with the %w verb to wrap the original error. This is the standard way to wrap errors in Go 1.13 and later.
• Think about how to handle the case where the input error is nil. Returning a new error with just the message is a reasonable approach.
• The order of the message and the original error in the final error string is important for readability. The message should generally come first.
• This exercise focuses on the mechanics of error wrapping. Error handling strategies (e.g., logging, retries) are outside the scope of this challenge.