proposal: Add constant error

[mkideal]

The origin of the problem

Here is an exmaple:

package mypkg

import "errors"

var (
    ErrNotFound = errors.New("not found")
)

func Find(s string) (int, error) {
    return 0, ErrNotFound
}

I need export the ErrNotFound, but ErrNotFound need to be guaranteed not to be modified.

Proposal

So I proposal add following code in errors package:

type Error string

func (e Error) Error() string { return string(e) }

Through doing this, I can define ErrNotFound like this:

const (
    ErrNotFound = errors.Error("not found")
)

[minux]

we can't define errors.Error as string, because then anyone can assign a (untyped) string to errors.Error, and that's the reason why errors.New returns a struct wrapping a string.

[mkideal]

can assign a (untyped) string to errors.Error

Maybe some people need this.

[bradfitz]

This isn't happening for Go 1, so kicking this into the Go2 abyss.

[minux]

If it's a Go2 item, then I'd suggest we change it to request proper constant support for more types (e.g. C++'s constexpr)

[bradfitz]

We can discuss later.

[nizsheanez]

Faced use case with context keys:

ctx.Value("key") // cause allocation for convert string "key" to interface{}

Global variable do this allocation once:

var CONTEXT_KEY interface{} = "key" // for now using var instead of constx 
...
ctx.Value(CONTEXT_KEY) 

[bradfitz]

Do not use strings as context keys. See #17302 and the new golint rule.

[rsc]

We used to use exactly the implementation of errors.Error given in the proposal. We moved away from it so that if two different packages used errors.New("msg") for different things, the two would not accidentally be equal.

I need export the ErrNotFound, but ErrNotFound need to be guaranteed not to be modified.

You probably don't need to guarantee it. The standard library exports many errors and makes no such guarantee, and programs work fine, because programs can mostly be trusted not to modify those errors (for example, they don't reassign io.EOF), and those programs that can't be trusted deserve to break badly anyway.

If you really needed to guarantee this, then instead of exporting the variable you could instead export a function that returns it:

var errNotFound = ...
func ErrNotFound() error { return errNotFound }

Then no one can modify the definition in use in your program.