Comment 1:

When the io.Copyn destination implements a ReaderFrom interface, the number of bytes
copied is limited to n by the LimitReader. For example,
package main
import (
    "bytes"
    "fmt"
    "io"
)
func main() {
    pfx := "01234567"
    sfx := "89"
    r := bytes.NewBuffer([]byte(pfx + sfx))
    w := bytes.NewBuffer(nil)
    n, err := io.Copyn(w, r, int64(len(pfx)))
    // 8 <nil>
    fmt.Println(n, err)
    // true true
    fmt.Println(r.String() == sfx, w.String() == pfx)
}

Comment 2:

In _, err = Copyn(dst, src, N) notice how the meaning of err varies depending on dst:
1) if dst satisfies ReaderFrom, err == nil means N bytes have or have not been copied.
2) if dst does not satisfy ReaderFrom, err == nil means N bytes have been copied.
Consider below program; its output is:
  3 <nil>
  3 <nil>
  3 EOF
  3 <nil>
while I was expecting more consistent:
  3 <nil>
  3 <nil>
  3 EOF
  3 EOF
package main
import (
        "bufio"
        "bytes"
        "io"
        "os"
        "strings"
        "fmt"
)
func main() {
        var w io.Writer
        w = bufio.NewWriter(os.Stdout)
        n, err := io.Copyn(w, strings.NewReader("foo"), 3)
        // 3 <nil>
        fmt.Println(n, err)
        w = bytes.NewBuffer(nil)
        n, err = io.Copyn(w, strings.NewReader("foo"), 3)
        // 3 <nil>
        fmt.Println(n, err)
        w = bufio.NewWriter(os.Stdout)
        n, err = io.Copyn(w, strings.NewReader("foo"), 4)
        // 3 EOF
        fmt.Println(n, err)
        w = bytes.NewBuffer(nil)
        n, err = io.Copyn(w, strings.NewReader("foo"), 4)
        // 3 <nil>
        fmt.Println(n, err)
}

Comment 3:

3821044

Owner changed to r...@golang.org.

Status changed to Started.

Comment 4:

This issue was closed by revision 0f26608.

Status changed to Fixed.