As mentioned, a quick look at RFC 4180 does not seem to explicitly describe what the behavior should be for empty lines.

/cc @dsnet @bradfitz @rsc

According to RFC 4180, section 2.1:

Each record is located on a separate line, delimited by a line break (CRLF).

Which suggests that this is a bug in the reader code.

However, I'm not going to be surprised if fixing this breaks lots of users due to Hyrum's law and we're forced to just document the errant behavior. Even though the package tries to follow RFC 4180, CSV files are one of those formats with many strange variants that do not folllow any specific grammar.

Interesting that this used to work in go1.3 and stopped working in go1.4, but not because the reader behavior changed, but that the writer behavior changed.

In go1.3, it would produce:

john
jane
""
jack

but in go1.4, it would produce:

john
jane

jack

The presence of an explicit "" made it clear to the reader that there was a record present.

The change in Go 1.4 is documented, but I guess not in user-visible documentation.

// We used to quote empty strings, but we do not anymore (as of Go 1.4).
// The two representations should be equivalent, but Postgres distinguishes
// quoted vs non-quoted empty string during database imports, and it has
// an option to force the quoted behavior for non-quoted CSV but it has
// no option to force the non-quoted behavior for quoted CSV, making
// CSV with quoted empty strings strictly less useful.
// Not quoting the empty string also makes this package match the behavior
// of Microsoft Excel and Google Drive.

See #7586.

Which suggests that this is a bug in the reader code.

However, I'm not going to be surprised if fixing this breaks lots of users due to Hyrum's law and we're forced to just document the errant behavior. Even though the package tries to follow RFC 4180, CSV files are one of those formats with many strange variants that do not folllow any specific grammar.

If we're worried about breaking existing code, we could add a boolean flag, which defaults to the current behaviour and then we could discuss flipping it (and potentially removing it) for Go 2.

If I understand the implementation correctly, then one cannot just initialise a Reader struct, one has to go through NewReader, because the underlying io.Reader is unexported. In that case, we can enforce our default in the constructor. (Or we could flip the boolean flag to mean e.g. ParseBlankLines, which has the desired default value.)

Something along the lines of this (haven't tested it, just sketching):

diff --git a/src/encoding/csv/reader.go b/src/encoding/csv/reader.go
index c40aa506b0..cd2b0ccfc1 100644
--- a/src/encoding/csv/reader.go
+++ b/src/encoding/csv/reader.go
@@ -16,8 +16,8 @@
 //
 // Carriage returns before newline characters are silently removed.
 //
-// Blank lines are ignored. A line with only whitespace characters (excluding
-// the ending newline character) is not considered a blank line.
+// Blank lines are ignored by default. A line with only whitespace characters
+// (excluding the ending newline character) is not considered a blank line.
 //
 // Fields which start and stop with the quote character " are called
 // quoted-fields. The beginning and ending quote are not part of the
@@ -142,6 +142,9 @@ type Reader struct {
 	// By default, each call to Read returns newly allocated memory owned by the caller.
 	ReuseRecord bool
 
+	// If SkipBlankLines is true (default), rows with no data are skipped.
+	SkipBlankLines bool
+
 	TrailingComma bool // Deprecated: No longer used.
 
 	r *bufio.Reader
@@ -169,8 +172,9 @@ type Reader struct {
 // NewReader returns a new Reader that reads from r.
 func NewReader(r io.Reader) *Reader {
 	return &Reader{
-		Comma: ',',
-		r:     bufio.NewReader(r),
+		Comma:          ',',
+		SkipBlankLines: true,
+		r:              bufio.NewReader(r),
 	}
 }
 
@@ -268,7 +272,7 @@ func (r *Reader) readRecord(dst []string) ([]string, error) {
 			line = nil
 			continue // Skip comment lines
 		}
-		if errRead == nil && len(line) == lengthNL(line) {
+		if r.SkipBlankLines && errRead == nil && len(line) == lengthNL(line) {
 			line = nil
 			continue // Skip empty lines
 		}

Here's a patch, including tests. If this is something that would be acceptable, I can go through the usual gerrit mechanism. Oh, I see PRs on Github are accepted, I'll do that then.

Also, if this patch goes through, I'd suggest for Go 2 to have the default reverted - interpret blank lines by default and either add a SkipBlankLines switch or remove this functionality altogether.

Change https://golang.org/cl/237658 mentions this issue: encoding/csv: allow for interpretation of empty lines

We've pretty much decided that we are not going to add additional knobs to encoding/csv. There are just too many variations in CSV files out there. Trying to handle all of them would lead to a massive proliferation of knobs and an unusable package API.

That's too bad, because two of the existing knobs are actually going against the "standard" - lazyquotes and comments, while this suggested knob actually tries to bring Go closer to standard compliance (while keeping backward compatibility).

Anyway, where can I register interest in changing this in Go 2? No knobs, just changing the default - blank lines are perfectly fine and should be interpreted as data.

There isn't going to be a big shift to Go 2. There may never be a Go 2, except perhaps for marketing reasons. For a package like this, there may someday be a encoding/csv/v2. Although personally I think that our experience with this package is that it would be better to drop it from the standard library, and encourage a variety of third party packages instead.

Should the documentation be updated to indicate that RFC 4180 is not fully supported? I just ran into this myself, and reading the RFC

   record = field *(COMMA field)
   name = field
   field = (escaped / non-escaped)
   escaped = DQUOTE *(TEXTDATA / COMMA / CR / LF / 2DQUOTE) DQUOTE
   non-escaped = *TEXTDATA
   ...
   TEXTDATA =  %x20-21 / %x23-2B / %x2D-7E

suggests strongly that blank lines should correspond to a single empty field.

I realize there's already a note a couple of paragraphs down in the encoding/csv documentation that states blank lines are ignored, but it's not made clear that this behavior contradicts the RFC.

Change https://golang.org/cl/363001 mentions this issue: encoding/csv: allow for interpretation of empty lines