list

func Chan ¶

func Chan(inp ...*list.List) (out <-chan *list.List)

Chan returns a channel to receive all inputs before close.

func ChanElement ¶

func ChanElement(inp ...*list.Element) (out <-chan *list.Element)

ChanElement returns a channel to receive all inputs before close.

func ChanElementFuncErr ¶

func ChanElementFuncErr(act func() (*list.Element, error)) (out <-chan *list.Element)

ChanElementFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanElementFuncNil ¶

func ChanElementFuncNil(act func() *list.Element) (out <-chan *list.Element)

ChanElementFuncNil returns a channel to receive all results of act until nil before close.

func ChanElementFuncNok ¶

func ChanElementFuncNok(act func() (*list.Element, bool)) (out <-chan *list.Element)

ChanElementFuncNok returns a channel to receive all results of act until nok before close.

func ChanElementS ¶

func ChanElementS(inp ...[]*list.Element) (out <-chan []*list.Element)

ChanElementS returns a channel to receive all inputs before close.

func ChanElementSFuncErr ¶

func ChanElementSFuncErr(act func() ([]*list.Element, error)) (out <-chan []*list.Element)

ChanElementSFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanElementSFuncNil ¶

func ChanElementSFuncNil(act func() []*list.Element) (out <-chan []*list.Element)

ChanElementSFuncNil returns a channel to receive all results of act until nil before close.

func ChanElementSFuncNok ¶

func ChanElementSFuncNok(act func() ([]*list.Element, bool)) (out <-chan []*list.Element)

ChanElementSFuncNok returns a channel to receive all results of act until nok before close.

func ChanElementSSlice ¶

func ChanElementSSlice(inp ...[][]*list.Element) (out <-chan []*list.Element)

ChanElementSSlice returns a channel to receive all inputs before close.

func ChanElementSlice ¶

func ChanElementSlice(inp ...[]*list.Element) (out <-chan *list.Element)

ChanElementSlice returns a channel to receive all inputs before close.

func ChanFuncErr ¶

func ChanFuncErr(act func() (*list.List, error)) (out <-chan *list.List)

ChanFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanFuncNil ¶

func ChanFuncNil(act func() *list.List) (out <-chan *list.List)

ChanFuncNil returns a channel to receive all results of act until nil before close.

func ChanFuncNok ¶

func ChanFuncNok(act func() (*list.List, bool)) (out <-chan *list.List)

ChanFuncNok returns a channel to receive all results of act until nok before close.

func ChanListS ¶

func ChanListS(inp ...[]*list.List) (out <-chan []*list.List)

ChanListS returns a channel to receive all inputs before close.

func ChanListSFuncErr ¶

func ChanListSFuncErr(act func() ([]*list.List, error)) (out <-chan []*list.List)

ChanListSFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanListSFuncNil ¶

func ChanListSFuncNil(act func() []*list.List) (out <-chan []*list.List)

ChanListSFuncNil returns a channel to receive all results of act until nil before close.

func ChanListSFuncNok ¶

func ChanListSFuncNok(act func() ([]*list.List, bool)) (out <-chan []*list.List)

ChanListSFuncNok returns a channel to receive all results of act until nok before close.

func ChanListSSlice ¶

func ChanListSSlice(inp ...[][]*list.List) (out <-chan []*list.List)

ChanListSSlice returns a channel to receive all inputs before close.

func ChanSlice ¶

func ChanSlice(inp ...[]*list.List) (out <-chan *list.List)

ChanSlice returns a channel to receive all inputs before close.

func Daisy ¶

func Daisy(inp <-chan *list.List, tube Tube) (out <-chan *list.List)

Daisy returns a channel to receive all inp after having passed thru tube.

func DaisyChain ¶

func DaisyChain(inp <-chan *list.List, tubes ...Tube) (out <-chan *list.List)

DaisyChain returns a channel to receive all inp after having passed thru all tubes.

func Done ¶

func Done(inp <-chan *list.List) (done <-chan struct{})

Done returns a channel to receive one signal before close after inp has been drained.

func DoneElement ¶

func DoneElement(inp <-chan *list.Element) (done <-chan struct{})

DoneElement returns a channel to receive one signal before close after inp has been drained.

func DoneElementFunc ¶

func DoneElementFunc(inp <-chan *list.Element, act func(a *list.Element)) (out <-chan struct{})

DoneElementFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DoneElementS ¶

func DoneElementS(inp <-chan []*list.Element) (done <-chan struct{})

DoneElementS returns a channel to receive one signal before close after inp has been drained.

func DoneElementSFunc ¶

func DoneElementSFunc(inp <-chan []*list.Element, act func(a []*list.Element)) (out <-chan struct{})

DoneElementSFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DoneElementSSlice ¶

func DoneElementSSlice(inp <-chan []*list.Element) (done <-chan [][]*list.Element)

DoneElementSSlice returns a channel which will receive a slice of all the ElementSs received on inp channel before close. Unlike DoneElementS, a full slice is sent once, not just an event.

func DoneElementSlice ¶

func DoneElementSlice(inp <-chan *list.Element) (done <-chan []*list.Element)

DoneElementSlice returns a channel which will receive a slice of all the Elements received on inp channel before close. Unlike DoneElement, a full slice is sent once, not just an event.

func DoneFunc ¶

func DoneFunc(inp <-chan *list.List, act func(a *list.List)) (out <-chan struct{})

DoneFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DoneListS ¶

func DoneListS(inp <-chan []*list.List) (done <-chan struct{})

DoneListS returns a channel to receive one signal before close after inp has been drained.

func DoneListSFunc ¶

func DoneListSFunc(inp <-chan []*list.List, act func(a []*list.List)) (out <-chan struct{})

DoneListSFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DoneListSSlice ¶

func DoneListSSlice(inp <-chan []*list.List) (done <-chan [][]*list.List)

DoneListSSlice returns a channel which will receive a slice of all the ListSs received on inp channel before close. Unlike DoneListS, a full slice is sent once, not just an event.

func DoneSlice ¶

func DoneSlice(inp <-chan *list.List) (done <-chan []*list.List)

DoneSlice returns a channel which will receive a slice of all the s received on inp channel before close. Unlike Done, a full slice is sent once, not just an event.

func ElementDaisy ¶

func ElementDaisy(inp <-chan *list.Element, tube ElementTube) (out <-chan *list.Element)

ElementDaisy returns a channel to receive all inp after having passed thru tube.

func ElementDaisyChain ¶

func ElementDaisyChain(inp <-chan *list.Element, tubes ...ElementTube) (out <-chan *list.Element)

ElementDaisyChain returns a channel to receive all inp after having passed thru all tubes.

func ElementSDaisy ¶

func ElementSDaisy(inp <-chan []*list.Element, tube ElementSTube) (out <-chan []*list.Element)

ElementSDaisy returns a channel to receive all inp after having passed thru tube.

func ElementSDaisyChain ¶

func ElementSDaisyChain(inp <-chan []*list.Element, tubes ...ElementSTube) (out <-chan []*list.Element)

ElementSDaisyChain returns a channel to receive all inp after having passed thru all tubes.

func Join ¶

func Join(out chan<- *list.List, inp ...*list.List) (done <-chan struct{})

Join sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinChan ¶

func JoinChan(out chan<- *list.List, inp <-chan *list.List) (done <-chan struct{})

JoinChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinElement ¶

func JoinElement(out chan<- *list.Element, inp ...*list.Element) (done <-chan struct{})

JoinElement sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinElementChan ¶

func JoinElementChan(out chan<- *list.Element, inp <-chan *list.Element) (done <-chan struct{})

JoinElementChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinElementS ¶

func JoinElementS(out chan<- []*list.Element, inp ...[]*list.Element) (done <-chan struct{})

JoinElementS sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinElementSChan ¶

func JoinElementSChan(out chan<- []*list.Element, inp <-chan []*list.Element) (done <-chan struct{})

JoinElementSChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinElementSSlice ¶

func JoinElementSSlice(out chan<- []*list.Element, inp ...[][]*list.Element) (done <-chan struct{})

JoinElementSSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinElementSlice ¶

func JoinElementSlice(out chan<- *list.Element, inp ...[]*list.Element) (done <-chan struct{})

JoinElementSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinListS ¶

func JoinListS(out chan<- []*list.List, inp ...[]*list.List) (done <-chan struct{})

JoinListS sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinListSChan ¶

func JoinListSChan(out chan<- []*list.List, inp <-chan []*list.List) (done <-chan struct{})

JoinListSChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinListSSlice ¶

func JoinListSSlice(out chan<- []*list.List, inp ...[][]*list.List) (done <-chan struct{})

JoinListSSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinSlice ¶

func JoinSlice(out chan<- *list.List, inp ...[]*list.List) (done <-chan struct{})

JoinSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func ListSDaisy ¶

func ListSDaisy(inp <-chan []*list.List, tube ListSTube) (out <-chan []*list.List)

ListSDaisy returns a channel to receive all inp after having passed thru tube.

func ListSDaisyChain ¶

func ListSDaisyChain(inp <-chan []*list.List, tubes ...ListSTube) (out <-chan []*list.List)

ListSDaisyChain returns a channel to receive all inp after having passed thru all tubes.

func MakeChan ¶

func MakeChan() (out chan *list.List)

MakeChan returns a new open channel (simply a 'chan *list.List' that is).

Note: No '-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myPipelineStartsHere := MakeChan()
// ... lot's of code to design and build Your favourite "myWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myPipelineStartsHere <- drop
}
close(myPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeBuffer) the channel is unbuffered.

func MakeElementChan ¶

func MakeElementChan() (out chan *list.Element)

MakeElementChan returns a new open channel (simply a 'chan *list.Element' that is).

Note: No 'Element-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myElementPipelineStartsHere := MakeElementChan()
// ... lot's of code to design and build Your favourite "myElementWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myElementPipelineStartsHere <- drop
}
close(myElementPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeElementBuffer) the channel is unbuffered.

func MakeElementSChan ¶

func MakeElementSChan() (out chan []*list.Element)

MakeElementSChan returns a new open channel (simply a 'chan []*list.Element' that is).

Note: No 'ElementS-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myElementSPipelineStartsHere := MakeElementSChan()
// ... lot's of code to design and build Your favourite "myElementSWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myElementSPipelineStartsHere <- drop
}
close(myElementSPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeElementSBuffer) the channel is unbuffered.

func MakeListSChan ¶

func MakeListSChan() (out chan []*list.List)

MakeListSChan returns a new open channel (simply a 'chan []*list.List' that is).

Note: No 'ListS-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myListSPipelineStartsHere := MakeListSChan()
// ... lot's of code to design and build Your favourite "myListSWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myListSPipelineStartsHere <- drop
}
close(myListSPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeListSBuffer) the channel is unbuffered.

func PipeBuffer ¶

func PipeBuffer(inp <-chan *list.List, cap int) (out <-chan *list.List)

PipeBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeElementBuffer ¶

func PipeElementBuffer(inp <-chan *list.Element, cap int) (out <-chan *list.Element)

PipeElementBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeElementFork ¶

func PipeElementFork(inp <-chan *list.Element) (out1, out2 <-chan *list.Element)

PipeElementFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeElementFunc ¶

func PipeElementFunc(inp <-chan *list.Element, act func(a *list.Element) *list.Element) (out <-chan *list.Element)

PipeElementFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeElementMap for functional people, but 'map' has a very different meaning in go lang.

func PipeElementSBuffer ¶

func PipeElementSBuffer(inp <-chan []*list.Element, cap int) (out <-chan []*list.Element)

PipeElementSBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeElementSFork ¶

func PipeElementSFork(inp <-chan []*list.Element) (out1, out2 <-chan []*list.Element)

PipeElementSFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeElementSFunc ¶

func PipeElementSFunc(inp <-chan []*list.Element, act func(a []*list.Element) []*list.Element) (out <-chan []*list.Element)

PipeElementSFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeElementSMap for functional people, but 'map' has a very different meaning in go lang.

func PipeFork ¶

func PipeFork(inp <-chan *list.List) (out1, out2 <-chan *list.List)

PipeFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeFunc ¶

func PipeFunc(inp <-chan *list.List, act func(a *list.List) *list.List) (out <-chan *list.List)

PipeFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeMap for functional people, but 'map' has a very different meaning in go lang.

func PipeListSBuffer ¶

func PipeListSBuffer(inp <-chan []*list.List, cap int) (out <-chan []*list.List)

PipeListSBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeListSFork ¶

func PipeListSFork(inp <-chan []*list.List) (out1, out2 <-chan []*list.List)

PipeListSFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeListSFunc ¶

func PipeListSFunc(inp <-chan []*list.List, act func(a []*list.List) []*list.List) (out <-chan []*list.List)

PipeListSFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeListSMap for functional people, but 'map' has a very different meaning in go lang.

func SendProxy ¶

func SendProxy(out chan<- *list.List) chan<- *list.List

SendProxy returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxyElement ¶

func SendProxyElement(out chan<- *list.Element) chan<- *list.Element

SendProxyElement returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxyElementS ¶

func SendProxyElementS(out chan<- []*list.Element) chan<- []*list.Element

SendProxyElementS returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxyListS ¶

func SendProxyListS(out chan<- []*list.List) chan<- []*list.List

SendProxyListS returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"