package bufio

Import Path
	bufio (on go.dev)

Dependency Relation
	imports 5 packages, and imported by 13 packages

Involved Source Files

	  d bufio.go
		Package bufio implements buffered I/O. It wraps an io.Reader or io.Writer
		object, creating another object (Reader or Writer) that also implements
		the interface but provides buffering and some help for textual I/O.

	    scan.go
Code Examples

	Scanner_Bytes
		package main
		
		import (
			"bufio"
			"fmt"
			"os"
			"strings"
		)
		
		func main() {
			scanner := bufio.NewScanner(strings.NewReader("gopher"))
			for scanner.Scan() {
				fmt.Println(len(scanner.Bytes()) == 6)
			}
			if err := scanner.Err(); err != nil {
				fmt.Fprintln(os.Stderr, "shouldn't see an error scanning a string")
			}
		}

	Scanner_custom
		package main
		
		import (
			"bufio"
			"fmt"
			"strconv"
			"strings"
		)
		
		func main() {
			// An artificial input source.
			const input = "1234 5678 1234567901234567890"
			scanner := bufio.NewScanner(strings.NewReader(input))
			// Create a custom split function by wrapping the existing ScanWords function.
			split := func(data []byte, atEOF bool) (advance int, token []byte, err error) {
				advance, token, err = bufio.ScanWords(data, atEOF)
				if err == nil && token != nil {
					_, err = strconv.ParseInt(string(token), 10, 32)
				}
				return
			}
			// Set the split function for the scanning operation.
			scanner.Split(split)
			// Validate the input
			for scanner.Scan() {
				fmt.Printf("%s\n", scanner.Text())
			}
		
			if err := scanner.Err(); err != nil {
				fmt.Printf("Invalid input: %s", err)
			}
		}

	Scanner_emptyFinalToken
		package main
		
		import (
			"bufio"
			"fmt"
			"os"
			"strings"
		)
		
		func main() {
			// Comma-separated list; last entry is empty.
			const input = "1,2,3,4,"
			scanner := bufio.NewScanner(strings.NewReader(input))
			// Define a split function that separates on commas.
			onComma := func(data []byte, atEOF bool) (advance int, token []byte, err error) {
				for i := 0; i < len(data); i++ {
					if data[i] == ',' {
						return i + 1, data[:i], nil
					}
				}
				if !atEOF {
					return 0, nil, nil
				}
				// There is one final token to be delivered, which may be the empty string.
				// Returning bufio.ErrFinalToken here tells Scan there are no more tokens after this
				// but does not trigger an error to be returned from Scan itself.
				return 0, data, bufio.ErrFinalToken
			}
			scanner.Split(onComma)
			// Scan.
			for scanner.Scan() {
				fmt.Printf("%q ", scanner.Text())
			}
			if err := scanner.Err(); err != nil {
				fmt.Fprintln(os.Stderr, "reading input:", err)
			}
		}

	Scanner_lines
		package main
		
		import (
			"bufio"
			"fmt"
			"os"
		)
		
		func main() {
			scanner := bufio.NewScanner(os.Stdin)
			for scanner.Scan() {
				fmt.Println(scanner.Text()) // Println will add back the final '\n'
			}
			if err := scanner.Err(); err != nil {
				fmt.Fprintln(os.Stderr, "reading standard input:", err)
			}
		}

	Scanner_words
		package main
		
		import (
			"bufio"
			"fmt"
			"os"
			"strings"
		)
		
		func main() {
			// An artificial input source.
			const input = "Now is the winter of our discontent,\nMade glorious summer by this sun of York.\n"
			scanner := bufio.NewScanner(strings.NewReader(input))
			// Set the split function for the scanning operation.
			scanner.Split(bufio.ScanWords)
			// Count the words.
			count := 0
			for scanner.Scan() {
				count++
			}
			if err := scanner.Err(); err != nil {
				fmt.Fprintln(os.Stderr, "reading input:", err)
			}
			fmt.Printf("%d\n", count)
		}

	Writer
		package main
		
		import (
			"bufio"
			"fmt"
			"os"
		)
		
		func main() {
			w := bufio.NewWriter(os.Stdout)
			fmt.Fprint(w, "Hello, ")
			fmt.Fprint(w, "world!")
			w.Flush() // Don't forget to flush!
		}

	Writer_AvailableBuffer
		package main
		
		import (
			"bufio"
			"os"
			"strconv"
		)
		
		func main() {
			w := bufio.NewWriter(os.Stdout)
			for _, i := range []int64{1, 2, 3, 4} {
				b := w.AvailableBuffer()
				b = strconv.AppendInt(b, i, 10)
				b = append(b, ' ')
				w.Write(b)
			}
			w.Flush()
		}


Package-Level Type Names (total 5, all are exported)

	/* sort exporteds by: alphabet | popularity */
	 type Reader (struct)
		Reader implements buffering for an io.Reader object.

		Fields (total 7, none are exported)
			/* 7 unexporteds ... *//* 7 unexporteds: */
			buf []byte
			err error
			lastByte int
				// last byte read for UnreadByte; -1 means invalid

			lastRuneSize int
				// size of last rune read for UnreadRune; -1 means invalid

			r int
				// buf read and write positions

			rd io.Reader
				// reader provided by the client

			w int
				// buf read and write positions

		Methods (total 20, in which 15 are exported)
			(*Reader) Buffered() int
				Buffered returns the number of bytes that can be read from the current buffer.

			(*Reader) Discard(n int) (discarded int, err error)
				Discard skips the next n bytes, returning the number of bytes discarded.
				
				If Discard skips fewer than n bytes, it also returns an error.
				If 0 <= n <= b.Buffered(), Discard is guaranteed to succeed without
				reading from the underlying io.Reader.

			(*Reader) Peek(n int) ([]byte, error)
				Peek returns the next n bytes without advancing the reader. The bytes stop
				being valid at the next read call. If Peek returns fewer than n bytes, it
				also returns an error explaining why the read is short. The error is
				ErrBufferFull if n is larger than b's buffer size.
				
				Calling Peek prevents a UnreadByte or UnreadRune call from succeeding
				until the next read operation.

			(*Reader) Read(p []byte) (n int, err error)
				Read reads data into p.
				It returns the number of bytes read into p.
				The bytes are taken from at most one Read on the underlying Reader,
				hence n may be less than len(p).
				To read exactly len(p) bytes, use io.ReadFull(b, p).
				If the underlying Reader can return a non-zero count with io.EOF,
				then this Read method can do so as well; see the [io.Reader] docs.

			(*Reader) ReadByte() (byte, error)
				ReadByte reads and returns a single byte.
				If no byte is available, returns an error.

			(*Reader) ReadBytes(delim byte) ([]byte, error)
				ReadBytes reads until the first occurrence of delim in the input,
				returning a slice containing the data up to and including the delimiter.
				If ReadBytes encounters an error before finding a delimiter,
				it returns the data read before the error and the error itself (often io.EOF).
				ReadBytes returns err != nil if and only if the returned data does not end in
				delim.
				For simple uses, a Scanner may be more convenient.

			(*Reader) ReadLine() (line []byte, isPrefix bool, err error)
				ReadLine is a low-level line-reading primitive. Most callers should use
				ReadBytes('\n') or ReadString('\n') instead or use a Scanner.
				
				ReadLine tries to return a single line, not including the end-of-line bytes.
				If the line was too long for the buffer then isPrefix is set and the
				beginning of the line is returned. The rest of the line will be returned
				from future calls. isPrefix will be false when returning the last fragment
				of the line. The returned buffer is only valid until the next call to
				ReadLine. ReadLine either returns a non-nil line or it returns an error,
				never both.
				
				The text returned from ReadLine does not include the line end ("\r\n" or "\n").
				No indication or error is given if the input ends without a final line end.
				Calling UnreadByte after ReadLine will always unread the last byte read
				(possibly a character belonging to the line end) even if that byte is not
				part of the line returned by ReadLine.

			(*Reader) ReadRune() (r rune, size int, err error)
				ReadRune reads a single UTF-8 encoded Unicode character and returns the
				rune and its size in bytes. If the encoded rune is invalid, it consumes one byte
				and returns unicode.ReplacementChar (U+FFFD) with a size of 1.

			(*Reader) ReadSlice(delim byte) (line []byte, err error)
				ReadSlice reads until the first occurrence of delim in the input,
				returning a slice pointing at the bytes in the buffer.
				The bytes stop being valid at the next read.
				If ReadSlice encounters an error before finding a delimiter,
				it returns all the data in the buffer and the error itself (often io.EOF).
				ReadSlice fails with error ErrBufferFull if the buffer fills without a delim.
				Because the data returned from ReadSlice will be overwritten
				by the next I/O operation, most clients should use
				ReadBytes or ReadString instead.
				ReadSlice returns err != nil if and only if line does not end in delim.

			(*Reader) ReadString(delim byte) (string, error)
				ReadString reads until the first occurrence of delim in the input,
				returning a string containing the data up to and including the delimiter.
				If ReadString encounters an error before finding a delimiter,
				it returns the data read before the error and the error itself (often io.EOF).
				ReadString returns err != nil if and only if the returned data does not end in
				delim.
				For simple uses, a Scanner may be more convenient.

			(*Reader) Reset(r io.Reader)
				Reset discards any buffered data, resets all state, and switches
				the buffered reader to read from r.
				Calling Reset on the zero value of Reader initializes the internal buffer
				to the default size.
				Calling b.Reset(b) (that is, resetting a Reader to itself) does nothing.

			(*Reader) Size() int
				Size returns the size of the underlying buffer in bytes.

			(*Reader) UnreadByte() error
				UnreadByte unreads the last byte. Only the most recently read byte can be unread.
				
				UnreadByte returns an error if the most recent method called on the
				Reader was not a read operation. Notably, Peek, Discard, and WriteTo are not
				considered read operations.

			(*Reader) UnreadRune() error
				UnreadRune unreads the last rune. If the most recent method called on
				the Reader was not a ReadRune, UnreadRune returns an error. (In this
				regard it is stricter than UnreadByte, which will unread the last byte
				from any read operation.)

			(*Reader) WriteTo(w io.Writer) (n int64, err error)
				WriteTo implements io.WriterTo.
				This may make multiple calls to the Read method of the underlying Reader.
				If the underlying reader supports the WriteTo method,
				this calls the underlying WriteTo without buffering.

			/* 5 unexporteds ... *//* 5 unexporteds: */
			(*Reader) collectFragments(delim byte) (fullBuffers [][]byte, finalFragment []byte, totalLen int, err error)
				collectFragments reads until the first occurrence of delim in the input. It
				returns (slice of full buffers, remaining bytes before delim, total number
				of bytes in the combined first two elements, error).
				The complete result is equal to
				`bytes.Join(append(fullBuffers, finalFragment), nil)`, which has a
				length of `totalLen`. The result is structured in this way to allow callers
				to minimize allocations and copies.

			(*Reader) fill()
				fill reads a new chunk into the buffer.

			(*Reader) readErr() error
			(*Reader) reset(buf []byte, r io.Reader)
			(*Reader) writeBuf(w io.Writer) (int64, error)
				writeBuf writes the Reader's buffer to the writer.

		Implements (at least 9, in which 8 are exported)
			*Reader : compress/flate.Reader
			*Reader : github.com/klauspost/compress/flate.Reader
			*Reader : io.ByteReader
			*Reader : io.ByteScanner
			*Reader : io.Reader
			*Reader : io.RuneReader
			*Reader : io.RuneScanner
			*Reader : io.WriterTo
			/* at least one unexported ... *//* at least one unexported: */
			*Reader : image.reader
		As Outputs Of (at least 4, in which 2 are exported)
			func NewReader(rd io.Reader) *Reader
			func NewReaderSize(rd io.Reader, size int) *Reader
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func net/http.newBufioReader(r io.Reader) *Reader
			func nhooyr.io/websocket.getBufioReader(r io.Reader) *Reader
		As Inputs Of (at least 13, in which 4 are exported)
			func NewReadWriter(r *Reader, w *Writer) *ReadWriter
			func net/http.ReadRequest(b *Reader) (*http.Request, error)
			func net/http.ReadResponse(r *Reader, req *http.Request) (*http.Response, error)
			func net/textproto.NewReader(r *Reader) *textproto.Reader
			/* 9+ unexporteds ... *//* 9+ unexporteds: */
			func net/http.newReadWriteCloserBody(br *Reader, rwc io.ReadWriteCloser) io.ReadWriteCloser
			func net/http.newTextprotoReader(br *Reader) *textproto.Reader
			func net/http.putBufioReader(br *Reader)
			func net/http.readRequest(b *Reader) (req *http.Request, err error)
			func net/http.readTransfer(msg any, r *Reader) (err error)
			func net/http.seeUpcomingDoubleCRLF(r *Reader) bool
			func net/http/internal.readChunkLine(b *Reader) ([]byte, error)
			func nhooyr.io/websocket.putBufioReader(br *Reader)
			func nhooyr.io/websocket.readFrameHeader(r *Reader, readBuf []byte) (h websocket.header, err error)

	 type ReadWriter (struct)
		ReadWriter stores pointers to a Reader and a Writer.
		It implements io.ReadWriter.

		Fields (total 9, in which 2 are exported)
			Reader *Reader
			Writer *Writer
			/* 7 unexporteds ... *//* 7 unexporteds: */
			Reader.lastByte int
				// last byte read for UnreadByte; -1 means invalid

			Reader.lastRuneSize int
				// size of last rune read for UnreadRune; -1 means invalid

			Reader.r int
				// buf read and write positions

			Reader.rd io.Reader
				// reader provided by the client

			Reader.w int
				// buf read and write positions

			Writer.n int
			Writer.wr io.Writer
		Methods (total 25, in which 20 are exported)
			( ReadWriter) Available() int
				Available returns how many bytes are unused in the buffer.

			( ReadWriter) AvailableBuffer() []byte
				AvailableBuffer returns an empty buffer with b.Available() capacity.
				This buffer is intended to be appended to and
				passed to an immediately succeeding Write call.
				The buffer is only valid until the next write operation on b.

			( ReadWriter) Discard(n int) (discarded int, err error)
				Discard skips the next n bytes, returning the number of bytes discarded.
				
				If Discard skips fewer than n bytes, it also returns an error.
				If 0 <= n <= b.Buffered(), Discard is guaranteed to succeed without
				reading from the underlying io.Reader.

			( ReadWriter) Flush() error
				Flush writes any buffered data to the underlying io.Writer.

			( ReadWriter) Peek(n int) ([]byte, error)
				Peek returns the next n bytes without advancing the reader. The bytes stop
				being valid at the next read call. If Peek returns fewer than n bytes, it
				also returns an error explaining why the read is short. The error is
				ErrBufferFull if n is larger than b's buffer size.
				
				Calling Peek prevents a UnreadByte or UnreadRune call from succeeding
				until the next read operation.

			( ReadWriter) Read(p []byte) (n int, err error)
				Read reads data into p.
				It returns the number of bytes read into p.
				The bytes are taken from at most one Read on the underlying Reader,
				hence n may be less than len(p).
				To read exactly len(p) bytes, use io.ReadFull(b, p).
				If the underlying Reader can return a non-zero count with io.EOF,
				then this Read method can do so as well; see the [io.Reader] docs.

			( ReadWriter) ReadByte() (byte, error)
				ReadByte reads and returns a single byte.
				If no byte is available, returns an error.

			( ReadWriter) ReadBytes(delim byte) ([]byte, error)
				ReadBytes reads until the first occurrence of delim in the input,
				returning a slice containing the data up to and including the delimiter.
				If ReadBytes encounters an error before finding a delimiter,
				it returns the data read before the error and the error itself (often io.EOF).
				ReadBytes returns err != nil if and only if the returned data does not end in
				delim.
				For simple uses, a Scanner may be more convenient.

			( ReadWriter) ReadFrom(r io.Reader) (n int64, err error)
				ReadFrom implements io.ReaderFrom. If the underlying writer
				supports the ReadFrom method, this calls the underlying ReadFrom.
				If there is buffered data and an underlying ReadFrom, this fills
				the buffer and writes it before calling ReadFrom.

			( ReadWriter) ReadLine() (line []byte, isPrefix bool, err error)
				ReadLine is a low-level line-reading primitive. Most callers should use
				ReadBytes('\n') or ReadString('\n') instead or use a Scanner.
				
				ReadLine tries to return a single line, not including the end-of-line bytes.
				If the line was too long for the buffer then isPrefix is set and the
				beginning of the line is returned. The rest of the line will be returned
				from future calls. isPrefix will be false when returning the last fragment
				of the line. The returned buffer is only valid until the next call to
				ReadLine. ReadLine either returns a non-nil line or it returns an error,
				never both.
				
				The text returned from ReadLine does not include the line end ("\r\n" or "\n").
				No indication or error is given if the input ends without a final line end.
				Calling UnreadByte after ReadLine will always unread the last byte read
				(possibly a character belonging to the line end) even if that byte is not
				part of the line returned by ReadLine.

			( ReadWriter) ReadRune() (r rune, size int, err error)
				ReadRune reads a single UTF-8 encoded Unicode character and returns the
				rune and its size in bytes. If the encoded rune is invalid, it consumes one byte
				and returns unicode.ReplacementChar (U+FFFD) with a size of 1.

			( ReadWriter) ReadSlice(delim byte) (line []byte, err error)
				ReadSlice reads until the first occurrence of delim in the input,
				returning a slice pointing at the bytes in the buffer.
				The bytes stop being valid at the next read.
				If ReadSlice encounters an error before finding a delimiter,
				it returns all the data in the buffer and the error itself (often io.EOF).
				ReadSlice fails with error ErrBufferFull if the buffer fills without a delim.
				Because the data returned from ReadSlice will be overwritten
				by the next I/O operation, most clients should use
				ReadBytes or ReadString instead.
				ReadSlice returns err != nil if and only if line does not end in delim.

			( ReadWriter) ReadString(delim byte) (string, error)
				ReadString reads until the first occurrence of delim in the input,
				returning a string containing the data up to and including the delimiter.
				If ReadString encounters an error before finding a delimiter,
				it returns the data read before the error and the error itself (often io.EOF).
				ReadString returns err != nil if and only if the returned data does not end in
				delim.
				For simple uses, a Scanner may be more convenient.

			( ReadWriter) UnreadByte() error
				UnreadByte unreads the last byte. Only the most recently read byte can be unread.
				
				UnreadByte returns an error if the most recent method called on the
				Reader was not a read operation. Notably, Peek, Discard, and WriteTo are not
				considered read operations.

			( ReadWriter) UnreadRune() error
				UnreadRune unreads the last rune. If the most recent method called on
				the Reader was not a ReadRune, UnreadRune returns an error. (In this
				regard it is stricter than UnreadByte, which will unread the last byte
				from any read operation.)

			( ReadWriter) Write(p []byte) (nn int, err error)
				Write writes the contents of p into the buffer.
				It returns the number of bytes written.
				If nn < len(p), it also returns an error explaining
				why the write is short.

			( ReadWriter) WriteByte(c byte) error
				WriteByte writes a single byte.

			( ReadWriter) WriteRune(r rune) (size int, err error)
				WriteRune writes a single Unicode code point, returning
				the number of bytes written and any error.

			( ReadWriter) WriteString(s string) (int, error)
				WriteString writes a string.
				It returns the number of bytes written.
				If the count is less than len(s), it also returns an error explaining
				why the write is short.

			( ReadWriter) WriteTo(w io.Writer) (n int64, err error)
				WriteTo implements io.WriterTo.
				This may make multiple calls to the Read method of the underlying Reader.
				If the underlying reader supports the WriteTo method,
				this calls the underlying WriteTo without buffering.

			/* 5 unexporteds ... *//* 5 unexporteds: */
			( ReadWriter) collectFragments(delim byte) (fullBuffers [][]byte, finalFragment []byte, totalLen int, err error)
				collectFragments reads until the first occurrence of delim in the input. It
				returns (slice of full buffers, remaining bytes before delim, total number
				of bytes in the combined first two elements, error).
				The complete result is equal to
				`bytes.Join(append(fullBuffers, finalFragment), nil)`, which has a
				length of `totalLen`. The result is structured in this way to allow callers
				to minimize allocations and copies.

			( ReadWriter) fill()
				fill reads a new chunk into the buffer.

			( ReadWriter) readErr() error
			( ReadWriter) reset(buf []byte, r io.Reader)
			( ReadWriter) writeBuf(w io.Writer) (int64, error)
				writeBuf writes the Reader's buffer to the writer.

		Implements (at least 17, in which 14 are exported)
			 ReadWriter : compress/flate.Reader
			 ReadWriter : github.com/klauspost/compress/flate.Reader
			 ReadWriter : internal/bisect.Writer
			 ReadWriter : io.ByteReader
			 ReadWriter : io.ByteScanner
			 ReadWriter : io.ByteWriter
			 ReadWriter : io.Reader
			 ReadWriter : io.ReaderFrom
			 ReadWriter : io.ReadWriter
			 ReadWriter : io.RuneReader
			 ReadWriter : io.RuneScanner
			 ReadWriter : io.StringWriter
			 ReadWriter : io.Writer
			 ReadWriter : io.WriterTo
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			 ReadWriter : crypto/tls.transcriptHash
			 ReadWriter : image.reader
			 ReadWriter : net/http.http2stringWriter
		As Outputs Of (at least 3, all are exported)
			func NewReadWriter(r *Reader, w *Writer) *ReadWriter
			func net/http.Hijacker.Hijack() (net.Conn, *ReadWriter, error)
			func net/http.(*ResponseController).Hijack() (net.Conn, *ReadWriter, error)

	 type Scanner (struct)
		Scanner provides a convenient interface for reading data such as
		a file of newline-delimited lines of text. Successive calls to
		the Scan method will step through the 'tokens' of a file, skipping
		the bytes between the tokens. The specification of a token is
		defined by a split function of type SplitFunc; the default split
		function breaks the input into lines with line termination stripped. Split
		functions are defined in this package for scanning a file into
		lines, bytes, UTF-8-encoded runes, and space-delimited words. The
		client may instead provide a custom split function.
		
		Scanning stops unrecoverably at EOF, the first I/O error, or a token too
		large to fit in the buffer. When a scan stops, the reader may have
		advanced arbitrarily far past the last token. Programs that need more
		control over error handling or large tokens, or must run sequential scans
		on a reader, should use bufio.Reader instead.

		Fields (total 11, none are exported)
			/* 11 unexporteds ... *//* 11 unexporteds: */
			buf []byte
				// Buffer used as argument to split.

			done bool
				// Scan has finished.

			empties int
				// Count of successive empty tokens.

			end int
				// End of data in buf.

			err error
				// Sticky error.

			maxTokenSize int
				// Maximum size of a token; modified by tests.

			r io.Reader
				// The reader provided by the client.

			scanCalled bool
				// Scan has been called; buffer is in use.

			split SplitFunc
				// The function to split the tokens.

			start int
				// First non-processed byte in buf.

			token []byte
				// Last token returned by split.

		Methods (total 8, in which 6 are exported)
			(*Scanner) Buffer(buf []byte, max int)
				Buffer sets the initial buffer to use when scanning and the maximum
				size of buffer that may be allocated during scanning. The maximum
				token size is the larger of max and cap(buf). If max <= cap(buf),
				Scan will use this buffer only and do no allocation.
				
				By default, Scan uses an internal buffer and sets the
				maximum token size to MaxScanTokenSize.
				
				Buffer panics if it is called after scanning has started.

			(*Scanner) Bytes() []byte
				Bytes returns the most recent token generated by a call to Scan.
				The underlying array may point to data that will be overwritten
				by a subsequent call to Scan. It does no allocation.

			(*Scanner) Err() error
				Err returns the first non-EOF error that was encountered by the Scanner.

			(*Scanner) Scan() bool
				Scan advances the Scanner to the next token, which will then be
				available through the Bytes or Text method. It returns false when the
				scan stops, either by reaching the end of the input or an error.
				After Scan returns false, the Err method will return any error that
				occurred during scanning, except that if it was io.EOF, Err
				will return nil.
				Scan panics if the split function returns too many empty
				tokens without advancing the input. This is a common error mode for
				scanners.

			(*Scanner) Split(split SplitFunc)
				Split sets the split function for the Scanner.
				The default split function is ScanLines.
				
				Split panics if it is called after scanning has started.

			(*Scanner) Text() string
				Text returns the most recent token generated by a call to Scan
				as a newly allocated string holding its bytes.

			/* 2 unexporteds ... *//* 2 unexporteds: */
			(*Scanner) advance(n int) bool
				advance consumes n bytes of the buffer. It reports whether the advance was legal.

			(*Scanner) setErr(err error)
				setErr records the first error encountered.

		As Outputs Of (at least one exported)
			func NewScanner(r io.Reader) *Scanner

	 type SplitFunc (func)
		SplitFunc is the signature of the split function used to tokenize the
		input. The arguments are an initial substring of the remaining unprocessed
		data and a flag, atEOF, that reports whether the Reader has no more data
		to give. The return values are the number of bytes to advance the input
		and the next token to return to the user, if any, plus an error, if any.
		
		Scanning stops if the function returns an error, in which case some of
		the input may be discarded. If that error is ErrFinalToken, scanning
		stops with no error.
		
		Otherwise, the Scanner advances the input. If the token is not nil,
		the Scanner returns it to the user. If the token is nil, the
		Scanner reads more data and continues scanning; if there is no more
		data--if atEOF was true--the Scanner returns. If the data does not
		yet hold a complete token, for instance if it has no newline while
		scanning lines, a SplitFunc can return (0, nil, nil) to signal the
		Scanner to read more data into the slice and try again with a
		longer slice starting at the same point in the input.
		
		The function is never called with an empty data slice unless atEOF
		is true. If atEOF is true, however, data may be non-empty and,
		as always, holds unprocessed text.

		As Inputs Of (at least one exported)
			func (*Scanner).Split(split SplitFunc)

	 type Writer (struct)
		Writer implements buffering for an io.Writer object.
		If an error occurs writing to a Writer, no more data will be
		accepted and all subsequent writes, and Flush, will return the error.
		After all data has been written, the client should call the
		Flush method to guarantee all data has been forwarded to
		the underlying io.Writer.

		Fields (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			buf []byte
			err error
			n int
			wr io.Writer
		Methods (total 11, all are exported)
			(*Writer) Available() int
				Available returns how many bytes are unused in the buffer.

			(*Writer) AvailableBuffer() []byte
				AvailableBuffer returns an empty buffer with b.Available() capacity.
				This buffer is intended to be appended to and
				passed to an immediately succeeding Write call.
				The buffer is only valid until the next write operation on b.

			(*Writer) Buffered() int
				Buffered returns the number of bytes that have been written into the current buffer.

			(*Writer) Flush() error
				Flush writes any buffered data to the underlying io.Writer.

			(*Writer) ReadFrom(r io.Reader) (n int64, err error)
				ReadFrom implements io.ReaderFrom. If the underlying writer
				supports the ReadFrom method, this calls the underlying ReadFrom.
				If there is buffered data and an underlying ReadFrom, this fills
				the buffer and writes it before calling ReadFrom.

			(*Writer) Reset(w io.Writer)
				Reset discards any unflushed buffered data, clears any error, and
				resets b to write its output to w.
				Calling Reset on the zero value of Writer initializes the internal buffer
				to the default size.
				Calling w.Reset(w) (that is, resetting a Writer to itself) does nothing.

			(*Writer) Size() int
				Size returns the size of the underlying buffer in bytes.

			(*Writer) Write(p []byte) (nn int, err error)
				Write writes the contents of p into the buffer.
				It returns the number of bytes written.
				If nn < len(p), it also returns an error explaining
				why the write is short.

			(*Writer) WriteByte(c byte) error
				WriteByte writes a single byte.

			(*Writer) WriteRune(r rune) (size int, err error)
				WriteRune writes a single Unicode code point, returning
				the number of bytes written and any error.

			(*Writer) WriteString(s string) (int, error)
				WriteString writes a string.
				It returns the number of bytes written.
				If the count is less than len(s), it also returns an error explaining
				why the write is short.

		Implements (at least 7, in which 5 are exported)
			*Writer : internal/bisect.Writer
			*Writer : io.ByteWriter
			*Writer : io.ReaderFrom
			*Writer : io.StringWriter
			*Writer : io.Writer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			*Writer : crypto/tls.transcriptHash
			*Writer : net/http.http2stringWriter
		As Outputs Of (at least 4, in which 2 are exported)
			func NewWriter(w io.Writer) *Writer
			func NewWriterSize(w io.Writer, size int) *Writer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func net/http.newBufioWriterSize(w io.Writer, size int) *Writer
			func nhooyr.io/websocket.getBufioWriter(w io.Writer) *Writer
		As Inputs Of (at least 7, in which 2 are exported)
			func NewReadWriter(r *Reader, w *Writer) *ReadWriter
			func net/textproto.NewWriter(w *Writer) *textproto.Writer
			/* 5+ unexporteds ... *//* 5+ unexporteds: */
			func net/http.putBufioWriter(bw *Writer)
			func net/http.writeStatusLine(bw *Writer, is11 bool, code int, scratch []byte)
			func nhooyr.io/websocket.extractBufioWriterBuf(bw *Writer, w io.Writer) []byte
			func nhooyr.io/websocket.putBufioWriter(bw *Writer)
			func nhooyr.io/websocket.writeFrameHeader(h websocket.header, w *Writer, buf []byte) (err error)


Package-Level Functions (total 12, in which 10 are exported)

	 func NewReader(rd io.Reader) *Reader
		NewReader returns a new Reader whose buffer has the default size.

	 func NewReaderSize(rd io.Reader, size int) *Reader
		NewReaderSize returns a new Reader whose buffer has at least the specified
		size. If the argument io.Reader is already a Reader with large enough
		size, it returns the underlying Reader.

	 func NewReadWriter(r *Reader, w *Writer) *ReadWriter
		NewReadWriter allocates a new ReadWriter that dispatches to r and w.

	 func NewScanner(r io.Reader) *Scanner
		NewScanner returns a new Scanner to read from r.
		The split function defaults to ScanLines.

	 func NewWriter(w io.Writer) *Writer
		NewWriter returns a new Writer whose buffer has the default size.
		If the argument io.Writer is already a Writer with large enough buffer size,
		it returns the underlying Writer.

	 func NewWriterSize(w io.Writer, size int) *Writer
		NewWriterSize returns a new Writer whose buffer has at least the specified
		size. If the argument io.Writer is already a Writer with large enough
		size, it returns the underlying Writer.

	 func ScanBytes(data []byte, atEOF bool) (advance int, token []byte, err error)
		ScanBytes is a split function for a Scanner that returns each byte as a token.

	 func ScanLines(data []byte, atEOF bool) (advance int, token []byte, err error)
		ScanLines is a split function for a Scanner that returns each line of
		text, stripped of any trailing end-of-line marker. The returned line may
		be empty. The end-of-line marker is one optional carriage return followed
		by one mandatory newline. In regular expression notation, it is `\r?\n`.
		The last non-empty line of input will be returned even if it has no
		newline.

	 func ScanRunes(data []byte, atEOF bool) (advance int, token []byte, err error)
		ScanRunes is a split function for a Scanner that returns each
		UTF-8-encoded rune as a token. The sequence of runes returned is
		equivalent to that from a range loop over the input as a string, which
		means that erroneous UTF-8 encodings translate to U+FFFD = "\xef\xbf\xbd".
		Because of the Scan interface, this makes it impossible for the client to
		distinguish correctly encoded replacement runes from encoding errors.

	 func ScanWords(data []byte, atEOF bool) (advance int, token []byte, err error)
		ScanWords is a split function for a Scanner that returns each
		space-separated word of text, with surrounding spaces deleted. It will
		never return an empty string. The definition of space is set by
		unicode.IsSpace.

	/* 2 unexporteds ... *//* 2 unexporteds: */
	 func dropCR(data []byte) []byte
		dropCR drops a terminal \r from the data.

	 func isSpace(r rune) bool
		isSpace reports whether the character is a Unicode white space character.
		We avoid dependency on the unicode package, but check validity of the implementation
		in the tests.


Package-Level Variables (total 12, in which 9 are exported)

	  var ErrAdvanceTooFar error
		Errors returned by Scanner.

	  var ErrBadReadCount error
		Errors returned by Scanner.

	  var ErrBufferFull error
	  var ErrFinalToken error
		ErrFinalToken is a special sentinel error value. It is intended to be
		returned by a Split function to indicate that the token being delivered
		with the error is the last token and scanning should stop after this one.
		After ErrFinalToken is received by Scan, scanning stops with no error.
		The value is useful to stop processing early or when it is necessary to
		deliver a final empty token. One could achieve the same behavior
		with a custom error value but providing one here is tidier.
		See the emptyFinalToken example for a use of this value.

	  var ErrInvalidUnreadByte error
	  var ErrInvalidUnreadRune error
	  var ErrNegativeAdvance error
		Errors returned by Scanner.

	  var ErrNegativeCount error
	  var ErrTooLong error
		Errors returned by Scanner.

	/* 3 unexporteds ... *//* 3 unexporteds: */
	  var errNegativeRead error
	  var errNegativeWrite error
	  var errorRune []byte
Package-Level Constants (total 5, in which 1 is exported)

	const MaxScanTokenSize = 65536
		MaxScanTokenSize is the maximum size used to buffer a token
		unless the user provides an explicit buffer with Scanner.Buffer.
		The actual maximum token size may be smaller as the buffer
		may need to include, for instance, a newline.

	/* 4 unexporteds ... *//* 4 unexporteds: */
	const defaultBufSize = 4096
	const maxConsecutiveEmptyReads = 100
	const minReadBufferSize = 16
	const startBufSize = 4096 // Size of initial allocation for buffer.

The pages are generated with Golds v0.6.7. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.