io

package

v0.0.0-...-5012a73 Latest Latest Go to latest Published: Jun 20, 2019 License: MIT Imports: 2 Imported by: 0

Details

Valid go.mod file

The Go module system was introduced in Go 1.11 and is the official dependency management solution for Go.
Redistributable license

Redistributable licenses place minimal restrictions on how software can be used, modified, and redistributed.
Tagged version

Modules with tagged versions give importers more predictable builds.
Stable version

When a project reaches major version v1 it is considered stable.
Learn more about best practices

Repository

github.com/golangsam/anytype

Links

Open Source Insights

Documentation ¶

Index ¶

Constants
func ByteReaderDaisy(inp <-chan io.ByteReader, tube ByteReaderTube) (out <-chan io.ByteReader)
func ByteReaderDaisyChain(inp <-chan io.ByteReader, tubes ...ByteReaderTube) (out <-chan io.ByteReader)
func ByteScannerDaisy(inp <-chan io.ByteScanner, tube ByteScannerTube) (out <-chan io.ByteScanner)
func ByteScannerDaisyChain(inp <-chan io.ByteScanner, tubes ...ByteScannerTube) (out <-chan io.ByteScanner)
func ByteWriterDaisy(inp <-chan io.ByteWriter, tube ByteWriterTube) (out <-chan io.ByteWriter)
func ByteWriterDaisyChain(inp <-chan io.ByteWriter, tubes ...ByteWriterTube) (out <-chan io.ByteWriter)
func ChanByteReader(inp ...io.ByteReader) chan io.ByteReader
func ChanByteReaderFuncErr(act func() (io.ByteReader, error)) <-chan io.ByteReader
func ChanByteReaderFuncNok(act func() (io.ByteReader, bool)) <-chan io.ByteReader
func ChanByteReaderSlice(inp ...[]io.ByteReader) chan io.ByteReader
func ChanByteScanner(inp ...io.ByteScanner) chan io.ByteScanner
func ChanByteScannerFuncErr(act func() (io.ByteScanner, error)) <-chan io.ByteScanner
func ChanByteScannerFuncNok(act func() (io.ByteScanner, bool)) <-chan io.ByteScanner
func ChanByteScannerSlice(inp ...[]io.ByteScanner) chan io.ByteScanner
func ChanByteWriter(inp ...io.ByteWriter) chan io.ByteWriter
func ChanByteWriterFuncErr(act func() (io.ByteWriter, error)) <-chan io.ByteWriter
func ChanByteWriterFuncNok(act func() (io.ByteWriter, bool)) <-chan io.ByteWriter
func ChanByteWriterSlice(inp ...[]io.ByteWriter) chan io.ByteWriter
func ChanCloser(inp ...io.Closer) chan io.Closer
func ChanCloserFuncErr(act func() (io.Closer, error)) <-chan io.Closer
func ChanCloserFuncNok(act func() (io.Closer, bool)) <-chan io.Closer
func ChanCloserSlice(inp ...[]io.Closer) chan io.Closer
func ChanLimitedReader(inp ...*io.LimitedReader) chan *io.LimitedReader
func ChanLimitedReaderFuncErr(act func() (*io.LimitedReader, error)) <-chan *io.LimitedReader
func ChanLimitedReaderFuncNok(act func() (*io.LimitedReader, bool)) <-chan *io.LimitedReader
func ChanLimitedReaderSlice(inp ...[]*io.LimitedReader) chan *io.LimitedReader
func ChanPipeReader(inp ...*io.PipeReader) chan *io.PipeReader
func ChanPipeReaderFuncErr(act func() (*io.PipeReader, error)) <-chan *io.PipeReader
func ChanPipeReaderFuncNok(act func() (*io.PipeReader, bool)) <-chan *io.PipeReader
func ChanPipeReaderSlice(inp ...[]*io.PipeReader) chan *io.PipeReader
func ChanPipeWriter(inp ...*io.PipeWriter) chan *io.PipeWriter
func ChanPipeWriterFuncErr(act func() (*io.PipeWriter, error)) <-chan *io.PipeWriter
func ChanPipeWriterFuncNok(act func() (*io.PipeWriter, bool)) <-chan *io.PipeWriter
func ChanPipeWriterSlice(inp ...[]*io.PipeWriter) chan *io.PipeWriter
func ChanReadCloser(inp ...io.ReadCloser) chan io.ReadCloser
func ChanReadCloserFuncErr(act func() (io.ReadCloser, error)) <-chan io.ReadCloser
func ChanReadCloserFuncNok(act func() (io.ReadCloser, bool)) <-chan io.ReadCloser
func ChanReadCloserSlice(inp ...[]io.ReadCloser) chan io.ReadCloser
func ChanReadSeeker(inp ...io.ReadSeeker) chan io.ReadSeeker
func ChanReadSeekerFuncErr(act func() (io.ReadSeeker, error)) <-chan io.ReadSeeker
func ChanReadSeekerFuncNok(act func() (io.ReadSeeker, bool)) <-chan io.ReadSeeker
func ChanReadSeekerSlice(inp ...[]io.ReadSeeker) chan io.ReadSeeker
func ChanReadWriteCloser(inp ...io.ReadWriteCloser) chan io.ReadWriteCloser
func ChanReadWriteCloserFuncErr(act func() (io.ReadWriteCloser, error)) <-chan io.ReadWriteCloser
func ChanReadWriteCloserFuncNok(act func() (io.ReadWriteCloser, bool)) <-chan io.ReadWriteCloser
func ChanReadWriteCloserSlice(inp ...[]io.ReadWriteCloser) chan io.ReadWriteCloser
func ChanReadWriteSeeker(inp ...io.ReadWriteSeeker) chan io.ReadWriteSeeker
func ChanReadWriteSeekerFuncErr(act func() (io.ReadWriteSeeker, error)) <-chan io.ReadWriteSeeker
func ChanReadWriteSeekerFuncNok(act func() (io.ReadWriteSeeker, bool)) <-chan io.ReadWriteSeeker
func ChanReadWriteSeekerSlice(inp ...[]io.ReadWriteSeeker) chan io.ReadWriteSeeker
func ChanReadWriter(inp ...io.ReadWriter) chan io.ReadWriter
func ChanReadWriterFuncErr(act func() (io.ReadWriter, error)) <-chan io.ReadWriter
func ChanReadWriterFuncNok(act func() (io.ReadWriter, bool)) <-chan io.ReadWriter
func ChanReadWriterSlice(inp ...[]io.ReadWriter) chan io.ReadWriter
func ChanReader(inp ...io.Reader) chan io.Reader
func ChanReaderAt(inp ...io.ReaderAt) chan io.ReaderAt
func ChanReaderAtFuncErr(act func() (io.ReaderAt, error)) <-chan io.ReaderAt
func ChanReaderAtFuncNok(act func() (io.ReaderAt, bool)) <-chan io.ReaderAt
func ChanReaderAtSlice(inp ...[]io.ReaderAt) chan io.ReaderAt
func ChanReaderFrom(inp ...io.ReaderFrom) chan io.ReaderFrom
func ChanReaderFromFuncErr(act func() (io.ReaderFrom, error)) <-chan io.ReaderFrom
func ChanReaderFromFuncNok(act func() (io.ReaderFrom, bool)) <-chan io.ReaderFrom
func ChanReaderFromSlice(inp ...[]io.ReaderFrom) chan io.ReaderFrom
func ChanReaderFuncErr(act func() (io.Reader, error)) <-chan io.Reader
func ChanReaderFuncNok(act func() (io.Reader, bool)) <-chan io.Reader
func ChanReaderSlice(inp ...[]io.Reader) chan io.Reader
func ChanRuneReader(inp ...io.RuneReader) chan io.RuneReader
func ChanRuneReaderFuncErr(act func() (io.RuneReader, error)) <-chan io.RuneReader
func ChanRuneReaderFuncNok(act func() (io.RuneReader, bool)) <-chan io.RuneReader
func ChanRuneReaderSlice(inp ...[]io.RuneReader) chan io.RuneReader
func ChanRuneScanner(inp ...io.RuneScanner) chan io.RuneScanner
func ChanRuneScannerFuncErr(act func() (io.RuneScanner, error)) <-chan io.RuneScanner
func ChanRuneScannerFuncNok(act func() (io.RuneScanner, bool)) <-chan io.RuneScanner
func ChanRuneScannerSlice(inp ...[]io.RuneScanner) chan io.RuneScanner
func ChanSectionReader(inp ...*io.SectionReader) chan *io.SectionReader
func ChanSectionReaderFuncErr(act func() (*io.SectionReader, error)) <-chan *io.SectionReader
func ChanSectionReaderFuncNok(act func() (*io.SectionReader, bool)) <-chan *io.SectionReader
func ChanSectionReaderSlice(inp ...[]*io.SectionReader) chan *io.SectionReader
func ChanSeeker(inp ...io.Seeker) chan io.Seeker
func ChanSeekerFuncErr(act func() (io.Seeker, error)) <-chan io.Seeker
func ChanSeekerFuncNok(act func() (io.Seeker, bool)) <-chan io.Seeker
func ChanSeekerSlice(inp ...[]io.Seeker) chan io.Seeker
func ChanWriteCloser(inp ...io.WriteCloser) chan io.WriteCloser
func ChanWriteCloserFuncErr(act func() (io.WriteCloser, error)) <-chan io.WriteCloser
func ChanWriteCloserFuncNok(act func() (io.WriteCloser, bool)) <-chan io.WriteCloser
func ChanWriteCloserSlice(inp ...[]io.WriteCloser) chan io.WriteCloser
func ChanWriteSeeker(inp ...io.WriteSeeker) chan io.WriteSeeker
func ChanWriteSeekerFuncErr(act func() (io.WriteSeeker, error)) <-chan io.WriteSeeker
func ChanWriteSeekerFuncNok(act func() (io.WriteSeeker, bool)) <-chan io.WriteSeeker
func ChanWriteSeekerSlice(inp ...[]io.WriteSeeker) chan io.WriteSeeker
func ChanWriter(inp ...io.Writer) chan io.Writer
func ChanWriterAt(inp ...io.WriterAt) chan io.WriterAt
func ChanWriterAtFuncErr(act func() (io.WriterAt, error)) <-chan io.WriterAt
func ChanWriterAtFuncNok(act func() (io.WriterAt, bool)) <-chan io.WriterAt
func ChanWriterAtSlice(inp ...[]io.WriterAt) chan io.WriterAt
func ChanWriterFuncErr(act func() (io.Writer, error)) <-chan io.Writer
func ChanWriterFuncNok(act func() (io.Writer, bool)) <-chan io.Writer
func ChanWriterSlice(inp ...[]io.Writer) chan io.Writer
func ChanWriterTo(inp ...io.WriterTo) chan io.WriterTo
func ChanWriterToFuncErr(act func() (io.WriterTo, error)) <-chan io.WriterTo
func ChanWriterToFuncNok(act func() (io.WriterTo, bool)) <-chan io.WriterTo
func ChanWriterToSlice(inp ...[]io.WriterTo) chan io.WriterTo
func CloserDaisy(inp <-chan io.Closer, tube CloserTube) (out <-chan io.Closer)
func CloserDaisyChain(inp <-chan io.Closer, tubes ...CloserTube) (out <-chan io.Closer)
func DoneByteReader(inp <-chan io.ByteReader) chan struct{}
func DoneByteReaderFunc(inp <-chan io.ByteReader, act func(a io.ByteReader)) chan struct{}
func DoneByteReaderSlice(inp <-chan io.ByteReader) chan []io.ByteReader
func DoneByteScanner(inp <-chan io.ByteScanner) chan struct{}
func DoneByteScannerFunc(inp <-chan io.ByteScanner, act func(a io.ByteScanner)) chan struct{}
func DoneByteScannerSlice(inp <-chan io.ByteScanner) chan []io.ByteScanner
func DoneByteWriter(inp <-chan io.ByteWriter) chan struct{}
func DoneByteWriterFunc(inp <-chan io.ByteWriter, act func(a io.ByteWriter)) chan struct{}
func DoneByteWriterSlice(inp <-chan io.ByteWriter) chan []io.ByteWriter
func DoneCloser(inp <-chan io.Closer) chan struct{}
func DoneCloserFunc(inp <-chan io.Closer, act func(a io.Closer)) chan struct{}
func DoneCloserSlice(inp <-chan io.Closer) chan []io.Closer
func DoneLimitedReader(inp <-chan *io.LimitedReader) chan struct{}
func DoneLimitedReaderFunc(inp <-chan *io.LimitedReader, act func(a *io.LimitedReader)) chan struct{}
func DoneLimitedReaderSlice(inp <-chan *io.LimitedReader) chan []*io.LimitedReader
func DonePipeReader(inp <-chan *io.PipeReader) chan struct{}
func DonePipeReaderFunc(inp <-chan *io.PipeReader, act func(a *io.PipeReader)) chan struct{}
func DonePipeReaderSlice(inp <-chan *io.PipeReader) chan []*io.PipeReader
func DonePipeWriter(inp <-chan *io.PipeWriter) chan struct{}
func DonePipeWriterFunc(inp <-chan *io.PipeWriter, act func(a *io.PipeWriter)) chan struct{}
func DonePipeWriterSlice(inp <-chan *io.PipeWriter) chan []*io.PipeWriter
func DoneReadCloser(inp <-chan io.ReadCloser) chan struct{}
func DoneReadCloserFunc(inp <-chan io.ReadCloser, act func(a io.ReadCloser)) chan struct{}
func DoneReadCloserSlice(inp <-chan io.ReadCloser) chan []io.ReadCloser
func DoneReadSeeker(inp <-chan io.ReadSeeker) chan struct{}
func DoneReadSeekerFunc(inp <-chan io.ReadSeeker, act func(a io.ReadSeeker)) chan struct{}
func DoneReadSeekerSlice(inp <-chan io.ReadSeeker) chan []io.ReadSeeker
func DoneReadWriteCloser(inp <-chan io.ReadWriteCloser) chan struct{}
func DoneReadWriteCloserFunc(inp <-chan io.ReadWriteCloser, act func(a io.ReadWriteCloser)) chan struct{}
func DoneReadWriteCloserSlice(inp <-chan io.ReadWriteCloser) chan []io.ReadWriteCloser
func DoneReadWriteSeeker(inp <-chan io.ReadWriteSeeker) chan struct{}
func DoneReadWriteSeekerFunc(inp <-chan io.ReadWriteSeeker, act func(a io.ReadWriteSeeker)) chan struct{}
func DoneReadWriteSeekerSlice(inp <-chan io.ReadWriteSeeker) chan []io.ReadWriteSeeker
func DoneReadWriter(inp <-chan io.ReadWriter) chan struct{}
func DoneReadWriterFunc(inp <-chan io.ReadWriter, act func(a io.ReadWriter)) chan struct{}
func DoneReadWriterSlice(inp <-chan io.ReadWriter) chan []io.ReadWriter
func DoneReader(inp <-chan io.Reader) chan struct{}
func DoneReaderAt(inp <-chan io.ReaderAt) chan struct{}
func DoneReaderAtFunc(inp <-chan io.ReaderAt, act func(a io.ReaderAt)) chan struct{}
func DoneReaderAtSlice(inp <-chan io.ReaderAt) chan []io.ReaderAt
func DoneReaderFrom(inp <-chan io.ReaderFrom) chan struct{}
func DoneReaderFromFunc(inp <-chan io.ReaderFrom, act func(a io.ReaderFrom)) chan struct{}
func DoneReaderFromSlice(inp <-chan io.ReaderFrom) chan []io.ReaderFrom
func DoneReaderFunc(inp <-chan io.Reader, act func(a io.Reader)) chan struct{}
func DoneReaderSlice(inp <-chan io.Reader) chan []io.Reader
func DoneRuneReader(inp <-chan io.RuneReader) chan struct{}
func DoneRuneReaderFunc(inp <-chan io.RuneReader, act func(a io.RuneReader)) chan struct{}
func DoneRuneReaderSlice(inp <-chan io.RuneReader) chan []io.RuneReader
func DoneRuneScanner(inp <-chan io.RuneScanner) chan struct{}
func DoneRuneScannerFunc(inp <-chan io.RuneScanner, act func(a io.RuneScanner)) chan struct{}
func DoneRuneScannerSlice(inp <-chan io.RuneScanner) chan []io.RuneScanner
func DoneSectionReader(inp <-chan *io.SectionReader) chan struct{}
func DoneSectionReaderFunc(inp <-chan *io.SectionReader, act func(a *io.SectionReader)) chan struct{}
func DoneSectionReaderSlice(inp <-chan *io.SectionReader) chan []*io.SectionReader
func DoneSeeker(inp <-chan io.Seeker) chan struct{}
func DoneSeekerFunc(inp <-chan io.Seeker, act func(a io.Seeker)) chan struct{}
func DoneSeekerSlice(inp <-chan io.Seeker) chan []io.Seeker
func DoneWriteCloser(inp <-chan io.WriteCloser) chan struct{}
func DoneWriteCloserFunc(inp <-chan io.WriteCloser, act func(a io.WriteCloser)) chan struct{}
func DoneWriteCloserSlice(inp <-chan io.WriteCloser) chan []io.WriteCloser
func DoneWriteSeeker(inp <-chan io.WriteSeeker) chan struct{}
func DoneWriteSeekerFunc(inp <-chan io.WriteSeeker, act func(a io.WriteSeeker)) chan struct{}
func DoneWriteSeekerSlice(inp <-chan io.WriteSeeker) chan []io.WriteSeeker
func DoneWriter(inp <-chan io.Writer) chan struct{}
func DoneWriterAt(inp <-chan io.WriterAt) chan struct{}
func DoneWriterAtFunc(inp <-chan io.WriterAt, act func(a io.WriterAt)) chan struct{}
func DoneWriterAtSlice(inp <-chan io.WriterAt) chan []io.WriterAt
func DoneWriterFunc(inp <-chan io.Writer, act func(a io.Writer)) chan struct{}
func DoneWriterSlice(inp <-chan io.Writer) chan []io.Writer
func DoneWriterTo(inp <-chan io.WriterTo) chan struct{}
func DoneWriterToFunc(inp <-chan io.WriterTo, act func(a io.WriterTo)) chan struct{}
func DoneWriterToSlice(inp <-chan io.WriterTo) chan []io.WriterTo
func JoinByteReader(out chan<- io.ByteReader, inp ...io.ByteReader) chan struct{}
func JoinByteReaderChan(out chan<- io.ByteReader, inp <-chan io.ByteReader) chan struct{}
func JoinByteReaderSlice(out chan<- io.ByteReader, inp ...[]io.ByteReader) chan struct{}
func JoinByteScanner(out chan<- io.ByteScanner, inp ...io.ByteScanner) chan struct{}
func JoinByteScannerChan(out chan<- io.ByteScanner, inp <-chan io.ByteScanner) chan struct{}
func JoinByteScannerSlice(out chan<- io.ByteScanner, inp ...[]io.ByteScanner) chan struct{}
func JoinByteWriter(out chan<- io.ByteWriter, inp ...io.ByteWriter) chan struct{}
func JoinByteWriterChan(out chan<- io.ByteWriter, inp <-chan io.ByteWriter) chan struct{}
func JoinByteWriterSlice(out chan<- io.ByteWriter, inp ...[]io.ByteWriter) chan struct{}
func JoinCloser(out chan<- io.Closer, inp ...io.Closer) chan struct{}
func JoinCloserChan(out chan<- io.Closer, inp <-chan io.Closer) chan struct{}
func JoinCloserSlice(out chan<- io.Closer, inp ...[]io.Closer) chan struct{}
func JoinLimitedReader(out chan<- *io.LimitedReader, inp ...*io.LimitedReader) chan struct{}
func JoinLimitedReaderChan(out chan<- *io.LimitedReader, inp <-chan *io.LimitedReader) chan struct{}
func JoinLimitedReaderSlice(out chan<- *io.LimitedReader, inp ...[]*io.LimitedReader) chan struct{}
func JoinPipeReader(out chan<- *io.PipeReader, inp ...*io.PipeReader) chan struct{}
func JoinPipeReaderChan(out chan<- *io.PipeReader, inp <-chan *io.PipeReader) chan struct{}
func JoinPipeReaderSlice(out chan<- *io.PipeReader, inp ...[]*io.PipeReader) chan struct{}
func JoinPipeWriter(out chan<- *io.PipeWriter, inp ...*io.PipeWriter) chan struct{}
func JoinPipeWriterChan(out chan<- *io.PipeWriter, inp <-chan *io.PipeWriter) chan struct{}
func JoinPipeWriterSlice(out chan<- *io.PipeWriter, inp ...[]*io.PipeWriter) chan struct{}
func JoinReadCloser(out chan<- io.ReadCloser, inp ...io.ReadCloser) chan struct{}
func JoinReadCloserChan(out chan<- io.ReadCloser, inp <-chan io.ReadCloser) chan struct{}
func JoinReadCloserSlice(out chan<- io.ReadCloser, inp ...[]io.ReadCloser) chan struct{}
func JoinReadSeeker(out chan<- io.ReadSeeker, inp ...io.ReadSeeker) chan struct{}
func JoinReadSeekerChan(out chan<- io.ReadSeeker, inp <-chan io.ReadSeeker) chan struct{}
func JoinReadSeekerSlice(out chan<- io.ReadSeeker, inp ...[]io.ReadSeeker) chan struct{}
func JoinReadWriteCloser(out chan<- io.ReadWriteCloser, inp ...io.ReadWriteCloser) chan struct{}
func JoinReadWriteCloserChan(out chan<- io.ReadWriteCloser, inp <-chan io.ReadWriteCloser) chan struct{}
func JoinReadWriteCloserSlice(out chan<- io.ReadWriteCloser, inp ...[]io.ReadWriteCloser) chan struct{}
func JoinReadWriteSeeker(out chan<- io.ReadWriteSeeker, inp ...io.ReadWriteSeeker) chan struct{}
func JoinReadWriteSeekerChan(out chan<- io.ReadWriteSeeker, inp <-chan io.ReadWriteSeeker) chan struct{}
func JoinReadWriteSeekerSlice(out chan<- io.ReadWriteSeeker, inp ...[]io.ReadWriteSeeker) chan struct{}
func JoinReadWriter(out chan<- io.ReadWriter, inp ...io.ReadWriter) chan struct{}
func JoinReadWriterChan(out chan<- io.ReadWriter, inp <-chan io.ReadWriter) chan struct{}
func JoinReadWriterSlice(out chan<- io.ReadWriter, inp ...[]io.ReadWriter) chan struct{}
func JoinReader(out chan<- io.Reader, inp ...io.Reader) chan struct{}
func JoinReaderAt(out chan<- io.ReaderAt, inp ...io.ReaderAt) chan struct{}
func JoinReaderAtChan(out chan<- io.ReaderAt, inp <-chan io.ReaderAt) chan struct{}
func JoinReaderAtSlice(out chan<- io.ReaderAt, inp ...[]io.ReaderAt) chan struct{}
func JoinReaderChan(out chan<- io.Reader, inp <-chan io.Reader) chan struct{}
func JoinReaderFrom(out chan<- io.ReaderFrom, inp ...io.ReaderFrom) chan struct{}
func JoinReaderFromChan(out chan<- io.ReaderFrom, inp <-chan io.ReaderFrom) chan struct{}
func JoinReaderFromSlice(out chan<- io.ReaderFrom, inp ...[]io.ReaderFrom) chan struct{}
func JoinReaderSlice(out chan<- io.Reader, inp ...[]io.Reader) chan struct{}
func JoinRuneReader(out chan<- io.RuneReader, inp ...io.RuneReader) chan struct{}
func JoinRuneReaderChan(out chan<- io.RuneReader, inp <-chan io.RuneReader) chan struct{}
func JoinRuneReaderSlice(out chan<- io.RuneReader, inp ...[]io.RuneReader) chan struct{}
func JoinRuneScanner(out chan<- io.RuneScanner, inp ...io.RuneScanner) chan struct{}
func JoinRuneScannerChan(out chan<- io.RuneScanner, inp <-chan io.RuneScanner) chan struct{}
func JoinRuneScannerSlice(out chan<- io.RuneScanner, inp ...[]io.RuneScanner) chan struct{}
func JoinSectionReader(out chan<- *io.SectionReader, inp ...*io.SectionReader) chan struct{}
func JoinSectionReaderChan(out chan<- *io.SectionReader, inp <-chan *io.SectionReader) chan struct{}
func JoinSectionReaderSlice(out chan<- *io.SectionReader, inp ...[]*io.SectionReader) chan struct{}
func JoinSeeker(out chan<- io.Seeker, inp ...io.Seeker) chan struct{}
func JoinSeekerChan(out chan<- io.Seeker, inp <-chan io.Seeker) chan struct{}
func JoinSeekerSlice(out chan<- io.Seeker, inp ...[]io.Seeker) chan struct{}
func JoinWriteCloser(out chan<- io.WriteCloser, inp ...io.WriteCloser) chan struct{}
func JoinWriteCloserChan(out chan<- io.WriteCloser, inp <-chan io.WriteCloser) chan struct{}
func JoinWriteCloserSlice(out chan<- io.WriteCloser, inp ...[]io.WriteCloser) chan struct{}
func JoinWriteSeeker(out chan<- io.WriteSeeker, inp ...io.WriteSeeker) chan struct{}
func JoinWriteSeekerChan(out chan<- io.WriteSeeker, inp <-chan io.WriteSeeker) chan struct{}
func JoinWriteSeekerSlice(out chan<- io.WriteSeeker, inp ...[]io.WriteSeeker) chan struct{}
func JoinWriter(out chan<- io.Writer, inp ...io.Writer) chan struct{}
func JoinWriterAt(out chan<- io.WriterAt, inp ...io.WriterAt) chan struct{}
func JoinWriterAtChan(out chan<- io.WriterAt, inp <-chan io.WriterAt) chan struct{}
func JoinWriterAtSlice(out chan<- io.WriterAt, inp ...[]io.WriterAt) chan struct{}
func JoinWriterChan(out chan<- io.Writer, inp <-chan io.Writer) chan struct{}
func JoinWriterSlice(out chan<- io.Writer, inp ...[]io.Writer) chan struct{}
func JoinWriterTo(out chan<- io.WriterTo, inp ...io.WriterTo) chan struct{}
func JoinWriterToChan(out chan<- io.WriterTo, inp <-chan io.WriterTo) chan struct{}
func JoinWriterToSlice(out chan<- io.WriterTo, inp ...[]io.WriterTo) chan struct{}
func LimitedReaderDaisy(inp <-chan *io.LimitedReader, tube LimitedReaderTube) (out <-chan *io.LimitedReader)
func LimitedReaderDaisyChain(inp <-chan *io.LimitedReader, tubes ...LimitedReaderTube) (out <-chan *io.LimitedReader)
func MakeByteReaderChan() chan io.ByteReader
func MakeByteScannerChan() chan io.ByteScanner
func MakeByteWriterChan() chan io.ByteWriter
func MakeCloserChan() chan io.Closer
func MakeLimitedReaderChan() chan *io.LimitedReader
func MakePipeReaderChan() chan *io.PipeReader
func MakePipeWriterChan() chan *io.PipeWriter
func MakeReadCloserChan() chan io.ReadCloser
func MakeReadSeekerChan() chan io.ReadSeeker
func MakeReadWriteCloserChan() chan io.ReadWriteCloser
func MakeReadWriteSeekerChan() chan io.ReadWriteSeeker
func MakeReadWriterChan() chan io.ReadWriter
func MakeReaderAtChan() chan io.ReaderAt
func MakeReaderChan() chan io.Reader
func MakeReaderFromChan() chan io.ReaderFrom
func MakeRuneReaderChan() chan io.RuneReader
func MakeRuneScannerChan() chan io.RuneScanner
func MakeSectionReaderChan() chan *io.SectionReader
func MakeSeekerChan() chan io.Seeker
func MakeWriteCloserChan() chan io.WriteCloser
func MakeWriteSeekerChan() chan io.WriteSeeker
func MakeWriterAtChan() chan io.WriterAt
func MakeWriterChan() chan io.Writer
func MakeWriterToChan() chan io.WriterTo
func PipeByteReaderBuffer(inp <-chan io.ByteReader, cap int) chan io.ByteReader
func PipeByteReaderFork(inp <-chan io.ByteReader) (chan io.ByteReader, chan io.ByteReader)
func PipeByteReaderFunc(inp <-chan io.ByteReader, act func(a io.ByteReader) io.ByteReader) chan io.ByteReader
func PipeByteScannerBuffer(inp <-chan io.ByteScanner, cap int) chan io.ByteScanner
func PipeByteScannerFork(inp <-chan io.ByteScanner) (chan io.ByteScanner, chan io.ByteScanner)
func PipeByteScannerFunc(inp <-chan io.ByteScanner, act func(a io.ByteScanner) io.ByteScanner) chan io.ByteScanner
func PipeByteWriterBuffer(inp <-chan io.ByteWriter, cap int) chan io.ByteWriter
func PipeByteWriterFork(inp <-chan io.ByteWriter) (chan io.ByteWriter, chan io.ByteWriter)
func PipeByteWriterFunc(inp <-chan io.ByteWriter, act func(a io.ByteWriter) io.ByteWriter) chan io.ByteWriter
func PipeCloserBuffer(inp <-chan io.Closer, cap int) chan io.Closer
func PipeCloserFork(inp <-chan io.Closer) (chan io.Closer, chan io.Closer)
func PipeCloserFunc(inp <-chan io.Closer, act func(a io.Closer) io.Closer) chan io.Closer
func PipeLimitedReaderBuffer(inp <-chan *io.LimitedReader, cap int) chan *io.LimitedReader
func PipeLimitedReaderFork(inp <-chan *io.LimitedReader) (chan *io.LimitedReader, chan *io.LimitedReader)
func PipeLimitedReaderFunc(inp <-chan *io.LimitedReader, act func(a *io.LimitedReader) *io.LimitedReader) chan *io.LimitedReader
func PipePipeReaderBuffer(inp <-chan *io.PipeReader, cap int) chan *io.PipeReader
func PipePipeReaderFork(inp <-chan *io.PipeReader) (chan *io.PipeReader, chan *io.PipeReader)
func PipePipeReaderFunc(inp <-chan *io.PipeReader, act func(a *io.PipeReader) *io.PipeReader) chan *io.PipeReader
func PipePipeWriterBuffer(inp <-chan *io.PipeWriter, cap int) chan *io.PipeWriter
func PipePipeWriterFork(inp <-chan *io.PipeWriter) (chan *io.PipeWriter, chan *io.PipeWriter)
func PipePipeWriterFunc(inp <-chan *io.PipeWriter, act func(a *io.PipeWriter) *io.PipeWriter) chan *io.PipeWriter
func PipeReadCloserBuffer(inp <-chan io.ReadCloser, cap int) chan io.ReadCloser
func PipeReadCloserFork(inp <-chan io.ReadCloser) (chan io.ReadCloser, chan io.ReadCloser)
func PipeReadCloserFunc(inp <-chan io.ReadCloser, act func(a io.ReadCloser) io.ReadCloser) chan io.ReadCloser
func PipeReadSeekerBuffer(inp <-chan io.ReadSeeker, cap int) chan io.ReadSeeker
func PipeReadSeekerFork(inp <-chan io.ReadSeeker) (chan io.ReadSeeker, chan io.ReadSeeker)
func PipeReadSeekerFunc(inp <-chan io.ReadSeeker, act func(a io.ReadSeeker) io.ReadSeeker) chan io.ReadSeeker
func PipeReadWriteCloserBuffer(inp <-chan io.ReadWriteCloser, cap int) chan io.ReadWriteCloser
func PipeReadWriteCloserFork(inp <-chan io.ReadWriteCloser) (chan io.ReadWriteCloser, chan io.ReadWriteCloser)
func PipeReadWriteCloserFunc(inp <-chan io.ReadWriteCloser, ...) chan io.ReadWriteCloser
func PipeReadWriteSeekerBuffer(inp <-chan io.ReadWriteSeeker, cap int) chan io.ReadWriteSeeker
func PipeReadWriteSeekerFork(inp <-chan io.ReadWriteSeeker) (chan io.ReadWriteSeeker, chan io.ReadWriteSeeker)
func PipeReadWriteSeekerFunc(inp <-chan io.ReadWriteSeeker, ...) chan io.ReadWriteSeeker
func PipeReadWriterBuffer(inp <-chan io.ReadWriter, cap int) chan io.ReadWriter
func PipeReadWriterFork(inp <-chan io.ReadWriter) (chan io.ReadWriter, chan io.ReadWriter)
func PipeReadWriterFunc(inp <-chan io.ReadWriter, act func(a io.ReadWriter) io.ReadWriter) chan io.ReadWriter
func PipeReaderAtBuffer(inp <-chan io.ReaderAt, cap int) chan io.ReaderAt
func PipeReaderAtFork(inp <-chan io.ReaderAt) (chan io.ReaderAt, chan io.ReaderAt)
func PipeReaderAtFunc(inp <-chan io.ReaderAt, act func(a io.ReaderAt) io.ReaderAt) chan io.ReaderAt
func PipeReaderBuffer(inp <-chan io.Reader, cap int) chan io.Reader
func PipeReaderDaisy(inp <-chan *io.PipeReader, tube PipeReaderTube) (out <-chan *io.PipeReader)
func PipeReaderDaisyChain(inp <-chan *io.PipeReader, tubes ...PipeReaderTube) (out <-chan *io.PipeReader)
func PipeReaderFork(inp <-chan io.Reader) (chan io.Reader, chan io.Reader)
func PipeReaderFromBuffer(inp <-chan io.ReaderFrom, cap int) chan io.ReaderFrom
func PipeReaderFromFork(inp <-chan io.ReaderFrom) (chan io.ReaderFrom, chan io.ReaderFrom)
func PipeReaderFromFunc(inp <-chan io.ReaderFrom, act func(a io.ReaderFrom) io.ReaderFrom) chan io.ReaderFrom
func PipeReaderFunc(inp <-chan io.Reader, act func(a io.Reader) io.Reader) chan io.Reader
func PipeRuneReaderBuffer(inp <-chan io.RuneReader, cap int) chan io.RuneReader
func PipeRuneReaderFork(inp <-chan io.RuneReader) (chan io.RuneReader, chan io.RuneReader)
func PipeRuneReaderFunc(inp <-chan io.RuneReader, act func(a io.RuneReader) io.RuneReader) chan io.RuneReader
func PipeRuneScannerBuffer(inp <-chan io.RuneScanner, cap int) chan io.RuneScanner
func PipeRuneScannerFork(inp <-chan io.RuneScanner) (chan io.RuneScanner, chan io.RuneScanner)
func PipeRuneScannerFunc(inp <-chan io.RuneScanner, act func(a io.RuneScanner) io.RuneScanner) chan io.RuneScanner
func PipeSectionReaderBuffer(inp <-chan *io.SectionReader, cap int) chan *io.SectionReader
func PipeSectionReaderFork(inp <-chan *io.SectionReader) (chan *io.SectionReader, chan *io.SectionReader)
func PipeSectionReaderFunc(inp <-chan *io.SectionReader, act func(a *io.SectionReader) *io.SectionReader) chan *io.SectionReader
func PipeSeekerBuffer(inp <-chan io.Seeker, cap int) chan io.Seeker
func PipeSeekerFork(inp <-chan io.Seeker) (chan io.Seeker, chan io.Seeker)
func PipeSeekerFunc(inp <-chan io.Seeker, act func(a io.Seeker) io.Seeker) chan io.Seeker
func PipeWriteCloserBuffer(inp <-chan io.WriteCloser, cap int) chan io.WriteCloser
func PipeWriteCloserFork(inp <-chan io.WriteCloser) (chan io.WriteCloser, chan io.WriteCloser)
func PipeWriteCloserFunc(inp <-chan io.WriteCloser, act func(a io.WriteCloser) io.WriteCloser) chan io.WriteCloser
func PipeWriteSeekerBuffer(inp <-chan io.WriteSeeker, cap int) chan io.WriteSeeker
func PipeWriteSeekerFork(inp <-chan io.WriteSeeker) (chan io.WriteSeeker, chan io.WriteSeeker)
func PipeWriteSeekerFunc(inp <-chan io.WriteSeeker, act func(a io.WriteSeeker) io.WriteSeeker) chan io.WriteSeeker
func PipeWriterAtBuffer(inp <-chan io.WriterAt, cap int) chan io.WriterAt
func PipeWriterAtFork(inp <-chan io.WriterAt) (chan io.WriterAt, chan io.WriterAt)
func PipeWriterAtFunc(inp <-chan io.WriterAt, act func(a io.WriterAt) io.WriterAt) chan io.WriterAt
func PipeWriterBuffer(inp <-chan io.Writer, cap int) chan io.Writer
func PipeWriterDaisy(inp <-chan *io.PipeWriter, tube PipeWriterTube) (out <-chan *io.PipeWriter)
func PipeWriterDaisyChain(inp <-chan *io.PipeWriter, tubes ...PipeWriterTube) (out <-chan *io.PipeWriter)
func PipeWriterFork(inp <-chan io.Writer) (chan io.Writer, chan io.Writer)
func PipeWriterFunc(inp <-chan io.Writer, act func(a io.Writer) io.Writer) chan io.Writer
func PipeWriterToBuffer(inp <-chan io.WriterTo, cap int) chan io.WriterTo
func PipeWriterToFork(inp <-chan io.WriterTo) (chan io.WriterTo, chan io.WriterTo)
func PipeWriterToFunc(inp <-chan io.WriterTo, act func(a io.WriterTo) io.WriterTo) chan io.WriterTo
func ReadCloserDaisy(inp <-chan io.ReadCloser, tube ReadCloserTube) (out <-chan io.ReadCloser)
func ReadCloserDaisyChain(inp <-chan io.ReadCloser, tubes ...ReadCloserTube) (out <-chan io.ReadCloser)
func ReadSeekerDaisy(inp <-chan io.ReadSeeker, tube ReadSeekerTube) (out <-chan io.ReadSeeker)
func ReadSeekerDaisyChain(inp <-chan io.ReadSeeker, tubes ...ReadSeekerTube) (out <-chan io.ReadSeeker)
func ReadWriteCloserDaisy(inp <-chan io.ReadWriteCloser, tube ReadWriteCloserTube) (out <-chan io.ReadWriteCloser)
func ReadWriteCloserDaisyChain(inp <-chan io.ReadWriteCloser, tubes ...ReadWriteCloserTube) (out <-chan io.ReadWriteCloser)
func ReadWriteSeekerDaisy(inp <-chan io.ReadWriteSeeker, tube ReadWriteSeekerTube) (out <-chan io.ReadWriteSeeker)
func ReadWriteSeekerDaisyChain(inp <-chan io.ReadWriteSeeker, tubes ...ReadWriteSeekerTube) (out <-chan io.ReadWriteSeeker)
func ReadWriterDaisy(inp <-chan io.ReadWriter, tube ReadWriterTube) (out <-chan io.ReadWriter)
func ReadWriterDaisyChain(inp <-chan io.ReadWriter, tubes ...ReadWriterTube) (out <-chan io.ReadWriter)
func ReaderAtDaisy(inp <-chan io.ReaderAt, tube ReaderAtTube) (out <-chan io.ReaderAt)
func ReaderAtDaisyChain(inp <-chan io.ReaderAt, tubes ...ReaderAtTube) (out <-chan io.ReaderAt)
func ReaderDaisy(inp <-chan io.Reader, tube ReaderTube) (out <-chan io.Reader)
func ReaderDaisyChain(inp <-chan io.Reader, tubes ...ReaderTube) (out <-chan io.Reader)
func ReaderFromDaisy(inp <-chan io.ReaderFrom, tube ReaderFromTube) (out <-chan io.ReaderFrom)
func ReaderFromDaisyChain(inp <-chan io.ReaderFrom, tubes ...ReaderFromTube) (out <-chan io.ReaderFrom)
func RuneReaderDaisy(inp <-chan io.RuneReader, tube RuneReaderTube) (out <-chan io.RuneReader)
func RuneReaderDaisyChain(inp <-chan io.RuneReader, tubes ...RuneReaderTube) (out <-chan io.RuneReader)
func RuneScannerDaisy(inp <-chan io.RuneScanner, tube RuneScannerTube) (out <-chan io.RuneScanner)
func RuneScannerDaisyChain(inp <-chan io.RuneScanner, tubes ...RuneScannerTube) (out <-chan io.RuneScanner)
func SectionReaderDaisy(inp <-chan *io.SectionReader, tube SectionReaderTube) (out <-chan *io.SectionReader)
func SectionReaderDaisyChain(inp <-chan *io.SectionReader, tubes ...SectionReaderTube) (out <-chan *io.SectionReader)
func SeekerDaisy(inp <-chan io.Seeker, tube SeekerTube) (out <-chan io.Seeker)
func SeekerDaisyChain(inp <-chan io.Seeker, tubes ...SeekerTube) (out <-chan io.Seeker)
func SendProxyByteReader(out chan<- io.ByteReader) chan<- io.ByteReader
func SendProxyByteScanner(out chan<- io.ByteScanner) chan<- io.ByteScanner
func SendProxyByteWriter(out chan<- io.ByteWriter) chan<- io.ByteWriter
func SendProxyCloser(out chan<- io.Closer) chan<- io.Closer
func SendProxyLimitedReader(out chan<- *io.LimitedReader) chan<- *io.LimitedReader
func SendProxyPipeReader(out chan<- *io.PipeReader) chan<- *io.PipeReader
func SendProxyPipeWriter(out chan<- *io.PipeWriter) chan<- *io.PipeWriter
func SendProxyReadCloser(out chan<- io.ReadCloser) chan<- io.ReadCloser
func SendProxyReadSeeker(out chan<- io.ReadSeeker) chan<- io.ReadSeeker
func SendProxyReadWriteCloser(out chan<- io.ReadWriteCloser) chan<- io.ReadWriteCloser
func SendProxyReadWriteSeeker(out chan<- io.ReadWriteSeeker) chan<- io.ReadWriteSeeker
func SendProxyReadWriter(out chan<- io.ReadWriter) chan<- io.ReadWriter
func SendProxyReader(out chan<- io.Reader) chan<- io.Reader
func SendProxyReaderAt(out chan<- io.ReaderAt) chan<- io.ReaderAt
func SendProxyReaderFrom(out chan<- io.ReaderFrom) chan<- io.ReaderFrom
func SendProxyRuneReader(out chan<- io.RuneReader) chan<- io.RuneReader
func SendProxyRuneScanner(out chan<- io.RuneScanner) chan<- io.RuneScanner
func SendProxySectionReader(out chan<- *io.SectionReader) chan<- *io.SectionReader
func SendProxySeeker(out chan<- io.Seeker) chan<- io.Seeker
func SendProxyWriteCloser(out chan<- io.WriteCloser) chan<- io.WriteCloser
func SendProxyWriteSeeker(out chan<- io.WriteSeeker) chan<- io.WriteSeeker
func SendProxyWriter(out chan<- io.Writer) chan<- io.Writer
func SendProxyWriterAt(out chan<- io.WriterAt) chan<- io.WriterAt
func SendProxyWriterTo(out chan<- io.WriterTo) chan<- io.WriterTo
func WriteCloserDaisy(inp <-chan io.WriteCloser, tube WriteCloserTube) (out <-chan io.WriteCloser)
func WriteCloserDaisyChain(inp <-chan io.WriteCloser, tubes ...WriteCloserTube) (out <-chan io.WriteCloser)
func WriteSeekerDaisy(inp <-chan io.WriteSeeker, tube WriteSeekerTube) (out <-chan io.WriteSeeker)
func WriteSeekerDaisyChain(inp <-chan io.WriteSeeker, tubes ...WriteSeekerTube) (out <-chan io.WriteSeeker)
func WriterAtDaisy(inp <-chan io.WriterAt, tube WriterAtTube) (out <-chan io.WriterAt)
func WriterAtDaisyChain(inp <-chan io.WriterAt, tubes ...WriterAtTube) (out <-chan io.WriterAt)
func WriterDaisy(inp <-chan io.Writer, tube WriterTube) (out <-chan io.Writer)
func WriterDaisyChain(inp <-chan io.Writer, tubes ...WriterTube) (out <-chan io.Writer)
func WriterToDaisy(inp <-chan io.WriterTo, tube WriterToTube) (out <-chan io.WriterTo)
func WriterToDaisyChain(inp <-chan io.WriterTo, tubes ...WriterToTube) (out <-chan io.WriterTo)
type ByteReaderTube
type ByteScannerTube
type ByteWriterTube
type CloserTube
type LimitedReaderTube
type PipeReaderTube
type PipeWriterTube
type ReadCloserTube
type ReadSeekerTube
type ReadWriteCloserTube
type ReadWriteSeekerTube
type ReadWriterTube
type ReaderAtTube
type ReaderFromTube
type ReaderTube
type RuneReaderTube
type RuneScannerTube
type SectionReaderTube
type SeekerTube
type WriteCloserTube
type WriteSeekerTube
type WriterAtTube
type WriterToTube
type WriterTube

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) chan io.ByteReader

ChanByteReader returns a channel to receive all inputs before close.

func ChanByteReaderFuncErr ¶

func ChanByteReaderFuncErr(act func() (io.ByteReader, error)) <-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)) <-chan io.ByteReader

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

func ChanByteReaderSlice ¶

func ChanByteReaderSlice(inp ...[]io.ByteReader) chan io.ByteReader

ChanByteReaderSlice returns a channel to receive all inputs before close.

func ChanByteScanner ¶

func ChanByteScanner(inp ...io.ByteScanner) chan io.ByteScanner

ChanByteScanner returns a channel to receive all inputs before close.

func ChanByteScannerFuncErr ¶

func ChanByteScannerFuncErr(act func() (io.ByteScanner, error)) <-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)) <-chan io.ByteScanner

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

func ChanByteScannerSlice ¶

func ChanByteScannerSlice(inp ...[]io.ByteScanner) chan io.ByteScanner

ChanByteScannerSlice returns a channel to receive all inputs before close.

func ChanByteWriter ¶

func ChanByteWriter(inp ...io.ByteWriter) chan io.ByteWriter

ChanByteWriter returns a channel to receive all inputs before close.

func ChanByteWriterFuncErr ¶

func ChanByteWriterFuncErr(act func() (io.ByteWriter, error)) <-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)) <-chan io.ByteWriter

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

func ChanByteWriterSlice ¶

func ChanByteWriterSlice(inp ...[]io.ByteWriter) chan io.ByteWriter

ChanByteWriterSlice returns a channel to receive all inputs before close.

func ChanCloser ¶

func ChanCloser(inp ...io.Closer) chan io.Closer

ChanCloser returns a channel to receive all inputs before close.

func ChanCloserFuncErr ¶

func ChanCloserFuncErr(act func() (io.Closer, error)) <-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)) <-chan io.Closer

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

func ChanCloserSlice ¶

func ChanCloserSlice(inp ...[]io.Closer) chan io.Closer

ChanCloserSlice returns a channel to receive all inputs before close.

func ChanLimitedReader ¶

func ChanLimitedReader(inp ...*io.LimitedReader) chan *io.LimitedReader

ChanLimitedReader returns a channel to receive all inputs before close.

func ChanLimitedReaderFuncErr ¶

func ChanLimitedReaderFuncErr(act func() (*io.LimitedReader, error)) <-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)) <-chan *io.LimitedReader

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

func ChanLimitedReaderSlice ¶

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

ChanLimitedReaderSlice returns a channel to receive all inputs before close.

func ChanPipeReader ¶

func ChanPipeReader(inp ...*io.PipeReader) chan *io.PipeReader

ChanPipeReader returns a channel to receive all inputs before close.

func ChanPipeReaderFuncErr ¶

func ChanPipeReaderFuncErr(act func() (*io.PipeReader, error)) <-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)) <-chan *io.PipeReader

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

func ChanPipeReaderSlice ¶

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

ChanPipeReaderSlice returns a channel to receive all inputs before close.

func ChanPipeWriter ¶

func ChanPipeWriter(inp ...*io.PipeWriter) chan *io.PipeWriter

ChanPipeWriter returns a channel to receive all inputs before close.

func ChanPipeWriterFuncErr ¶

func ChanPipeWriterFuncErr(act func() (*io.PipeWriter, error)) <-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)) <-chan *io.PipeWriter

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

func ChanPipeWriterSlice ¶

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

ChanPipeWriterSlice returns a channel to receive all inputs before close.

func ChanReadCloser ¶

func ChanReadCloser(inp ...io.ReadCloser) chan io.ReadCloser

ChanReadCloser returns a channel to receive all inputs before close.

func ChanReadCloserFuncErr ¶

func ChanReadCloserFuncErr(act func() (io.ReadCloser, error)) <-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)) <-chan io.ReadCloser

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

func ChanReadCloserSlice ¶

func ChanReadCloserSlice(inp ...[]io.ReadCloser) chan io.ReadCloser

ChanReadCloserSlice returns a channel to receive all inputs before close.

func ChanReadSeeker ¶

func ChanReadSeeker(inp ...io.ReadSeeker) chan io.ReadSeeker

ChanReadSeeker returns a channel to receive all inputs before close.

func ChanReadSeekerFuncErr ¶

func ChanReadSeekerFuncErr(act func() (io.ReadSeeker, error)) <-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)) <-chan io.ReadSeeker

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

func ChanReadSeekerSlice ¶

func ChanReadSeekerSlice(inp ...[]io.ReadSeeker) chan io.ReadSeeker

ChanReadSeekerSlice returns a channel to receive all inputs before close.

func ChanReadWriteCloser ¶

func ChanReadWriteCloser(inp ...io.ReadWriteCloser) chan io.ReadWriteCloser

ChanReadWriteCloser returns a channel to receive all inputs before close.

func ChanReadWriteCloserFuncErr ¶

func ChanReadWriteCloserFuncErr(act func() (io.ReadWriteCloser, error)) <-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)) <-chan io.ReadWriteCloser

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

func ChanReadWriteCloserSlice ¶

func ChanReadWriteCloserSlice(inp ...[]io.ReadWriteCloser) chan io.ReadWriteCloser

ChanReadWriteCloserSlice returns a channel to receive all inputs before close.

func ChanReadWriteSeeker ¶

func ChanReadWriteSeeker(inp ...io.ReadWriteSeeker) chan io.ReadWriteSeeker

ChanReadWriteSeeker returns a channel to receive all inputs before close.

func ChanReadWriteSeekerFuncErr ¶

func ChanReadWriteSeekerFuncErr(act func() (io.ReadWriteSeeker, error)) <-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)) <-chan io.ReadWriteSeeker

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

func ChanReadWriteSeekerSlice ¶

func ChanReadWriteSeekerSlice(inp ...[]io.ReadWriteSeeker) chan io.ReadWriteSeeker

ChanReadWriteSeekerSlice returns a channel to receive all inputs before close.

func ChanReadWriter ¶

func ChanReadWriter(inp ...io.ReadWriter) chan io.ReadWriter

ChanReadWriter returns a channel to receive all inputs before close.

func ChanReadWriterFuncErr ¶

func ChanReadWriterFuncErr(act func() (io.ReadWriter, error)) <-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)) <-chan io.ReadWriter

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

func ChanReadWriterSlice ¶

func ChanReadWriterSlice(inp ...[]io.ReadWriter) chan io.ReadWriter

ChanReadWriterSlice returns a channel to receive all inputs before close.

func ChanReader ¶

func ChanReader(inp ...io.Reader) chan io.Reader

ChanReader returns a channel to receive all inputs before close.

func ChanReaderAt ¶

func ChanReaderAt(inp ...io.ReaderAt) chan io.ReaderAt

ChanReaderAt returns a channel to receive all inputs before close.

func ChanReaderAtFuncErr ¶

func ChanReaderAtFuncErr(act func() (io.ReaderAt, error)) <-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)) <-chan io.ReaderAt

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

func ChanReaderAtSlice ¶

func ChanReaderAtSlice(inp ...[]io.ReaderAt) chan io.ReaderAt

ChanReaderAtSlice returns a channel to receive all inputs before close.

func ChanReaderFrom ¶

func ChanReaderFrom(inp ...io.ReaderFrom) chan io.ReaderFrom

ChanReaderFrom returns a channel to receive all inputs before close.

func ChanReaderFromFuncErr ¶

func ChanReaderFromFuncErr(act func() (io.ReaderFrom, error)) <-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)) <-chan io.ReaderFrom

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

func ChanReaderFromSlice ¶

func ChanReaderFromSlice(inp ...[]io.ReaderFrom) chan io.ReaderFrom

ChanReaderFromSlice returns a channel to receive all inputs before close.

func ChanReaderFuncErr ¶

func ChanReaderFuncErr(act func() (io.Reader, error)) <-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)) <-chan io.Reader

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

func ChanReaderSlice ¶

func ChanReaderSlice(inp ...[]io.Reader) chan io.Reader

ChanReaderSlice returns a channel to receive all inputs before close.

func ChanRuneReader ¶

func ChanRuneReader(inp ...io.RuneReader) chan io.RuneReader

ChanRuneReader returns a channel to receive all inputs before close.

func ChanRuneReaderFuncErr ¶

func ChanRuneReaderFuncErr(act func() (io.RuneReader, error)) <-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)) <-chan io.RuneReader

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

func ChanRuneReaderSlice ¶

func ChanRuneReaderSlice(inp ...[]io.RuneReader) chan io.RuneReader

ChanRuneReaderSlice returns a channel to receive all inputs before close.

func ChanRuneScanner ¶

func ChanRuneScanner(inp ...io.RuneScanner) chan io.RuneScanner

ChanRuneScanner returns a channel to receive all inputs before close.

func ChanRuneScannerFuncErr ¶

func ChanRuneScannerFuncErr(act func() (io.RuneScanner, error)) <-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)) <-chan io.RuneScanner

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

func ChanRuneScannerSlice ¶

func ChanRuneScannerSlice(inp ...[]io.RuneScanner) chan io.RuneScanner

ChanRuneScannerSlice returns a channel to receive all inputs before close.

func ChanSectionReader ¶

func ChanSectionReader(inp ...*io.SectionReader) chan *io.SectionReader

ChanSectionReader returns a channel to receive all inputs before close.

func ChanSectionReaderFuncErr ¶

func ChanSectionReaderFuncErr(act func() (*io.SectionReader, error)) <-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)) <-chan *io.SectionReader

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

func ChanSectionReaderSlice ¶

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

ChanSectionReaderSlice returns a channel to receive all inputs before close.

func ChanSeeker ¶

func ChanSeeker(inp ...io.Seeker) chan io.Seeker

ChanSeeker returns a channel to receive all inputs before close.

func ChanSeekerFuncErr ¶

func ChanSeekerFuncErr(act func() (io.Seeker, error)) <-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)) <-chan io.Seeker

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

func ChanSeekerSlice ¶

func ChanSeekerSlice(inp ...[]io.Seeker) chan io.Seeker

ChanSeekerSlice returns a channel to receive all inputs before close.

func ChanWriteCloser ¶

func ChanWriteCloser(inp ...io.WriteCloser) chan io.WriteCloser

ChanWriteCloser returns a channel to receive all inputs before close.

func ChanWriteCloserFuncErr ¶

func ChanWriteCloserFuncErr(act func() (io.WriteCloser, error)) <-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)) <-chan io.WriteCloser

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

func ChanWriteCloserSlice ¶

func ChanWriteCloserSlice(inp ...[]io.WriteCloser) chan io.WriteCloser

ChanWriteCloserSlice returns a channel to receive all inputs before close.

func ChanWriteSeeker ¶

func ChanWriteSeeker(inp ...io.WriteSeeker) chan io.WriteSeeker

ChanWriteSeeker returns a channel to receive all inputs before close.

func ChanWriteSeekerFuncErr ¶

func ChanWriteSeekerFuncErr(act func() (io.WriteSeeker, error)) <-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)) <-chan io.WriteSeeker

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

func ChanWriteSeekerSlice ¶

func ChanWriteSeekerSlice(inp ...[]io.WriteSeeker) chan io.WriteSeeker

ChanWriteSeekerSlice returns a channel to receive all inputs before close.

func ChanWriter ¶

func ChanWriter(inp ...io.Writer) chan io.Writer

ChanWriter returns a channel to receive all inputs before close.

func ChanWriterAt ¶

func ChanWriterAt(inp ...io.WriterAt) chan io.WriterAt

ChanWriterAt returns a channel to receive all inputs before close.

func ChanWriterAtFuncErr ¶

func ChanWriterAtFuncErr(act func() (io.WriterAt, error)) <-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)) <-chan io.WriterAt

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

func ChanWriterAtSlice ¶

func ChanWriterAtSlice(inp ...[]io.WriterAt) chan io.WriterAt

ChanWriterAtSlice returns a channel to receive all inputs before close.

func ChanWriterFuncErr ¶

func ChanWriterFuncErr(act func() (io.Writer, error)) <-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)) <-chan io.Writer

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

func ChanWriterSlice ¶

func ChanWriterSlice(inp ...[]io.Writer) chan io.Writer

ChanWriterSlice returns a channel to receive all inputs before close.

func ChanWriterTo ¶

func ChanWriterTo(inp ...io.WriterTo) chan io.WriterTo

ChanWriterTo returns a channel to receive all inputs before close.

func ChanWriterToFuncErr ¶

func ChanWriterToFuncErr(act func() (io.WriterTo, error)) <-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)) <-chan io.WriterTo

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

func ChanWriterToSlice ¶

func ChanWriterToSlice(inp ...[]io.WriterTo) 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) 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)) 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) 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) 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)) 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) 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) 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)) 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) 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) 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)) 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) 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) 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)) 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) 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) 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)) 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) 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) 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)) 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) 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) 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)) 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) 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) 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)) 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) 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) 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)) 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) 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) 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)) 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) 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) 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)) 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) 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) 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) 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)) 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) 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) 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)) 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) 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)) 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) 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) 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)) 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) 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) 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)) 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) 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) 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)) 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) 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) 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)) 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) 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) 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)) 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) 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) 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)) 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) 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) 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) 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)) 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) 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)) 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) 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) 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)) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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() 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() 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() 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() 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() 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() 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() 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() 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() 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() 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() 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() 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() 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() 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() 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() 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() 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() 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() 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() 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() 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() 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() 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() 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) 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) (chan io.ByteReader, 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) 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) 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) (chan io.ByteScanner, 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) 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) 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) (chan io.ByteWriter, 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) 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) 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) (chan io.Closer, 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) 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) 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) (chan *io.LimitedReader, 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) 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) 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) (chan *io.PipeReader, 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) 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) 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) (chan *io.PipeWriter, 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) 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) 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) (chan io.ReadCloser, 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) 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) 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) (chan io.ReadSeeker, 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) 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) 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) (chan io.ReadWriteCloser, 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) 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) 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) (chan io.ReadWriteSeeker, 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) 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) 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) (chan io.ReadWriter, 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) 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) 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) (chan io.ReaderAt, 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) 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) 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) (chan io.Reader, 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) 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) (chan io.ReaderFrom, 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) 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) 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) 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) (chan io.RuneReader, 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) 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) 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) (chan io.RuneScanner, 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) 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) 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) (chan *io.SectionReader, 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) 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) 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) (chan io.Seeker, 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) 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) 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) (chan io.WriteCloser, 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) 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) 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) (chan io.WriteSeeker, 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) 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) 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) (chan io.WriterAt, 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) 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) 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) (chan io.Writer, 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) 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) 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) (chan io.WriterTo, 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) 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.

Source Files ¶

View all Source files

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL