code review 9132045: regexp: doc fix

src/pkg/regexp/regexp.go

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // Package regexp implements regular expression search.
 //
 // The syntax of the regular expressions accepted is the same
 // general syntax used by Perl, Python, and other languages.
 // More precisely, it is the syntax accepted by RE2 and described at
 // http://code.google.com/p/re2/wiki/Syntax, except for \C.
@@ skipping 379 matching lines @@
 
 // Match returns whether the Regexp matches the byte slice b.
 // The return value is a boolean: true for match, false for no match.
 func (re *Regexp) Match(b []byte) bool {
         return re.doExecute(nil, b, "", 0, 0) != nil
 }
 
 // MatchReader checks whether a textual regular expression matches the text
 // read by the RuneReader.  More complicated queries need to use Compile and
 // the full Regexp interface.
-func MatchReader(pattern string, r io.RuneReader) (matched bool, error error) {
+func MatchReader(pattern string, r io.RuneReader) (matched bool, err error) {
         re, err := Compile(pattern)
         if err != nil {
                 return false, err
         }
         return re.MatchReader(r), nil
 }
 
 // MatchString checks whether a textual regular expression
 // matches a string.  More complicated queries need
 // to use Compile and the full Regexp interface.
-func MatchString(pattern string, s string) (matched bool, error error) {
+func MatchString(pattern string, s string) (matched bool, err error) {
         re, err := Compile(pattern)
         if err != nil {
                 return false, err
         }
         return re.MatchString(s), nil
 }
 
 // Match checks whether a textual regular expression
 // matches a byte slice.  More complicated queries need
 // to use Compile and the full Regexp interface.
-func Match(pattern string, b []byte) (matched bool, error error) {
+func Match(pattern string, b []byte) (matched bool, err error) {
         re, err := Compile(pattern)
         if err != nil {
                 return false, err
         }
         return re.Match(b), nil
 }
 
 // ReplaceAllString returns a copy of src, replacing matches of the Regexp
 // with the replacement string repl.  Inside repl, $ signs are interpreted as
 // in Expand, so for instance $1 represents the text of the first submatch.
@@ skipping 667 matching lines @@
                 }
                 beg = match[1]
         }
 
         if end != len(s) {
                 strings = append(strings, s[beg:])
         }
 
         return strings
 }