Please follow the instruction/template of proposal.
https://github.com/golang/proposal#readme

Is FieldPos not sufficient (see https://pkg.go.dev/encoding/csv#Reader.FieldPos)? If not, what do you want instead?

I note that encoding/json.Decoder and encoding/xml.Decoder both have a InputOffset method.

@ianlancetaylor
If use FieldPos, it's need to count the number of rows first, which will affect performance.

Here is an examples

package main

import (
	"bufio"
	"encoding/csv"
	"fmt"
	"io"
	"os"
	"reflect"
	"unsafe"
)

type ProgressReader struct {
	r          io.Reader
	totalBytes int64
	bytes      int64
}

func NewProgressReader(totalBytes int64, r io.Reader) *ProgressReader {
	if totalBytes <= 0 {
		panic("the totalBytes must greater than 0")
	}
	return &ProgressReader{
		r:          r,
		totalBytes: totalBytes,
	}
}

func (r *ProgressReader) Read(p []byte) (n int, err error) {
	n, err = r.r.Read(p)
	r.bytes += int64(n)
	return
}

func (r *ProgressReader) Percentage() float64 {
	return 100 * float64(r.bytes) / float64(r.totalBytes)
}

func (r *ProgressReader) PercentageOffset(n int64) float64 {
	return 100 * float64(r.bytes+n) / float64(r.totalBytes)
}

func (r *ProgressReader) Bytes() int64 {
	return r.bytes
}

func main() {
	f, err := os.Open("x.csv")
	if err != nil {
		panic(err)
	}
	stat, err := f.Stat()
	if err != nil {
		panic(err)
	}

	totalBytes := stat.Size()
	pr := NewProgressReader(totalBytes, f)
	r := csv.NewReader(pr)

	rf := reflect.ValueOf(r).Elem().FieldByName("r")
	rf = reflect.NewAt(rf.Type(), unsafe.Pointer(rf.UnsafeAddr())).Elem()
	br := rf.Interface().(*bufio.Reader)
	// Can *bufio.Reader be exported?

	for {
		_, err := r.Read()
		if err != nil {
			if err == io.EOF {
				break
			}
			panic(err)
		}
		fmt.Printf(
			"%.3f %.3f %d\n",
			pr.Percentage(),
			pr.PercentageOffset(int64(-br.Buffered())), // or exported the Buffered
			-br.Buffered(),
		)
	}
}

OK, if you don't want FieldPos, then what do you want instead?

If performance is an issue, then consider that anything we do is going to cost a little bit of performance, only it will cost that performance for everybody. But I don't see why performance would be a significant issue here.

@ianlancetaylor
This will read twice. When the file is relatively large, we need to consider performance.

Is it possible to add the following functions?

// Buffered returns the number of bytes that can be read from the current buffer of Reader.
func (r *Reader) Buffered() int {
	return r.r.Buffered()
}

Therefore, it is possible to know the number of bytes that were actually read.

Please follow the instruction/template of proposal. https://github.com/golang/proposal#readme
@mengzhuo
Is this okay?

Adding a Buffered method is easy but seems awkward to use. More importantly, it ties the encoding/csv API closely to bufio.Reader, which is currently an implementation detail.

Can we take a step back? What is the problem that you are trying to address?

OK, it's make sense.

I want to calculate the percentage of bytes that have been read from the file. Due to the buffer of *bufio.Reader, the percentage cannot be accurately calculated.

How about check the type of io.Reader in NewReader, use it directly when io.Reader is already *bufio.Reader?

Or others.

How about check the type of io.Reader in NewReader, use it directly when io.Reader is already *bufio.Reader?

That already happens. See the implementation of bufio.NewReader.

Thanks. It's work.

package main

import (
	"bufio"
	"encoding/csv"
	"fmt"
	"io"
	"os"
)

type ProgressReader struct {
	r          io.Reader
	totalBytes int64
	bytes      int64
}

func NewProgressReader(totalBytes int64, r io.Reader) *ProgressReader {
	if totalBytes <= 0 {
		panic("the totalBytes must greater than 0")
	}
	return &ProgressReader{
		r:          r,
		totalBytes: totalBytes,
	}
}

func (r *ProgressReader) Read(p []byte) (n int, err error) {
	n, err = r.r.Read(p)
	r.bytes += int64(n)
	return n, err
}

func (r *ProgressReader) Percentage() float64 {
	return 100 * float64(r.bytes) / float64(r.totalBytes)
}

func (r *ProgressReader) PercentageOffset(n int64) float64 {
	return 100 * float64(r.bytes+n) / float64(r.totalBytes)
}

func (r *ProgressReader) Bytes() int64 {
	return r.bytes
}

func main() {
	f, err := os.Open("xxx.csv")
	if err != nil {
		panic(err)
	}
	stat, err := f.Stat()
	if err != nil {
		panic(err)
	}

	totalBytes := stat.Size()
	pr := NewProgressReader(totalBytes, f)
	br := bufio.NewReader(pr)
	r := csv.NewReader(br)

	for {
		_, err := r.Read()
		if err != nil {
			if err == io.EOF {
				break
			}
			panic(err)
		}
		fmt.Printf(
			"%.3f %.3f %d\n",
			pr.Percentage(),
			pr.PercentageOffset(int64(-br.Buffered())),
			-br.Buffered(),
		)
	}
}

OK, should we consider this proposal to be retracted? Thanks.

OK, thanks again!

#43401