This proposal lacks detail. What is a ContainsOnly? Can you share links to those "many packages" that implement their own? How does it compare to ContainsAny?

Can you share links to those "many packages" that implement their own?

It looks like i lied. I only saw two packages implement it and both of which are for semantic versioning and they use it to check if s only contains alphanum and -. Although it may have other uses.

I am sorry.

What is a ContainsOnly?
How does it compare to ContainsAny?

It may look like this.

// ContainsAny reports whether s only contains Unicode codepoints which are in chars

func ContainsOnly(s, chars string) bool {
	if len(s) == 0 || len(chars) == 0 {
		return false
	}
outer:
	for _, r := range s {
		for _, c := range chars {
			if r == c {
				continue outer
			}
		}
		return false
	}
	return true
}

// or

func ContainsOnly(s, chars string) bool {
	if len(s) == 0 || len(chars) == 0 {
		return false
	}
	for _, r := range s {
		if strings.ContainsRune(chars, r) == false {
			return false
		}
	}
	return true
}

I think this could be written as strings.Trim(s, chars) == "".

Does this really come up often enough to deserve its own function? Can you point to some existing code that would be simpler if this function were available? Thanks.

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

This comes up, e.g., to test that all characters in an email address are valid, but I think that doing an O(n m) loop is wrong when you can use a lookup map instead.

@carlmjohnson for small char strings, the O(n m) version might be faster.

The downside of using ContainsOnly for testing a character set is that the character set is very large. Passing "abcdefghijklmnopqrstuvwxyzABCDEFGHJKLMNOPQRSTUVWXYZ0123456789" and making the function figure out how to do that seems much worse (and less efficient) than just writing 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z' || '0' <= c && c <= '9'. It's also much harder to read. Did you notice the missing I in the string?

It's even worse if Unicode is involved.

It doesn't seem like we have a compelling use case here.

Based on the discussion above, this proposal seems like a likely decline.
— rsc for the proposal review group

No change in consensus, so declined.
— rsc for the proposal review group