list

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

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

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

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

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

type ElementChan interface {
	ElementROnlyChan // aka "<-chan" - receive only
	ElementSOnlyChan // aka "chan<-" - send only
}

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"
}

type ElementSChan interface {
	ElementSROnlyChan // aka "<-chan" - receive only
	ElementSSOnlyChan // aka "chan<-" - send only
}

type ElementSOnlyChan interface {
	ProvideElement(dat *list.Element) // the send function - aka "MyKind <- some Element"
}

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"
}

type ElementSSOnlyChan interface {
	ProvideElementS(dat []*list.Element) // the send function - aka "MyKind <- some ElementS"
}

type ListSChan interface {
	ListSROnlyChan // aka "<-chan" - receive only
	ListSSOnlyChan // aka "chan<-" - send only
}

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"
}

type ListSSOnlyChan interface {
	ProvideListS(dat []*list.List) // the send function - aka "MyKind <- some ListS"
}

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"
}

type SOnlyChan interface {
	Provide(dat *list.List) // the send function - aka "MyKind <- some "
}