code review 4607052: os.Error API: don't export os.ErrorString, use os.NewEr...

src/pkg/io/io.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 io provides basic interfaces to I/O primitives.
 // Its primary job is to wrap existing implementations of such primitives,
 // such as those in package os, into shared public interfaces that
 // abstract the functionality, plus some other related primitives.
 package io
 
 import "os"
 
 // Error represents an unexpected I/O behavior.
 type Error struct {
-        os.Error

[rsc, 2011/06/21 19:03:48]

Instead of this, which I fear will lead to more complex things being stuffed in
here, could you make this

type Error struct {
    String string
}

func (e *Error) String() string { return e.String }

and then the code using it doesn't have to change.
Same in http and bufio and websocket.


Thanks.

[gri1, 2011/06/21 19:12:30]

Done.

-}
+        ErrorString string
+}
+
+func (err *Error) String() string { return err.ErrorString }
 
 // ErrShortWrite means that a write accepted fewer bytes than requested
 // but failed to return an explicit error.
-var ErrShortWrite os.Error = &Error{os.NewError("short write")}
+var ErrShortWrite os.Error = &Error{"short write"}
 
 // ErrShortBuffer means that a read required a longer buffer than was provided.
-var ErrShortBuffer os.Error = &Error{os.NewError("short buffer")}
+var ErrShortBuffer os.Error = &Error{"short buffer"}
 
 // ErrUnexpectedEOF means that os.EOF was encountered in the
 // middle of reading a fixed-size block or data structure.
-var ErrUnexpectedEOF os.Error = &Error{os.NewError("unexpected EOF")}
+var ErrUnexpectedEOF os.Error = &Error{"unexpected EOF"}
 
 // Reader is the interface that wraps the basic Read method.
 //
 // Read reads up to len(p) bytes into p.  It returns the number of bytes
 // read (0 <= n <= len(p)) and any error encountered.
 // Even if Read returns n < len(p),
 // it may use all of p as scratch space during the call.
 // If some data is available but not len(p) bytes, Read conventionally
 // returns what is available rather than block waiting for more.
 //
@@ skipping 363 matching lines @@
         }
         off += s.base
         if max := s.limit - off; int64(len(p)) > max {
                 p = p[0:max]
         }
         return s.r.ReadAt(p, off)
 }
 
 // Size returns the size of the section in bytes.
 func (s *SectionReader) Size() int64 { return s.limit - s.base }