Documentation
¶
Index ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type Chan ¶
type Chan interface {
ROnlyChan // aka "<-chan" - receive only
SOnlyChan // aka "chan<-" - send only
}
Chan represents a bidirectional channel
type ElementChan ¶
type ElementChan interface {
ElementROnlyChan // aka "<-chan" - receive only
ElementSOnlyChan // aka "chan<-" - send only
}
ElementChan represents a bidirectional channel
type ElementROnlyChan ¶
type ElementROnlyChan interface {
RequestElement() (dat *list.Element) // the receive function - aka "MyElement := <-MyElementROnlyChan"
TryElement() (dat *list.Element, open bool) // the multi-valued comma-ok receive function - aka "MyElement, ok := <-MyElementROnlyChan"
}
ElementROnlyChan represents a receive-only channel
type ElementSChan ¶
type ElementSChan interface {
ElementSROnlyChan // aka "<-chan" - receive only
ElementSSOnlyChan // aka "chan<-" - send only
}
ElementSChan represents a bidirectional channel
type ElementSOnlyChan ¶
type ElementSOnlyChan interface {
ProvideElement(dat *list.Element) // the send function - aka "MyKind <- some Element"
}
ElementSOnlyChan represents a send-only channel
type ElementSROnlyChan ¶
type ElementSROnlyChan interface {
RequestElementS() (dat []*list.Element) // the receive function - aka "MyElementS := <-MyElementSROnlyChan"
TryElementS() (dat []*list.Element, open bool) // the multi-valued comma-ok receive function - aka "MyElementS, ok := <-MyElementSROnlyChan"
}
ElementSROnlyChan represents a receive-only channel
type ElementSSOnlyChan ¶
type ElementSSOnlyChan interface {
ProvideElementS(dat []*list.Element) // the send function - aka "MyKind <- some ElementS"
}
ElementSSOnlyChan represents a send-only channel
type ListSChan ¶
type ListSChan interface {
ListSROnlyChan // aka "<-chan" - receive only
ListSSOnlyChan // aka "chan<-" - send only
}
ListSChan represents a bidirectional channel
type ListSROnlyChan ¶
type ListSROnlyChan interface {
RequestListS() (dat []*list.List) // the receive function - aka "MyListS := <-MyListSROnlyChan"
TryListS() (dat []*list.List, open bool) // the multi-valued comma-ok receive function - aka "MyListS, ok := <-MyListSROnlyChan"
}
ListSROnlyChan represents a receive-only channel
type ListSSOnlyChan ¶
type ListSSOnlyChan interface {
ProvideListS(dat []*list.List) // the send function - aka "MyKind <- some ListS"
}
ListSSOnlyChan represents a send-only channel
type ROnlyChan ¶
type ROnlyChan interface {
Request() (dat *list.List) // the receive function - aka "My := <-MyROnlyChan"
Try() (dat *list.List, 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 ¶
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
type SChElement ¶
type SChElement struct {
// contains filtered or unexported fields
}
SChElement is a supply channel
func MakeSupplyElementBuff ¶
func MakeSupplyElementBuff(cap int) *SChElement
MakeSupplyElementBuff returns a (pointer to a) fresh buffered (with capacity cap) supply channel
func MakeSupplyElementChan ¶
func MakeSupplyElementChan() *SChElement
MakeSupplyElementChan returns a (pointer to a) fresh unbuffered supply channel
func (*SChElement) ProvideElement ¶
func (c *SChElement) ProvideElement(dat *list.Element)
ProvideElement is the send function - aka "MyKind <- some Element"
func (*SChElement) RequestElement ¶
func (c *SChElement) RequestElement() (dat *list.Element)
RequestElement is the receive function - aka "some Element <- MyKind"
func (*SChElement) TryElement ¶
func (c *SChElement) TryElement() (dat *list.Element, open bool)
TryElement is the comma-ok multi-valued form of RequestElement and reports whether a received value was sent before the Element channel was closed.
type SChElementS ¶
type SChElementS struct {
// contains filtered or unexported fields
}
SChElementS is a supply channel
func MakeSupplyElementSBuff ¶
func MakeSupplyElementSBuff(cap int) *SChElementS
MakeSupplyElementSBuff returns a (pointer to a) fresh buffered (with capacity cap) supply channel
func MakeSupplyElementSChan ¶
func MakeSupplyElementSChan() *SChElementS
MakeSupplyElementSChan returns a (pointer to a) fresh unbuffered supply channel
func (*SChElementS) ProvideElementS ¶
func (c *SChElementS) ProvideElementS(dat []*list.Element)
ProvideElementS is the send function - aka "MyKind <- some ElementS"
func (*SChElementS) RequestElementS ¶
func (c *SChElementS) RequestElementS() (dat []*list.Element)
RequestElementS is the receive function - aka "some ElementS <- MyKind"
func (*SChElementS) TryElementS ¶
func (c *SChElementS) TryElementS() (dat []*list.Element, open bool)
TryElementS is the comma-ok multi-valued form of RequestElementS and reports whether a received value was sent before the ElementS channel was closed.
type SChListS ¶
type SChListS struct {
// contains filtered or unexported fields
}
SChListS is a supply channel
func MakeSupplyListSBuff ¶
MakeSupplyListSBuff returns a (pointer to a) fresh buffered (with capacity cap) supply channel
func MakeSupplyListSChan ¶
func MakeSupplyListSChan() *SChListS
MakeSupplyListSChan returns a (pointer to a) fresh unbuffered supply channel
func (*SChListS) ProvideListS ¶
ProvideListS is the send function - aka "MyKind <- some ListS"
func (*SChListS) RequestListS ¶
RequestListS is the receive function - aka "some ListS <- MyKind"
Source Files