Skip to content

proposal: spec: language: make slices of constant strings constant if the indexes are constant #28591

Open
@ainar-g

Description

@ainar-g

This will probably be assigned a Go2 label, although I think that it could be done during Go 1.

Consider multiline string constants:

const multiline = `
This is a long text
that spans multiple lines
and then ends.
`

If you feed this text to a parser and it finds a problem on the first line ("This is a long text"), it will actually report that the error is on the second line because of the leading newline. One might think that this is easily solved by slicing the string:

const multiline = `
This is a long text
that spans multiple lines
and then ends.
`[1:]

But this won't compile. The Spec currently says:

(…) For untyped string operands the result is a non-constant value of type string. (…)

Why not make it constant? After all, len(multiline) is constant.


There are other solutions to this. One could just use multiline[1:] everywhere where one doesn't want the leading newline. Or start "This is a long text" on the first line, but that hurts readability and "editability". Another solution is to make multiline a variable. The use case is pretty obscure and there isn't an immediate need for this, so this proposal is more about a question, why are slices (and indexing!) of constant strings not constant in the first place?

Activity

added this to the Proposal milestone on Nov 4, 2018
changed the title [-]proposal: make slices of constant strings constant if the indexes are constant[/-] [+]proposal: spec: make slices of constant strings constant if the indexes are constant[/+] on Nov 5, 2018
changed the title [-]proposal: spec: make slices of constant strings constant if the indexes are constant[/-] [+]proposal: Go 2: language: make slices of constant strings constant if the indexes are constant[/+] on Nov 5, 2018
ianlancetaylor

ianlancetaylor commented on Nov 5, 2018

@ianlancetaylor
Contributor

Marking as Go 2 because we've decided that all language changes are Go 2.

I know that this has been discussed in the past but I don't remember why it wasn't changed. Maybe simply because it rarely comes up in practice.

ianlancetaylor

ianlancetaylor commented on Dec 11, 2018

@ianlancetaylor
Contributor

We should also consider accepting

const c = "abc"[1]
added
NeedsDecisionFeedback is required from experts, contributors, and/or the community before a change can be made.
on Dec 11, 2018
removed
NeedsDecisionFeedback is required from experts, contributors, and/or the community before a change can be made.
on Aug 16, 2019
added
NeedsDecisionFeedback is required from experts, contributors, and/or the community before a change can be made.
on Sep 3, 2019
griesemer

griesemer commented on Jan 29, 2020

@griesemer
Contributor

It turns out that this proposed change is not backward-compatible after all ...

Consider "A"[0] : With the proposed change, this expression evaluates to the untyped byte constant 65. But if we try to negate this value, as in:

var _ = -"A"[0]

we will get an error: -"A"[0] (constant -65 of type byte) overflows byte . This is currently (without the change) valid code. Oops!

For similar reasons, constant index expressions are not backwards-compatible either. The length of a constant slice expression len("abc"[0:2]) is an untyped integer constant (3), but if we negate it and try to assign it to a variable of uint type, we will get an error.

var _ uint = -uint(len("abc"[0:2]))

(Without the change, these values are not constant, and the compiler won't complain.)

Fun times!

griesemer

griesemer commented on Jan 29, 2020

@griesemer
Contributor

Related: #11370, #11368.

jimmyfrasche

jimmyfrasche commented on Jan 29, 2020

@jimmyfrasche
Member

Would

const (
  a = "abc"[iota]
  b
  c
)

be legal?

griesemer

griesemer commented on Jan 29, 2020

@griesemer
Contributor

@jimmyfrasche Very nice! Indeed it would.

27 remaining items

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    Type

    No type

    Projects

    No projects

    Relationships

    None yet

      Development

      No branches or pull requests

        Participants

        @bradfitz@rsc@jimmyfrasche@ianlancetaylor@ainar-g

        Issue actions

          proposal: spec: language: make slices of constant strings constant if the indexes are constant · Issue #28591 · golang/go