Proposals for Go 1.15
We are close to the Go 1.14 release, planned for February assuming all goes well, with an RC1 candidate almost ready. Per the process outlined in the Go 2, here we come! blog post, it is again the time in our development and release cycle to consider if and what language or library changes we might want to include for our next release, Go 1.15, scheduled for August of this year.
The primary goals for Go remain package and version management, better error
handling support, and generics. Module support is in good shape and getting
better with each day, and we are also making progress on the generics front
(more on that later this year). Our attempt seven months ago at providing a
better error handling mechanism, the
try proposal, met good support
but also strong opposition and we decided to abandon it. In its aftermath there
were many follow-up proposals, but none of them seemed convincing enough,
clearly superior to the
try proposal, or less likely to cause similar
controversy. Thus, we have not further pursued changes to error handling
for now. Perhaps some future insight will help us to improve upon the status
Given that modules and generics are actively being worked on, and with error handling changes out of the way for the time being, what other changes should we pursue, if any? There are some perennial favorites such as requests for enums and immutable types, but none of those ideas are sufficiently developed yet, nor are they urgent enough to warrant a lot of attention by the Go team, especially when also considering the cost of making a language change.
After reviewing all potentially viable proposals, and more importantly, because
we don’t want to incrementally add new features without a long-term plan, we
concluded that it is better to hold off with major changes this time. Instead
we concentrate on a couple of new
vet checks and a minor adjustment to the
language. We have selected the following three proposals:
string(int) conversion in
We were planning to get this done for the upcoming Go 1.14 release but we didn’t
get around to it, so here it is again. The
string(int) conversion was introduced
early in Go for convenience, but it is confusing to newcomers (
"10") and not justified anymore now that the conversion is available
Since removing this conversion is
not a backwards-compatible change, we propose to start with a
vet error instead.
Diagnose impossible interface-interface type assertions in
Currently, Go permits any type assertion
x.(T) (and corresponding type switch case)
where the type of
T are interfaces. Yet, if both
T have a method
with the same name but different signatures it is impossible for any value assigned
x to also implement
T; such type assertions will always fail at runtime
(panic or evaluate to
false). Since we know this at compile time, the compiler
might as well report an error. Reporting a compiler error in this case is not a
backwards-compatible change, thus we also propose to start with a
#28591. Constant-evaluate index and slice expressions with constant strings and indices.
Currently, indexing or slicing a constant string with a constant index, or indices,
produces a non-constant
string value, respectively. But if all operands
are constant, the compiler can constant-evaluate such expressions and produce a
constant (possibly untyped) result. This is a fully backward-compatible change
and we propose to make the necessary adjustments to the spec and compilers.
(Correction: We found out after posting that this change is not backward-compatible; see comment for details.)
We believe that none of these three proposals are controversial but there’s always a chance that we missed something important. For that reason we plan to have the proposals implemented at the beginning of the Go 1.15 release cycle (at or shortly after the Go 1.14 release) so that there is plenty of time to gather experience and provide feedback. Per the proposal evaluation process, the final decision will be made at the end of the development cycle, at the beginning of May, 2020.
And one more thing…
We receive many more language change proposals (issues labeled LanguageChange) than we can review thoroughly. For instance, just for error handling alone, there are 57 issues, of which five are currently still open. Since the cost of making a language change, no matter how small, is high and the benefits are often unclear, we must err on the side of caution. Consequently, most language change proposals get rejected sooner or later, sometimes with minimal feedback. This is unsatisfactory for all parties involved. If you have spent a lot of time and effort outlining your idea in detail, it would be nice to not have it immediately rejected. On the flip side, because the general proposal process is deliberately simple, it is very easy to create language change proposals that are only marginally explored, causing the review committee significant amounts of work. To improve this experience for everybody we are adding a new questionnaire for language changes: filling out that template will help reviewers evaluate proposals more efficiently because they don’t need to try to answer those questions themselves. And hopefully it will also provide better guidance for proposers by setting expectations right from the start. This is an experiment that we will refine over time as needed.
Thank you for helping us improve the Go experience!