io

package
v0.0.0-...-5012a73 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Jun 20, 2019 License: MIT Imports: 2 Imported by: 0

Documentation

Index

Constants

View Source
const ByteReaderCAP = 10

ByteReaderCAP is the capacity of the buffered proxy channel

View Source
const ByteReaderQUE = 16

ByteReaderQUE is the allocated size of the circular queue

View Source
const ByteScannerCAP = 10

ByteScannerCAP is the capacity of the buffered proxy channel

View Source
const ByteScannerQUE = 16

ByteScannerQUE is the allocated size of the circular queue

View Source
const ByteWriterCAP = 10

ByteWriterCAP is the capacity of the buffered proxy channel

View Source
const ByteWriterQUE = 16

ByteWriterQUE is the allocated size of the circular queue

View Source
const CloserCAP = 10

CloserCAP is the capacity of the buffered proxy channel

View Source
const CloserQUE = 16

CloserQUE is the allocated size of the circular queue

View Source
const LimitedReaderCAP = 10

LimitedReaderCAP is the capacity of the buffered proxy channel

View Source
const LimitedReaderQUE = 16

LimitedReaderQUE is the allocated size of the circular queue

View Source
const PipeReaderCAP = 10

PipeReaderCAP is the capacity of the buffered proxy channel

View Source
const PipeReaderQUE = 16

PipeReaderQUE is the allocated size of the circular queue

View Source
const PipeWriterCAP = 10

PipeWriterCAP is the capacity of the buffered proxy channel

View Source
const PipeWriterQUE = 16

PipeWriterQUE is the allocated size of the circular queue

View Source
const ReadCloserCAP = 10

ReadCloserCAP is the capacity of the buffered proxy channel

View Source
const ReadCloserQUE = 16

ReadCloserQUE is the allocated size of the circular queue

View Source
const ReadSeekerCAP = 10

ReadSeekerCAP is the capacity of the buffered proxy channel

View Source
const ReadSeekerQUE = 16

ReadSeekerQUE is the allocated size of the circular queue

View Source
const ReadWriteCloserCAP = 10

ReadWriteCloserCAP is the capacity of the buffered proxy channel

View Source
const ReadWriteCloserQUE = 16

ReadWriteCloserQUE is the allocated size of the circular queue

View Source
const ReadWriteSeekerCAP = 10

ReadWriteSeekerCAP is the capacity of the buffered proxy channel

View Source
const ReadWriteSeekerQUE = 16

ReadWriteSeekerQUE is the allocated size of the circular queue

View Source
const ReadWriterCAP = 10

ReadWriterCAP is the capacity of the buffered proxy channel

View Source
const ReadWriterQUE = 16

ReadWriterQUE is the allocated size of the circular queue

View Source
const ReaderAtCAP = 10

ReaderAtCAP is the capacity of the buffered proxy channel

View Source
const ReaderAtQUE = 16

ReaderAtQUE is the allocated size of the circular queue

View Source
const ReaderCAP = 10

ReaderCAP is the capacity of the buffered proxy channel

View Source
const ReaderFromCAP = 10

ReaderFromCAP is the capacity of the buffered proxy channel

View Source
const ReaderFromQUE = 16

ReaderFromQUE is the allocated size of the circular queue

View Source
const ReaderQUE = 16

ReaderQUE is the allocated size of the circular queue

View Source
const RuneReaderCAP = 10

RuneReaderCAP is the capacity of the buffered proxy channel

View Source
const RuneReaderQUE = 16

RuneReaderQUE is the allocated size of the circular queue

View Source
const RuneScannerCAP = 10

RuneScannerCAP is the capacity of the buffered proxy channel

View Source
const RuneScannerQUE = 16

RuneScannerQUE is the allocated size of the circular queue

View Source
const SectionReaderCAP = 10

SectionReaderCAP is the capacity of the buffered proxy channel

View Source
const SectionReaderQUE = 16

SectionReaderQUE is the allocated size of the circular queue

View Source
const SeekerCAP = 10

SeekerCAP is the capacity of the buffered proxy channel

View Source
const SeekerQUE = 16

SeekerQUE is the allocated size of the circular queue

View Source
const WriteCloserCAP = 10

WriteCloserCAP is the capacity of the buffered proxy channel

View Source
const WriteCloserQUE = 16

WriteCloserQUE is the allocated size of the circular queue

View Source
const WriteSeekerCAP = 10

WriteSeekerCAP is the capacity of the buffered proxy channel

View Source
const WriteSeekerQUE = 16

WriteSeekerQUE is the allocated size of the circular queue

View Source
const WriterAtCAP = 10

WriterAtCAP is the capacity of the buffered proxy channel

View Source
const WriterAtQUE = 16

WriterAtQUE is the allocated size of the circular queue

View Source
const WriterCAP = 10

WriterCAP is the capacity of the buffered proxy channel

View Source
const WriterQUE = 16

WriterQUE is the allocated size of the circular queue

View Source
const WriterToCAP = 10

WriterToCAP is the capacity of the buffered proxy channel

View Source
const WriterToQUE = 16

WriterToQUE is the allocated size of the circular queue

Variables

This section is empty.

Functions

func ByteReaderDaisy

func ByteReaderDaisy(inp <-chan io.ByteReader, tube ByteReaderTube) (out <-chan io.ByteReader)

ByteReaderDaisy returns a channel to receive all inp after having passed thru tube.

func ByteReaderDaisyChain

func ByteReaderDaisyChain(inp <-chan io.ByteReader, tubes ...ByteReaderTube) (out <-chan io.ByteReader)

ByteReaderDaisyChain returns a channel to receive all inp after having passed thru all tubes.

func ByteScannerDaisy

func ByteScannerDaisy(inp <-chan io.ByteScanner, tube ByteScannerTube) (out <-chan io.ByteScanner)

ByteScannerDaisy returns a channel to receive all inp after having passed thru tube.

func ByteScannerDaisyChain

func ByteScannerDaisyChain(inp <-chan io.ByteScanner, tubes ...ByteScannerTube) (out <-chan io.ByteScanner)

ByteScannerDaisyChain returns a channel to receive all inp after having passed thru all tubes.

func ByteWriterDaisy

func ByteWriterDaisy(inp <-chan io.ByteWriter, tube ByteWriterTube) (out <-chan io.ByteWriter)

ByteWriterDaisy returns a channel to receive all inp after having passed thru tube.

func ByteWriterDaisyChain

func ByteWriterDaisyChain(inp <-chan io.ByteWriter, tubes ...ByteWriterTube) (out <-chan io.ByteWriter)

ByteWriterDaisyChain returns a channel to receive all inp after having passed thru all tubes.

func ChanByteReader

func ChanByteReader(inp ...io.ByteReader) (out <-chan io.ByteReader)

ChanByteReader returns a channel to receive all inputs before close.

func ChanByteReaderFuncErr

func ChanByteReaderFuncErr(act func() (io.ByteReader, error)) (out <-chan io.ByteReader)

ChanByteReaderFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanByteReaderFuncNok

func ChanByteReaderFuncNok(act func() (io.ByteReader, bool)) (out <-chan io.ByteReader)

ChanByteReaderFuncNok returns a channel to receive all results of act until nok before close.

func ChanByteReaderSlice

func ChanByteReaderSlice(inp ...[]io.ByteReader) (out <-chan io.ByteReader)

ChanByteReaderSlice returns a channel to receive all inputs before close.

func ChanByteScanner

func ChanByteScanner(inp ...io.ByteScanner) (out <-chan io.ByteScanner)

ChanByteScanner returns a channel to receive all inputs before close.

func ChanByteScannerFuncErr

func ChanByteScannerFuncErr(act func() (io.ByteScanner, error)) (out <-chan io.ByteScanner)

ChanByteScannerFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanByteScannerFuncNok

func ChanByteScannerFuncNok(act func() (io.ByteScanner, bool)) (out <-chan io.ByteScanner)

ChanByteScannerFuncNok returns a channel to receive all results of act until nok before close.

func ChanByteScannerSlice

func ChanByteScannerSlice(inp ...[]io.ByteScanner) (out <-chan io.ByteScanner)

ChanByteScannerSlice returns a channel to receive all inputs before close.

func ChanByteWriter

func ChanByteWriter(inp ...io.ByteWriter) (out <-chan io.ByteWriter)

ChanByteWriter returns a channel to receive all inputs before close.

func ChanByteWriterFuncErr

func ChanByteWriterFuncErr(act func() (io.ByteWriter, error)) (out <-chan io.ByteWriter)

ChanByteWriterFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanByteWriterFuncNok

func ChanByteWriterFuncNok(act func() (io.ByteWriter, bool)) (out <-chan io.ByteWriter)

ChanByteWriterFuncNok returns a channel to receive all results of act until nok before close.

func ChanByteWriterSlice

func ChanByteWriterSlice(inp ...[]io.ByteWriter) (out <-chan io.ByteWriter)

ChanByteWriterSlice returns a channel to receive all inputs before close.

func ChanCloser

func ChanCloser(inp ...io.Closer) (out <-chan io.Closer)

ChanCloser returns a channel to receive all inputs before close.

func ChanCloserFuncErr

func ChanCloserFuncErr(act func() (io.Closer, error)) (out <-chan io.Closer)

ChanCloserFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanCloserFuncNok

func ChanCloserFuncNok(act func() (io.Closer, bool)) (out <-chan io.Closer)

ChanCloserFuncNok returns a channel to receive all results of act until nok before close.

func ChanCloserSlice

func ChanCloserSlice(inp ...[]io.Closer) (out <-chan io.Closer)

ChanCloserSlice returns a channel to receive all inputs before close.

func ChanLimitedReader

func ChanLimitedReader(inp ...*io.LimitedReader) (out <-chan *io.LimitedReader)

ChanLimitedReader returns a channel to receive all inputs before close.

func ChanLimitedReaderFuncErr

func ChanLimitedReaderFuncErr(act func() (*io.LimitedReader, error)) (out <-chan *io.LimitedReader)

ChanLimitedReaderFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanLimitedReaderFuncNok

func ChanLimitedReaderFuncNok(act func() (*io.LimitedReader, bool)) (out <-chan *io.LimitedReader)

ChanLimitedReaderFuncNok returns a channel to receive all results of act until nok before close.

func ChanLimitedReaderSlice

func ChanLimitedReaderSlice(inp ...[]*io.LimitedReader) (out <-chan *io.LimitedReader)

ChanLimitedReaderSlice returns a channel to receive all inputs before close.

func ChanPipeReader

func ChanPipeReader(inp ...*io.PipeReader) (out <-chan *io.PipeReader)

ChanPipeReader returns a channel to receive all inputs before close.

func ChanPipeReaderFuncErr

func ChanPipeReaderFuncErr(act func() (*io.PipeReader, error)) (out <-chan *io.PipeReader)

ChanPipeReaderFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanPipeReaderFuncNok

func ChanPipeReaderFuncNok(act func() (*io.PipeReader, bool)) (out <-chan *io.PipeReader)

ChanPipeReaderFuncNok returns a channel to receive all results of act until nok before close.

func ChanPipeReaderSlice

func ChanPipeReaderSlice(inp ...[]*io.PipeReader) (out <-chan *io.PipeReader)

ChanPipeReaderSlice returns a channel to receive all inputs before close.

func ChanPipeWriter

func ChanPipeWriter(inp ...*io.PipeWriter) (out <-chan *io.PipeWriter)

ChanPipeWriter returns a channel to receive all inputs before close.

func ChanPipeWriterFuncErr

func ChanPipeWriterFuncErr(act func() (*io.PipeWriter, error)) (out <-chan *io.PipeWriter)

ChanPipeWriterFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanPipeWriterFuncNok

func ChanPipeWriterFuncNok(act func() (*io.PipeWriter, bool)) (out <-chan *io.PipeWriter)

ChanPipeWriterFuncNok returns a channel to receive all results of act until nok before close.

func ChanPipeWriterSlice

func ChanPipeWriterSlice(inp ...[]*io.PipeWriter) (out <-chan *io.PipeWriter)

ChanPipeWriterSlice returns a channel to receive all inputs before close.

func ChanReadCloser

func ChanReadCloser(inp ...io.ReadCloser) (out <-chan io.ReadCloser)

ChanReadCloser returns a channel to receive all inputs before close.

func ChanReadCloserFuncErr

func ChanReadCloserFuncErr(act func() (io.ReadCloser, error)) (out <-chan io.ReadCloser)

ChanReadCloserFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanReadCloserFuncNok

func ChanReadCloserFuncNok(act func() (io.ReadCloser, bool)) (out <-chan io.ReadCloser)

ChanReadCloserFuncNok returns a channel to receive all results of act until nok before close.

func ChanReadCloserSlice

func ChanReadCloserSlice(inp ...[]io.ReadCloser) (out <-chan io.ReadCloser)

ChanReadCloserSlice returns a channel to receive all inputs before close.

func ChanReadSeeker

func ChanReadSeeker(inp ...io.ReadSeeker) (out <-chan io.ReadSeeker)

ChanReadSeeker returns a channel to receive all inputs before close.

func ChanReadSeekerFuncErr

func ChanReadSeekerFuncErr(act func() (io.ReadSeeker, error)) (out <-chan io.ReadSeeker)

ChanReadSeekerFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanReadSeekerFuncNok

func ChanReadSeekerFuncNok(act func() (io.ReadSeeker, bool)) (out <-chan io.ReadSeeker)

ChanReadSeekerFuncNok returns a channel to receive all results of act until nok before close.

func ChanReadSeekerSlice

func ChanReadSeekerSlice(inp ...[]io.ReadSeeker) (out <-chan io.ReadSeeker)

ChanReadSeekerSlice returns a channel to receive all inputs before close.

func ChanReadWriteCloser

func ChanReadWriteCloser(inp ...io.ReadWriteCloser) (out <-chan io.ReadWriteCloser)

ChanReadWriteCloser returns a channel to receive all inputs before close.

func ChanReadWriteCloserFuncErr

func ChanReadWriteCloserFuncErr(act func() (io.ReadWriteCloser, error)) (out <-chan io.ReadWriteCloser)

ChanReadWriteCloserFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanReadWriteCloserFuncNok

func ChanReadWriteCloserFuncNok(act func() (io.ReadWriteCloser, bool)) (out <-chan io.ReadWriteCloser)

ChanReadWriteCloserFuncNok returns a channel to receive all results of act until nok before close.

func ChanReadWriteCloserSlice

func ChanReadWriteCloserSlice(inp ...[]io.ReadWriteCloser) (out <-chan io.ReadWriteCloser)

ChanReadWriteCloserSlice returns a channel to receive all inputs before close.

func ChanReadWriteSeeker

func ChanReadWriteSeeker(inp ...io.ReadWriteSeeker) (out <-chan io.ReadWriteSeeker)

ChanReadWriteSeeker returns a channel to receive all inputs before close.

func ChanReadWriteSeekerFuncErr

func ChanReadWriteSeekerFuncErr(act func() (io.ReadWriteSeeker, error)) (out <-chan io.ReadWriteSeeker)

ChanReadWriteSeekerFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanReadWriteSeekerFuncNok

func ChanReadWriteSeekerFuncNok(act func() (io.ReadWriteSeeker, bool)) (out <-chan io.ReadWriteSeeker)

ChanReadWriteSeekerFuncNok returns a channel to receive all results of act until nok before close.

func ChanReadWriteSeekerSlice

func ChanReadWriteSeekerSlice(inp ...[]io.ReadWriteSeeker) (out <-chan io.ReadWriteSeeker)

ChanReadWriteSeekerSlice returns a channel to receive all inputs before close.

func ChanReadWriter

func ChanReadWriter(inp ...io.ReadWriter) (out <-chan io.ReadWriter)

ChanReadWriter returns a channel to receive all inputs before close.

func ChanReadWriterFuncErr

func ChanReadWriterFuncErr(act func() (io.ReadWriter, error)) (out <-chan io.ReadWriter)

ChanReadWriterFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanReadWriterFuncNok

func ChanReadWriterFuncNok(act func() (io.ReadWriter, bool)) (out <-chan io.ReadWriter)

ChanReadWriterFuncNok returns a channel to receive all results of act until nok before close.

func ChanReadWriterSlice

func ChanReadWriterSlice(inp ...[]io.ReadWriter) (out <-chan io.ReadWriter)

ChanReadWriterSlice returns a channel to receive all inputs before close.

func ChanReader

func ChanReader(inp ...io.Reader) (out <-chan io.Reader)

ChanReader returns a channel to receive all inputs before close.

func ChanReaderAt

func ChanReaderAt(inp ...io.ReaderAt) (out <-chan io.ReaderAt)

ChanReaderAt returns a channel to receive all inputs before close.

func ChanReaderAtFuncErr

func ChanReaderAtFuncErr(act func() (io.ReaderAt, error)) (out <-chan io.ReaderAt)

ChanReaderAtFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanReaderAtFuncNok

func ChanReaderAtFuncNok(act func() (io.ReaderAt, bool)) (out <-chan io.ReaderAt)

ChanReaderAtFuncNok returns a channel to receive all results of act until nok before close.

func ChanReaderAtSlice

func ChanReaderAtSlice(inp ...[]io.ReaderAt) (out <-chan io.ReaderAt)

ChanReaderAtSlice returns a channel to receive all inputs before close.

func ChanReaderFrom

func ChanReaderFrom(inp ...io.ReaderFrom) (out <-chan io.ReaderFrom)

ChanReaderFrom returns a channel to receive all inputs before close.

func ChanReaderFromFuncErr

func ChanReaderFromFuncErr(act func() (io.ReaderFrom, error)) (out <-chan io.ReaderFrom)

ChanReaderFromFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanReaderFromFuncNok

func ChanReaderFromFuncNok(act func() (io.ReaderFrom, bool)) (out <-chan io.ReaderFrom)

ChanReaderFromFuncNok returns a channel to receive all results of act until nok before close.

func ChanReaderFromSlice

func ChanReaderFromSlice(inp ...[]io.ReaderFrom) (out <-chan io.ReaderFrom)

ChanReaderFromSlice returns a channel to receive all inputs before close.

func ChanReaderFuncErr

func ChanReaderFuncErr(act func() (io.Reader, error)) (out <-chan io.Reader)

ChanReaderFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanReaderFuncNok

func ChanReaderFuncNok(act func() (io.Reader, bool)) (out <-chan io.Reader)

ChanReaderFuncNok returns a channel to receive all results of act until nok before close.

func ChanReaderSlice

func ChanReaderSlice(inp ...[]io.Reader) (out <-chan io.Reader)

ChanReaderSlice returns a channel to receive all inputs before close.

func ChanRuneReader

func ChanRuneReader(inp ...io.RuneReader) (out <-chan io.RuneReader)

ChanRuneReader returns a channel to receive all inputs before close.

func ChanRuneReaderFuncErr

func ChanRuneReaderFuncErr(act func() (io.RuneReader, error)) (out <-chan io.RuneReader)

ChanRuneReaderFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanRuneReaderFuncNok

func ChanRuneReaderFuncNok(act func() (io.RuneReader, bool)) (out <-chan io.RuneReader)

ChanRuneReaderFuncNok returns a channel to receive all results of act until nok before close.

func ChanRuneReaderSlice

func ChanRuneReaderSlice(inp ...[]io.RuneReader) (out <-chan io.RuneReader)

ChanRuneReaderSlice returns a channel to receive all inputs before close.

func ChanRuneScanner

func ChanRuneScanner(inp ...io.RuneScanner) (out <-chan io.RuneScanner)

ChanRuneScanner returns a channel to receive all inputs before close.

func ChanRuneScannerFuncErr

func ChanRuneScannerFuncErr(act func() (io.RuneScanner, error)) (out <-chan io.RuneScanner)

ChanRuneScannerFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanRuneScannerFuncNok

func ChanRuneScannerFuncNok(act func() (io.RuneScanner, bool)) (out <-chan io.RuneScanner)

ChanRuneScannerFuncNok returns a channel to receive all results of act until nok before close.

func ChanRuneScannerSlice

func ChanRuneScannerSlice(inp ...[]io.RuneScanner) (out <-chan io.RuneScanner)

ChanRuneScannerSlice returns a channel to receive all inputs before close.

func ChanSectionReader

func ChanSectionReader(inp ...*io.SectionReader) (out <-chan *io.SectionReader)

ChanSectionReader returns a channel to receive all inputs before close.

func ChanSectionReaderFuncErr

func ChanSectionReaderFuncErr(act func() (*io.SectionReader, error)) (out <-chan *io.SectionReader)

ChanSectionReaderFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanSectionReaderFuncNok

func ChanSectionReaderFuncNok(act func() (*io.SectionReader, bool)) (out <-chan *io.SectionReader)

ChanSectionReaderFuncNok returns a channel to receive all results of act until nok before close.

func ChanSectionReaderSlice

func ChanSectionReaderSlice(inp ...[]*io.SectionReader) (out <-chan *io.SectionReader)

ChanSectionReaderSlice returns a channel to receive all inputs before close.

func ChanSeeker

func ChanSeeker(inp ...io.Seeker) (out <-chan io.Seeker)

ChanSeeker returns a channel to receive all inputs before close.

func ChanSeekerFuncErr

func ChanSeekerFuncErr(act func() (io.Seeker, error)) (out <-chan io.Seeker)

ChanSeekerFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanSeekerFuncNok

func ChanSeekerFuncNok(act func() (io.Seeker, bool)) (out <-chan io.Seeker)

ChanSeekerFuncNok returns a channel to receive all results of act until nok before close.

func ChanSeekerSlice

func ChanSeekerSlice(inp ...[]io.Seeker) (out <-chan io.Seeker)

ChanSeekerSlice returns a channel to receive all inputs before close.

func ChanWriteCloser

func ChanWriteCloser(inp ...io.WriteCloser) (out <-chan io.WriteCloser)

ChanWriteCloser returns a channel to receive all inputs before close.

func ChanWriteCloserFuncErr

func ChanWriteCloserFuncErr(act func() (io.WriteCloser, error)) (out <-chan io.WriteCloser)

ChanWriteCloserFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanWriteCloserFuncNok

func ChanWriteCloserFuncNok(act func() (io.WriteCloser, bool)) (out <-chan io.WriteCloser)

ChanWriteCloserFuncNok returns a channel to receive all results of act until nok before close.

func ChanWriteCloserSlice

func ChanWriteCloserSlice(inp ...[]io.WriteCloser) (out <-chan io.WriteCloser)

ChanWriteCloserSlice returns a channel to receive all inputs before close.

func ChanWriteSeeker

func ChanWriteSeeker(inp ...io.WriteSeeker) (out <-chan io.WriteSeeker)

ChanWriteSeeker returns a channel to receive all inputs before close.

func ChanWriteSeekerFuncErr

func ChanWriteSeekerFuncErr(act func() (io.WriteSeeker, error)) (out <-chan io.WriteSeeker)

ChanWriteSeekerFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanWriteSeekerFuncNok

func ChanWriteSeekerFuncNok(act func() (io.WriteSeeker, bool)) (out <-chan io.WriteSeeker)

ChanWriteSeekerFuncNok returns a channel to receive all results of act until nok before close.

func ChanWriteSeekerSlice

func ChanWriteSeekerSlice(inp ...[]io.WriteSeeker) (out <-chan io.WriteSeeker)

ChanWriteSeekerSlice returns a channel to receive all inputs before close.

func ChanWriter

func ChanWriter(inp ...io.Writer) (out <-chan io.Writer)

ChanWriter returns a channel to receive all inputs before close.

func ChanWriterAt

func ChanWriterAt(inp ...io.WriterAt) (out <-chan io.WriterAt)

ChanWriterAt returns a channel to receive all inputs before close.

func ChanWriterAtFuncErr

func ChanWriterAtFuncErr(act func() (io.WriterAt, error)) (out <-chan io.WriterAt)

ChanWriterAtFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanWriterAtFuncNok

func ChanWriterAtFuncNok(act func() (io.WriterAt, bool)) (out <-chan io.WriterAt)

ChanWriterAtFuncNok returns a channel to receive all results of act until nok before close.

func ChanWriterAtSlice

func ChanWriterAtSlice(inp ...[]io.WriterAt) (out <-chan io.WriterAt)

ChanWriterAtSlice returns a channel to receive all inputs before close.

func ChanWriterFuncErr

func ChanWriterFuncErr(act func() (io.Writer, error)) (out <-chan io.Writer)

ChanWriterFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanWriterFuncNok

func ChanWriterFuncNok(act func() (io.Writer, bool)) (out <-chan io.Writer)

ChanWriterFuncNok returns a channel to receive all results of act until nok before close.

func ChanWriterSlice

func ChanWriterSlice(inp ...[]io.Writer) (out <-chan io.Writer)

ChanWriterSlice returns a channel to receive all inputs before close.

func ChanWriterTo

func ChanWriterTo(inp ...io.WriterTo) (out <-chan io.WriterTo)

ChanWriterTo returns a channel to receive all inputs before close.

func ChanWriterToFuncErr

func ChanWriterToFuncErr(act func() (io.WriterTo, error)) (out <-chan io.WriterTo)

ChanWriterToFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanWriterToFuncNok

func ChanWriterToFuncNok(act func() (io.WriterTo, bool)) (out <-chan io.WriterTo)

ChanWriterToFuncNok returns a channel to receive all results of act until nok before close.

func ChanWriterToSlice

func ChanWriterToSlice(inp ...[]io.WriterTo) (out <-chan io.WriterTo)

ChanWriterToSlice returns a channel to receive all inputs before close.

func CloserDaisy

func CloserDaisy(inp <-chan io.Closer, tube CloserTube) (out <-chan io.Closer)

CloserDaisy returns a channel to receive all inp after having passed thru tube.

func CloserDaisyChain

func CloserDaisyChain(inp <-chan io.Closer, tubes ...CloserTube) (out <-chan io.Closer)

CloserDaisyChain returns a channel to receive all inp after having passed thru all tubes.

func DoneByteReader

func DoneByteReader(inp <-chan io.ByteReader) (done <-chan struct{})

DoneByteReader returns a channel to receive one signal before close after inp has been drained.

func DoneByteReaderFunc

func DoneByteReaderFunc(inp <-chan io.ByteReader, act func(a io.ByteReader)) (out <-chan struct{})

DoneByteReaderFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DoneByteReaderSlice

func DoneByteReaderSlice(inp <-chan io.ByteReader) (done <-chan ([]io.ByteReader))

DoneByteReaderSlice returns a channel which will receive a slice of all the ByteReaders received on inp channel before close. Unlike DoneByteReader, a full slice is sent once, not just an event.

func DoneByteScanner

func DoneByteScanner(inp <-chan io.ByteScanner) (done <-chan struct{})

DoneByteScanner returns a channel to receive one signal before close after inp has been drained.

func DoneByteScannerFunc

func DoneByteScannerFunc(inp <-chan io.ByteScanner, act func(a io.ByteScanner)) (out <-chan struct{})

DoneByteScannerFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DoneByteScannerSlice

func DoneByteScannerSlice(inp <-chan io.ByteScanner) (done <-chan ([]io.ByteScanner))

DoneByteScannerSlice returns a channel which will receive a slice of all the ByteScanners received on inp channel before close. Unlike DoneByteScanner, a full slice is sent once, not just an event.

func DoneByteWriter

func DoneByteWriter(inp <-chan io.ByteWriter) (done <-chan struct{})

DoneByteWriter returns a channel to receive one signal before close after inp has been drained.

func DoneByteWriterFunc

func DoneByteWriterFunc(inp <-chan io.ByteWriter, act func(a io.ByteWriter)) (out <-chan struct{})

DoneByteWriterFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DoneByteWriterSlice

func DoneByteWriterSlice(inp <-chan io.ByteWriter) (done <-chan ([]io.ByteWriter))

DoneByteWriterSlice returns a channel which will receive a slice of all the ByteWriters received on inp channel before close. Unlike DoneByteWriter, a full slice is sent once, not just an event.

func DoneCloser

func DoneCloser(inp <-chan io.Closer) (done <-chan struct{})

DoneCloser returns a channel to receive one signal before close after inp has been drained.

func DoneCloserFunc

func DoneCloserFunc(inp <-chan io.Closer, act func(a io.Closer)) (out <-chan struct{})

DoneCloserFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DoneCloserSlice

func DoneCloserSlice(inp <-chan io.Closer) (done <-chan ([]io.Closer))

DoneCloserSlice returns a channel which will receive a slice of all the Closers received on inp channel before close. Unlike DoneCloser, a full slice is sent once, not just an event.

func DoneLimitedReader

func DoneLimitedReader(inp <-chan *io.LimitedReader) (done <-chan struct{})

DoneLimitedReader returns a channel to receive one signal before close after inp has been drained.

func DoneLimitedReaderFunc

func DoneLimitedReaderFunc(inp <-chan *io.LimitedReader, act func(a *io.LimitedReader)) (out <-chan struct{})

DoneLimitedReaderFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DoneLimitedReaderSlice

func DoneLimitedReaderSlice(inp <-chan *io.LimitedReader) (done <-chan ([]*io.LimitedReader))

DoneLimitedReaderSlice returns a channel which will receive a slice of all the LimitedReaders received on inp channel before close. Unlike DoneLimitedReader, a full slice is sent once, not just an event.

func DonePipeReader

func DonePipeReader(inp <-chan *io.PipeReader) (done <-chan struct{})

DonePipeReader returns a channel to receive one signal before close after inp has been drained.

func DonePipeReaderFunc

func DonePipeReaderFunc(inp <-chan *io.PipeReader, act func(a *io.PipeReader)) (out <-chan struct{})

DonePipeReaderFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DonePipeReaderSlice

func DonePipeReaderSlice(inp <-chan *io.PipeReader) (done <-chan ([]*io.PipeReader))

DonePipeReaderSlice returns a channel which will receive a slice of all the PipeReaders received on inp channel before close. Unlike DonePipeReader, a full slice is sent once, not just an event.

func DonePipeWriter

func DonePipeWriter(inp <-chan *io.PipeWriter) (done <-chan struct{})

DonePipeWriter returns a channel to receive one signal before close after inp has been drained.

func DonePipeWriterFunc

func DonePipeWriterFunc(inp <-chan *io.PipeWriter, act func(a *io.PipeWriter)) (out <-chan struct{})

DonePipeWriterFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DonePipeWriterSlice

func DonePipeWriterSlice(inp <-chan *io.PipeWriter) (done <-chan ([]*io.PipeWriter))

DonePipeWriterSlice returns a channel which will receive a slice of all the PipeWriters received on inp channel before close. Unlike DonePipeWriter, a full slice is sent once, not just an event.

func DoneReadCloser

func DoneReadCloser(inp <-chan io.ReadCloser) (done <-chan struct{})

DoneReadCloser returns a channel to receive one signal before close after inp has been drained.

func DoneReadCloserFunc

func DoneReadCloserFunc(inp <-chan io.ReadCloser, act func(a io.ReadCloser)) (out <-chan struct{})

DoneReadCloserFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DoneReadCloserSlice

func DoneReadCloserSlice(inp <-chan io.ReadCloser) (done <-chan ([]io.ReadCloser))

DoneReadCloserSlice returns a channel which will receive a slice of all the ReadClosers received on inp channel before close. Unlike DoneReadCloser, a full slice is sent once, not just an event.

func DoneReadSeeker

func DoneReadSeeker(inp <-chan io.ReadSeeker) (done <-chan struct{})

DoneReadSeeker returns a channel to receive one signal before close after inp has been drained.

func DoneReadSeekerFunc

func DoneReadSeekerFunc(inp <-chan io.ReadSeeker, act func(a io.ReadSeeker)) (out <-chan struct{})

DoneReadSeekerFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DoneReadSeekerSlice

func DoneReadSeekerSlice(inp <-chan io.ReadSeeker) (done <-chan ([]io.ReadSeeker))

DoneReadSeekerSlice returns a channel which will receive a slice of all the ReadSeekers received on inp channel before close. Unlike DoneReadSeeker, a full slice is sent once, not just an event.

func DoneReadWriteCloser

func DoneReadWriteCloser(inp <-chan io.ReadWriteCloser) (done <-chan struct{})

DoneReadWriteCloser returns a channel to receive one signal before close after inp has been drained.

func DoneReadWriteCloserFunc

func DoneReadWriteCloserFunc(inp <-chan io.ReadWriteCloser, act func(a io.ReadWriteCloser)) (out <-chan struct{})

DoneReadWriteCloserFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DoneReadWriteCloserSlice

func DoneReadWriteCloserSlice(inp <-chan io.ReadWriteCloser) (done <-chan ([]io.ReadWriteCloser))

DoneReadWriteCloserSlice returns a channel which will receive a slice of all the ReadWriteClosers received on inp channel before close. Unlike DoneReadWriteCloser, a full slice is sent once, not just an event.

func DoneReadWriteSeeker

func DoneReadWriteSeeker(inp <-chan io.ReadWriteSeeker) (done <-chan struct{})

DoneReadWriteSeeker returns a channel to receive one signal before close after inp has been drained.

func DoneReadWriteSeekerFunc

func DoneReadWriteSeekerFunc(inp <-chan io.ReadWriteSeeker, act func(a io.ReadWriteSeeker)) (out <-chan struct{})

DoneReadWriteSeekerFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DoneReadWriteSeekerSlice

func DoneReadWriteSeekerSlice(inp <-chan io.ReadWriteSeeker) (done <-chan ([]io.ReadWriteSeeker))

DoneReadWriteSeekerSlice returns a channel which will receive a slice of all the ReadWriteSeekers received on inp channel before close. Unlike DoneReadWriteSeeker, a full slice is sent once, not just an event.

func DoneReadWriter

func DoneReadWriter(inp <-chan io.ReadWriter) (done <-chan struct{})

DoneReadWriter returns a channel to receive one signal before close after inp has been drained.

func DoneReadWriterFunc

func DoneReadWriterFunc(inp <-chan io.ReadWriter, act func(a io.ReadWriter)) (out <-chan struct{})

DoneReadWriterFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DoneReadWriterSlice

func DoneReadWriterSlice(inp <-chan io.ReadWriter) (done <-chan ([]io.ReadWriter))

DoneReadWriterSlice returns a channel which will receive a slice of all the ReadWriters received on inp channel before close. Unlike DoneReadWriter, a full slice is sent once, not just an event.

func DoneReader

func DoneReader(inp <-chan io.Reader) (done <-chan struct{})

DoneReader returns a channel to receive one signal before close after inp has been drained.

func DoneReaderAt

func DoneReaderAt(inp <-chan io.ReaderAt) (done <-chan struct{})

DoneReaderAt returns a channel to receive one signal before close after inp has been drained.

func DoneReaderAtFunc

func DoneReaderAtFunc(inp <-chan io.ReaderAt, act func(a io.ReaderAt)) (out <-chan struct{})

DoneReaderAtFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DoneReaderAtSlice

func DoneReaderAtSlice(inp <-chan io.ReaderAt) (done <-chan ([]io.ReaderAt))

DoneReaderAtSlice returns a channel which will receive a slice of all the ReaderAts received on inp channel before close. Unlike DoneReaderAt, a full slice is sent once, not just an event.

func DoneReaderFrom

func DoneReaderFrom(inp <-chan io.ReaderFrom) (done <-chan struct{})

DoneReaderFrom returns a channel to receive one signal before close after inp has been drained.

func DoneReaderFromFunc

func DoneReaderFromFunc(inp <-chan io.ReaderFrom, act func(a io.ReaderFrom)) (out <-chan struct{})

DoneReaderFromFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DoneReaderFromSlice

func DoneReaderFromSlice(inp <-chan io.ReaderFrom) (done <-chan ([]io.ReaderFrom))

DoneReaderFromSlice returns a channel which will receive a slice of all the ReaderFroms received on inp channel before close. Unlike DoneReaderFrom, a full slice is sent once, not just an event.

func DoneReaderFunc

func DoneReaderFunc(inp <-chan io.Reader, act func(a io.Reader)) (out <-chan struct{})

DoneReaderFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DoneReaderSlice

func DoneReaderSlice(inp <-chan io.Reader) (done <-chan ([]io.Reader))

DoneReaderSlice returns a channel which will receive a slice of all the Readers received on inp channel before close. Unlike DoneReader, a full slice is sent once, not just an event.

func DoneRuneReader

func DoneRuneReader(inp <-chan io.RuneReader) (done <-chan struct{})

DoneRuneReader returns a channel to receive one signal before close after inp has been drained.

func DoneRuneReaderFunc

func DoneRuneReaderFunc(inp <-chan io.RuneReader, act func(a io.RuneReader)) (out <-chan struct{})

DoneRuneReaderFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DoneRuneReaderSlice

func DoneRuneReaderSlice(inp <-chan io.RuneReader) (done <-chan ([]io.RuneReader))

DoneRuneReaderSlice returns a channel which will receive a slice of all the RuneReaders received on inp channel before close. Unlike DoneRuneReader, a full slice is sent once, not just an event.

func DoneRuneScanner

func DoneRuneScanner(inp <-chan io.RuneScanner) (done <-chan struct{})

DoneRuneScanner returns a channel to receive one signal before close after inp has been drained.

func DoneRuneScannerFunc

func DoneRuneScannerFunc(inp <-chan io.RuneScanner, act func(a io.RuneScanner)) (out <-chan struct{})

DoneRuneScannerFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DoneRuneScannerSlice

func DoneRuneScannerSlice(inp <-chan io.RuneScanner) (done <-chan ([]io.RuneScanner))

DoneRuneScannerSlice returns a channel which will receive a slice of all the RuneScanners received on inp channel before close. Unlike DoneRuneScanner, a full slice is sent once, not just an event.

func DoneSectionReader

func DoneSectionReader(inp <-chan *io.SectionReader) (done <-chan struct{})

DoneSectionReader returns a channel to receive one signal before close after inp has been drained.

func DoneSectionReaderFunc

func DoneSectionReaderFunc(inp <-chan *io.SectionReader, act func(a *io.SectionReader)) (out <-chan struct{})

DoneSectionReaderFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DoneSectionReaderSlice

func DoneSectionReaderSlice(inp <-chan *io.SectionReader) (done <-chan ([]*io.SectionReader))

DoneSectionReaderSlice returns a channel which will receive a slice of all the SectionReaders received on inp channel before close. Unlike DoneSectionReader, a full slice is sent once, not just an event.

func DoneSeeker

func DoneSeeker(inp <-chan io.Seeker) (done <-chan struct{})

DoneSeeker returns a channel to receive one signal before close after inp has been drained.

func DoneSeekerFunc

func DoneSeekerFunc(inp <-chan io.Seeker, act func(a io.Seeker)) (out <-chan struct{})

DoneSeekerFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DoneSeekerSlice

func DoneSeekerSlice(inp <-chan io.Seeker) (done <-chan ([]io.Seeker))

DoneSeekerSlice returns a channel which will receive a slice of all the Seekers received on inp channel before close. Unlike DoneSeeker, a full slice is sent once, not just an event.

func DoneWriteCloser

func DoneWriteCloser(inp <-chan io.WriteCloser) (done <-chan struct{})

DoneWriteCloser returns a channel to receive one signal before close after inp has been drained.

func DoneWriteCloserFunc

func DoneWriteCloserFunc(inp <-chan io.WriteCloser, act func(a io.WriteCloser)) (out <-chan struct{})

DoneWriteCloserFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DoneWriteCloserSlice

func DoneWriteCloserSlice(inp <-chan io.WriteCloser) (done <-chan ([]io.WriteCloser))

DoneWriteCloserSlice returns a channel which will receive a slice of all the WriteClosers received on inp channel before close. Unlike DoneWriteCloser, a full slice is sent once, not just an event.

func DoneWriteSeeker

func DoneWriteSeeker(inp <-chan io.WriteSeeker) (done <-chan struct{})

DoneWriteSeeker returns a channel to receive one signal before close after inp has been drained.

func DoneWriteSeekerFunc

func DoneWriteSeekerFunc(inp <-chan io.WriteSeeker, act func(a io.WriteSeeker)) (out <-chan struct{})

DoneWriteSeekerFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DoneWriteSeekerSlice

func DoneWriteSeekerSlice(inp <-chan io.WriteSeeker) (done <-chan ([]io.WriteSeeker))

DoneWriteSeekerSlice returns a channel which will receive a slice of all the WriteSeekers received on inp channel before close. Unlike DoneWriteSeeker, a full slice is sent once, not just an event.

func DoneWriter

func DoneWriter(inp <-chan io.Writer) (done <-chan struct{})

DoneWriter returns a channel to receive one signal before close after inp has been drained.

func DoneWriterAt

func DoneWriterAt(inp <-chan io.WriterAt) (done <-chan struct{})

DoneWriterAt returns a channel to receive one signal before close after inp has been drained.

func DoneWriterAtFunc

func DoneWriterAtFunc(inp <-chan io.WriterAt, act func(a io.WriterAt)) (out <-chan struct{})

DoneWriterAtFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DoneWriterAtSlice

func DoneWriterAtSlice(inp <-chan io.WriterAt) (done <-chan ([]io.WriterAt))

DoneWriterAtSlice returns a channel which will receive a slice of all the WriterAts received on inp channel before close. Unlike DoneWriterAt, a full slice is sent once, not just an event.

func DoneWriterFunc

func DoneWriterFunc(inp <-chan io.Writer, act func(a io.Writer)) (out <-chan struct{})

DoneWriterFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DoneWriterSlice

func DoneWriterSlice(inp <-chan io.Writer) (done <-chan ([]io.Writer))

DoneWriterSlice returns a channel which will receive a slice of all the Writers received on inp channel before close. Unlike DoneWriter, a full slice is sent once, not just an event.

func DoneWriterTo

func DoneWriterTo(inp <-chan io.WriterTo) (done <-chan struct{})

DoneWriterTo returns a channel to receive one signal before close after inp has been drained.

func DoneWriterToFunc

func DoneWriterToFunc(inp <-chan io.WriterTo, act func(a io.WriterTo)) (out <-chan struct{})

DoneWriterToFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DoneWriterToSlice

func DoneWriterToSlice(inp <-chan io.WriterTo) (done <-chan ([]io.WriterTo))

DoneWriterToSlice returns a channel which will receive a slice of all the WriterTos received on inp channel before close. Unlike DoneWriterTo, a full slice is sent once, not just an event.

func JoinByteReader

func JoinByteReader(out chan<- io.ByteReader, inp ...io.ByteReader) (done <-chan struct{})

JoinByteReader sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinByteReaderChan

func JoinByteReaderChan(out chan<- io.ByteReader, inp <-chan io.ByteReader) (done <-chan struct{})

JoinByteReaderChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinByteReaderSlice

func JoinByteReaderSlice(out chan<- io.ByteReader, inp ...[]io.ByteReader) (done <-chan struct{})

JoinByteReaderSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinByteScanner

func JoinByteScanner(out chan<- io.ByteScanner, inp ...io.ByteScanner) (done <-chan struct{})

JoinByteScanner sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinByteScannerChan

func JoinByteScannerChan(out chan<- io.ByteScanner, inp <-chan io.ByteScanner) (done <-chan struct{})

JoinByteScannerChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinByteScannerSlice

func JoinByteScannerSlice(out chan<- io.ByteScanner, inp ...[]io.ByteScanner) (done <-chan struct{})

JoinByteScannerSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinByteWriter

func JoinByteWriter(out chan<- io.ByteWriter, inp ...io.ByteWriter) (done <-chan struct{})

JoinByteWriter sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinByteWriterChan

func JoinByteWriterChan(out chan<- io.ByteWriter, inp <-chan io.ByteWriter) (done <-chan struct{})

JoinByteWriterChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinByteWriterSlice

func JoinByteWriterSlice(out chan<- io.ByteWriter, inp ...[]io.ByteWriter) (done <-chan struct{})

JoinByteWriterSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinCloser

func JoinCloser(out chan<- io.Closer, inp ...io.Closer) (done <-chan struct{})

JoinCloser sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinCloserChan

func JoinCloserChan(out chan<- io.Closer, inp <-chan io.Closer) (done <-chan struct{})

JoinCloserChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinCloserSlice

func JoinCloserSlice(out chan<- io.Closer, inp ...[]io.Closer) (done <-chan struct{})

JoinCloserSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinLimitedReader

func JoinLimitedReader(out chan<- *io.LimitedReader, inp ...*io.LimitedReader) (done <-chan struct{})

JoinLimitedReader sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinLimitedReaderChan

func JoinLimitedReaderChan(out chan<- *io.LimitedReader, inp <-chan *io.LimitedReader) (done <-chan struct{})

JoinLimitedReaderChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinLimitedReaderSlice

func JoinLimitedReaderSlice(out chan<- *io.LimitedReader, inp ...[]*io.LimitedReader) (done <-chan struct{})

JoinLimitedReaderSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinPipeReader

func JoinPipeReader(out chan<- *io.PipeReader, inp ...*io.PipeReader) (done <-chan struct{})

JoinPipeReader sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinPipeReaderChan

func JoinPipeReaderChan(out chan<- *io.PipeReader, inp <-chan *io.PipeReader) (done <-chan struct{})

JoinPipeReaderChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinPipeReaderSlice

func JoinPipeReaderSlice(out chan<- *io.PipeReader, inp ...[]*io.PipeReader) (done <-chan struct{})

JoinPipeReaderSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinPipeWriter

func JoinPipeWriter(out chan<- *io.PipeWriter, inp ...*io.PipeWriter) (done <-chan struct{})

JoinPipeWriter sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinPipeWriterChan

func JoinPipeWriterChan(out chan<- *io.PipeWriter, inp <-chan *io.PipeWriter) (done <-chan struct{})

JoinPipeWriterChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinPipeWriterSlice

func JoinPipeWriterSlice(out chan<- *io.PipeWriter, inp ...[]*io.PipeWriter) (done <-chan struct{})

JoinPipeWriterSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinReadCloser

func JoinReadCloser(out chan<- io.ReadCloser, inp ...io.ReadCloser) (done <-chan struct{})

JoinReadCloser sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinReadCloserChan

func JoinReadCloserChan(out chan<- io.ReadCloser, inp <-chan io.ReadCloser) (done <-chan struct{})

JoinReadCloserChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinReadCloserSlice

func JoinReadCloserSlice(out chan<- io.ReadCloser, inp ...[]io.ReadCloser) (done <-chan struct{})

JoinReadCloserSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinReadSeeker

func JoinReadSeeker(out chan<- io.ReadSeeker, inp ...io.ReadSeeker) (done <-chan struct{})

JoinReadSeeker sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinReadSeekerChan

func JoinReadSeekerChan(out chan<- io.ReadSeeker, inp <-chan io.ReadSeeker) (done <-chan struct{})

JoinReadSeekerChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinReadSeekerSlice

func JoinReadSeekerSlice(out chan<- io.ReadSeeker, inp ...[]io.ReadSeeker) (done <-chan struct{})

JoinReadSeekerSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinReadWriteCloser

func JoinReadWriteCloser(out chan<- io.ReadWriteCloser, inp ...io.ReadWriteCloser) (done <-chan struct{})

JoinReadWriteCloser sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinReadWriteCloserChan

func JoinReadWriteCloserChan(out chan<- io.ReadWriteCloser, inp <-chan io.ReadWriteCloser) (done <-chan struct{})

JoinReadWriteCloserChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinReadWriteCloserSlice

func JoinReadWriteCloserSlice(out chan<- io.ReadWriteCloser, inp ...[]io.ReadWriteCloser) (done <-chan struct{})

JoinReadWriteCloserSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinReadWriteSeeker

func JoinReadWriteSeeker(out chan<- io.ReadWriteSeeker, inp ...io.ReadWriteSeeker) (done <-chan struct{})

JoinReadWriteSeeker sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinReadWriteSeekerChan

func JoinReadWriteSeekerChan(out chan<- io.ReadWriteSeeker, inp <-chan io.ReadWriteSeeker) (done <-chan struct{})

JoinReadWriteSeekerChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinReadWriteSeekerSlice

func JoinReadWriteSeekerSlice(out chan<- io.ReadWriteSeeker, inp ...[]io.ReadWriteSeeker) (done <-chan struct{})

JoinReadWriteSeekerSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinReadWriter

func JoinReadWriter(out chan<- io.ReadWriter, inp ...io.ReadWriter) (done <-chan struct{})

JoinReadWriter sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinReadWriterChan

func JoinReadWriterChan(out chan<- io.ReadWriter, inp <-chan io.ReadWriter) (done <-chan struct{})

JoinReadWriterChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinReadWriterSlice

func JoinReadWriterSlice(out chan<- io.ReadWriter, inp ...[]io.ReadWriter) (done <-chan struct{})

JoinReadWriterSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinReader

func JoinReader(out chan<- io.Reader, inp ...io.Reader) (done <-chan struct{})

JoinReader sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinReaderAt

func JoinReaderAt(out chan<- io.ReaderAt, inp ...io.ReaderAt) (done <-chan struct{})

JoinReaderAt sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinReaderAtChan

func JoinReaderAtChan(out chan<- io.ReaderAt, inp <-chan io.ReaderAt) (done <-chan struct{})

JoinReaderAtChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinReaderAtSlice

func JoinReaderAtSlice(out chan<- io.ReaderAt, inp ...[]io.ReaderAt) (done <-chan struct{})

JoinReaderAtSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinReaderChan

func JoinReaderChan(out chan<- io.Reader, inp <-chan io.Reader) (done <-chan struct{})

JoinReaderChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinReaderFrom

func JoinReaderFrom(out chan<- io.ReaderFrom, inp ...io.ReaderFrom) (done <-chan struct{})

JoinReaderFrom sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinReaderFromChan

func JoinReaderFromChan(out chan<- io.ReaderFrom, inp <-chan io.ReaderFrom) (done <-chan struct{})

JoinReaderFromChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinReaderFromSlice

func JoinReaderFromSlice(out chan<- io.ReaderFrom, inp ...[]io.ReaderFrom) (done <-chan struct{})

JoinReaderFromSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinReaderSlice

func JoinReaderSlice(out chan<- io.Reader, inp ...[]io.Reader) (done <-chan struct{})

JoinReaderSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinRuneReader

func JoinRuneReader(out chan<- io.RuneReader, inp ...io.RuneReader) (done <-chan struct{})

JoinRuneReader sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinRuneReaderChan

func JoinRuneReaderChan(out chan<- io.RuneReader, inp <-chan io.RuneReader) (done <-chan struct{})

JoinRuneReaderChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinRuneReaderSlice

func JoinRuneReaderSlice(out chan<- io.RuneReader, inp ...[]io.RuneReader) (done <-chan struct{})

JoinRuneReaderSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinRuneScanner

func JoinRuneScanner(out chan<- io.RuneScanner, inp ...io.RuneScanner) (done <-chan struct{})

JoinRuneScanner sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinRuneScannerChan

func JoinRuneScannerChan(out chan<- io.RuneScanner, inp <-chan io.RuneScanner) (done <-chan struct{})

JoinRuneScannerChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinRuneScannerSlice

func JoinRuneScannerSlice(out chan<- io.RuneScanner, inp ...[]io.RuneScanner) (done <-chan struct{})

JoinRuneScannerSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinSectionReader

func JoinSectionReader(out chan<- *io.SectionReader, inp ...*io.SectionReader) (done <-chan struct{})

JoinSectionReader sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinSectionReaderChan

func JoinSectionReaderChan(out chan<- *io.SectionReader, inp <-chan *io.SectionReader) (done <-chan struct{})

JoinSectionReaderChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinSectionReaderSlice

func JoinSectionReaderSlice(out chan<- *io.SectionReader, inp ...[]*io.SectionReader) (done <-chan struct{})

JoinSectionReaderSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinSeeker

func JoinSeeker(out chan<- io.Seeker, inp ...io.Seeker) (done <-chan struct{})

JoinSeeker sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinSeekerChan

func JoinSeekerChan(out chan<- io.Seeker, inp <-chan io.Seeker) (done <-chan struct{})

JoinSeekerChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinSeekerSlice

func JoinSeekerSlice(out chan<- io.Seeker, inp ...[]io.Seeker) (done <-chan struct{})

JoinSeekerSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinWriteCloser

func JoinWriteCloser(out chan<- io.WriteCloser, inp ...io.WriteCloser) (done <-chan struct{})

JoinWriteCloser sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinWriteCloserChan

func JoinWriteCloserChan(out chan<- io.WriteCloser, inp <-chan io.WriteCloser) (done <-chan struct{})

JoinWriteCloserChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinWriteCloserSlice

func JoinWriteCloserSlice(out chan<- io.WriteCloser, inp ...[]io.WriteCloser) (done <-chan struct{})

JoinWriteCloserSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinWriteSeeker

func JoinWriteSeeker(out chan<- io.WriteSeeker, inp ...io.WriteSeeker) (done <-chan struct{})

JoinWriteSeeker sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinWriteSeekerChan

func JoinWriteSeekerChan(out chan<- io.WriteSeeker, inp <-chan io.WriteSeeker) (done <-chan struct{})

JoinWriteSeekerChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinWriteSeekerSlice

func JoinWriteSeekerSlice(out chan<- io.WriteSeeker, inp ...[]io.WriteSeeker) (done <-chan struct{})

JoinWriteSeekerSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinWriter

func JoinWriter(out chan<- io.Writer, inp ...io.Writer) (done <-chan struct{})

JoinWriter sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinWriterAt

func JoinWriterAt(out chan<- io.WriterAt, inp ...io.WriterAt) (done <-chan struct{})

JoinWriterAt sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinWriterAtChan

func JoinWriterAtChan(out chan<- io.WriterAt, inp <-chan io.WriterAt) (done <-chan struct{})

JoinWriterAtChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinWriterAtSlice

func JoinWriterAtSlice(out chan<- io.WriterAt, inp ...[]io.WriterAt) (done <-chan struct{})

JoinWriterAtSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinWriterChan

func JoinWriterChan(out chan<- io.Writer, inp <-chan io.Writer) (done <-chan struct{})

JoinWriterChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinWriterSlice

func JoinWriterSlice(out chan<- io.Writer, inp ...[]io.Writer) (done <-chan struct{})

JoinWriterSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinWriterTo

func JoinWriterTo(out chan<- io.WriterTo, inp ...io.WriterTo) (done <-chan struct{})

JoinWriterTo sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinWriterToChan

func JoinWriterToChan(out chan<- io.WriterTo, inp <-chan io.WriterTo) (done <-chan struct{})

JoinWriterToChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinWriterToSlice

func JoinWriterToSlice(out chan<- io.WriterTo, inp ...[]io.WriterTo) (done <-chan struct{})

JoinWriterToSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func LimitedReaderDaisy

func LimitedReaderDaisy(inp <-chan *io.LimitedReader, tube LimitedReaderTube) (out <-chan *io.LimitedReader)

LimitedReaderDaisy returns a channel to receive all inp after having passed thru tube.

func LimitedReaderDaisyChain

func LimitedReaderDaisyChain(inp <-chan *io.LimitedReader, tubes ...LimitedReaderTube) (out <-chan *io.LimitedReader)

LimitedReaderDaisyChain returns a channel to receive all inp after having passed thru all tubes.

func MakeByteReaderChan

func MakeByteReaderChan() (out chan io.ByteReader)

MakeByteReaderChan returns a new open channel (simply a 'chan io.ByteReader' that is).

Note: No 'ByteReader-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myByteReaderPipelineStartsHere := MakeByteReaderChan()
// ... lot's of code to design and build Your favourite "myByteReaderWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myByteReaderPipelineStartsHere <- drop
}
close(myByteReaderPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeByteReaderBuffer) the channel is unbuffered.

func MakeByteScannerChan

func MakeByteScannerChan() (out chan io.ByteScanner)

MakeByteScannerChan returns a new open channel (simply a 'chan io.ByteScanner' that is).

Note: No 'ByteScanner-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myByteScannerPipelineStartsHere := MakeByteScannerChan()
// ... lot's of code to design and build Your favourite "myByteScannerWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myByteScannerPipelineStartsHere <- drop
}
close(myByteScannerPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeByteScannerBuffer) the channel is unbuffered.

func MakeByteWriterChan

func MakeByteWriterChan() (out chan io.ByteWriter)

MakeByteWriterChan returns a new open channel (simply a 'chan io.ByteWriter' that is).

Note: No 'ByteWriter-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myByteWriterPipelineStartsHere := MakeByteWriterChan()
// ... lot's of code to design and build Your favourite "myByteWriterWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myByteWriterPipelineStartsHere <- drop
}
close(myByteWriterPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeByteWriterBuffer) the channel is unbuffered.

func MakeCloserChan

func MakeCloserChan() (out chan io.Closer)

MakeCloserChan returns a new open channel (simply a 'chan io.Closer' that is).

Note: No 'Closer-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myCloserPipelineStartsHere := MakeCloserChan()
// ... lot's of code to design and build Your favourite "myCloserWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myCloserPipelineStartsHere <- drop
}
close(myCloserPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeCloserBuffer) the channel is unbuffered.

func MakeLimitedReaderChan

func MakeLimitedReaderChan() (out chan *io.LimitedReader)

MakeLimitedReaderChan returns a new open channel (simply a 'chan *io.LimitedReader' that is).

Note: No 'LimitedReader-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myLimitedReaderPipelineStartsHere := MakeLimitedReaderChan()
// ... lot's of code to design and build Your favourite "myLimitedReaderWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myLimitedReaderPipelineStartsHere <- drop
}
close(myLimitedReaderPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeLimitedReaderBuffer) the channel is unbuffered.

func MakePipeReaderChan

func MakePipeReaderChan() (out chan *io.PipeReader)

MakePipeReaderChan returns a new open channel (simply a 'chan *io.PipeReader' that is).

Note: No 'PipeReader-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myPipeReaderPipelineStartsHere := MakePipeReaderChan()
// ... lot's of code to design and build Your favourite "myPipeReaderWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myPipeReaderPipelineStartsHere <- drop
}
close(myPipeReaderPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipePipeReaderBuffer) the channel is unbuffered.

func MakePipeWriterChan

func MakePipeWriterChan() (out chan *io.PipeWriter)

MakePipeWriterChan returns a new open channel (simply a 'chan *io.PipeWriter' that is).

Note: No 'PipeWriter-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myPipeWriterPipelineStartsHere := MakePipeWriterChan()
// ... lot's of code to design and build Your favourite "myPipeWriterWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myPipeWriterPipelineStartsHere <- drop
}
close(myPipeWriterPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipePipeWriterBuffer) the channel is unbuffered.

func MakeReadCloserChan

func MakeReadCloserChan() (out chan io.ReadCloser)

MakeReadCloserChan returns a new open channel (simply a 'chan io.ReadCloser' that is).

Note: No 'ReadCloser-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myReadCloserPipelineStartsHere := MakeReadCloserChan()
// ... lot's of code to design and build Your favourite "myReadCloserWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myReadCloserPipelineStartsHere <- drop
}
close(myReadCloserPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeReadCloserBuffer) the channel is unbuffered.

func MakeReadSeekerChan

func MakeReadSeekerChan() (out chan io.ReadSeeker)

MakeReadSeekerChan returns a new open channel (simply a 'chan io.ReadSeeker' that is).

Note: No 'ReadSeeker-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myReadSeekerPipelineStartsHere := MakeReadSeekerChan()
// ... lot's of code to design and build Your favourite "myReadSeekerWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myReadSeekerPipelineStartsHere <- drop
}
close(myReadSeekerPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeReadSeekerBuffer) the channel is unbuffered.

func MakeReadWriteCloserChan

func MakeReadWriteCloserChan() (out chan io.ReadWriteCloser)

MakeReadWriteCloserChan returns a new open channel (simply a 'chan io.ReadWriteCloser' that is).

Note: No 'ReadWriteCloser-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myReadWriteCloserPipelineStartsHere := MakeReadWriteCloserChan()
// ... lot's of code to design and build Your favourite "myReadWriteCloserWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myReadWriteCloserPipelineStartsHere <- drop
}
close(myReadWriteCloserPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeReadWriteCloserBuffer) the channel is unbuffered.

func MakeReadWriteSeekerChan

func MakeReadWriteSeekerChan() (out chan io.ReadWriteSeeker)

MakeReadWriteSeekerChan returns a new open channel (simply a 'chan io.ReadWriteSeeker' that is).

Note: No 'ReadWriteSeeker-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myReadWriteSeekerPipelineStartsHere := MakeReadWriteSeekerChan()
// ... lot's of code to design and build Your favourite "myReadWriteSeekerWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myReadWriteSeekerPipelineStartsHere <- drop
}
close(myReadWriteSeekerPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeReadWriteSeekerBuffer) the channel is unbuffered.

func MakeReadWriterChan

func MakeReadWriterChan() (out chan io.ReadWriter)

MakeReadWriterChan returns a new open channel (simply a 'chan io.ReadWriter' that is).

Note: No 'ReadWriter-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myReadWriterPipelineStartsHere := MakeReadWriterChan()
// ... lot's of code to design and build Your favourite "myReadWriterWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myReadWriterPipelineStartsHere <- drop
}
close(myReadWriterPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeReadWriterBuffer) the channel is unbuffered.

func MakeReaderAtChan

func MakeReaderAtChan() (out chan io.ReaderAt)

MakeReaderAtChan returns a new open channel (simply a 'chan io.ReaderAt' that is).

Note: No 'ReaderAt-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myReaderAtPipelineStartsHere := MakeReaderAtChan()
// ... lot's of code to design and build Your favourite "myReaderAtWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myReaderAtPipelineStartsHere <- drop
}
close(myReaderAtPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeReaderAtBuffer) the channel is unbuffered.

func MakeReaderChan

func MakeReaderChan() (out chan io.Reader)

MakeReaderChan returns a new open channel (simply a 'chan io.Reader' that is).

Note: No 'Reader-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myReaderPipelineStartsHere := MakeReaderChan()
// ... lot's of code to design and build Your favourite "myReaderWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myReaderPipelineStartsHere <- drop
}
close(myReaderPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeReaderBuffer) the channel is unbuffered.

func MakeReaderFromChan

func MakeReaderFromChan() (out chan io.ReaderFrom)

MakeReaderFromChan returns a new open channel (simply a 'chan io.ReaderFrom' that is).

Note: No 'ReaderFrom-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myReaderFromPipelineStartsHere := MakeReaderFromChan()
// ... lot's of code to design and build Your favourite "myReaderFromWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myReaderFromPipelineStartsHere <- drop
}
close(myReaderFromPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeReaderFromBuffer) the channel is unbuffered.

func MakeRuneReaderChan

func MakeRuneReaderChan() (out chan io.RuneReader)

MakeRuneReaderChan returns a new open channel (simply a 'chan io.RuneReader' that is).

Note: No 'RuneReader-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myRuneReaderPipelineStartsHere := MakeRuneReaderChan()
// ... lot's of code to design and build Your favourite "myRuneReaderWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myRuneReaderPipelineStartsHere <- drop
}
close(myRuneReaderPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeRuneReaderBuffer) the channel is unbuffered.

func MakeRuneScannerChan

func MakeRuneScannerChan() (out chan io.RuneScanner)

MakeRuneScannerChan returns a new open channel (simply a 'chan io.RuneScanner' that is).

Note: No 'RuneScanner-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myRuneScannerPipelineStartsHere := MakeRuneScannerChan()
// ... lot's of code to design and build Your favourite "myRuneScannerWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myRuneScannerPipelineStartsHere <- drop
}
close(myRuneScannerPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeRuneScannerBuffer) the channel is unbuffered.

func MakeSectionReaderChan

func MakeSectionReaderChan() (out chan *io.SectionReader)

MakeSectionReaderChan returns a new open channel (simply a 'chan *io.SectionReader' that is).

Note: No 'SectionReader-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var mySectionReaderPipelineStartsHere := MakeSectionReaderChan()
// ... lot's of code to design and build Your favourite "mySectionReaderWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	mySectionReaderPipelineStartsHere <- drop
}
close(mySectionReaderPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeSectionReaderBuffer) the channel is unbuffered.

func MakeSeekerChan

func MakeSeekerChan() (out chan io.Seeker)

MakeSeekerChan returns a new open channel (simply a 'chan io.Seeker' that is).

Note: No 'Seeker-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var mySeekerPipelineStartsHere := MakeSeekerChan()
// ... lot's of code to design and build Your favourite "mySeekerWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	mySeekerPipelineStartsHere <- drop
}
close(mySeekerPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeSeekerBuffer) the channel is unbuffered.

func MakeWriteCloserChan

func MakeWriteCloserChan() (out chan io.WriteCloser)

MakeWriteCloserChan returns a new open channel (simply a 'chan io.WriteCloser' that is).

Note: No 'WriteCloser-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myWriteCloserPipelineStartsHere := MakeWriteCloserChan()
// ... lot's of code to design and build Your favourite "myWriteCloserWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myWriteCloserPipelineStartsHere <- drop
}
close(myWriteCloserPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeWriteCloserBuffer) the channel is unbuffered.

func MakeWriteSeekerChan

func MakeWriteSeekerChan() (out chan io.WriteSeeker)

MakeWriteSeekerChan returns a new open channel (simply a 'chan io.WriteSeeker' that is).

Note: No 'WriteSeeker-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myWriteSeekerPipelineStartsHere := MakeWriteSeekerChan()
// ... lot's of code to design and build Your favourite "myWriteSeekerWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myWriteSeekerPipelineStartsHere <- drop
}
close(myWriteSeekerPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeWriteSeekerBuffer) the channel is unbuffered.

func MakeWriterAtChan

func MakeWriterAtChan() (out chan io.WriterAt)

MakeWriterAtChan returns a new open channel (simply a 'chan io.WriterAt' that is).

Note: No 'WriterAt-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myWriterAtPipelineStartsHere := MakeWriterAtChan()
// ... lot's of code to design and build Your favourite "myWriterAtWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myWriterAtPipelineStartsHere <- drop
}
close(myWriterAtPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeWriterAtBuffer) the channel is unbuffered.

func MakeWriterChan

func MakeWriterChan() (out chan io.Writer)

MakeWriterChan returns a new open channel (simply a 'chan io.Writer' that is).

Note: No 'Writer-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myWriterPipelineStartsHere := MakeWriterChan()
// ... lot's of code to design and build Your favourite "myWriterWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myWriterPipelineStartsHere <- drop
}
close(myWriterPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeWriterBuffer) the channel is unbuffered.

func MakeWriterToChan

func MakeWriterToChan() (out chan io.WriterTo)

MakeWriterToChan returns a new open channel (simply a 'chan io.WriterTo' that is).

Note: No 'WriterTo-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myWriterToPipelineStartsHere := MakeWriterToChan()
// ... lot's of code to design and build Your favourite "myWriterToWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myWriterToPipelineStartsHere <- drop
}
close(myWriterToPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeWriterToBuffer) the channel is unbuffered.

func PipeByteReaderBuffer

func PipeByteReaderBuffer(inp <-chan io.ByteReader, cap int) (out <-chan io.ByteReader)

PipeByteReaderBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeByteReaderFork

func PipeByteReaderFork(inp <-chan io.ByteReader) (out1, out2 <-chan io.ByteReader)

PipeByteReaderFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeByteReaderFunc

func PipeByteReaderFunc(inp <-chan io.ByteReader, act func(a io.ByteReader) io.ByteReader) (out <-chan io.ByteReader)

PipeByteReaderFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeByteReaderMap for functional people, but 'map' has a very different meaning in go lang.

func PipeByteScannerBuffer

func PipeByteScannerBuffer(inp <-chan io.ByteScanner, cap int) (out <-chan io.ByteScanner)

PipeByteScannerBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeByteScannerFork

func PipeByteScannerFork(inp <-chan io.ByteScanner) (out1, out2 <-chan io.ByteScanner)

PipeByteScannerFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeByteScannerFunc

func PipeByteScannerFunc(inp <-chan io.ByteScanner, act func(a io.ByteScanner) io.ByteScanner) (out <-chan io.ByteScanner)

PipeByteScannerFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeByteScannerMap for functional people, but 'map' has a very different meaning in go lang.

func PipeByteWriterBuffer

func PipeByteWriterBuffer(inp <-chan io.ByteWriter, cap int) (out <-chan io.ByteWriter)

PipeByteWriterBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeByteWriterFork

func PipeByteWriterFork(inp <-chan io.ByteWriter) (out1, out2 <-chan io.ByteWriter)

PipeByteWriterFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeByteWriterFunc

func PipeByteWriterFunc(inp <-chan io.ByteWriter, act func(a io.ByteWriter) io.ByteWriter) (out <-chan io.ByteWriter)

PipeByteWriterFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeByteWriterMap for functional people, but 'map' has a very different meaning in go lang.

func PipeCloserBuffer

func PipeCloserBuffer(inp <-chan io.Closer, cap int) (out <-chan io.Closer)

PipeCloserBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeCloserFork

func PipeCloserFork(inp <-chan io.Closer) (out1, out2 <-chan io.Closer)

PipeCloserFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeCloserFunc

func PipeCloserFunc(inp <-chan io.Closer, act func(a io.Closer) io.Closer) (out <-chan io.Closer)

PipeCloserFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeCloserMap for functional people, but 'map' has a very different meaning in go lang.

func PipeLimitedReaderBuffer

func PipeLimitedReaderBuffer(inp <-chan *io.LimitedReader, cap int) (out <-chan *io.LimitedReader)

PipeLimitedReaderBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeLimitedReaderFork

func PipeLimitedReaderFork(inp <-chan *io.LimitedReader) (out1, out2 <-chan *io.LimitedReader)

PipeLimitedReaderFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeLimitedReaderFunc

func PipeLimitedReaderFunc(inp <-chan *io.LimitedReader, act func(a *io.LimitedReader) *io.LimitedReader) (out <-chan *io.LimitedReader)

PipeLimitedReaderFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeLimitedReaderMap for functional people, but 'map' has a very different meaning in go lang.

func PipePipeReaderBuffer

func PipePipeReaderBuffer(inp <-chan *io.PipeReader, cap int) (out <-chan *io.PipeReader)

PipePipeReaderBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipePipeReaderFork

func PipePipeReaderFork(inp <-chan *io.PipeReader) (out1, out2 <-chan *io.PipeReader)

PipePipeReaderFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipePipeReaderFunc

func PipePipeReaderFunc(inp <-chan *io.PipeReader, act func(a *io.PipeReader) *io.PipeReader) (out <-chan *io.PipeReader)

PipePipeReaderFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipePipeReaderMap for functional people, but 'map' has a very different meaning in go lang.

func PipePipeWriterBuffer

func PipePipeWriterBuffer(inp <-chan *io.PipeWriter, cap int) (out <-chan *io.PipeWriter)

PipePipeWriterBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipePipeWriterFork

func PipePipeWriterFork(inp <-chan *io.PipeWriter) (out1, out2 <-chan *io.PipeWriter)

PipePipeWriterFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipePipeWriterFunc

func PipePipeWriterFunc(inp <-chan *io.PipeWriter, act func(a *io.PipeWriter) *io.PipeWriter) (out <-chan *io.PipeWriter)

PipePipeWriterFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipePipeWriterMap for functional people, but 'map' has a very different meaning in go lang.

func PipeReadCloserBuffer

func PipeReadCloserBuffer(inp <-chan io.ReadCloser, cap int) (out <-chan io.ReadCloser)

PipeReadCloserBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeReadCloserFork

func PipeReadCloserFork(inp <-chan io.ReadCloser) (out1, out2 <-chan io.ReadCloser)

PipeReadCloserFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeReadCloserFunc

func PipeReadCloserFunc(inp <-chan io.ReadCloser, act func(a io.ReadCloser) io.ReadCloser) (out <-chan io.ReadCloser)

PipeReadCloserFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeReadCloserMap for functional people, but 'map' has a very different meaning in go lang.

func PipeReadSeekerBuffer

func PipeReadSeekerBuffer(inp <-chan io.ReadSeeker, cap int) (out <-chan io.ReadSeeker)

PipeReadSeekerBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeReadSeekerFork

func PipeReadSeekerFork(inp <-chan io.ReadSeeker) (out1, out2 <-chan io.ReadSeeker)

PipeReadSeekerFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeReadSeekerFunc

func PipeReadSeekerFunc(inp <-chan io.ReadSeeker, act func(a io.ReadSeeker) io.ReadSeeker) (out <-chan io.ReadSeeker)

PipeReadSeekerFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeReadSeekerMap for functional people, but 'map' has a very different meaning in go lang.

func PipeReadWriteCloserBuffer

func PipeReadWriteCloserBuffer(inp <-chan io.ReadWriteCloser, cap int) (out <-chan io.ReadWriteCloser)

PipeReadWriteCloserBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeReadWriteCloserFork

func PipeReadWriteCloserFork(inp <-chan io.ReadWriteCloser) (out1, out2 <-chan io.ReadWriteCloser)

PipeReadWriteCloserFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeReadWriteCloserFunc

func PipeReadWriteCloserFunc(inp <-chan io.ReadWriteCloser, act func(a io.ReadWriteCloser) io.ReadWriteCloser) (out <-chan io.ReadWriteCloser)

PipeReadWriteCloserFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeReadWriteCloserMap for functional people, but 'map' has a very different meaning in go lang.

func PipeReadWriteSeekerBuffer

func PipeReadWriteSeekerBuffer(inp <-chan io.ReadWriteSeeker, cap int) (out <-chan io.ReadWriteSeeker)

PipeReadWriteSeekerBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeReadWriteSeekerFork

func PipeReadWriteSeekerFork(inp <-chan io.ReadWriteSeeker) (out1, out2 <-chan io.ReadWriteSeeker)

PipeReadWriteSeekerFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeReadWriteSeekerFunc

func PipeReadWriteSeekerFunc(inp <-chan io.ReadWriteSeeker, act func(a io.ReadWriteSeeker) io.ReadWriteSeeker) (out <-chan io.ReadWriteSeeker)

PipeReadWriteSeekerFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeReadWriteSeekerMap for functional people, but 'map' has a very different meaning in go lang.

func PipeReadWriterBuffer

func PipeReadWriterBuffer(inp <-chan io.ReadWriter, cap int) (out <-chan io.ReadWriter)

PipeReadWriterBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeReadWriterFork

func PipeReadWriterFork(inp <-chan io.ReadWriter) (out1, out2 <-chan io.ReadWriter)

PipeReadWriterFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeReadWriterFunc

func PipeReadWriterFunc(inp <-chan io.ReadWriter, act func(a io.ReadWriter) io.ReadWriter) (out <-chan io.ReadWriter)

PipeReadWriterFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeReadWriterMap for functional people, but 'map' has a very different meaning in go lang.

func PipeReaderAtBuffer

func PipeReaderAtBuffer(inp <-chan io.ReaderAt, cap int) (out <-chan io.ReaderAt)

PipeReaderAtBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeReaderAtFork

func PipeReaderAtFork(inp <-chan io.ReaderAt) (out1, out2 <-chan io.ReaderAt)

PipeReaderAtFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeReaderAtFunc

func PipeReaderAtFunc(inp <-chan io.ReaderAt, act func(a io.ReaderAt) io.ReaderAt) (out <-chan io.ReaderAt)

PipeReaderAtFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeReaderAtMap for functional people, but 'map' has a very different meaning in go lang.

func PipeReaderBuffer

func PipeReaderBuffer(inp <-chan io.Reader, cap int) (out <-chan io.Reader)

PipeReaderBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeReaderDaisy

func PipeReaderDaisy(inp <-chan *io.PipeReader, tube PipeReaderTube) (out <-chan *io.PipeReader)

PipeReaderDaisy returns a channel to receive all inp after having passed thru tube.

func PipeReaderDaisyChain

func PipeReaderDaisyChain(inp <-chan *io.PipeReader, tubes ...PipeReaderTube) (out <-chan *io.PipeReader)

PipeReaderDaisyChain returns a channel to receive all inp after having passed thru all tubes.

func PipeReaderFork

func PipeReaderFork(inp <-chan io.Reader) (out1, out2 <-chan io.Reader)

PipeReaderFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeReaderFromBuffer

func PipeReaderFromBuffer(inp <-chan io.ReaderFrom, cap int) (out <-chan io.ReaderFrom)

PipeReaderFromBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeReaderFromFork

func PipeReaderFromFork(inp <-chan io.ReaderFrom) (out1, out2 <-chan io.ReaderFrom)

PipeReaderFromFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeReaderFromFunc

func PipeReaderFromFunc(inp <-chan io.ReaderFrom, act func(a io.ReaderFrom) io.ReaderFrom) (out <-chan io.ReaderFrom)

PipeReaderFromFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeReaderFromMap for functional people, but 'map' has a very different meaning in go lang.

func PipeReaderFunc

func PipeReaderFunc(inp <-chan io.Reader, act func(a io.Reader) io.Reader) (out <-chan io.Reader)

PipeReaderFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeReaderMap for functional people, but 'map' has a very different meaning in go lang.

func PipeRuneReaderBuffer

func PipeRuneReaderBuffer(inp <-chan io.RuneReader, cap int) (out <-chan io.RuneReader)

PipeRuneReaderBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeRuneReaderFork

func PipeRuneReaderFork(inp <-chan io.RuneReader) (out1, out2 <-chan io.RuneReader)

PipeRuneReaderFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeRuneReaderFunc

func PipeRuneReaderFunc(inp <-chan io.RuneReader, act func(a io.RuneReader) io.RuneReader) (out <-chan io.RuneReader)

PipeRuneReaderFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeRuneReaderMap for functional people, but 'map' has a very different meaning in go lang.

func PipeRuneScannerBuffer

func PipeRuneScannerBuffer(inp <-chan io.RuneScanner, cap int) (out <-chan io.RuneScanner)

PipeRuneScannerBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeRuneScannerFork

func PipeRuneScannerFork(inp <-chan io.RuneScanner) (out1, out2 <-chan io.RuneScanner)

PipeRuneScannerFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeRuneScannerFunc

func PipeRuneScannerFunc(inp <-chan io.RuneScanner, act func(a io.RuneScanner) io.RuneScanner) (out <-chan io.RuneScanner)

PipeRuneScannerFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeRuneScannerMap for functional people, but 'map' has a very different meaning in go lang.

func PipeSectionReaderBuffer

func PipeSectionReaderBuffer(inp <-chan *io.SectionReader, cap int) (out <-chan *io.SectionReader)

PipeSectionReaderBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeSectionReaderFork

func PipeSectionReaderFork(inp <-chan *io.SectionReader) (out1, out2 <-chan *io.SectionReader)

PipeSectionReaderFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeSectionReaderFunc

func PipeSectionReaderFunc(inp <-chan *io.SectionReader, act func(a *io.SectionReader) *io.SectionReader) (out <-chan *io.SectionReader)

PipeSectionReaderFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeSectionReaderMap for functional people, but 'map' has a very different meaning in go lang.

func PipeSeekerBuffer

func PipeSeekerBuffer(inp <-chan io.Seeker, cap int) (out <-chan io.Seeker)

PipeSeekerBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeSeekerFork

func PipeSeekerFork(inp <-chan io.Seeker) (out1, out2 <-chan io.Seeker)

PipeSeekerFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeSeekerFunc

func PipeSeekerFunc(inp <-chan io.Seeker, act func(a io.Seeker) io.Seeker) (out <-chan io.Seeker)

PipeSeekerFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeSeekerMap for functional people, but 'map' has a very different meaning in go lang.

func PipeWriteCloserBuffer

func PipeWriteCloserBuffer(inp <-chan io.WriteCloser, cap int) (out <-chan io.WriteCloser)

PipeWriteCloserBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeWriteCloserFork

func PipeWriteCloserFork(inp <-chan io.WriteCloser) (out1, out2 <-chan io.WriteCloser)

PipeWriteCloserFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeWriteCloserFunc

func PipeWriteCloserFunc(inp <-chan io.WriteCloser, act func(a io.WriteCloser) io.WriteCloser) (out <-chan io.WriteCloser)

PipeWriteCloserFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeWriteCloserMap for functional people, but 'map' has a very different meaning in go lang.

func PipeWriteSeekerBuffer

func PipeWriteSeekerBuffer(inp <-chan io.WriteSeeker, cap int) (out <-chan io.WriteSeeker)

PipeWriteSeekerBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeWriteSeekerFork

func PipeWriteSeekerFork(inp <-chan io.WriteSeeker) (out1, out2 <-chan io.WriteSeeker)

PipeWriteSeekerFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeWriteSeekerFunc

func PipeWriteSeekerFunc(inp <-chan io.WriteSeeker, act func(a io.WriteSeeker) io.WriteSeeker) (out <-chan io.WriteSeeker)

PipeWriteSeekerFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeWriteSeekerMap for functional people, but 'map' has a very different meaning in go lang.

func PipeWriterAtBuffer

func PipeWriterAtBuffer(inp <-chan io.WriterAt, cap int) (out <-chan io.WriterAt)

PipeWriterAtBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeWriterAtFork

func PipeWriterAtFork(inp <-chan io.WriterAt) (out1, out2 <-chan io.WriterAt)

PipeWriterAtFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeWriterAtFunc

func PipeWriterAtFunc(inp <-chan io.WriterAt, act func(a io.WriterAt) io.WriterAt) (out <-chan io.WriterAt)

PipeWriterAtFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeWriterAtMap for functional people, but 'map' has a very different meaning in go lang.

func PipeWriterBuffer

func PipeWriterBuffer(inp <-chan io.Writer, cap int) (out <-chan io.Writer)

PipeWriterBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeWriterDaisy

func PipeWriterDaisy(inp <-chan *io.PipeWriter, tube PipeWriterTube) (out <-chan *io.PipeWriter)

PipeWriterDaisy returns a channel to receive all inp after having passed thru tube.

func PipeWriterDaisyChain

func PipeWriterDaisyChain(inp <-chan *io.PipeWriter, tubes ...PipeWriterTube) (out <-chan *io.PipeWriter)

PipeWriterDaisyChain returns a channel to receive all inp after having passed thru all tubes.

func PipeWriterFork

func PipeWriterFork(inp <-chan io.Writer) (out1, out2 <-chan io.Writer)

PipeWriterFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeWriterFunc

func PipeWriterFunc(inp <-chan io.Writer, act func(a io.Writer) io.Writer) (out <-chan io.Writer)

PipeWriterFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeWriterMap for functional people, but 'map' has a very different meaning in go lang.

func PipeWriterToBuffer

func PipeWriterToBuffer(inp <-chan io.WriterTo, cap int) (out <-chan io.WriterTo)

PipeWriterToBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeWriterToFork

func PipeWriterToFork(inp <-chan io.WriterTo) (out1, out2 <-chan io.WriterTo)

PipeWriterToFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeWriterToFunc

func PipeWriterToFunc(inp <-chan io.WriterTo, act func(a io.WriterTo) io.WriterTo) (out <-chan io.WriterTo)

PipeWriterToFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeWriterToMap for functional people, but 'map' has a very different meaning in go lang.

func ReadCloserDaisy

func ReadCloserDaisy(inp <-chan io.ReadCloser, tube ReadCloserTube) (out <-chan io.ReadCloser)

ReadCloserDaisy returns a channel to receive all inp after having passed thru tube.

func ReadCloserDaisyChain

func ReadCloserDaisyChain(inp <-chan io.ReadCloser, tubes ...ReadCloserTube) (out <-chan io.ReadCloser)

ReadCloserDaisyChain returns a channel to receive all inp after having passed thru all tubes.

func ReadSeekerDaisy

func ReadSeekerDaisy(inp <-chan io.ReadSeeker, tube ReadSeekerTube) (out <-chan io.ReadSeeker)

ReadSeekerDaisy returns a channel to receive all inp after having passed thru tube.

func ReadSeekerDaisyChain

func ReadSeekerDaisyChain(inp <-chan io.ReadSeeker, tubes ...ReadSeekerTube) (out <-chan io.ReadSeeker)

ReadSeekerDaisyChain returns a channel to receive all inp after having passed thru all tubes.

func ReadWriteCloserDaisy

func ReadWriteCloserDaisy(inp <-chan io.ReadWriteCloser, tube ReadWriteCloserTube) (out <-chan io.ReadWriteCloser)

ReadWriteCloserDaisy returns a channel to receive all inp after having passed thru tube.

func ReadWriteCloserDaisyChain

func ReadWriteCloserDaisyChain(inp <-chan io.ReadWriteCloser, tubes ...ReadWriteCloserTube) (out <-chan io.ReadWriteCloser)

ReadWriteCloserDaisyChain returns a channel to receive all inp after having passed thru all tubes.

func ReadWriteSeekerDaisy

func ReadWriteSeekerDaisy(inp <-chan io.ReadWriteSeeker, tube ReadWriteSeekerTube) (out <-chan io.ReadWriteSeeker)

ReadWriteSeekerDaisy returns a channel to receive all inp after having passed thru tube.

func ReadWriteSeekerDaisyChain

func ReadWriteSeekerDaisyChain(inp <-chan io.ReadWriteSeeker, tubes ...ReadWriteSeekerTube) (out <-chan io.ReadWriteSeeker)

ReadWriteSeekerDaisyChain returns a channel to receive all inp after having passed thru all tubes.

func ReadWriterDaisy

func ReadWriterDaisy(inp <-chan io.ReadWriter, tube ReadWriterTube) (out <-chan io.ReadWriter)

ReadWriterDaisy returns a channel to receive all inp after having passed thru tube.

func ReadWriterDaisyChain

func ReadWriterDaisyChain(inp <-chan io.ReadWriter, tubes ...ReadWriterTube) (out <-chan io.ReadWriter)

ReadWriterDaisyChain returns a channel to receive all inp after having passed thru all tubes.

func ReaderAtDaisy

func ReaderAtDaisy(inp <-chan io.ReaderAt, tube ReaderAtTube) (out <-chan io.ReaderAt)

ReaderAtDaisy returns a channel to receive all inp after having passed thru tube.

func ReaderAtDaisyChain

func ReaderAtDaisyChain(inp <-chan io.ReaderAt, tubes ...ReaderAtTube) (out <-chan io.ReaderAt)

ReaderAtDaisyChain returns a channel to receive all inp after having passed thru all tubes.

func ReaderDaisy

func ReaderDaisy(inp <-chan io.Reader, tube ReaderTube) (out <-chan io.Reader)

ReaderDaisy returns a channel to receive all inp after having passed thru tube.

func ReaderDaisyChain

func ReaderDaisyChain(inp <-chan io.Reader, tubes ...ReaderTube) (out <-chan io.Reader)

ReaderDaisyChain returns a channel to receive all inp after having passed thru all tubes.

func ReaderFromDaisy

func ReaderFromDaisy(inp <-chan io.ReaderFrom, tube ReaderFromTube) (out <-chan io.ReaderFrom)

ReaderFromDaisy returns a channel to receive all inp after having passed thru tube.

func ReaderFromDaisyChain

func ReaderFromDaisyChain(inp <-chan io.ReaderFrom, tubes ...ReaderFromTube) (out <-chan io.ReaderFrom)

ReaderFromDaisyChain returns a channel to receive all inp after having passed thru all tubes.

func RuneReaderDaisy

func RuneReaderDaisy(inp <-chan io.RuneReader, tube RuneReaderTube) (out <-chan io.RuneReader)

RuneReaderDaisy returns a channel to receive all inp after having passed thru tube.

func RuneReaderDaisyChain

func RuneReaderDaisyChain(inp <-chan io.RuneReader, tubes ...RuneReaderTube) (out <-chan io.RuneReader)

RuneReaderDaisyChain returns a channel to receive all inp after having passed thru all tubes.

func RuneScannerDaisy

func RuneScannerDaisy(inp <-chan io.RuneScanner, tube RuneScannerTube) (out <-chan io.RuneScanner)

RuneScannerDaisy returns a channel to receive all inp after having passed thru tube.

func RuneScannerDaisyChain

func RuneScannerDaisyChain(inp <-chan io.RuneScanner, tubes ...RuneScannerTube) (out <-chan io.RuneScanner)

RuneScannerDaisyChain returns a channel to receive all inp after having passed thru all tubes.

func SectionReaderDaisy

func SectionReaderDaisy(inp <-chan *io.SectionReader, tube SectionReaderTube) (out <-chan *io.SectionReader)

SectionReaderDaisy returns a channel to receive all inp after having passed thru tube.

func SectionReaderDaisyChain

func SectionReaderDaisyChain(inp <-chan *io.SectionReader, tubes ...SectionReaderTube) (out <-chan *io.SectionReader)

SectionReaderDaisyChain returns a channel to receive all inp after having passed thru all tubes.

func SeekerDaisy

func SeekerDaisy(inp <-chan io.Seeker, tube SeekerTube) (out <-chan io.Seeker)

SeekerDaisy returns a channel to receive all inp after having passed thru tube.

func SeekerDaisyChain

func SeekerDaisyChain(inp <-chan io.Seeker, tubes ...SeekerTube) (out <-chan io.Seeker)

SeekerDaisyChain returns a channel to receive all inp after having passed thru all tubes.

func SendProxyByteReader

func SendProxyByteReader(out chan<- io.ByteReader) chan<- io.ByteReader

SendProxyByteReader returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxyByteScanner

func SendProxyByteScanner(out chan<- io.ByteScanner) chan<- io.ByteScanner

SendProxyByteScanner returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxyByteWriter

func SendProxyByteWriter(out chan<- io.ByteWriter) chan<- io.ByteWriter

SendProxyByteWriter returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxyCloser

func SendProxyCloser(out chan<- io.Closer) chan<- io.Closer

SendProxyCloser returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxyLimitedReader

func SendProxyLimitedReader(out chan<- *io.LimitedReader) chan<- *io.LimitedReader

SendProxyLimitedReader returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxyPipeReader

func SendProxyPipeReader(out chan<- *io.PipeReader) chan<- *io.PipeReader

SendProxyPipeReader returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxyPipeWriter

func SendProxyPipeWriter(out chan<- *io.PipeWriter) chan<- *io.PipeWriter

SendProxyPipeWriter returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxyReadCloser

func SendProxyReadCloser(out chan<- io.ReadCloser) chan<- io.ReadCloser

SendProxyReadCloser returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxyReadSeeker

func SendProxyReadSeeker(out chan<- io.ReadSeeker) chan<- io.ReadSeeker

SendProxyReadSeeker returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxyReadWriteCloser

func SendProxyReadWriteCloser(out chan<- io.ReadWriteCloser) chan<- io.ReadWriteCloser

SendProxyReadWriteCloser returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxyReadWriteSeeker

func SendProxyReadWriteSeeker(out chan<- io.ReadWriteSeeker) chan<- io.ReadWriteSeeker

SendProxyReadWriteSeeker returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxyReadWriter

func SendProxyReadWriter(out chan<- io.ReadWriter) chan<- io.ReadWriter

SendProxyReadWriter returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxyReader

func SendProxyReader(out chan<- io.Reader) chan<- io.Reader

SendProxyReader returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxyReaderAt

func SendProxyReaderAt(out chan<- io.ReaderAt) chan<- io.ReaderAt

SendProxyReaderAt returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxyReaderFrom

func SendProxyReaderFrom(out chan<- io.ReaderFrom) chan<- io.ReaderFrom

SendProxyReaderFrom returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxyRuneReader

func SendProxyRuneReader(out chan<- io.RuneReader) chan<- io.RuneReader

SendProxyRuneReader returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxyRuneScanner

func SendProxyRuneScanner(out chan<- io.RuneScanner) chan<- io.RuneScanner

SendProxyRuneScanner returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxySectionReader

func SendProxySectionReader(out chan<- *io.SectionReader) chan<- *io.SectionReader

SendProxySectionReader returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxySeeker

func SendProxySeeker(out chan<- io.Seeker) chan<- io.Seeker

SendProxySeeker returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxyWriteCloser

func SendProxyWriteCloser(out chan<- io.WriteCloser) chan<- io.WriteCloser

SendProxyWriteCloser returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxyWriteSeeker

func SendProxyWriteSeeker(out chan<- io.WriteSeeker) chan<- io.WriteSeeker

SendProxyWriteSeeker returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxyWriter

func SendProxyWriter(out chan<- io.Writer) chan<- io.Writer

SendProxyWriter returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxyWriterAt

func SendProxyWriterAt(out chan<- io.WriterAt) chan<- io.WriterAt

SendProxyWriterAt returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxyWriterTo

func SendProxyWriterTo(out chan<- io.WriterTo) chan<- io.WriterTo

SendProxyWriterTo returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func WriteCloserDaisy

func WriteCloserDaisy(inp <-chan io.WriteCloser, tube WriteCloserTube) (out <-chan io.WriteCloser)

WriteCloserDaisy returns a channel to receive all inp after having passed thru tube.

func WriteCloserDaisyChain

func WriteCloserDaisyChain(inp <-chan io.WriteCloser, tubes ...WriteCloserTube) (out <-chan io.WriteCloser)

WriteCloserDaisyChain returns a channel to receive all inp after having passed thru all tubes.

func WriteSeekerDaisy

func WriteSeekerDaisy(inp <-chan io.WriteSeeker, tube WriteSeekerTube) (out <-chan io.WriteSeeker)

WriteSeekerDaisy returns a channel to receive all inp after having passed thru tube.

func WriteSeekerDaisyChain

func WriteSeekerDaisyChain(inp <-chan io.WriteSeeker, tubes ...WriteSeekerTube) (out <-chan io.WriteSeeker)

WriteSeekerDaisyChain returns a channel to receive all inp after having passed thru all tubes.

func WriterAtDaisy

func WriterAtDaisy(inp <-chan io.WriterAt, tube WriterAtTube) (out <-chan io.WriterAt)

WriterAtDaisy returns a channel to receive all inp after having passed thru tube.

func WriterAtDaisyChain

func WriterAtDaisyChain(inp <-chan io.WriterAt, tubes ...WriterAtTube) (out <-chan io.WriterAt)

WriterAtDaisyChain returns a channel to receive all inp after having passed thru all tubes.

func WriterDaisy

func WriterDaisy(inp <-chan io.Writer, tube WriterTube) (out <-chan io.Writer)

WriterDaisy returns a channel to receive all inp after having passed thru tube.

func WriterDaisyChain

func WriterDaisyChain(inp <-chan io.Writer, tubes ...WriterTube) (out <-chan io.Writer)

WriterDaisyChain returns a channel to receive all inp after having passed thru all tubes.

func WriterToDaisy

func WriterToDaisy(inp <-chan io.WriterTo, tube WriterToTube) (out <-chan io.WriterTo)

WriterToDaisy returns a channel to receive all inp after having passed thru tube.

func WriterToDaisyChain

func WriterToDaisyChain(inp <-chan io.WriterTo, tubes ...WriterToTube) (out <-chan io.WriterTo)

WriterToDaisyChain returns a channel to receive all inp after having passed thru all tubes.

Types

type ByteReaderTube

type ByteReaderTube func(inp <-chan io.ByteReader, out <-chan io.ByteReader)

ByteReaderTube is the signature for a pipe function.

type ByteScannerTube

type ByteScannerTube func(inp <-chan io.ByteScanner, out <-chan io.ByteScanner)

ByteScannerTube is the signature for a pipe function.

type ByteWriterTube

type ByteWriterTube func(inp <-chan io.ByteWriter, out <-chan io.ByteWriter)

ByteWriterTube is the signature for a pipe function.

type CloserTube

type CloserTube func(inp <-chan io.Closer, out <-chan io.Closer)

CloserTube is the signature for a pipe function.

type LimitedReaderTube

type LimitedReaderTube func(inp <-chan *io.LimitedReader, out <-chan *io.LimitedReader)

LimitedReaderTube is the signature for a pipe function.

type PipeReaderTube

type PipeReaderTube func(inp <-chan *io.PipeReader, out <-chan *io.PipeReader)

PipeReaderTube is the signature for a pipe function.

type PipeWriterTube

type PipeWriterTube func(inp <-chan *io.PipeWriter, out <-chan *io.PipeWriter)

PipeWriterTube is the signature for a pipe function.

type ReadCloserTube

type ReadCloserTube func(inp <-chan io.ReadCloser, out <-chan io.ReadCloser)

ReadCloserTube is the signature for a pipe function.

type ReadSeekerTube

type ReadSeekerTube func(inp <-chan io.ReadSeeker, out <-chan io.ReadSeeker)

ReadSeekerTube is the signature for a pipe function.

type ReadWriteCloserTube

type ReadWriteCloserTube func(inp <-chan io.ReadWriteCloser, out <-chan io.ReadWriteCloser)

ReadWriteCloserTube is the signature for a pipe function.

type ReadWriteSeekerTube

type ReadWriteSeekerTube func(inp <-chan io.ReadWriteSeeker, out <-chan io.ReadWriteSeeker)

ReadWriteSeekerTube is the signature for a pipe function.

type ReadWriterTube

type ReadWriterTube func(inp <-chan io.ReadWriter, out <-chan io.ReadWriter)

ReadWriterTube is the signature for a pipe function.

type ReaderAtTube

type ReaderAtTube func(inp <-chan io.ReaderAt, out <-chan io.ReaderAt)

ReaderAtTube is the signature for a pipe function.

type ReaderFromTube

type ReaderFromTube func(inp <-chan io.ReaderFrom, out <-chan io.ReaderFrom)

ReaderFromTube is the signature for a pipe function.

type ReaderTube

type ReaderTube func(inp <-chan io.Reader, out <-chan io.Reader)

ReaderTube is the signature for a pipe function.

type RuneReaderTube

type RuneReaderTube func(inp <-chan io.RuneReader, out <-chan io.RuneReader)

RuneReaderTube is the signature for a pipe function.

type RuneScannerTube

type RuneScannerTube func(inp <-chan io.RuneScanner, out <-chan io.RuneScanner)

RuneScannerTube is the signature for a pipe function.

type SectionReaderTube

type SectionReaderTube func(inp <-chan *io.SectionReader, out <-chan *io.SectionReader)

SectionReaderTube is the signature for a pipe function.

type SeekerTube

type SeekerTube func(inp <-chan io.Seeker, out <-chan io.Seeker)

SeekerTube is the signature for a pipe function.

type WriteCloserTube

type WriteCloserTube func(inp <-chan io.WriteCloser, out <-chan io.WriteCloser)

WriteCloserTube is the signature for a pipe function.

type WriteSeekerTube

type WriteSeekerTube func(inp <-chan io.WriteSeeker, out <-chan io.WriteSeeker)

WriteSeekerTube is the signature for a pipe function.

type WriterAtTube

type WriterAtTube func(inp <-chan io.WriterAt, out <-chan io.WriterAt)

WriterAtTube is the signature for a pipe function.

type WriterToTube

type WriterToTube func(inp <-chan io.WriterTo, out <-chan io.WriterTo)

WriterToTube is the signature for a pipe function.

type WriterTube

type WriterTube func(inp <-chan io.Writer, out <-chan io.Writer)

WriterTube is the signature for a pipe function.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL