pat

Documentation

Index

• type Chan
• type DCh
  • func MakeDemandBuff(cap int) *DCh
  • func MakeDemandChan() *DCh
  • func (c *DCh) Provide(dat struct{})
  • func (c *DCh) Request() (dat struct{})
  • func (c *DCh) Try() (dat struct{}, open bool)
• type DChPatS
  • func MakeDemandPatSBuff(cap int) *DChPatS
  • func MakeDemandPatSChan() *DChPatS
  • func (c *DChPatS) ProvidePatS(dat []struct{})
  • func (c *DChPatS) RequestPatS() (dat []struct{})
  • func (c *DChPatS) TryPatS() (dat []struct{}, open bool)
• type PatSChan
• type PatSROnlyChan
• type PatSSOnlyChan
• type ROnlyChan
• type SCh
  • func MakeSupplyBuff(cap int) *SCh
  • func MakeSupplyChan() *SCh
  • func (c *SCh) Provide(dat struct{})
  • func (c *SCh) Request() (dat struct{})
  • func (c *SCh) Try() (dat struct{}, open bool)
• type SChPatS
  • func MakeSupplyPatSBuff(cap int) *SChPatS
  • func MakeSupplyPatSChan() *SChPatS
  • func (c *SChPatS) ProvidePatS(dat []struct{})
  • func (c *SChPatS) RequestPatS() (dat []struct{})
  • func (c *SChPatS) TryPatS() (dat []struct{}, open bool)
• 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 struct{})

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

func (*DCh) Request

func (c *DCh) Request() (dat struct{})

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

func (*DCh) Try

func (c *DCh) Try() (dat struct{}, 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 DChPatS

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

DChPatS is a demand channel

func MakeDemandPatSBuff

func MakeDemandPatSBuff(cap int) *DChPatS

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

func MakeDemandPatSChan

func MakeDemandPatSChan() *DChPatS

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

func (*DChPatS) ProvidePatS

func (c *DChPatS) ProvidePatS(dat []struct{})

ProvidePatS is the send function - aka "MyKind <- some PatS"

func (*DChPatS) RequestPatS

func (c *DChPatS) RequestPatS() (dat []struct{})

RequestPatS is the receive function - aka "some PatS <- MyKind"

func (*DChPatS) TryPatS

func (c *DChPatS) TryPatS() (dat []struct{}, open bool)

TryPatS is the comma-ok multi-valued form of RequestPatS and reports whether a received value was sent before the PatS channel was closed.

type PatSChan

type PatSChan interface {
	PatSROnlyChan // aka "<-chan" - receive only
	PatSSOnlyChan // aka "chan<-" - send only
}

PatSChan represents a bidirectional channel

type PatSROnlyChan

type PatSROnlyChan interface {
	RequestPatS() (dat []struct{})        // the receive function - aka "MyPatS := <-MyPatSROnlyChan"
	TryPatS() (dat []struct{}, open bool) // the multi-valued comma-ok receive function - aka "MyPatS, ok := <-MyPatSROnlyChan"
}

PatSROnlyChan represents a receive-only channel

type PatSSOnlyChan

type PatSSOnlyChan interface {
	ProvidePatS(dat []struct{}) // the send function - aka "MyKind <- some PatS"
}

PatSSOnlyChan represents a send-only channel

type ROnlyChan

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

ROnlyChan represents a receive-only channel

type SCh

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

SCh is a supply channel

func MakeSupplyBuff

func MakeSupplyBuff(cap int) *SCh

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

func MakeSupplyChan

func MakeSupplyChan() *SCh

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

func (*SCh) Provide

func (c *SCh) Provide(dat struct{})

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

func (*SCh) Request

func (c *SCh) Request() (dat struct{})

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

func (*SCh) Try

func (c *SCh) Try() (dat struct{}, 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 SChPatS

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

SChPatS is a supply channel

func MakeSupplyPatSBuff

func MakeSupplyPatSBuff(cap int) *SChPatS

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

func MakeSupplyPatSChan

func MakeSupplyPatSChan() *SChPatS

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

func (*SChPatS) ProvidePatS

func (c *SChPatS) ProvidePatS(dat []struct{})

ProvidePatS is the send function - aka "MyKind <- some PatS"

func (*SChPatS) RequestPatS

func (c *SChPatS) RequestPatS() (dat []struct{})

RequestPatS is the receive function - aka "some PatS <- MyKind"

func (*SChPatS) TryPatS

func (c *SChPatS) TryPatS() (dat []struct{}, open bool)

TryPatS is the comma-ok multi-valued form of RequestPatS and reports whether a received value was sent before the PatS channel was closed.

type SOnlyChan

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

SOnlyChan represents a send-only channel