IsRune

Documentation

Index

• type Chan
• type DCh
  • func MakeDemandBuff(cap int) *DCh
  • func MakeDemandChan() *DCh
  • func (c *DCh) Provide(dat rune)
  • func (c *DCh) Request() (dat rune)
  • func (c *DCh) Try() (dat rune, open bool)
• type DChRuneReader
  • func MakeDemandRuneReaderBuff(cap int) *DChRuneReader
  • func MakeDemandRuneReaderChan() *DChRuneReader
  • func (c *DChRuneReader) ProvideRuneReader(dat io.RuneReader)
  • func (c *DChRuneReader) RequestRuneReader() (dat io.RuneReader)
  • func (c *DChRuneReader) TryRuneReader() (dat io.RuneReader, open bool)
• type DChRuneS
  • func MakeDemandRuneSBuff(cap int) *DChRuneS
  • func MakeDemandRuneSChan() *DChRuneS
  • func (c *DChRuneS) ProvideRuneS(dat []rune)
  • func (c *DChRuneS) RequestRuneS() (dat []rune)
  • func (c *DChRuneS) TryRuneS() (dat []rune, open bool)
• type DChRuneScanner
  • func MakeDemandRuneScannerBuff(cap int) *DChRuneScanner
  • func MakeDemandRuneScannerChan() *DChRuneScanner
  • func (c *DChRuneScanner) ProvideRuneScanner(dat io.RuneScanner)
  • func (c *DChRuneScanner) RequestRuneScanner() (dat io.RuneScanner)
  • func (c *DChRuneScanner) TryRuneScanner() (dat io.RuneScanner, open bool)
• type ROnlyChan
• type RuneReaderChan
• type RuneReaderROnlyChan
• type RuneReaderSOnlyChan
• type RuneSChan
• type RuneSROnlyChan
• type RuneSSOnlyChan
• type RuneScannerChan
• type RuneScannerROnlyChan
• type RuneScannerSOnlyChan
• type SOnlyChan

Types

type Chan

type Chan interface {
	ROnlyChan // aka "<-chan" - receive only
	SOnlyChan // aka "chan<-" - send only
}

Chan represents a bidirectional channel

type DCh

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

DCh is a demand channel

func MakeDemandBuff

func MakeDemandBuff(cap int) *DCh

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

func MakeDemandChan

func MakeDemandChan() *DCh

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

func (*DCh) Provide

func (c *DCh) Provide(dat rune)

Provide is the send function - aka "MyKind <- some "

func (*DCh) Request

func (c *DCh) Request() (dat rune)

Request is the receive function - aka "some <- MyKind"

func (*DCh) Try

func (c *DCh) Try() (dat rune, open bool)

Try is the comma-ok multi-valued form of Request and reports whether a received value was sent before the 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 DChRuneS

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

DChRuneS is a demand channel

func MakeDemandRuneSBuff

func MakeDemandRuneSBuff(cap int) *DChRuneS

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

func MakeDemandRuneSChan

func MakeDemandRuneSChan() *DChRuneS

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

func (*DChRuneS) ProvideRuneS

func (c *DChRuneS) ProvideRuneS(dat []rune)

ProvideRuneS is the send function - aka "MyKind <- some RuneS"

func (*DChRuneS) RequestRuneS

func (c *DChRuneS) RequestRuneS() (dat []rune)

RequestRuneS is the receive function - aka "some RuneS <- MyKind"

func (*DChRuneS) TryRuneS

func (c *DChRuneS) TryRuneS() (dat []rune, open bool)

TryRuneS is the comma-ok multi-valued form of RequestRuneS and reports whether a received value was sent before the RuneS 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 ROnlyChan

type ROnlyChan interface {
	Request() (dat rune)        // the receive function - aka "My := <-MyROnlyChan"
	Try() (dat rune, open bool) // the multi-valued comma-ok receive function - aka "My, ok := <-MyROnlyChan"
}

ROnlyChan represents a receive-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 RuneSChan

type RuneSChan interface {
	RuneSROnlyChan // aka "<-chan" - receive only
	RuneSSOnlyChan // aka "chan<-" - send only
}

RuneSChan represents a bidirectional channel

type RuneSROnlyChan

type RuneSROnlyChan interface {
	RequestRuneS() (dat []rune)        // the receive function - aka "MyRuneS := <-MyRuneSROnlyChan"
	TryRuneS() (dat []rune, open bool) // the multi-valued comma-ok receive function - aka "MyRuneS, ok := <-MyRuneSROnlyChan"
}

RuneSROnlyChan represents a receive-only channel

type RuneSSOnlyChan

type RuneSSOnlyChan interface {
	ProvideRuneS(dat []rune) // the send function - aka "MyKind <- some RuneS"
}

RuneSSOnlyChan 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 SOnlyChan

type SOnlyChan interface {
	Provide(dat rune) // the send function - aka "MyKind <- some "
}

SOnlyChan represents a send-only channel