regexp: prefer fewer doesn't work with (.*)+?

[dazhuangzhuang1024]

What version of Go are you using (go version)?

$ go version
go version go1.12.6 darwin/amd64

Does this issue reproduce with the latest release?

yes

What operating system and processor architecture are you using (go env)?

go env Output

$ go env
GOARCH="amd64"
GOBIN=""
GOCACHE="/Users/liangji.zlj/Library/Caches/go-build"
GOEXE=""
GOFLAGS=""
GOHOSTARCH="amd64"
GOHOSTOS="darwin"
GOOS="darwin"
GOPATH="/Users/liangji.zlj/workspace/go_workspace"
GOPROXY=""
GORACE=""
GOROOT="/usr/local/Cellar/go/1.12.6/libexec"
GOTMPDIR=""
GOTOOLDIR="/usr/local/Cellar/go/1.12.6/libexec/pkg/tool/darwin_amd64"
GCCGO="gccgo"
CC="clang"
CXX="clang++"
CGO_ENABLED="1"
GOMOD="/Users/liangji.zlj/workspace/go_workspace/src/hello/go.mod"
CGO_CFLAGS="-g -O2"
CGO_CPPFLAGS=""
CGO_CXXFLAGS="-g -O2"
CGO_FFLAGS="-g -O2"
CGO_LDFLAGS="-g -O2"
PKG_CONFIG="pkg-config"
GOGCCFLAGS="-fPIC -m64 -pthread -fno-caret-diagnostics -Qunused-arguments -fmessage-length=0 -fdebug-prefix-map=/var/folders/5t/xqwqx3sd29n17qyy0qlm2rq00000gn/T/go-build122003158=/tmp/go-build -gno-record-gcc-switches -fno-common"

What did you do?

func main() {
	contextTest := "abbbb\ncd\nefg\nhepq"
	reg := regexp.MustCompile(`(?s)(.*)+?e`)
	res := reg.FindStringSubmatch(contextTest)
	fmt.Println(res[0])
}

What did you expect to see?

abbbb
cd
e

What did you see instead?

abbbb
cd
efg
he

[av86743]

Perhaps you want (.*?)? ? does not affect preceding nested *, only immediately preceding +. So (.*) grows as much as it can, stopping only at the last e.

[dazhuangzhuang1024]

@av86743 Do you mean +? can't affect (.*) ? But, I find +? can affect preceding normal characters. For example, ([a-z])+?.

[av86743]

Affect repetitions of constant pattern - yes, indeed. Affect behavior of nested repetition modifier in preceding capture - no, it doesn't.

Should I also point out the inefficiency of your original pattern? In order to figure out the last e, it still has to scan the entire tail that follows that last e.

[dazhuangzhuang1024]

So, the behavior of +? affect preceding "repetitions of constant pattern" and "nested repetition modifier" is different.

Of course, I know my original pattern is inefficiency. I want to figure out the first e and I'm
just wondering why the result of (.*)+?e and .+?e is different in my simple case.

Thank you very much!

[av86743]

So, the behavior of +? affect preceding "repetitions of constant pattern" and "nested repetition modifier" is different.

I wouldn't say +? behavior is different in your cases. For (.*)+?, you expect that ? would also force .* to take the shortest match, but it does not. On the contrary, it takes the longest match, as it should (without *?.) ? only affects + in preceding (.*)+ or .+.

[katiehockman]

For future questions about Go, see https://golang.org/wiki/Questions.

[andybons]

Hi there,
We have decided that our experiment to allow questions on the issue tracker has not had the outcome we desired, so I am closing this issue. I'm sorry that we can't answer your question here.

There are many other methods to get help if you're still curious:

• Stack Overflow with questions tagged "go"

• The Go Forum, a web-based forum

• Gophers Slack, use the invite app for access. The #general channel is a good starting point.

• Go Community on Hashnode with questions and posts tagged with "go"

• The golang-nuts mailing list

• IRC channel #go-nuts on Freenode

Thanks