How is regexp.MustMatch("pattern", []byte("subject")) different from regexp.MustCompile("pattern").Match([]byte("subject")), beyond saving you a few characters?

The purpose of the MustMatch function is to provide a more concise and readable way to perform the common task of matching a regular expression against a byte slice, reader, or string. The difference between MustMatch and MustCompile().Match is that MustMatch combines both the compilation and matching steps into a single function call, making the code more straightforward and easier to read. This can be especially useful in cases where the pattern is only used once or in cases where it's important to clearly convey the intention of the code.

So, just to be clear, the only difference is that your code becomes slightly shorter? You still end up with the same error checking and number of lines, as far as I can tell. Adding new API to just save typing a few characters seems like a bad idea in general to me, unless those savings are very common, like adding any as an alias for interface{}.

Yes, you are correct in that the main difference between MustMatch and MustCompile("pattern").Match([]byte("subject")) is the conciseness of the code. While the error handling is the same in both cases, the MustMatch function provides a more readable and concise way to perform regular expression matching.

However, it's important to note that conciseness and readability are still valuable attributes in programming. By making the code easier to follow and understand, MustMatch can improve the overall maintainability and quality of the codebase. Additionally, the ability to write code in a more concise and readable way can increase developer productivity and reduce the likelihood of errors.

In summary, the MustMatch function may be a useful addition to the Go programming language even if it only offers a small reduction in code length, as it can improve the overall readability and maintainability of the code.

The addition of regexp.MustMatch may not necessarily improve code readability, as the use of regexp.MustCompile(...).Match already provides a clear and concise way of matching a regular expression and handling errors. The use of regexp.MustMatch could add additional complexity to the code, making it harder to understand and maintain. In general, it's best to keep the code simple and stick with established patterns, rather than adding new functions that might not have a clear advantage over existing ones.

I understand your concern that this new function may not necessarily improve code readability and may even add additional complexity to the code.

I would like to point out that the primary benefit of the regexp.MustMatch function is to provide a more concise and readable way to match a regular expression, as compared to using regexp.MustCompile(...).Match. In some cases, the use of regexp.MustCompile(...).Match can result in longer and less readable code, especially when used multiple times within a single program.

In terms of established patterns, regexp.MustMatch would simply provide an alternative approach that developers can choose to use based on their own preferences and specific use cases. It is important to note that it would not replace the existing regexp.MustCompile(...).Match function, but rather coexist with it as a choice for developers.

I hope this clarifies the potential benefits of adding regexp.MustMatch to the Go standard library.

I believe we can decline this as another variant of #47593 (comment)

these shorter functions are simple wrappers for any package that needs it frequently enough to write.