proposal: os: add ErrNotSupported

[bcmills]

We currently have many different syscall errors that indicate operations or functions that are not supported by the current platform:

• syscall.EWINDOWS indicates an operation not supported by windows.
• syscall.EPLAN9 indicates an operation not supported by plan 9.
• On POSIX platforms:
  • ENOSYS indicates function not implemented.
  • ENOTSUP indicates functionality not supported or operation not supported.
  • EOPNOTSUPP indicates operation not supported on socket. On some platforms, it is identical to ENOTSUP.

However, none of those constants is portable: syscall.ENOSYS and syscall.ENOTSUP are not defined on plan9, and errors.Is(syscall.EWINDOWS, syscall.ENOSYS) returns false on Windows, requiring separate windows source files just to be able to name the error code.

In addition:

• net/http, x/net/websocket, and cmd/go/internal/lockedfile/internal/filelock (see also proposal: os: make the internal lockedfile package public #33974) all define errors named ErrNotSupported with similar semantics.
• x/net/webdav and x/net/websocket both define similar errors named ErrNotImplemented, although websocket (ironically!) does not appear to ever actually use it.

We obviously can't collapse all of these errors back down into one. However, we can make them easier to manage!

I propose that we add a pre-defined error in the os package, tentatively named ErrNotSupported, with the error string operation not supported. Errors could define Is(os.ErrNotSupported) for any error that means “the operation is not supported for its operands, but the operands are not necessarily invalid”

The oserror and syscall packages would then be modified such that errors.Is(err, os.ErrNotSupported) returns true for all of syscall.EWINDOWS, syscall.EPLAN9, syscall.ENOSYS, syscall.ENOTSUP, and syscall.EOPNOTSUPP.

[earthboundkid]

If ErrNotSupported were an interface, you could implement it without importing package os.

Simplest way:

func IsErrNotSupported(err error) bool {
	var s interface {
		error
		NotSupported() bool
	}
	if errors.As(err, &s) {
		return s.NotSupported()
	}
	return false
}

type myError struct {
	error
}

func (me myError) NotSupported() bool { return true }

func main() {
	fmt.Println(IsErrNotSupported(errors.New("nope")))
	fmt.Println(IsErrNotSupported(myError{errors.New("yep")}))
}

[rsc]

Is this now a duplicate of #41198?

[rsc]

This proposal has been added to the active column of the proposals project
and will now be reviewed at the weekly proposal review meetings.
— rsc for the proposal review group

[rsc]

This proposal has been added to the active column of the proposals project
and will now be reviewed at the weekly proposal review meetings.
— rsc for the proposal review group

[nightlyone]

If ErrNotSupported were an interface, you could implement it without importing package os.

That seems als much better to me, because that would enable supporting it in your own programs too and even allow to add details why something is not supported.

[rsc]

This proposal is a duplicate of a previously discussed proposal, as noted above,
and there is no significant new information to justify reopening the discussion.
The issue has therefore been declined as a duplicate.
— rsc for the proposal review group