io

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

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

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

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type ByteReaderChan 

type ByteReaderChan interface {
	ByteReaderROnlyChan // aka "<-chan" - receive only
	ByteReaderSOnlyChan // aka "chan<-" - send only
}

ByteReaderChan represents a bidirectional channel

type ByteReaderROnlyChan 

type ByteReaderROnlyChan interface {
	RequestByteReader() (dat io.ByteReader)        // the receive function - aka "MyByteReader := <-MyByteReaderROnlyChan"
	TryByteReader() (dat io.ByteReader, open bool) // the multi-valued comma-ok receive function - aka "MyByteReader, ok := <-MyByteReaderROnlyChan"
}

ByteReaderROnlyChan represents a receive-only channel

type ByteReaderSOnlyChan 

type ByteReaderSOnlyChan interface {
	ProvideByteReader(dat io.ByteReader) // the send function - aka "MyKind <- some ByteReader"
}

ByteReaderSOnlyChan represents a send-only channel

type ByteScannerChan 

type ByteScannerChan interface {
	ByteScannerROnlyChan // aka "<-chan" - receive only
	ByteScannerSOnlyChan // aka "chan<-" - send only
}

ByteScannerChan represents a bidirectional channel

type ByteScannerROnlyChan 

type ByteScannerROnlyChan interface {
	RequestByteScanner() (dat io.ByteScanner)        // the receive function - aka "MyByteScanner := <-MyByteScannerROnlyChan"
	TryByteScanner() (dat io.ByteScanner, open bool) // the multi-valued comma-ok receive function - aka "MyByteScanner, ok := <-MyByteScannerROnlyChan"
}

ByteScannerROnlyChan represents a receive-only channel

type ByteScannerSOnlyChan 

type ByteScannerSOnlyChan interface {
	ProvideByteScanner(dat io.ByteScanner) // the send function - aka "MyKind <- some ByteScanner"
}

ByteScannerSOnlyChan represents a send-only channel

type ByteWriterChan 

type ByteWriterChan interface {
	ByteWriterROnlyChan // aka "<-chan" - receive only
	ByteWriterSOnlyChan // aka "chan<-" - send only
}

ByteWriterChan represents a bidirectional channel

type ByteWriterROnlyChan 

type ByteWriterROnlyChan interface {
	RequestByteWriter() (dat io.ByteWriter)        // the receive function - aka "MyByteWriter := <-MyByteWriterROnlyChan"
	TryByteWriter() (dat io.ByteWriter, open bool) // the multi-valued comma-ok receive function - aka "MyByteWriter, ok := <-MyByteWriterROnlyChan"
}

ByteWriterROnlyChan represents a receive-only channel

type ByteWriterSOnlyChan 

type ByteWriterSOnlyChan interface {
	ProvideByteWriter(dat io.ByteWriter) // the send function - aka "MyKind <- some ByteWriter"
}

ByteWriterSOnlyChan represents a send-only channel

type CloserChan 

type CloserChan interface {
	CloserROnlyChan // aka "<-chan" - receive only
	CloserSOnlyChan // aka "chan<-" - send only
}

CloserChan represents a bidirectional channel

type CloserROnlyChan 

type CloserROnlyChan interface {
	RequestCloser() (dat io.Closer)        // the receive function - aka "MyCloser := <-MyCloserROnlyChan"
	TryCloser() (dat io.Closer, open bool) // the multi-valued comma-ok receive function - aka "MyCloser, ok := <-MyCloserROnlyChan"
}

CloserROnlyChan represents a receive-only channel

type CloserSOnlyChan 

type CloserSOnlyChan interface {
	ProvideCloser(dat io.Closer) // the send function - aka "MyKind <- some Closer"
}

CloserSOnlyChan represents a send-only channel

type DChByteReader 

type DChByteReader struct {
	// contains filtered or unexported fields
}

DChByteReader is a demand channel

func MakeDemandByteReaderBuff 

func MakeDemandByteReaderBuff(cap int) *DChByteReader

MakeDemandByteReaderBuff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandByteReaderChan 

func MakeDemandByteReaderChan() *DChByteReader

MakeDemandByteReaderChan returns a (pointer to a) fresh unbuffered demand channel

func (*DChByteReader) ProvideByteReader 

func (c *DChByteReader) ProvideByteReader(dat io.ByteReader)

ProvideByteReader is the send function - aka "MyKind <- some ByteReader"

func (*DChByteReader) RequestByteReader 

func (c *DChByteReader) RequestByteReader() (dat io.ByteReader)

RequestByteReader is the receive function - aka "some ByteReader <- MyKind"

func (*DChByteReader) TryByteReader 

func (c *DChByteReader) TryByteReader() (dat io.ByteReader, open bool)

TryByteReader is the comma-ok multi-valued form of RequestByteReader and reports whether a received value was sent before the ByteReader channel was closed.

type DChByteScanner 

type DChByteScanner struct {
	// contains filtered or unexported fields
}

DChByteScanner is a demand channel

func MakeDemandByteScannerBuff 

func MakeDemandByteScannerBuff(cap int) *DChByteScanner

MakeDemandByteScannerBuff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandByteScannerChan 

func MakeDemandByteScannerChan() *DChByteScanner

MakeDemandByteScannerChan returns a (pointer to a) fresh unbuffered demand channel

func (*DChByteScanner) ProvideByteScanner 

func (c *DChByteScanner) ProvideByteScanner(dat io.ByteScanner)

ProvideByteScanner is the send function - aka "MyKind <- some ByteScanner"

func (*DChByteScanner) RequestByteScanner 

func (c *DChByteScanner) RequestByteScanner() (dat io.ByteScanner)

RequestByteScanner is the receive function - aka "some ByteScanner <- MyKind"

func (*DChByteScanner) TryByteScanner 

func (c *DChByteScanner) TryByteScanner() (dat io.ByteScanner, open bool)

TryByteScanner is the comma-ok multi-valued form of RequestByteScanner and reports whether a received value was sent before the ByteScanner channel was closed.

type DChByteWriter 

type DChByteWriter struct {
	// contains filtered or unexported fields
}

DChByteWriter is a demand channel

func MakeDemandByteWriterBuff 

func MakeDemandByteWriterBuff(cap int) *DChByteWriter

MakeDemandByteWriterBuff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandByteWriterChan 

func MakeDemandByteWriterChan() *DChByteWriter

MakeDemandByteWriterChan returns a (pointer to a) fresh unbuffered demand channel

func (*DChByteWriter) ProvideByteWriter 

func (c *DChByteWriter) ProvideByteWriter(dat io.ByteWriter)

ProvideByteWriter is the send function - aka "MyKind <- some ByteWriter"

func (*DChByteWriter) RequestByteWriter 

func (c *DChByteWriter) RequestByteWriter() (dat io.ByteWriter)

RequestByteWriter is the receive function - aka "some ByteWriter <- MyKind"

func (*DChByteWriter) TryByteWriter 

func (c *DChByteWriter) TryByteWriter() (dat io.ByteWriter, open bool)

TryByteWriter is the comma-ok multi-valued form of RequestByteWriter and reports whether a received value was sent before the ByteWriter channel was closed.

type DChCloser 

type DChCloser struct {
	// contains filtered or unexported fields
}

DChCloser is a demand channel

func MakeDemandCloserBuff 

func MakeDemandCloserBuff(cap int) *DChCloser

MakeDemandCloserBuff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandCloserChan 

func MakeDemandCloserChan() *DChCloser

MakeDemandCloserChan returns a (pointer to a) fresh unbuffered demand channel

func (*DChCloser) ProvideCloser 

func (c *DChCloser) ProvideCloser(dat io.Closer)

ProvideCloser is the send function - aka "MyKind <- some Closer"

func (*DChCloser) RequestCloser 

func (c *DChCloser) RequestCloser() (dat io.Closer)

RequestCloser is the receive function - aka "some Closer <- MyKind"

func (*DChCloser) TryCloser 

func (c *DChCloser) TryCloser() (dat io.Closer, open bool)

TryCloser is the comma-ok multi-valued form of RequestCloser and reports whether a received value was sent before the Closer channel was closed.

type DChLimitedReader 

type DChLimitedReader struct {
	// contains filtered or unexported fields
}

DChLimitedReader is a demand channel

func MakeDemandLimitedReaderBuff 

func MakeDemandLimitedReaderBuff(cap int) *DChLimitedReader

MakeDemandLimitedReaderBuff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandLimitedReaderChan 

func MakeDemandLimitedReaderChan() *DChLimitedReader

MakeDemandLimitedReaderChan returns a (pointer to a) fresh unbuffered demand channel

func (*DChLimitedReader) ProvideLimitedReader 

func (c *DChLimitedReader) ProvideLimitedReader(dat *io.LimitedReader)

ProvideLimitedReader is the send function - aka "MyKind <- some LimitedReader"

func (*DChLimitedReader) RequestLimitedReader 

func (c *DChLimitedReader) RequestLimitedReader() (dat *io.LimitedReader)

RequestLimitedReader is the receive function - aka "some LimitedReader <- MyKind"

func (*DChLimitedReader) TryLimitedReader 

func (c *DChLimitedReader) TryLimitedReader() (dat *io.LimitedReader, open bool)

TryLimitedReader is the comma-ok multi-valued form of RequestLimitedReader and reports whether a received value was sent before the LimitedReader channel was closed.

type DChPipeReader 

type DChPipeReader struct {
	// contains filtered or unexported fields
}

DChPipeReader is a demand channel

func MakeDemandPipeReaderBuff 

func MakeDemandPipeReaderBuff(cap int) *DChPipeReader

MakeDemandPipeReaderBuff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandPipeReaderChan 

func MakeDemandPipeReaderChan() *DChPipeReader

MakeDemandPipeReaderChan returns a (pointer to a) fresh unbuffered demand channel

func (*DChPipeReader) ProvidePipeReader 

func (c *DChPipeReader) ProvidePipeReader(dat *io.PipeReader)

ProvidePipeReader is the send function - aka "MyKind <- some PipeReader"

func (*DChPipeReader) RequestPipeReader 

func (c *DChPipeReader) RequestPipeReader() (dat *io.PipeReader)

RequestPipeReader is the receive function - aka "some PipeReader <- MyKind"

func (*DChPipeReader) TryPipeReader 

func (c *DChPipeReader) TryPipeReader() (dat *io.PipeReader, open bool)

TryPipeReader is the comma-ok multi-valued form of RequestPipeReader and reports whether a received value was sent before the PipeReader channel was closed.

type DChPipeWriter 

type DChPipeWriter struct {
	// contains filtered or unexported fields
}

DChPipeWriter is a demand channel

func MakeDemandPipeWriterBuff 

func MakeDemandPipeWriterBuff(cap int) *DChPipeWriter

MakeDemandPipeWriterBuff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandPipeWriterChan 

func MakeDemandPipeWriterChan() *DChPipeWriter

MakeDemandPipeWriterChan returns a (pointer to a) fresh unbuffered demand channel

func (*DChPipeWriter) ProvidePipeWriter 

func (c *DChPipeWriter) ProvidePipeWriter(dat *io.PipeWriter)

ProvidePipeWriter is the send function - aka "MyKind <- some PipeWriter"

func (*DChPipeWriter) RequestPipeWriter 

func (c *DChPipeWriter) RequestPipeWriter() (dat *io.PipeWriter)

RequestPipeWriter is the receive function - aka "some PipeWriter <- MyKind"

func (*DChPipeWriter) TryPipeWriter 

func (c *DChPipeWriter) TryPipeWriter() (dat *io.PipeWriter, open bool)

TryPipeWriter is the comma-ok multi-valued form of RequestPipeWriter and reports whether a received value was sent before the PipeWriter channel was closed.

type DChReadCloser 

type DChReadCloser struct {
	// contains filtered or unexported fields
}

DChReadCloser is a demand channel

func MakeDemandReadCloserBuff 

func MakeDemandReadCloserBuff(cap int) *DChReadCloser

MakeDemandReadCloserBuff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandReadCloserChan 

func MakeDemandReadCloserChan() *DChReadCloser

MakeDemandReadCloserChan returns a (pointer to a) fresh unbuffered demand channel

func (*DChReadCloser) ProvideReadCloser 

func (c *DChReadCloser) ProvideReadCloser(dat io.ReadCloser)

ProvideReadCloser is the send function - aka "MyKind <- some ReadCloser"

func (*DChReadCloser) RequestReadCloser 

func (c *DChReadCloser) RequestReadCloser() (dat io.ReadCloser)

RequestReadCloser is the receive function - aka "some ReadCloser <- MyKind"

func (*DChReadCloser) TryReadCloser 

func (c *DChReadCloser) TryReadCloser() (dat io.ReadCloser, open bool)

TryReadCloser is the comma-ok multi-valued form of RequestReadCloser and reports whether a received value was sent before the ReadCloser channel was closed.

type DChReadSeeker 

type DChReadSeeker struct {
	// contains filtered or unexported fields
}

DChReadSeeker is a demand channel

func MakeDemandReadSeekerBuff 

func MakeDemandReadSeekerBuff(cap int) *DChReadSeeker

MakeDemandReadSeekerBuff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandReadSeekerChan 

func MakeDemandReadSeekerChan() *DChReadSeeker

MakeDemandReadSeekerChan returns a (pointer to a) fresh unbuffered demand channel

func (*DChReadSeeker) ProvideReadSeeker 

func (c *DChReadSeeker) ProvideReadSeeker(dat io.ReadSeeker)

ProvideReadSeeker is the send function - aka "MyKind <- some ReadSeeker"

func (*DChReadSeeker) RequestReadSeeker 

func (c *DChReadSeeker) RequestReadSeeker() (dat io.ReadSeeker)

RequestReadSeeker is the receive function - aka "some ReadSeeker <- MyKind"

func (*DChReadSeeker) TryReadSeeker 

func (c *DChReadSeeker) TryReadSeeker() (dat io.ReadSeeker, open bool)

TryReadSeeker is the comma-ok multi-valued form of RequestReadSeeker and reports whether a received value was sent before the ReadSeeker channel was closed.

type DChReadWriteCloser 

type DChReadWriteCloser struct {
	// contains filtered or unexported fields
}

DChReadWriteCloser is a demand channel

func MakeDemandReadWriteCloserBuff 

func MakeDemandReadWriteCloserBuff(cap int) *DChReadWriteCloser

MakeDemandReadWriteCloserBuff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandReadWriteCloserChan 

func MakeDemandReadWriteCloserChan() *DChReadWriteCloser

MakeDemandReadWriteCloserChan returns a (pointer to a) fresh unbuffered demand channel

func (*DChReadWriteCloser) ProvideReadWriteCloser 

func (c *DChReadWriteCloser) ProvideReadWriteCloser(dat io.ReadWriteCloser)

ProvideReadWriteCloser is the send function - aka "MyKind <- some ReadWriteCloser"

func (*DChReadWriteCloser) RequestReadWriteCloser 

func (c *DChReadWriteCloser) RequestReadWriteCloser() (dat io.ReadWriteCloser)

RequestReadWriteCloser is the receive function - aka "some ReadWriteCloser <- MyKind"

func (*DChReadWriteCloser) TryReadWriteCloser 

func (c *DChReadWriteCloser) TryReadWriteCloser() (dat io.ReadWriteCloser, open bool)

TryReadWriteCloser is the comma-ok multi-valued form of RequestReadWriteCloser and reports whether a received value was sent before the ReadWriteCloser channel was closed.

type DChReadWriteSeeker 

type DChReadWriteSeeker struct {
	// contains filtered or unexported fields
}

DChReadWriteSeeker is a demand channel

func MakeDemandReadWriteSeekerBuff 

func MakeDemandReadWriteSeekerBuff(cap int) *DChReadWriteSeeker

MakeDemandReadWriteSeekerBuff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandReadWriteSeekerChan 

func MakeDemandReadWriteSeekerChan() *DChReadWriteSeeker

MakeDemandReadWriteSeekerChan returns a (pointer to a) fresh unbuffered demand channel

func (*DChReadWriteSeeker) ProvideReadWriteSeeker 

func (c *DChReadWriteSeeker) ProvideReadWriteSeeker(dat io.ReadWriteSeeker)

ProvideReadWriteSeeker is the send function - aka "MyKind <- some ReadWriteSeeker"

func (*DChReadWriteSeeker) RequestReadWriteSeeker 

func (c *DChReadWriteSeeker) RequestReadWriteSeeker() (dat io.ReadWriteSeeker)

RequestReadWriteSeeker is the receive function - aka "some ReadWriteSeeker <- MyKind"

func (*DChReadWriteSeeker) TryReadWriteSeeker 

func (c *DChReadWriteSeeker) TryReadWriteSeeker() (dat io.ReadWriteSeeker, open bool)

TryReadWriteSeeker is the comma-ok multi-valued form of RequestReadWriteSeeker and reports whether a received value was sent before the ReadWriteSeeker channel was closed.

type DChReadWriter 

type DChReadWriter struct {
	// contains filtered or unexported fields
}

DChReadWriter is a demand channel

func MakeDemandReadWriterBuff 

func MakeDemandReadWriterBuff(cap int) *DChReadWriter

MakeDemandReadWriterBuff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandReadWriterChan 

func MakeDemandReadWriterChan() *DChReadWriter

MakeDemandReadWriterChan returns a (pointer to a) fresh unbuffered demand channel

func (*DChReadWriter) ProvideReadWriter 

func (c *DChReadWriter) ProvideReadWriter(dat io.ReadWriter)

ProvideReadWriter is the send function - aka "MyKind <- some ReadWriter"

func (*DChReadWriter) RequestReadWriter 

func (c *DChReadWriter) RequestReadWriter() (dat io.ReadWriter)

RequestReadWriter is the receive function - aka "some ReadWriter <- MyKind"

func (*DChReadWriter) TryReadWriter 

func (c *DChReadWriter) TryReadWriter() (dat io.ReadWriter, open bool)

TryReadWriter is the comma-ok multi-valued form of RequestReadWriter and reports whether a received value was sent before the ReadWriter channel was closed.

type DChReader 

type DChReader struct {
	// contains filtered or unexported fields
}

DChReader is a demand channel

func MakeDemandReaderBuff 

func MakeDemandReaderBuff(cap int) *DChReader

MakeDemandReaderBuff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandReaderChan 

func MakeDemandReaderChan() *DChReader

MakeDemandReaderChan returns a (pointer to a) fresh unbuffered demand channel

func (*DChReader) ProvideReader 

func (c *DChReader) ProvideReader(dat io.Reader)

ProvideReader is the send function - aka "MyKind <- some Reader"

func (*DChReader) RequestReader 

func (c *DChReader) RequestReader() (dat io.Reader)

RequestReader is the receive function - aka "some Reader <- MyKind"

func (*DChReader) TryReader 

func (c *DChReader) TryReader() (dat io.Reader, open bool)

TryReader is the comma-ok multi-valued form of RequestReader and reports whether a received value was sent before the Reader channel was closed.

type DChReaderAt 

type DChReaderAt struct {
	// contains filtered or unexported fields
}

DChReaderAt is a demand channel

func MakeDemandReaderAtBuff 

func MakeDemandReaderAtBuff(cap int) *DChReaderAt

MakeDemandReaderAtBuff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandReaderAtChan 

func MakeDemandReaderAtChan() *DChReaderAt

MakeDemandReaderAtChan returns a (pointer to a) fresh unbuffered demand channel

func (*DChReaderAt) ProvideReaderAt 

func (c *DChReaderAt) ProvideReaderAt(dat io.ReaderAt)

ProvideReaderAt is the send function - aka "MyKind <- some ReaderAt"

func (*DChReaderAt) RequestReaderAt 

func (c *DChReaderAt) RequestReaderAt() (dat io.ReaderAt)

RequestReaderAt is the receive function - aka "some ReaderAt <- MyKind"

func (*DChReaderAt) TryReaderAt 

func (c *DChReaderAt) TryReaderAt() (dat io.ReaderAt, open bool)

TryReaderAt is the comma-ok multi-valued form of RequestReaderAt and reports whether a received value was sent before the ReaderAt channel was closed.

type DChReaderFrom 

type DChReaderFrom struct {
	// contains filtered or unexported fields
}

DChReaderFrom is a demand channel

func MakeDemandReaderFromBuff 

func MakeDemandReaderFromBuff(cap int) *DChReaderFrom

MakeDemandReaderFromBuff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandReaderFromChan 

func MakeDemandReaderFromChan() *DChReaderFrom

MakeDemandReaderFromChan returns a (pointer to a) fresh unbuffered demand channel

func (*DChReaderFrom) ProvideReaderFrom 

func (c *DChReaderFrom) ProvideReaderFrom(dat io.ReaderFrom)

ProvideReaderFrom is the send function - aka "MyKind <- some ReaderFrom"

func (*DChReaderFrom) RequestReaderFrom 

func (c *DChReaderFrom) RequestReaderFrom() (dat io.ReaderFrom)

RequestReaderFrom is the receive function - aka "some ReaderFrom <- MyKind"

func (*DChReaderFrom) TryReaderFrom 

func (c *DChReaderFrom) TryReaderFrom() (dat io.ReaderFrom, open bool)

TryReaderFrom is the comma-ok multi-valued form of RequestReaderFrom and reports whether a received value was sent before the ReaderFrom channel was closed.

type DChRuneReader 

type DChRuneReader struct {
	// contains filtered or unexported fields
}

DChRuneReader is a demand channel

func MakeDemandRuneReaderBuff 

func MakeDemandRuneReaderBuff(cap int) *DChRuneReader

MakeDemandRuneReaderBuff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandRuneReaderChan 

func MakeDemandRuneReaderChan() *DChRuneReader

MakeDemandRuneReaderChan returns a (pointer to a) fresh unbuffered demand channel

func (*DChRuneReader) ProvideRuneReader 

func (c *DChRuneReader) ProvideRuneReader(dat io.RuneReader)

ProvideRuneReader is the send function - aka "MyKind <- some RuneReader"

func (*DChRuneReader) RequestRuneReader 

func (c *DChRuneReader) RequestRuneReader() (dat io.RuneReader)

RequestRuneReader is the receive function - aka "some RuneReader <- MyKind"

func (*DChRuneReader) TryRuneReader 

func (c *DChRuneReader) TryRuneReader() (dat io.RuneReader, open bool)

TryRuneReader is the comma-ok multi-valued form of RequestRuneReader and reports whether a received value was sent before the RuneReader channel was closed.

type DChRuneScanner 

type DChRuneScanner struct {
	// contains filtered or unexported fields
}

DChRuneScanner is a demand channel

func MakeDemandRuneScannerBuff 

func MakeDemandRuneScannerBuff(cap int) *DChRuneScanner

MakeDemandRuneScannerBuff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandRuneScannerChan 

func MakeDemandRuneScannerChan() *DChRuneScanner

MakeDemandRuneScannerChan returns a (pointer to a) fresh unbuffered demand channel

func (*DChRuneScanner) ProvideRuneScanner 

func (c *DChRuneScanner) ProvideRuneScanner(dat io.RuneScanner)

ProvideRuneScanner is the send function - aka "MyKind <- some RuneScanner"

func (*DChRuneScanner) RequestRuneScanner 

func (c *DChRuneScanner) RequestRuneScanner() (dat io.RuneScanner)

RequestRuneScanner is the receive function - aka "some RuneScanner <- MyKind"

func (*DChRuneScanner) TryRuneScanner 

func (c *DChRuneScanner) TryRuneScanner() (dat io.RuneScanner, open bool)

TryRuneScanner is the comma-ok multi-valued form of RequestRuneScanner and reports whether a received value was sent before the RuneScanner channel was closed.

type DChSectionReader 

type DChSectionReader struct {
	// contains filtered or unexported fields
}

DChSectionReader is a demand channel

func MakeDemandSectionReaderBuff 

func MakeDemandSectionReaderBuff(cap int) *DChSectionReader

MakeDemandSectionReaderBuff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandSectionReaderChan 

func MakeDemandSectionReaderChan() *DChSectionReader

MakeDemandSectionReaderChan returns a (pointer to a) fresh unbuffered demand channel

func (*DChSectionReader) ProvideSectionReader 

func (c *DChSectionReader) ProvideSectionReader(dat *io.SectionReader)

ProvideSectionReader is the send function - aka "MyKind <- some SectionReader"

func (*DChSectionReader) RequestSectionReader 

func (c *DChSectionReader) RequestSectionReader() (dat *io.SectionReader)

RequestSectionReader is the receive function - aka "some SectionReader <- MyKind"

func (*DChSectionReader) TrySectionReader 

func (c *DChSectionReader) TrySectionReader() (dat *io.SectionReader, open bool)

TrySectionReader is the comma-ok multi-valued form of RequestSectionReader and reports whether a received value was sent before the SectionReader channel was closed.

type DChSeeker 

type DChSeeker struct {
	// contains filtered or unexported fields
}

DChSeeker is a demand channel

func MakeDemandSeekerBuff 

func MakeDemandSeekerBuff(cap int) *DChSeeker

MakeDemandSeekerBuff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandSeekerChan 

func MakeDemandSeekerChan() *DChSeeker

MakeDemandSeekerChan returns a (pointer to a) fresh unbuffered demand channel

func (*DChSeeker) ProvideSeeker 

func (c *DChSeeker) ProvideSeeker(dat io.Seeker)

ProvideSeeker is the send function - aka "MyKind <- some Seeker"

func (*DChSeeker) RequestSeeker 

func (c *DChSeeker) RequestSeeker() (dat io.Seeker)

RequestSeeker is the receive function - aka "some Seeker <- MyKind"

func (*DChSeeker) TrySeeker 

func (c *DChSeeker) TrySeeker() (dat io.Seeker, open bool)

TrySeeker is the comma-ok multi-valued form of RequestSeeker and reports whether a received value was sent before the Seeker channel was closed.

type DChWriteCloser 

type DChWriteCloser struct {
	// contains filtered or unexported fields
}

DChWriteCloser is a demand channel

func MakeDemandWriteCloserBuff 

func MakeDemandWriteCloserBuff(cap int) *DChWriteCloser

MakeDemandWriteCloserBuff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandWriteCloserChan 

func MakeDemandWriteCloserChan() *DChWriteCloser

MakeDemandWriteCloserChan returns a (pointer to a) fresh unbuffered demand channel

func (*DChWriteCloser) ProvideWriteCloser 

func (c *DChWriteCloser) ProvideWriteCloser(dat io.WriteCloser)

ProvideWriteCloser is the send function - aka "MyKind <- some WriteCloser"

func (*DChWriteCloser) RequestWriteCloser 

func (c *DChWriteCloser) RequestWriteCloser() (dat io.WriteCloser)

RequestWriteCloser is the receive function - aka "some WriteCloser <- MyKind"

func (*DChWriteCloser) TryWriteCloser 

func (c *DChWriteCloser) TryWriteCloser() (dat io.WriteCloser, open bool)

TryWriteCloser is the comma-ok multi-valued form of RequestWriteCloser and reports whether a received value was sent before the WriteCloser channel was closed.

type DChWriteSeeker 

type DChWriteSeeker struct {
	// contains filtered or unexported fields
}

DChWriteSeeker is a demand channel

func MakeDemandWriteSeekerBuff 

func MakeDemandWriteSeekerBuff(cap int) *DChWriteSeeker

MakeDemandWriteSeekerBuff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandWriteSeekerChan 

func MakeDemandWriteSeekerChan() *DChWriteSeeker

MakeDemandWriteSeekerChan returns a (pointer to a) fresh unbuffered demand channel

func (*DChWriteSeeker) ProvideWriteSeeker 

func (c *DChWriteSeeker) ProvideWriteSeeker(dat io.WriteSeeker)

ProvideWriteSeeker is the send function - aka "MyKind <- some WriteSeeker"

func (*DChWriteSeeker) RequestWriteSeeker 

func (c *DChWriteSeeker) RequestWriteSeeker() (dat io.WriteSeeker)

RequestWriteSeeker is the receive function - aka "some WriteSeeker <- MyKind"

func (*DChWriteSeeker) TryWriteSeeker 

func (c *DChWriteSeeker) TryWriteSeeker() (dat io.WriteSeeker, open bool)

TryWriteSeeker is the comma-ok multi-valued form of RequestWriteSeeker and reports whether a received value was sent before the WriteSeeker channel was closed.

type DChWriter 

type DChWriter struct {
	// contains filtered or unexported fields
}

DChWriter is a demand channel

func MakeDemandWriterBuff 

func MakeDemandWriterBuff(cap int) *DChWriter

MakeDemandWriterBuff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandWriterChan 

func MakeDemandWriterChan() *DChWriter

MakeDemandWriterChan returns a (pointer to a) fresh unbuffered demand channel

func (*DChWriter) ProvideWriter 

func (c *DChWriter) ProvideWriter(dat io.Writer)

ProvideWriter is the send function - aka "MyKind <- some Writer"

func (*DChWriter) RequestWriter 

func (c *DChWriter) RequestWriter() (dat io.Writer)

RequestWriter is the receive function - aka "some Writer <- MyKind"

func (*DChWriter) TryWriter 

func (c *DChWriter) TryWriter() (dat io.Writer, open bool)

TryWriter is the comma-ok multi-valued form of RequestWriter and reports whether a received value was sent before the Writer channel was closed.

type DChWriterAt 

type DChWriterAt struct {
	// contains filtered or unexported fields
}

DChWriterAt is a demand channel

func MakeDemandWriterAtBuff 

func MakeDemandWriterAtBuff(cap int) *DChWriterAt

MakeDemandWriterAtBuff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandWriterAtChan 

func MakeDemandWriterAtChan() *DChWriterAt

MakeDemandWriterAtChan returns a (pointer to a) fresh unbuffered demand channel

func (*DChWriterAt) ProvideWriterAt 

func (c *DChWriterAt) ProvideWriterAt(dat io.WriterAt)

ProvideWriterAt is the send function - aka "MyKind <- some WriterAt"

func (*DChWriterAt) RequestWriterAt 

func (c *DChWriterAt) RequestWriterAt() (dat io.WriterAt)

RequestWriterAt is the receive function - aka "some WriterAt <- MyKind"

func (*DChWriterAt) TryWriterAt 

func (c *DChWriterAt) TryWriterAt() (dat io.WriterAt, open bool)

TryWriterAt is the comma-ok multi-valued form of RequestWriterAt and reports whether a received value was sent before the WriterAt channel was closed.

type DChWriterTo 

type DChWriterTo struct {
	// contains filtered or unexported fields
}

DChWriterTo is a demand channel

func MakeDemandWriterToBuff 

func MakeDemandWriterToBuff(cap int) *DChWriterTo

MakeDemandWriterToBuff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandWriterToChan 

func MakeDemandWriterToChan() *DChWriterTo

MakeDemandWriterToChan returns a (pointer to a) fresh unbuffered demand channel

func (*DChWriterTo) ProvideWriterTo 

func (c *DChWriterTo) ProvideWriterTo(dat io.WriterTo)

ProvideWriterTo is the send function - aka "MyKind <- some WriterTo"

func (*DChWriterTo) RequestWriterTo 

func (c *DChWriterTo) RequestWriterTo() (dat io.WriterTo)

RequestWriterTo is the receive function - aka "some WriterTo <- MyKind"

func (*DChWriterTo) TryWriterTo 

func (c *DChWriterTo) TryWriterTo() (dat io.WriterTo, open bool)

TryWriterTo is the comma-ok multi-valued form of RequestWriterTo and reports whether a received value was sent before the WriterTo channel was closed.

type LimitedReaderChan 

type LimitedReaderChan interface {
	LimitedReaderROnlyChan // aka "<-chan" - receive only
	LimitedReaderSOnlyChan // aka "chan<-" - send only
}

LimitedReaderChan represents a bidirectional channel

type LimitedReaderROnlyChan 

type LimitedReaderROnlyChan interface {
	RequestLimitedReader() (dat *io.LimitedReader)        // the receive function - aka "MyLimitedReader := <-MyLimitedReaderROnlyChan"
	TryLimitedReader() (dat *io.LimitedReader, open bool) // the multi-valued comma-ok receive function - aka "MyLimitedReader, ok := <-MyLimitedReaderROnlyChan"
}

LimitedReaderROnlyChan represents a receive-only channel

type LimitedReaderSOnlyChan 

type LimitedReaderSOnlyChan interface {
	ProvideLimitedReader(dat *io.LimitedReader) // the send function - aka "MyKind <- some LimitedReader"
}

LimitedReaderSOnlyChan represents a send-only channel

type PipeReaderChan 

type PipeReaderChan interface {
	PipeReaderROnlyChan // aka "<-chan" - receive only
	PipeReaderSOnlyChan // aka "chan<-" - send only
}

PipeReaderChan represents a bidirectional channel

type PipeReaderROnlyChan 

type PipeReaderROnlyChan interface {
	RequestPipeReader() (dat *io.PipeReader)        // the receive function - aka "MyPipeReader := <-MyPipeReaderROnlyChan"
	TryPipeReader() (dat *io.PipeReader, open bool) // the multi-valued comma-ok receive function - aka "MyPipeReader, ok := <-MyPipeReaderROnlyChan"
}

PipeReaderROnlyChan represents a receive-only channel

type PipeReaderSOnlyChan 

type PipeReaderSOnlyChan interface {
	ProvidePipeReader(dat *io.PipeReader) // the send function - aka "MyKind <- some PipeReader"
}

PipeReaderSOnlyChan represents a send-only channel

type PipeWriterChan 

type PipeWriterChan interface {
	PipeWriterROnlyChan // aka "<-chan" - receive only
	PipeWriterSOnlyChan // aka "chan<-" - send only
}

PipeWriterChan represents a bidirectional channel

type PipeWriterROnlyChan 

type PipeWriterROnlyChan interface {
	RequestPipeWriter() (dat *io.PipeWriter)        // the receive function - aka "MyPipeWriter := <-MyPipeWriterROnlyChan"
	TryPipeWriter() (dat *io.PipeWriter, open bool) // the multi-valued comma-ok receive function - aka "MyPipeWriter, ok := <-MyPipeWriterROnlyChan"
}

PipeWriterROnlyChan represents a receive-only channel

type PipeWriterSOnlyChan 

type PipeWriterSOnlyChan interface {
	ProvidePipeWriter(dat *io.PipeWriter) // the send function - aka "MyKind <- some PipeWriter"
}

PipeWriterSOnlyChan represents a send-only channel

type ReadCloserChan 

type ReadCloserChan interface {
	ReadCloserROnlyChan // aka "<-chan" - receive only
	ReadCloserSOnlyChan // aka "chan<-" - send only
}

ReadCloserChan represents a bidirectional channel

type ReadCloserROnlyChan 

type ReadCloserROnlyChan interface {
	RequestReadCloser() (dat io.ReadCloser)        // the receive function - aka "MyReadCloser := <-MyReadCloserROnlyChan"
	TryReadCloser() (dat io.ReadCloser, open bool) // the multi-valued comma-ok receive function - aka "MyReadCloser, ok := <-MyReadCloserROnlyChan"
}

ReadCloserROnlyChan represents a receive-only channel

type ReadCloserSOnlyChan 

type ReadCloserSOnlyChan interface {
	ProvideReadCloser(dat io.ReadCloser) // the send function - aka "MyKind <- some ReadCloser"
}

ReadCloserSOnlyChan represents a send-only channel

type ReadSeekerChan 

type ReadSeekerChan interface {
	ReadSeekerROnlyChan // aka "<-chan" - receive only
	ReadSeekerSOnlyChan // aka "chan<-" - send only
}

ReadSeekerChan represents a bidirectional channel

type ReadSeekerROnlyChan 

type ReadSeekerROnlyChan interface {
	RequestReadSeeker() (dat io.ReadSeeker)        // the receive function - aka "MyReadSeeker := <-MyReadSeekerROnlyChan"
	TryReadSeeker() (dat io.ReadSeeker, open bool) // the multi-valued comma-ok receive function - aka "MyReadSeeker, ok := <-MyReadSeekerROnlyChan"
}

ReadSeekerROnlyChan represents a receive-only channel

type ReadSeekerSOnlyChan 

type ReadSeekerSOnlyChan interface {
	ProvideReadSeeker(dat io.ReadSeeker) // the send function - aka "MyKind <- some ReadSeeker"
}

ReadSeekerSOnlyChan represents a send-only channel

type ReadWriteCloserChan 

type ReadWriteCloserChan interface {
	ReadWriteCloserROnlyChan // aka "<-chan" - receive only
	ReadWriteCloserSOnlyChan // aka "chan<-" - send only
}

ReadWriteCloserChan represents a bidirectional channel

type ReadWriteCloserROnlyChan 

type ReadWriteCloserROnlyChan interface {
	RequestReadWriteCloser() (dat io.ReadWriteCloser)        // the receive function - aka "MyReadWriteCloser := <-MyReadWriteCloserROnlyChan"
	TryReadWriteCloser() (dat io.ReadWriteCloser, open bool) // the multi-valued comma-ok receive function - aka "MyReadWriteCloser, ok := <-MyReadWriteCloserROnlyChan"
}

ReadWriteCloserROnlyChan represents a receive-only channel

type ReadWriteCloserSOnlyChan 

type ReadWriteCloserSOnlyChan interface {
	ProvideReadWriteCloser(dat io.ReadWriteCloser) // the send function - aka "MyKind <- some ReadWriteCloser"
}

ReadWriteCloserSOnlyChan represents a send-only channel

type ReadWriteSeekerChan 

type ReadWriteSeekerChan interface {
	ReadWriteSeekerROnlyChan // aka "<-chan" - receive only
	ReadWriteSeekerSOnlyChan // aka "chan<-" - send only
}

ReadWriteSeekerChan represents a bidirectional channel

type ReadWriteSeekerROnlyChan 

type ReadWriteSeekerROnlyChan interface {
	RequestReadWriteSeeker() (dat io.ReadWriteSeeker)        // the receive function - aka "MyReadWriteSeeker := <-MyReadWriteSeekerROnlyChan"
	TryReadWriteSeeker() (dat io.ReadWriteSeeker, open bool) // the multi-valued comma-ok receive function - aka "MyReadWriteSeeker, ok := <-MyReadWriteSeekerROnlyChan"
}

ReadWriteSeekerROnlyChan represents a receive-only channel

type ReadWriteSeekerSOnlyChan 

type ReadWriteSeekerSOnlyChan interface {
	ProvideReadWriteSeeker(dat io.ReadWriteSeeker) // the send function - aka "MyKind <- some ReadWriteSeeker"
}

ReadWriteSeekerSOnlyChan represents a send-only channel

type ReadWriterChan 

type ReadWriterChan interface {
	ReadWriterROnlyChan // aka "<-chan" - receive only
	ReadWriterSOnlyChan // aka "chan<-" - send only
}

ReadWriterChan represents a bidirectional channel

type ReadWriterROnlyChan 

type ReadWriterROnlyChan interface {
	RequestReadWriter() (dat io.ReadWriter)        // the receive function - aka "MyReadWriter := <-MyReadWriterROnlyChan"
	TryReadWriter() (dat io.ReadWriter, open bool) // the multi-valued comma-ok receive function - aka "MyReadWriter, ok := <-MyReadWriterROnlyChan"
}

ReadWriterROnlyChan represents a receive-only channel

type ReadWriterSOnlyChan 

type ReadWriterSOnlyChan interface {
	ProvideReadWriter(dat io.ReadWriter) // the send function - aka "MyKind <- some ReadWriter"
}

ReadWriterSOnlyChan represents a send-only channel

type ReaderAtChan 

type ReaderAtChan interface {
	ReaderAtROnlyChan // aka "<-chan" - receive only
	ReaderAtSOnlyChan // aka "chan<-" - send only
}

ReaderAtChan represents a bidirectional channel

type ReaderAtROnlyChan 

type ReaderAtROnlyChan interface {
	RequestReaderAt() (dat io.ReaderAt)        // the receive function - aka "MyReaderAt := <-MyReaderAtROnlyChan"
	TryReaderAt() (dat io.ReaderAt, open bool) // the multi-valued comma-ok receive function - aka "MyReaderAt, ok := <-MyReaderAtROnlyChan"
}

ReaderAtROnlyChan represents a receive-only channel

type ReaderAtSOnlyChan 

type ReaderAtSOnlyChan interface {
	ProvideReaderAt(dat io.ReaderAt) // the send function - aka "MyKind <- some ReaderAt"
}

ReaderAtSOnlyChan represents a send-only channel

type ReaderChan 

type ReaderChan interface {
	ReaderROnlyChan // aka "<-chan" - receive only
	ReaderSOnlyChan // aka "chan<-" - send only
}

ReaderChan represents a bidirectional channel

type ReaderFromChan 

type ReaderFromChan interface {
	ReaderFromROnlyChan // aka "<-chan" - receive only
	ReaderFromSOnlyChan // aka "chan<-" - send only
}

ReaderFromChan represents a bidirectional channel

type ReaderFromROnlyChan 

type ReaderFromROnlyChan interface {
	RequestReaderFrom() (dat io.ReaderFrom)        // the receive function - aka "MyReaderFrom := <-MyReaderFromROnlyChan"
	TryReaderFrom() (dat io.ReaderFrom, open bool) // the multi-valued comma-ok receive function - aka "MyReaderFrom, ok := <-MyReaderFromROnlyChan"
}

ReaderFromROnlyChan represents a receive-only channel

type ReaderFromSOnlyChan 

type ReaderFromSOnlyChan interface {
	ProvideReaderFrom(dat io.ReaderFrom) // the send function - aka "MyKind <- some ReaderFrom"
}

ReaderFromSOnlyChan represents a send-only channel

type ReaderROnlyChan 

type ReaderROnlyChan interface {
	RequestReader() (dat io.Reader)        // the receive function - aka "MyReader := <-MyReaderROnlyChan"
	TryReader() (dat io.Reader, open bool) // the multi-valued comma-ok receive function - aka "MyReader, ok := <-MyReaderROnlyChan"
}

ReaderROnlyChan represents a receive-only channel

type ReaderSOnlyChan 

type ReaderSOnlyChan interface {
	ProvideReader(dat io.Reader) // the send function - aka "MyKind <- some Reader"
}

ReaderSOnlyChan represents a send-only channel

type RuneReaderChan 

type RuneReaderChan interface {
	RuneReaderROnlyChan // aka "<-chan" - receive only
	RuneReaderSOnlyChan // aka "chan<-" - send only
}

RuneReaderChan represents a bidirectional channel

type RuneReaderROnlyChan 

type RuneReaderROnlyChan interface {
	RequestRuneReader() (dat io.RuneReader)        // the receive function - aka "MyRuneReader := <-MyRuneReaderROnlyChan"
	TryRuneReader() (dat io.RuneReader, open bool) // the multi-valued comma-ok receive function - aka "MyRuneReader, ok := <-MyRuneReaderROnlyChan"
}

RuneReaderROnlyChan represents a receive-only channel

type RuneReaderSOnlyChan 

type RuneReaderSOnlyChan interface {
	ProvideRuneReader(dat io.RuneReader) // the send function - aka "MyKind <- some RuneReader"
}

RuneReaderSOnlyChan represents a send-only channel

type RuneScannerChan 

type RuneScannerChan interface {
	RuneScannerROnlyChan // aka "<-chan" - receive only
	RuneScannerSOnlyChan // aka "chan<-" - send only
}

RuneScannerChan represents a bidirectional channel

type RuneScannerROnlyChan 

type RuneScannerROnlyChan interface {
	RequestRuneScanner() (dat io.RuneScanner)        // the receive function - aka "MyRuneScanner := <-MyRuneScannerROnlyChan"
	TryRuneScanner() (dat io.RuneScanner, open bool) // the multi-valued comma-ok receive function - aka "MyRuneScanner, ok := <-MyRuneScannerROnlyChan"
}

RuneScannerROnlyChan represents a receive-only channel

type RuneScannerSOnlyChan 

type RuneScannerSOnlyChan interface {
	ProvideRuneScanner(dat io.RuneScanner) // the send function - aka "MyKind <- some RuneScanner"
}

RuneScannerSOnlyChan represents a send-only channel

type SChByteReader 

type SChByteReader struct {
	// contains filtered or unexported fields
}

SChByteReader is a supply channel

func MakeSupplyByteReaderBuff 

func MakeSupplyByteReaderBuff(cap int) *SChByteReader

MakeSupplyByteReaderBuff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyByteReaderChan 

func MakeSupplyByteReaderChan() *SChByteReader

MakeSupplyByteReaderChan returns a (pointer to a) fresh unbuffered supply channel

func (*SChByteReader) ProvideByteReader 

func (c *SChByteReader) ProvideByteReader(dat io.ByteReader)

ProvideByteReader is the send function - aka "MyKind <- some ByteReader"

func (*SChByteReader) RequestByteReader 

func (c *SChByteReader) RequestByteReader() (dat io.ByteReader)

RequestByteReader is the receive function - aka "some ByteReader <- MyKind"

func (*SChByteReader) TryByteReader 

func (c *SChByteReader) TryByteReader() (dat io.ByteReader, open bool)

TryByteReader is the comma-ok multi-valued form of RequestByteReader and reports whether a received value was sent before the ByteReader channel was closed.

type SChByteScanner 

type SChByteScanner struct {
	// contains filtered or unexported fields
}

SChByteScanner is a supply channel

func MakeSupplyByteScannerBuff 

func MakeSupplyByteScannerBuff(cap int) *SChByteScanner

MakeSupplyByteScannerBuff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyByteScannerChan 

func MakeSupplyByteScannerChan() *SChByteScanner

MakeSupplyByteScannerChan returns a (pointer to a) fresh unbuffered supply channel

func (*SChByteScanner) ProvideByteScanner 

func (c *SChByteScanner) ProvideByteScanner(dat io.ByteScanner)

ProvideByteScanner is the send function - aka "MyKind <- some ByteScanner"

func (*SChByteScanner) RequestByteScanner 

func (c *SChByteScanner) RequestByteScanner() (dat io.ByteScanner)

RequestByteScanner is the receive function - aka "some ByteScanner <- MyKind"

func (*SChByteScanner) TryByteScanner 

func (c *SChByteScanner) TryByteScanner() (dat io.ByteScanner, open bool)

TryByteScanner is the comma-ok multi-valued form of RequestByteScanner and reports whether a received value was sent before the ByteScanner channel was closed.

type SChByteWriter 

type SChByteWriter struct {
	// contains filtered or unexported fields
}

SChByteWriter is a supply channel

func MakeSupplyByteWriterBuff 

func MakeSupplyByteWriterBuff(cap int) *SChByteWriter

MakeSupplyByteWriterBuff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyByteWriterChan 

func MakeSupplyByteWriterChan() *SChByteWriter

MakeSupplyByteWriterChan returns a (pointer to a) fresh unbuffered supply channel

func (*SChByteWriter) ProvideByteWriter 

func (c *SChByteWriter) ProvideByteWriter(dat io.ByteWriter)

ProvideByteWriter is the send function - aka "MyKind <- some ByteWriter"

func (*SChByteWriter) RequestByteWriter 

func (c *SChByteWriter) RequestByteWriter() (dat io.ByteWriter)

RequestByteWriter is the receive function - aka "some ByteWriter <- MyKind"

func (*SChByteWriter) TryByteWriter 

func (c *SChByteWriter) TryByteWriter() (dat io.ByteWriter, open bool)

TryByteWriter is the comma-ok multi-valued form of RequestByteWriter and reports whether a received value was sent before the ByteWriter channel was closed.

type SChCloser 

type SChCloser struct {
	// contains filtered or unexported fields
}

SChCloser is a supply channel

func MakeSupplyCloserBuff 

func MakeSupplyCloserBuff(cap int) *SChCloser

MakeSupplyCloserBuff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyCloserChan 

func MakeSupplyCloserChan() *SChCloser

MakeSupplyCloserChan returns a (pointer to a) fresh unbuffered supply channel

func (*SChCloser) ProvideCloser 

func (c *SChCloser) ProvideCloser(dat io.Closer)

ProvideCloser is the send function - aka "MyKind <- some Closer"

func (*SChCloser) RequestCloser 

func (c *SChCloser) RequestCloser() (dat io.Closer)

RequestCloser is the receive function - aka "some Closer <- MyKind"

func (*SChCloser) TryCloser 

func (c *SChCloser) TryCloser() (dat io.Closer, open bool)

TryCloser is the comma-ok multi-valued form of RequestCloser and reports whether a received value was sent before the Closer channel was closed.

type SChLimitedReader 

type SChLimitedReader struct {
	// contains filtered or unexported fields
}

SChLimitedReader is a supply channel

func MakeSupplyLimitedReaderBuff 

func MakeSupplyLimitedReaderBuff(cap int) *SChLimitedReader

MakeSupplyLimitedReaderBuff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyLimitedReaderChan 

func MakeSupplyLimitedReaderChan() *SChLimitedReader

MakeSupplyLimitedReaderChan returns a (pointer to a) fresh unbuffered supply channel

func (*SChLimitedReader) ProvideLimitedReader 

func (c *SChLimitedReader) ProvideLimitedReader(dat *io.LimitedReader)

ProvideLimitedReader is the send function - aka "MyKind <- some LimitedReader"

func (*SChLimitedReader) RequestLimitedReader 

func (c *SChLimitedReader) RequestLimitedReader() (dat *io.LimitedReader)

RequestLimitedReader is the receive function - aka "some LimitedReader <- MyKind"

func (*SChLimitedReader) TryLimitedReader 

func (c *SChLimitedReader) TryLimitedReader() (dat *io.LimitedReader, open bool)

TryLimitedReader is the comma-ok multi-valued form of RequestLimitedReader and reports whether a received value was sent before the LimitedReader channel was closed.

type SChPipeReader 

type SChPipeReader struct {
	// contains filtered or unexported fields
}

SChPipeReader is a supply channel

func MakeSupplyPipeReaderBuff 

func MakeSupplyPipeReaderBuff(cap int) *SChPipeReader

MakeSupplyPipeReaderBuff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyPipeReaderChan 

func MakeSupplyPipeReaderChan() *SChPipeReader

MakeSupplyPipeReaderChan returns a (pointer to a) fresh unbuffered supply channel

func (*SChPipeReader) ProvidePipeReader 

func (c *SChPipeReader) ProvidePipeReader(dat *io.PipeReader)

ProvidePipeReader is the send function - aka "MyKind <- some PipeReader"

func (*SChPipeReader) RequestPipeReader 

func (c *SChPipeReader) RequestPipeReader() (dat *io.PipeReader)

RequestPipeReader is the receive function - aka "some PipeReader <- MyKind"

func (*SChPipeReader) TryPipeReader 

func (c *SChPipeReader) TryPipeReader() (dat *io.PipeReader, open bool)

TryPipeReader is the comma-ok multi-valued form of RequestPipeReader and reports whether a received value was sent before the PipeReader channel was closed.

type SChPipeWriter 

type SChPipeWriter struct {
	// contains filtered or unexported fields
}

SChPipeWriter is a supply channel

func MakeSupplyPipeWriterBuff 

func MakeSupplyPipeWriterBuff(cap int) *SChPipeWriter

MakeSupplyPipeWriterBuff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyPipeWriterChan 

func MakeSupplyPipeWriterChan() *SChPipeWriter

MakeSupplyPipeWriterChan returns a (pointer to a) fresh unbuffered supply channel

func (*SChPipeWriter) ProvidePipeWriter 

func (c *SChPipeWriter) ProvidePipeWriter(dat *io.PipeWriter)

ProvidePipeWriter is the send function - aka "MyKind <- some PipeWriter"

func (*SChPipeWriter) RequestPipeWriter 

func (c *SChPipeWriter) RequestPipeWriter() (dat *io.PipeWriter)

RequestPipeWriter is the receive function - aka "some PipeWriter <- MyKind"

func (*SChPipeWriter) TryPipeWriter 

func (c *SChPipeWriter) TryPipeWriter() (dat *io.PipeWriter, open bool)

TryPipeWriter is the comma-ok multi-valued form of RequestPipeWriter and reports whether a received value was sent before the PipeWriter channel was closed.

type SChReadCloser 

type SChReadCloser struct {
	// contains filtered or unexported fields
}

SChReadCloser is a supply channel

func MakeSupplyReadCloserBuff 

func MakeSupplyReadCloserBuff(cap int) *SChReadCloser

MakeSupplyReadCloserBuff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyReadCloserChan 

func MakeSupplyReadCloserChan() *SChReadCloser

MakeSupplyReadCloserChan returns a (pointer to a) fresh unbuffered supply channel

func (*SChReadCloser) ProvideReadCloser 

func (c *SChReadCloser) ProvideReadCloser(dat io.ReadCloser)

ProvideReadCloser is the send function - aka "MyKind <- some ReadCloser"

func (*SChReadCloser) RequestReadCloser 

func (c *SChReadCloser) RequestReadCloser() (dat io.ReadCloser)

RequestReadCloser is the receive function - aka "some ReadCloser <- MyKind"

func (*SChReadCloser) TryReadCloser 

func (c *SChReadCloser) TryReadCloser() (dat io.ReadCloser, open bool)

TryReadCloser is the comma-ok multi-valued form of RequestReadCloser and reports whether a received value was sent before the ReadCloser channel was closed.

type SChReadSeeker 

type SChReadSeeker struct {
	// contains filtered or unexported fields
}

SChReadSeeker is a supply channel

func MakeSupplyReadSeekerBuff 

func MakeSupplyReadSeekerBuff(cap int) *SChReadSeeker

MakeSupplyReadSeekerBuff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyReadSeekerChan 

func MakeSupplyReadSeekerChan() *SChReadSeeker

MakeSupplyReadSeekerChan returns a (pointer to a) fresh unbuffered supply channel

func (*SChReadSeeker) ProvideReadSeeker 

func (c *SChReadSeeker) ProvideReadSeeker(dat io.ReadSeeker)

ProvideReadSeeker is the send function - aka "MyKind <- some ReadSeeker"

func (*SChReadSeeker) RequestReadSeeker 

func (c *SChReadSeeker) RequestReadSeeker() (dat io.ReadSeeker)

RequestReadSeeker is the receive function - aka "some ReadSeeker <- MyKind"

func (*SChReadSeeker) TryReadSeeker 

func (c *SChReadSeeker) TryReadSeeker() (dat io.ReadSeeker, open bool)

TryReadSeeker is the comma-ok multi-valued form of RequestReadSeeker and reports whether a received value was sent before the ReadSeeker channel was closed.

type SChReadWriteCloser 

type SChReadWriteCloser struct {
	// contains filtered or unexported fields
}

SChReadWriteCloser is a supply channel

func MakeSupplyReadWriteCloserBuff 

func MakeSupplyReadWriteCloserBuff(cap int) *SChReadWriteCloser

MakeSupplyReadWriteCloserBuff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyReadWriteCloserChan 

func MakeSupplyReadWriteCloserChan() *SChReadWriteCloser

MakeSupplyReadWriteCloserChan returns a (pointer to a) fresh unbuffered supply channel

func (*SChReadWriteCloser) ProvideReadWriteCloser 

func (c *SChReadWriteCloser) ProvideReadWriteCloser(dat io.ReadWriteCloser)

ProvideReadWriteCloser is the send function - aka "MyKind <- some ReadWriteCloser"

func (*SChReadWriteCloser) RequestReadWriteCloser 

func (c *SChReadWriteCloser) RequestReadWriteCloser() (dat io.ReadWriteCloser)

RequestReadWriteCloser is the receive function - aka "some ReadWriteCloser <- MyKind"

func (*SChReadWriteCloser) TryReadWriteCloser 

func (c *SChReadWriteCloser) TryReadWriteCloser() (dat io.ReadWriteCloser, open bool)

TryReadWriteCloser is the comma-ok multi-valued form of RequestReadWriteCloser and reports whether a received value was sent before the ReadWriteCloser channel was closed.

type SChReadWriteSeeker 

type SChReadWriteSeeker struct {
	// contains filtered or unexported fields
}

SChReadWriteSeeker is a supply channel

func MakeSupplyReadWriteSeekerBuff 

func MakeSupplyReadWriteSeekerBuff(cap int) *SChReadWriteSeeker

MakeSupplyReadWriteSeekerBuff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyReadWriteSeekerChan 

func MakeSupplyReadWriteSeekerChan() *SChReadWriteSeeker

MakeSupplyReadWriteSeekerChan returns a (pointer to a) fresh unbuffered supply channel

func (*SChReadWriteSeeker) ProvideReadWriteSeeker 

func (c *SChReadWriteSeeker) ProvideReadWriteSeeker(dat io.ReadWriteSeeker)

ProvideReadWriteSeeker is the send function - aka "MyKind <- some ReadWriteSeeker"

func (*SChReadWriteSeeker) RequestReadWriteSeeker 

func (c *SChReadWriteSeeker) RequestReadWriteSeeker() (dat io.ReadWriteSeeker)

RequestReadWriteSeeker is the receive function - aka "some ReadWriteSeeker <- MyKind"

func (*SChReadWriteSeeker) TryReadWriteSeeker 

func (c *SChReadWriteSeeker) TryReadWriteSeeker() (dat io.ReadWriteSeeker, open bool)

TryReadWriteSeeker is the comma-ok multi-valued form of RequestReadWriteSeeker and reports whether a received value was sent before the ReadWriteSeeker channel was closed.

type SChReadWriter 

type SChReadWriter struct {
	// contains filtered or unexported fields
}

SChReadWriter is a supply channel

func MakeSupplyReadWriterBuff 

func MakeSupplyReadWriterBuff(cap int) *SChReadWriter

MakeSupplyReadWriterBuff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyReadWriterChan 

func MakeSupplyReadWriterChan() *SChReadWriter

MakeSupplyReadWriterChan returns a (pointer to a) fresh unbuffered supply channel

func (*SChReadWriter) ProvideReadWriter 

func (c *SChReadWriter) ProvideReadWriter(dat io.ReadWriter)

ProvideReadWriter is the send function - aka "MyKind <- some ReadWriter"

func (*SChReadWriter) RequestReadWriter 

func (c *SChReadWriter) RequestReadWriter() (dat io.ReadWriter)

RequestReadWriter is the receive function - aka "some ReadWriter <- MyKind"

func (*SChReadWriter) TryReadWriter 

func (c *SChReadWriter) TryReadWriter() (dat io.ReadWriter, open bool)

TryReadWriter is the comma-ok multi-valued form of RequestReadWriter and reports whether a received value was sent before the ReadWriter channel was closed.

type SChReader 

type SChReader struct {
	// contains filtered or unexported fields
}

SChReader is a supply channel

func MakeSupplyReaderBuff 

func MakeSupplyReaderBuff(cap int) *SChReader

MakeSupplyReaderBuff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyReaderChan 

func MakeSupplyReaderChan() *SChReader

MakeSupplyReaderChan returns a (pointer to a) fresh unbuffered supply channel

func (*SChReader) ProvideReader 

func (c *SChReader) ProvideReader(dat io.Reader)

ProvideReader is the send function - aka "MyKind <- some Reader"

func (*SChReader) RequestReader 

func (c *SChReader) RequestReader() (dat io.Reader)

RequestReader is the receive function - aka "some Reader <- MyKind"

func (*SChReader) TryReader 

func (c *SChReader) TryReader() (dat io.Reader, open bool)

TryReader is the comma-ok multi-valued form of RequestReader and reports whether a received value was sent before the Reader channel was closed.

type SChReaderAt 

type SChReaderAt struct {
	// contains filtered or unexported fields
}

SChReaderAt is a supply channel

func MakeSupplyReaderAtBuff 

func MakeSupplyReaderAtBuff(cap int) *SChReaderAt

MakeSupplyReaderAtBuff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyReaderAtChan 

func MakeSupplyReaderAtChan() *SChReaderAt

MakeSupplyReaderAtChan returns a (pointer to a) fresh unbuffered supply channel

func (*SChReaderAt) ProvideReaderAt 

func (c *SChReaderAt) ProvideReaderAt(dat io.ReaderAt)

ProvideReaderAt is the send function - aka "MyKind <- some ReaderAt"

func (*SChReaderAt) RequestReaderAt 

func (c *SChReaderAt) RequestReaderAt() (dat io.ReaderAt)

RequestReaderAt is the receive function - aka "some ReaderAt <- MyKind"

func (*SChReaderAt) TryReaderAt 

func (c *SChReaderAt) TryReaderAt() (dat io.ReaderAt, open bool)

TryReaderAt is the comma-ok multi-valued form of RequestReaderAt and reports whether a received value was sent before the ReaderAt channel was closed.

type SChReaderFrom 

type SChReaderFrom struct {
	// contains filtered or unexported fields
}

SChReaderFrom is a supply channel

func MakeSupplyReaderFromBuff 

func MakeSupplyReaderFromBuff(cap int) *SChReaderFrom

MakeSupplyReaderFromBuff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyReaderFromChan 

func MakeSupplyReaderFromChan() *SChReaderFrom

MakeSupplyReaderFromChan returns a (pointer to a) fresh unbuffered supply channel

func (*SChReaderFrom) ProvideReaderFrom 

func (c *SChReaderFrom) ProvideReaderFrom(dat io.ReaderFrom)

ProvideReaderFrom is the send function - aka "MyKind <- some ReaderFrom"

func (*SChReaderFrom) RequestReaderFrom 

func (c *SChReaderFrom) RequestReaderFrom() (dat io.ReaderFrom)

RequestReaderFrom is the receive function - aka "some ReaderFrom <- MyKind"

func (*SChReaderFrom) TryReaderFrom 

func (c *SChReaderFrom) TryReaderFrom() (dat io.ReaderFrom, open bool)

TryReaderFrom is the comma-ok multi-valued form of RequestReaderFrom and reports whether a received value was sent before the ReaderFrom channel was closed.

type SChRuneReader 

type SChRuneReader struct {
	// contains filtered or unexported fields
}

SChRuneReader is a supply channel

func MakeSupplyRuneReaderBuff 

func MakeSupplyRuneReaderBuff(cap int) *SChRuneReader

MakeSupplyRuneReaderBuff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyRuneReaderChan 

func MakeSupplyRuneReaderChan() *SChRuneReader

MakeSupplyRuneReaderChan returns a (pointer to a) fresh unbuffered supply channel

func (*SChRuneReader) ProvideRuneReader 

func (c *SChRuneReader) ProvideRuneReader(dat io.RuneReader)

ProvideRuneReader is the send function - aka "MyKind <- some RuneReader"

func (*SChRuneReader) RequestRuneReader 

func (c *SChRuneReader) RequestRuneReader() (dat io.RuneReader)

RequestRuneReader is the receive function - aka "some RuneReader <- MyKind"

func (*SChRuneReader) TryRuneReader 

func (c *SChRuneReader) TryRuneReader() (dat io.RuneReader, open bool)

TryRuneReader is the comma-ok multi-valued form of RequestRuneReader and reports whether a received value was sent before the RuneReader channel was closed.

type SChRuneScanner 

type SChRuneScanner struct {
	// contains filtered or unexported fields
}

SChRuneScanner is a supply channel

func MakeSupplyRuneScannerBuff 

func MakeSupplyRuneScannerBuff(cap int) *SChRuneScanner

MakeSupplyRuneScannerBuff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyRuneScannerChan 

func MakeSupplyRuneScannerChan() *SChRuneScanner

MakeSupplyRuneScannerChan returns a (pointer to a) fresh unbuffered supply channel

func (*SChRuneScanner) ProvideRuneScanner 

func (c *SChRuneScanner) ProvideRuneScanner(dat io.RuneScanner)

ProvideRuneScanner is the send function - aka "MyKind <- some RuneScanner"

func (*SChRuneScanner) RequestRuneScanner 

func (c *SChRuneScanner) RequestRuneScanner() (dat io.RuneScanner)

RequestRuneScanner is the receive function - aka "some RuneScanner <- MyKind"

func (*SChRuneScanner) TryRuneScanner 

func (c *SChRuneScanner) TryRuneScanner() (dat io.RuneScanner, open bool)

TryRuneScanner is the comma-ok multi-valued form of RequestRuneScanner and reports whether a received value was sent before the RuneScanner channel was closed.

type SChSectionReader 

type SChSectionReader struct {
	// contains filtered or unexported fields
}

SChSectionReader is a supply channel

func MakeSupplySectionReaderBuff 

func MakeSupplySectionReaderBuff(cap int) *SChSectionReader

MakeSupplySectionReaderBuff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplySectionReaderChan 

func MakeSupplySectionReaderChan() *SChSectionReader

MakeSupplySectionReaderChan returns a (pointer to a) fresh unbuffered supply channel

func (*SChSectionReader) ProvideSectionReader 

func (c *SChSectionReader) ProvideSectionReader(dat *io.SectionReader)

ProvideSectionReader is the send function - aka "MyKind <- some SectionReader"

func (*SChSectionReader) RequestSectionReader 

func (c *SChSectionReader) RequestSectionReader() (dat *io.SectionReader)

RequestSectionReader is the receive function - aka "some SectionReader <- MyKind"

func (*SChSectionReader) TrySectionReader 

func (c *SChSectionReader) TrySectionReader() (dat *io.SectionReader, open bool)

TrySectionReader is the comma-ok multi-valued form of RequestSectionReader and reports whether a received value was sent before the SectionReader channel was closed.

type SChSeeker 

type SChSeeker struct {
	// contains filtered or unexported fields
}

SChSeeker is a supply channel

func MakeSupplySeekerBuff 

func MakeSupplySeekerBuff(cap int) *SChSeeker

MakeSupplySeekerBuff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplySeekerChan 

func MakeSupplySeekerChan() *SChSeeker

MakeSupplySeekerChan returns a (pointer to a) fresh unbuffered supply channel

func (*SChSeeker) ProvideSeeker 

func (c *SChSeeker) ProvideSeeker(dat io.Seeker)

ProvideSeeker is the send function - aka "MyKind <- some Seeker"

func (*SChSeeker) RequestSeeker 

func (c *SChSeeker) RequestSeeker() (dat io.Seeker)

RequestSeeker is the receive function - aka "some Seeker <- MyKind"

func (*SChSeeker) TrySeeker 

func (c *SChSeeker) TrySeeker() (dat io.Seeker, open bool)

TrySeeker is the comma-ok multi-valued form of RequestSeeker and reports whether a received value was sent before the Seeker channel was closed.

type SChWriteCloser 

type SChWriteCloser struct {
	// contains filtered or unexported fields
}

SChWriteCloser is a supply channel

func MakeSupplyWriteCloserBuff 

func MakeSupplyWriteCloserBuff(cap int) *SChWriteCloser

MakeSupplyWriteCloserBuff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyWriteCloserChan 

func MakeSupplyWriteCloserChan() *SChWriteCloser

MakeSupplyWriteCloserChan returns a (pointer to a) fresh unbuffered supply channel

func (*SChWriteCloser) ProvideWriteCloser 

func (c *SChWriteCloser) ProvideWriteCloser(dat io.WriteCloser)

ProvideWriteCloser is the send function - aka "MyKind <- some WriteCloser"

func (*SChWriteCloser) RequestWriteCloser 

func (c *SChWriteCloser) RequestWriteCloser() (dat io.WriteCloser)

RequestWriteCloser is the receive function - aka "some WriteCloser <- MyKind"

func (*SChWriteCloser) TryWriteCloser 

func (c *SChWriteCloser) TryWriteCloser() (dat io.WriteCloser, open bool)

TryWriteCloser is the comma-ok multi-valued form of RequestWriteCloser and reports whether a received value was sent before the WriteCloser channel was closed.

type SChWriteSeeker 

type SChWriteSeeker struct {
	// contains filtered or unexported fields
}

SChWriteSeeker is a supply channel

func MakeSupplyWriteSeekerBuff 

func MakeSupplyWriteSeekerBuff(cap int) *SChWriteSeeker

MakeSupplyWriteSeekerBuff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyWriteSeekerChan 

func MakeSupplyWriteSeekerChan() *SChWriteSeeker

MakeSupplyWriteSeekerChan returns a (pointer to a) fresh unbuffered supply channel

func (*SChWriteSeeker) ProvideWriteSeeker 

func (c *SChWriteSeeker) ProvideWriteSeeker(dat io.WriteSeeker)

ProvideWriteSeeker is the send function - aka "MyKind <- some WriteSeeker"

func (*SChWriteSeeker) RequestWriteSeeker 

func (c *SChWriteSeeker) RequestWriteSeeker() (dat io.WriteSeeker)

RequestWriteSeeker is the receive function - aka "some WriteSeeker <- MyKind"

func (*SChWriteSeeker) TryWriteSeeker 

func (c *SChWriteSeeker) TryWriteSeeker() (dat io.WriteSeeker, open bool)

TryWriteSeeker is the comma-ok multi-valued form of RequestWriteSeeker and reports whether a received value was sent before the WriteSeeker channel was closed.

type SChWriter 

type SChWriter struct {
	// contains filtered or unexported fields
}

SChWriter is a supply channel

func MakeSupplyWriterBuff 

func MakeSupplyWriterBuff(cap int) *SChWriter

MakeSupplyWriterBuff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyWriterChan 

func MakeSupplyWriterChan() *SChWriter

MakeSupplyWriterChan returns a (pointer to a) fresh unbuffered supply channel

func (*SChWriter) ProvideWriter 

func (c *SChWriter) ProvideWriter(dat io.Writer)

ProvideWriter is the send function - aka "MyKind <- some Writer"

func (*SChWriter) RequestWriter 

func (c *SChWriter) RequestWriter() (dat io.Writer)

RequestWriter is the receive function - aka "some Writer <- MyKind"

func (*SChWriter) TryWriter 

func (c *SChWriter) TryWriter() (dat io.Writer, open bool)

TryWriter is the comma-ok multi-valued form of RequestWriter and reports whether a received value was sent before the Writer channel was closed.

type SChWriterAt 

type SChWriterAt struct {
	// contains filtered or unexported fields
}

SChWriterAt is a supply channel

func MakeSupplyWriterAtBuff 

func MakeSupplyWriterAtBuff(cap int) *SChWriterAt

MakeSupplyWriterAtBuff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyWriterAtChan 

func MakeSupplyWriterAtChan() *SChWriterAt

MakeSupplyWriterAtChan returns a (pointer to a) fresh unbuffered supply channel

func (*SChWriterAt) ProvideWriterAt 

func (c *SChWriterAt) ProvideWriterAt(dat io.WriterAt)

ProvideWriterAt is the send function - aka "MyKind <- some WriterAt"

func (*SChWriterAt) RequestWriterAt 

func (c *SChWriterAt) RequestWriterAt() (dat io.WriterAt)

RequestWriterAt is the receive function - aka "some WriterAt <- MyKind"

func (*SChWriterAt) TryWriterAt 

func (c *SChWriterAt) TryWriterAt() (dat io.WriterAt, open bool)

TryWriterAt is the comma-ok multi-valued form of RequestWriterAt and reports whether a received value was sent before the WriterAt channel was closed.

type SChWriterTo 

type SChWriterTo struct {
	// contains filtered or unexported fields
}

SChWriterTo is a supply channel

func MakeSupplyWriterToBuff 

func MakeSupplyWriterToBuff(cap int) *SChWriterTo

MakeSupplyWriterToBuff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyWriterToChan 

func MakeSupplyWriterToChan() *SChWriterTo

MakeSupplyWriterToChan returns a (pointer to a) fresh unbuffered supply channel

func (*SChWriterTo) ProvideWriterTo 

func (c *SChWriterTo) ProvideWriterTo(dat io.WriterTo)

ProvideWriterTo is the send function - aka "MyKind <- some WriterTo"

func (*SChWriterTo) RequestWriterTo 

func (c *SChWriterTo) RequestWriterTo() (dat io.WriterTo)

RequestWriterTo is the receive function - aka "some WriterTo <- MyKind"

func (*SChWriterTo) TryWriterTo 

func (c *SChWriterTo) TryWriterTo() (dat io.WriterTo, open bool)

TryWriterTo is the comma-ok multi-valued form of RequestWriterTo and reports whether a received value was sent before the WriterTo channel was closed.

type SectionReaderChan 

type SectionReaderChan interface {
	SectionReaderROnlyChan // aka "<-chan" - receive only
	SectionReaderSOnlyChan // aka "chan<-" - send only
}

SectionReaderChan represents a bidirectional channel

type SectionReaderROnlyChan 

type SectionReaderROnlyChan interface {
	RequestSectionReader() (dat *io.SectionReader)        // the receive function - aka "MySectionReader := <-MySectionReaderROnlyChan"
	TrySectionReader() (dat *io.SectionReader, open bool) // the multi-valued comma-ok receive function - aka "MySectionReader, ok := <-MySectionReaderROnlyChan"
}

SectionReaderROnlyChan represents a receive-only channel

type SectionReaderSOnlyChan 

type SectionReaderSOnlyChan interface {
	ProvideSectionReader(dat *io.SectionReader) // the send function - aka "MyKind <- some SectionReader"
}

SectionReaderSOnlyChan represents a send-only channel

type SeekerChan 

type SeekerChan interface {
	SeekerROnlyChan // aka "<-chan" - receive only
	SeekerSOnlyChan // aka "chan<-" - send only
}

SeekerChan represents a bidirectional channel

type SeekerROnlyChan 

type SeekerROnlyChan interface {
	RequestSeeker() (dat io.Seeker)        // the receive function - aka "MySeeker := <-MySeekerROnlyChan"
	TrySeeker() (dat io.Seeker, open bool) // the multi-valued comma-ok receive function - aka "MySeeker, ok := <-MySeekerROnlyChan"
}

SeekerROnlyChan represents a receive-only channel

type SeekerSOnlyChan 

type SeekerSOnlyChan interface {
	ProvideSeeker(dat io.Seeker) // the send function - aka "MyKind <- some Seeker"
}

SeekerSOnlyChan represents a send-only channel

type WriteCloserChan 

type WriteCloserChan interface {
	WriteCloserROnlyChan // aka "<-chan" - receive only
	WriteCloserSOnlyChan // aka "chan<-" - send only
}

WriteCloserChan represents a bidirectional channel

type WriteCloserROnlyChan 

type WriteCloserROnlyChan interface {
	RequestWriteCloser() (dat io.WriteCloser)        // the receive function - aka "MyWriteCloser := <-MyWriteCloserROnlyChan"
	TryWriteCloser() (dat io.WriteCloser, open bool) // the multi-valued comma-ok receive function - aka "MyWriteCloser, ok := <-MyWriteCloserROnlyChan"
}

WriteCloserROnlyChan represents a receive-only channel

type WriteCloserSOnlyChan 

type WriteCloserSOnlyChan interface {
	ProvideWriteCloser(dat io.WriteCloser) // the send function - aka "MyKind <- some WriteCloser"
}

WriteCloserSOnlyChan represents a send-only channel

type WriteSeekerChan 

type WriteSeekerChan interface {
	WriteSeekerROnlyChan // aka "<-chan" - receive only
	WriteSeekerSOnlyChan // aka "chan<-" - send only
}

WriteSeekerChan represents a bidirectional channel

type WriteSeekerROnlyChan 

type WriteSeekerROnlyChan interface {
	RequestWriteSeeker() (dat io.WriteSeeker)        // the receive function - aka "MyWriteSeeker := <-MyWriteSeekerROnlyChan"
	TryWriteSeeker() (dat io.WriteSeeker, open bool) // the multi-valued comma-ok receive function - aka "MyWriteSeeker, ok := <-MyWriteSeekerROnlyChan"
}

WriteSeekerROnlyChan represents a receive-only channel

type WriteSeekerSOnlyChan 

type WriteSeekerSOnlyChan interface {
	ProvideWriteSeeker(dat io.WriteSeeker) // the send function - aka "MyKind <- some WriteSeeker"
}

WriteSeekerSOnlyChan represents a send-only channel

type WriterAtChan 

type WriterAtChan interface {
	WriterAtROnlyChan // aka "<-chan" - receive only
	WriterAtSOnlyChan // aka "chan<-" - send only
}

WriterAtChan represents a bidirectional channel

type WriterAtROnlyChan 

type WriterAtROnlyChan interface {
	RequestWriterAt() (dat io.WriterAt)        // the receive function - aka "MyWriterAt := <-MyWriterAtROnlyChan"
	TryWriterAt() (dat io.WriterAt, open bool) // the multi-valued comma-ok receive function - aka "MyWriterAt, ok := <-MyWriterAtROnlyChan"
}

WriterAtROnlyChan represents a receive-only channel

type WriterAtSOnlyChan 

type WriterAtSOnlyChan interface {
	ProvideWriterAt(dat io.WriterAt) // the send function - aka "MyKind <- some WriterAt"
}

WriterAtSOnlyChan represents a send-only channel

type WriterChan 

type WriterChan interface {
	WriterROnlyChan // aka "<-chan" - receive only
	WriterSOnlyChan // aka "chan<-" - send only
}

WriterChan represents a bidirectional channel

type WriterROnlyChan 

type WriterROnlyChan interface {
	RequestWriter() (dat io.Writer)        // the receive function - aka "MyWriter := <-MyWriterROnlyChan"
	TryWriter() (dat io.Writer, open bool) // the multi-valued comma-ok receive function - aka "MyWriter, ok := <-MyWriterROnlyChan"
}

WriterROnlyChan represents a receive-only channel

type WriterSOnlyChan 

type WriterSOnlyChan interface {
	ProvideWriter(dat io.Writer) // the send function - aka "MyKind <- some Writer"
}

WriterSOnlyChan represents a send-only channel

type WriterToChan 

type WriterToChan interface {
	WriterToROnlyChan // aka "<-chan" - receive only
	WriterToSOnlyChan // aka "chan<-" - send only
}

WriterToChan represents a bidirectional channel

type WriterToROnlyChan 

type WriterToROnlyChan interface {
	RequestWriterTo() (dat io.WriterTo)        // the receive function - aka "MyWriterTo := <-MyWriterToROnlyChan"
	TryWriterTo() (dat io.WriterTo, open bool) // the multi-valued comma-ok receive function - aka "MyWriterTo, ok := <-MyWriterToROnlyChan"
}

WriterToROnlyChan represents a receive-only channel

type WriterToSOnlyChan 

type WriterToSOnlyChan interface {
	ProvideWriterTo(dat io.WriterTo) // the send function - aka "MyKind <- some WriterTo"
}

WriterToSOnlyChan represents a send-only channel

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.