How to create a custom error that's a subtype of another custom error, like inherited?

For a given custom error type:

type CustomError struct {
	// Err optionally wraps the original error.
	Err error `json:"-"`

	// Human readable message.
	Message string `json:"message" validate:"required,gte=3"`

	// StatusCode is a valid HTTP status code, e.g.: 404.
	StatusCode int `json:"-"`
}

Which implements both Error() string, and the Unwrap() error interface, also have a factory:

func NewCustomError(m string, s int, e error) *CustomError {}

How to create another "type", based on CustomType - let's call it FailedTo for errors such as "Failed to created X" which will have by default:

• A prefixed Message with Failed to
• Status code of 500

and on top of that, another one, such as FailedToCreateSomething in a way where....

func createSomething() error {
    return FailedToCreateSomething(errors.New("File is busy"))
}

errCreateSomething := createSomething()

...errCreateSomething is type of FailedToCreateSomething, also FailedTo, and CustomError?

Let's distill the example down to it's essence.

package customerror

import (
	"errors"
)

type CustomError struct {
	Aux string
	Err error
}

func (cE *CustomError) Error() string { /*...*/ }
func (err *CustomError) Unwrap() error { return err.Err }

func NewFailedToError(aux string, err error) error {
    return &CustomError{ Aux: aux, Err: err }
}

var FailedToWriteToFile = NewFailedToError("write to file", nil)

We can now get to the question in the gist:

// Some function just for demonstration.
func WriteToFile() error {
    // Something caused some error..
    errSome := errors.New("Failed to open file")

    // How can I set the `err` value of `FailedToWriteToFile` to `errSome`
    // without setting that for all `FailedToWriteToFile` instances (pointer)?
    // while still making it of `FailedToWriteToFile` type (errors.Is(errSome, FailedToWriteToFil))?
    return FailedToWriteToFile
}

Let's reframe this question to how do I make an errSome with a new message where errors.Is(errSome, FailedToWriteToFil) holds.

We can checkout the documentation of errors.Is:
> Is reports whether any error in err's chain matches target.
>
> The chain consists of err itself followed by the sequence of errors obtained by repeatedly calling Unwrap.
>
> An error is considered to match a target if it is equal to that target or if it implements a method Is(error) bool such that Is(target) returns true.
>
> An error type might provide an Is method so it can be treated as equivalent to an existing error. For example, if MyError defines
>
> func (m MyError) Is(target error) bool { return target == fs.ErrExist }
>
> then Is(MyError{}, fs.ErrExist) returns true. See syscall.Errno.Is for an example in the standard library.

This gives us two paths. One of the paths is to put FailedToWriteToFile on the Unwrap chain. CustomError has enough fields for this if we use the Err field to point to FailedToWriteToFile, e.g.

&CustomError{Aux: "Failed to open file", Err: FailedToWriteToFile}

Unwrap() on this is == to FailedToWriteToFile. FWIW Aux could be field of type error if you are trying to capture an error value coming from another source. As long as the Unwrap() chain leads to the FailedToWriteToFile eventually.

The other path is to define an Is predicate on CustomError. There are a lot of possible predicates to choose from. A simple one is that all *CustomError are considered equivalent. That would be:

func (e *CustomError) Is(target error) bool {
  _, ok := target.(*CustomError)
  return ok
}

Code:

import (
	"fmt"
	logger "log"
	"os"
	"testing"
)

var log = logger.Default()

func TestErrorWrapping(t *testing.T) {
	_, err := os.ReadFile("wrong file path")
	if err != nil {
        // custom error with wrapped a source error
		err = fmt.Errorf("can't read file, %w", err)
        // print it
		log.Printf("something went wrong, %s", err.Error())
	}
}

Output:
> something went wrong, can't read file, open wrong file path: The system cannot find the file specified.