io.Reader endless loop with fmt.Fscan

Not sure why, but my io.Reader implementation appears to be flawed somehow?

The docs for io.Reader state that returning a non-zero byte count and a non-nil error should be ok:

> It may return the (non-nil) error from the same call or return the error (and n == 0) from a subsequent call. An instance of this general case is that a Reader returning a non-zero number of bytes at the end of the input stream may return either err == EOF or err == nil. The next Read should return 0, EOF.
>
> Callers should always process the n > 0 bytes returned before considering the error err. Doing so correctly handles I/O errors that happen after reading some bytes and also both of the allowed EOF behaviors.

But this doesn't work for fmt.Fscan, instead hanging the program:

package main

import (
	"fmt"
	"io"
)

type Byte byte

func (b Byte) Read(p []byte) (n int, err error) {
	if len(p) == 0 {
		return 0, io.ErrShortBuffer
	}
	p[0] = byte(b)
	return 1, io.EOF
}

func main() {
	var n int
	b := Byte('9')
	z, err := fmt.Fscan(b, &n)
	fmt.Println(n, z, err)
}

Of course, it works if i instead return a zero byte count with io.EOF separately:

type Byte struct {
	v   byte
	eof bool
}

func (b *Byte) Read(p []byte) (n int, err error) {
	if len(p) == 0 {
		return 0, io.ErrShortBuffer
	}
	if b.eof {
		return 0, io.EOF
	}
	p[0] = b.v
	b.eof = true
	return 1, nil
}

func main() {
	var n int
	b := Byte{v: '9'}
	z, err := fmt.Fscan(&b, &n)
	fmt.Println(n, z, err)
}

Is there a flaw in my original implementation, or should i simply not depend on this particular bit of documented behavior of io.Reader and always separately return 0, io.EOF when there is no more data to read?

fmt.Scanf does handle returning the count and io.EOF correctly, but your reader continues to return values even after io.EOF.

Because the scanner implementation relies on using io.ReadFull, which uses io.ReadAtLeast, you are going need a more complete implementation to work with repeated reads. You can test this by taking your extended version which tracks EOF, and return io.EOF on the first Read and it will still work with fmt.Fscan as expected.

Key excerpts from the docs:

io.ReadFull:
> ... it does not treat an EOF from Read as an error to be reported

io.ReadAtLeast:
> The error is EOF only if no bytes were read.

Because these io helpers need to interpret io.EOF themselves, their callers can only look for the actual data returned, and since your reader continues to return data, they will repeat the call indefinitely. This is easily demonstrated by calling io.ReadAll repeatedly on your reader, which returns another value every time.

b := Byte('9')
fmt.Println(io.ReadAll(b))
fmt.Println(io.ReadAll(b))
fmt.Println(io.ReadAll(b))

// [57] <nil>
// [57] <nil>
// [57] <nil>

https://go.dev/play/p/It_4BWLsSP8