IsOrdered

package

v0.0.0-...-5012a73 Latest Latest Go to latest Published: Jun 20, 2019 License: MIT Imports: 1 Imported by: 0

Details

Valid go.mod file

The Go module system was introduced in Go 1.11 and is the official dependency management solution for Go.
Redistributable license

Redistributable licenses place minimal restrictions on how software can be used, modified, and redistributed.
Tagged version

Modules with tagged versions give importers more predictable builds.
Stable version

When a project reaches major version v1 it is considered stable.
Learn more about best practices

Repository

github.com/golangsam/anytype

Links

Open Source Insights

Documentation ¶

Index ¶

Constants
func ChanFloat32(inp ...float32) chan float32
func ChanFloat32FuncErr(act func() (float32, error)) <-chan float32
func ChanFloat32FuncNok(act func() (float32, bool)) <-chan float32
func ChanFloat32Slice(inp ...[]float32) chan float32
func ChanFloat64(inp ...float64) chan float64
func ChanFloat64FuncErr(act func() (float64, error)) <-chan float64
func ChanFloat64FuncNok(act func() (float64, bool)) <-chan float64
func ChanFloat64Slice(inp ...[]float64) chan float64
func ChanInt(inp ...int) chan int
func ChanInt16(inp ...int16) chan int16
func ChanInt16FuncErr(act func() (int16, error)) <-chan int16
func ChanInt16FuncNok(act func() (int16, bool)) <-chan int16
func ChanInt16Slice(inp ...[]int16) chan int16
func ChanInt32(inp ...int32) chan int32
func ChanInt32FuncErr(act func() (int32, error)) <-chan int32
func ChanInt32FuncNok(act func() (int32, bool)) <-chan int32
func ChanInt32Slice(inp ...[]int32) chan int32
func ChanInt64(inp ...int64) chan int64
func ChanInt64FuncErr(act func() (int64, error)) <-chan int64
func ChanInt64FuncNok(act func() (int64, bool)) <-chan int64
func ChanInt64Slice(inp ...[]int64) chan int64
func ChanInt8(inp ...int8) chan int8
func ChanInt8FuncErr(act func() (int8, error)) <-chan int8
func ChanInt8FuncNok(act func() (int8, bool)) <-chan int8
func ChanInt8Slice(inp ...[]int8) chan int8
func ChanIntFuncErr(act func() (int, error)) <-chan int
func ChanIntFuncNok(act func() (int, bool)) <-chan int
func ChanIntSlice(inp ...[]int) chan int
func ChanString(inp ...string) chan string
func ChanStringFuncErr(act func() (string, error)) <-chan string
func ChanStringFuncNok(act func() (string, bool)) <-chan string
func ChanStringSlice(inp ...[]string) chan string
func ChanUInt(inp ...uint) chan uint
func ChanUInt16(inp ...uint16) chan uint16
func ChanUInt16FuncErr(act func() (uint16, error)) <-chan uint16
func ChanUInt16FuncNok(act func() (uint16, bool)) <-chan uint16
func ChanUInt16Slice(inp ...[]uint16) chan uint16
func ChanUInt32(inp ...uint32) chan uint32
func ChanUInt32FuncErr(act func() (uint32, error)) <-chan uint32
func ChanUInt32FuncNok(act func() (uint32, bool)) <-chan uint32
func ChanUInt32Slice(inp ...[]uint32) chan uint32
func ChanUInt64(inp ...uint64) chan uint64
func ChanUInt64FuncErr(act func() (uint64, error)) <-chan uint64
func ChanUInt64FuncNok(act func() (uint64, bool)) <-chan uint64
func ChanUInt64Slice(inp ...[]uint64) chan uint64
func ChanUInt8(inp ...uint8) chan uint8
func ChanUInt8FuncErr(act func() (uint8, error)) <-chan uint8
func ChanUInt8FuncNok(act func() (uint8, bool)) <-chan uint8
func ChanUInt8Slice(inp ...[]uint8) chan uint8
func ChanUIntFuncErr(act func() (uint, error)) <-chan uint
func ChanUIntFuncNok(act func() (uint, bool)) <-chan uint
func ChanUIntSlice(inp ...[]uint) chan uint
func DoneFloat32(inp <-chan float32) chan struct{}
func DoneFloat32Func(inp <-chan float32, act func(a float32)) chan struct{}
func DoneFloat32Slice(inp <-chan float32) chan []float32
func DoneFloat64(inp <-chan float64) chan struct{}
func DoneFloat64Func(inp <-chan float64, act func(a float64)) chan struct{}
func DoneFloat64Slice(inp <-chan float64) chan []float64
func DoneInt(inp <-chan int) chan struct{}
func DoneInt16(inp <-chan int16) chan struct{}
func DoneInt16Func(inp <-chan int16, act func(a int16)) chan struct{}
func DoneInt16Slice(inp <-chan int16) chan []int16
func DoneInt32(inp <-chan int32) chan struct{}
func DoneInt32Func(inp <-chan int32, act func(a int32)) chan struct{}
func DoneInt32Slice(inp <-chan int32) chan []int32
func DoneInt64(inp <-chan int64) chan struct{}
func DoneInt64Func(inp <-chan int64, act func(a int64)) chan struct{}
func DoneInt64Slice(inp <-chan int64) chan []int64
func DoneInt8(inp <-chan int8) chan struct{}
func DoneInt8Func(inp <-chan int8, act func(a int8)) chan struct{}
func DoneInt8Slice(inp <-chan int8) chan []int8
func DoneIntFunc(inp <-chan int, act func(a int)) chan struct{}
func DoneIntSlice(inp <-chan int) chan []int
func DoneString(inp <-chan string) chan struct{}
func DoneStringFunc(inp <-chan string, act func(a string)) chan struct{}
func DoneStringSlice(inp <-chan string) chan []string
func DoneUInt(inp <-chan uint) chan struct{}
func DoneUInt16(inp <-chan uint16) chan struct{}
func DoneUInt16Func(inp <-chan uint16, act func(a uint16)) chan struct{}
func DoneUInt16Slice(inp <-chan uint16) chan []uint16
func DoneUInt32(inp <-chan uint32) chan struct{}
func DoneUInt32Func(inp <-chan uint32, act func(a uint32)) chan struct{}
func DoneUInt32Slice(inp <-chan uint32) chan []uint32
func DoneUInt64(inp <-chan uint64) chan struct{}
func DoneUInt64Func(inp <-chan uint64, act func(a uint64)) chan struct{}
func DoneUInt64Slice(inp <-chan uint64) chan []uint64
func DoneUInt8(inp <-chan uint8) chan struct{}
func DoneUInt8Func(inp <-chan uint8, act func(a uint8)) chan struct{}
func DoneUInt8Slice(inp <-chan uint8) chan []uint8
func DoneUIntFunc(inp <-chan uint, act func(a uint)) chan struct{}
func DoneUIntSlice(inp <-chan uint) chan []uint
func Float32Daisy(inp <-chan float32, tube Float32Tube) (out <-chan float32)
func Float32DaisyChain(inp <-chan float32, tubes ...Float32Tube) (out <-chan float32)
func Float64Daisy(inp <-chan float64, tube Float64Tube) (out <-chan float64)
func Float64DaisyChain(inp <-chan float64, tubes ...Float64Tube) (out <-chan float64)
func Int16Daisy(inp <-chan int16, tube Int16Tube) (out <-chan int16)
func Int16DaisyChain(inp <-chan int16, tubes ...Int16Tube) (out <-chan int16)
func Int32Daisy(inp <-chan int32, tube Int32Tube) (out <-chan int32)
func Int32DaisyChain(inp <-chan int32, tubes ...Int32Tube) (out <-chan int32)
func Int64Daisy(inp <-chan int64, tube Int64Tube) (out <-chan int64)
func Int64DaisyChain(inp <-chan int64, tubes ...Int64Tube) (out <-chan int64)
func Int8Daisy(inp <-chan int8, tube Int8Tube) (out <-chan int8)
func Int8DaisyChain(inp <-chan int8, tubes ...Int8Tube) (out <-chan int8)
func IntDaisy(inp <-chan int, tube IntTube) (out <-chan int)
func IntDaisyChain(inp <-chan int, tubes ...IntTube) (out <-chan int)
func JoinFloat32(out chan<- float32, inp ...float32) chan struct{}
func JoinFloat32Chan(out chan<- float32, inp <-chan float32) chan struct{}
func JoinFloat32Slice(out chan<- float32, inp ...[]float32) chan struct{}
func JoinFloat64(out chan<- float64, inp ...float64) chan struct{}
func JoinFloat64Chan(out chan<- float64, inp <-chan float64) chan struct{}
func JoinFloat64Slice(out chan<- float64, inp ...[]float64) chan struct{}
func JoinInt(out chan<- int, inp ...int) chan struct{}
func JoinInt16(out chan<- int16, inp ...int16) chan struct{}
func JoinInt16Chan(out chan<- int16, inp <-chan int16) chan struct{}
func JoinInt16Slice(out chan<- int16, inp ...[]int16) chan struct{}
func JoinInt32(out chan<- int32, inp ...int32) chan struct{}
func JoinInt32Chan(out chan<- int32, inp <-chan int32) chan struct{}
func JoinInt32Slice(out chan<- int32, inp ...[]int32) chan struct{}
func JoinInt64(out chan<- int64, inp ...int64) chan struct{}
func JoinInt64Chan(out chan<- int64, inp <-chan int64) chan struct{}
func JoinInt64Slice(out chan<- int64, inp ...[]int64) chan struct{}
func JoinInt8(out chan<- int8, inp ...int8) chan struct{}
func JoinInt8Chan(out chan<- int8, inp <-chan int8) chan struct{}
func JoinInt8Slice(out chan<- int8, inp ...[]int8) chan struct{}
func JoinIntChan(out chan<- int, inp <-chan int) chan struct{}
func JoinIntSlice(out chan<- int, inp ...[]int) chan struct{}
func JoinString(out chan<- string, inp ...string) chan struct{}
func JoinStringChan(out chan<- string, inp <-chan string) chan struct{}
func JoinStringSlice(out chan<- string, inp ...[]string) chan struct{}
func JoinUInt(out chan<- uint, inp ...uint) chan struct{}
func JoinUInt16(out chan<- uint16, inp ...uint16) chan struct{}
func JoinUInt16Chan(out chan<- uint16, inp <-chan uint16) chan struct{}
func JoinUInt16Slice(out chan<- uint16, inp ...[]uint16) chan struct{}
func JoinUInt32(out chan<- uint32, inp ...uint32) chan struct{}
func JoinUInt32Chan(out chan<- uint32, inp <-chan uint32) chan struct{}
func JoinUInt32Slice(out chan<- uint32, inp ...[]uint32) chan struct{}
func JoinUInt64(out chan<- uint64, inp ...uint64) chan struct{}
func JoinUInt64Chan(out chan<- uint64, inp <-chan uint64) chan struct{}
func JoinUInt64Slice(out chan<- uint64, inp ...[]uint64) chan struct{}
func JoinUInt8(out chan<- uint8, inp ...uint8) chan struct{}
func JoinUInt8Chan(out chan<- uint8, inp <-chan uint8) chan struct{}
func JoinUInt8Slice(out chan<- uint8, inp ...[]uint8) chan struct{}
func JoinUIntChan(out chan<- uint, inp <-chan uint) chan struct{}
func JoinUIntSlice(out chan<- uint, inp ...[]uint) chan struct{}
func MakeFloat32Chan() chan float32
func MakeFloat64Chan() chan float64
func MakeInt16Chan() chan int16
func MakeInt32Chan() chan int32
func MakeInt64Chan() chan int64
func MakeInt8Chan() chan int8
func MakeIntChan() chan int
func MakeStringChan() chan string
func MakeUInt16Chan() chan uint16
func MakeUInt32Chan() chan uint32
func MakeUInt64Chan() chan uint64
func MakeUInt8Chan() chan uint8
func MakeUIntChan() chan uint
func MergeFloat32(inps ...<-chan float32) (out <-chan float32)
func MergeFloat64(inps ...<-chan float64) (out <-chan float64)
func MergeInt(inps ...<-chan int) (out <-chan int)
func MergeInt16(inps ...<-chan int16) (out <-chan int16)
func MergeInt32(inps ...<-chan int32) (out <-chan int32)
func MergeInt64(inps ...<-chan int64) (out <-chan int64)
func MergeInt8(inps ...<-chan int8) (out <-chan int8)
func MergeString(inps ...<-chan string) (out <-chan string)
func MergeUInt(inps ...<-chan uint) (out <-chan uint)
func MergeUInt16(inps ...<-chan uint16) (out <-chan uint16)
func MergeUInt32(inps ...<-chan uint32) (out <-chan uint32)
func MergeUInt64(inps ...<-chan uint64) (out <-chan uint64)
func MergeUInt8(inps ...<-chan uint8) (out <-chan uint8)
func PipeFloat32Buffer(inp <-chan float32, cap int) chan float32
func PipeFloat32Fork(inp <-chan float32) (chan float32, chan float32)
func PipeFloat32Func(inp <-chan float32, act func(a float32) float32) chan float32
func PipeFloat64Buffer(inp <-chan float64, cap int) chan float64
func PipeFloat64Fork(inp <-chan float64) (chan float64, chan float64)
func PipeFloat64Func(inp <-chan float64, act func(a float64) float64) chan float64
func PipeInt16Buffer(inp <-chan int16, cap int) chan int16
func PipeInt16Fork(inp <-chan int16) (chan int16, chan int16)
func PipeInt16Func(inp <-chan int16, act func(a int16) int16) chan int16
func PipeInt32Buffer(inp <-chan int32, cap int) chan int32
func PipeInt32Fork(inp <-chan int32) (chan int32, chan int32)
func PipeInt32Func(inp <-chan int32, act func(a int32) int32) chan int32
func PipeInt64Buffer(inp <-chan int64, cap int) chan int64
func PipeInt64Fork(inp <-chan int64) (chan int64, chan int64)
func PipeInt64Func(inp <-chan int64, act func(a int64) int64) chan int64
func PipeInt8Buffer(inp <-chan int8, cap int) chan int8
func PipeInt8Fork(inp <-chan int8) (chan int8, chan int8)
func PipeInt8Func(inp <-chan int8, act func(a int8) int8) chan int8
func PipeIntBuffer(inp <-chan int, cap int) chan int
func PipeIntFork(inp <-chan int) (chan int, chan int)
func PipeIntFunc(inp <-chan int, act func(a int) int) chan int
func PipeStringBuffer(inp <-chan string, cap int) chan string
func PipeStringFork(inp <-chan string) (chan string, chan string)
func PipeStringFunc(inp <-chan string, act func(a string) string) chan string
func PipeUInt16Buffer(inp <-chan uint16, cap int) chan uint16
func PipeUInt16Fork(inp <-chan uint16) (chan uint16, chan uint16)
func PipeUInt16Func(inp <-chan uint16, act func(a uint16) uint16) chan uint16
func PipeUInt32Buffer(inp <-chan uint32, cap int) chan uint32
func PipeUInt32Fork(inp <-chan uint32) (chan uint32, chan uint32)
func PipeUInt32Func(inp <-chan uint32, act func(a uint32) uint32) chan uint32
func PipeUInt64Buffer(inp <-chan uint64, cap int) chan uint64
func PipeUInt64Fork(inp <-chan uint64) (chan uint64, chan uint64)
func PipeUInt64Func(inp <-chan uint64, act func(a uint64) uint64) chan uint64
func PipeUInt8Buffer(inp <-chan uint8, cap int) chan uint8
func PipeUInt8Fork(inp <-chan uint8) (chan uint8, chan uint8)
func PipeUInt8Func(inp <-chan uint8, act func(a uint8) uint8) chan uint8
func PipeUIntBuffer(inp <-chan uint, cap int) chan uint
func PipeUIntFork(inp <-chan uint) (chan uint, chan uint)
func PipeUIntFunc(inp <-chan uint, act func(a uint) uint) chan uint
func SendProxyFloat32(out chan<- float32) chan<- float32
func SendProxyFloat64(out chan<- float64) chan<- float64
func SendProxyInt(out chan<- int) chan<- int
func SendProxyInt16(out chan<- int16) chan<- int16
func SendProxyInt32(out chan<- int32) chan<- int32
func SendProxyInt64(out chan<- int64) chan<- int64
func SendProxyInt8(out chan<- int8) chan<- int8
func SendProxyString(out chan<- string) chan<- string
func SendProxyUInt(out chan<- uint) chan<- uint
func SendProxyUInt16(out chan<- uint16) chan<- uint16
func SendProxyUInt32(out chan<- uint32) chan<- uint32
func SendProxyUInt64(out chan<- uint64) chan<- uint64
func SendProxyUInt8(out chan<- uint8) chan<- uint8
func StringDaisy(inp <-chan string, tube StringTube) (out <-chan string)
func StringDaisyChain(inp <-chan string, tubes ...StringTube) (out <-chan string)
func UInt16Daisy(inp <-chan uint16, tube UInt16Tube) (out <-chan uint16)
func UInt16DaisyChain(inp <-chan uint16, tubes ...UInt16Tube) (out <-chan uint16)
func UInt32Daisy(inp <-chan uint32, tube UInt32Tube) (out <-chan uint32)
func UInt32DaisyChain(inp <-chan uint32, tubes ...UInt32Tube) (out <-chan uint32)
func UInt64Daisy(inp <-chan uint64, tube UInt64Tube) (out <-chan uint64)
func UInt64DaisyChain(inp <-chan uint64, tubes ...UInt64Tube) (out <-chan uint64)
func UInt8Daisy(inp <-chan uint8, tube UInt8Tube) (out <-chan uint8)
func UInt8DaisyChain(inp <-chan uint8, tubes ...UInt8Tube) (out <-chan uint8)
func UIntDaisy(inp <-chan uint, tube UIntTube) (out <-chan uint)
func UIntDaisyChain(inp <-chan uint, tubes ...UIntTube) (out <-chan uint)
type BasicInfo
type BasicKind
type Float32Tube
type Float64Tube
type Int16Tube
type Int32Tube
type Int64Tube
type Int8Tube
type IntTube
type StringTube
type UInt16Tube
type UInt32Tube
type UInt64Tube
type UInt8Tube
type UIntTube

Constants ¶

View Source

const Float32CAP = 10

Float32CAP is the capacity of the buffered proxy channel

View Source

const Float32QUE = 16

Float32QUE is the allocated size of the circular queue

View Source

const Float64CAP = 10

Float64CAP is the capacity of the buffered proxy channel

View Source

const Float64QUE = 16

Float64QUE is the allocated size of the circular queue

View Source

const Int16CAP = 10

Int16CAP is the capacity of the buffered proxy channel

View Source

const Int16QUE = 16

Int16QUE is the allocated size of the circular queue

View Source

const Int32CAP = 10

Int32CAP is the capacity of the buffered proxy channel

View Source

const Int32QUE = 16

Int32QUE is the allocated size of the circular queue

View Source

const Int64CAP = 10

Int64CAP is the capacity of the buffered proxy channel

View Source

const Int64QUE = 16

Int64QUE is the allocated size of the circular queue

View Source

const Int8CAP = 10

Int8CAP is the capacity of the buffered proxy channel

View Source

const Int8QUE = 16

Int8QUE is the allocated size of the circular queue

View Source

const IntCAP = 10

IntCAP is the capacity of the buffered proxy channel

View Source

const IntQUE = 16

IntQUE is the allocated size of the circular queue

View Source

const StringCAP = 10

StringCAP is the capacity of the buffered proxy channel

View Source

const StringQUE = 16

StringQUE is the allocated size of the circular queue

View Source

const UInt16CAP = 10

UInt16CAP is the capacity of the buffered proxy channel

View Source

const UInt16QUE = 16

UInt16QUE is the allocated size of the circular queue

View Source

const UInt32CAP = 10

UInt32CAP is the capacity of the buffered proxy channel

View Source

const UInt32QUE = 16

UInt32QUE is the allocated size of the circular queue

View Source

const UInt64CAP = 10

UInt64CAP is the capacity of the buffered proxy channel

View Source

const UInt64QUE = 16

UInt64QUE is the allocated size of the circular queue

View Source

const UInt8CAP = 10

UInt8CAP is the capacity of the buffered proxy channel

View Source

const UInt8QUE = 16

UInt8QUE is the allocated size of the circular queue

View Source

const UIntCAP = 10

UIntCAP is the capacity of the buffered proxy channel

View Source

const UIntQUE = 16

UIntQUE is the allocated size of the circular queue

Variables ¶

This section is empty.

Functions ¶

func ChanFloat32 ¶

func ChanFloat32(inp ...float32) chan float32

ChanFloat32 returns a channel to receive all inputs before close.

func ChanFloat32FuncErr ¶

func ChanFloat32FuncErr(act func() (float32, error)) <-chan float32

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

func ChanFloat32FuncNok ¶

func ChanFloat32FuncNok(act func() (float32, bool)) <-chan float32

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

func ChanFloat32Slice ¶

func ChanFloat32Slice(inp ...[]float32) chan float32

ChanFloat32Slice returns a channel to receive all inputs before close.

func ChanFloat64 ¶

func ChanFloat64(inp ...float64) chan float64

ChanFloat64 returns a channel to receive all inputs before close.

func ChanFloat64FuncErr ¶

func ChanFloat64FuncErr(act func() (float64, error)) <-chan float64

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

func ChanFloat64FuncNok ¶

func ChanFloat64FuncNok(act func() (float64, bool)) <-chan float64

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

func ChanFloat64Slice ¶

func ChanFloat64Slice(inp ...[]float64) chan float64

ChanFloat64Slice returns a channel to receive all inputs before close.

func ChanInt ¶

func ChanInt(inp ...int) chan int

ChanInt returns a channel to receive all inputs before close.

func ChanInt16 ¶

func ChanInt16(inp ...int16) chan int16

ChanInt16 returns a channel to receive all inputs before close.

func ChanInt16FuncErr ¶

func ChanInt16FuncErr(act func() (int16, error)) <-chan int16

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

func ChanInt16FuncNok ¶

func ChanInt16FuncNok(act func() (int16, bool)) <-chan int16

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

func ChanInt16Slice ¶

func ChanInt16Slice(inp ...[]int16) chan int16

ChanInt16Slice returns a channel to receive all inputs before close.

func ChanInt32 ¶

func ChanInt32(inp ...int32) chan int32

ChanInt32 returns a channel to receive all inputs before close.

func ChanInt32FuncErr ¶

func ChanInt32FuncErr(act func() (int32, error)) <-chan int32

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

func ChanInt32FuncNok ¶

func ChanInt32FuncNok(act func() (int32, bool)) <-chan int32

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

func ChanInt32Slice ¶

func ChanInt32Slice(inp ...[]int32) chan int32

ChanInt32Slice returns a channel to receive all inputs before close.

func ChanInt64 ¶

func ChanInt64(inp ...int64) chan int64

ChanInt64 returns a channel to receive all inputs before close.

func ChanInt64FuncErr ¶

func ChanInt64FuncErr(act func() (int64, error)) <-chan int64

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

func ChanInt64FuncNok ¶

func ChanInt64FuncNok(act func() (int64, bool)) <-chan int64

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

func ChanInt64Slice ¶

func ChanInt64Slice(inp ...[]int64) chan int64

ChanInt64Slice returns a channel to receive all inputs before close.

func ChanInt8 ¶

func ChanInt8(inp ...int8) chan int8

ChanInt8 returns a channel to receive all inputs before close.

func ChanInt8FuncErr ¶

func ChanInt8FuncErr(act func() (int8, error)) <-chan int8

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

func ChanInt8FuncNok ¶

func ChanInt8FuncNok(act func() (int8, bool)) <-chan int8

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

func ChanInt8Slice ¶

func ChanInt8Slice(inp ...[]int8) chan int8

ChanInt8Slice returns a channel to receive all inputs before close.

func ChanIntFuncErr ¶

func ChanIntFuncErr(act func() (int, error)) <-chan int

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

func ChanIntFuncNok ¶

func ChanIntFuncNok(act func() (int, bool)) <-chan int

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

func ChanIntSlice ¶

func ChanIntSlice(inp ...[]int) chan int

ChanIntSlice returns a channel to receive all inputs before close.

func ChanString ¶

func ChanString(inp ...string) chan string

ChanString returns a channel to receive all inputs before close.

func ChanStringFuncErr ¶

func ChanStringFuncErr(act func() (string, error)) <-chan string

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

func ChanStringFuncNok ¶

func ChanStringFuncNok(act func() (string, bool)) <-chan string

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

func ChanStringSlice ¶

func ChanStringSlice(inp ...[]string) chan string

ChanStringSlice returns a channel to receive all inputs before close.

func ChanUInt ¶

func ChanUInt(inp ...uint) chan uint

ChanUInt returns a channel to receive all inputs before close.

func ChanUInt16 ¶

func ChanUInt16(inp ...uint16) chan uint16

ChanUInt16 returns a channel to receive all inputs before close.

func ChanUInt16FuncErr ¶

func ChanUInt16FuncErr(act func() (uint16, error)) <-chan uint16

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

func ChanUInt16FuncNok ¶

func ChanUInt16FuncNok(act func() (uint16, bool)) <-chan uint16

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

func ChanUInt16Slice ¶

func ChanUInt16Slice(inp ...[]uint16) chan uint16

ChanUInt16Slice returns a channel to receive all inputs before close.

func ChanUInt32 ¶

func ChanUInt32(inp ...uint32) chan uint32

ChanUInt32 returns a channel to receive all inputs before close.

func ChanUInt32FuncErr ¶

func ChanUInt32FuncErr(act func() (uint32, error)) <-chan uint32

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

func ChanUInt32FuncNok ¶

func ChanUInt32FuncNok(act func() (uint32, bool)) <-chan uint32

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

func ChanUInt32Slice ¶

func ChanUInt32Slice(inp ...[]uint32) chan uint32

ChanUInt32Slice returns a channel to receive all inputs before close.

func ChanUInt64 ¶

func ChanUInt64(inp ...uint64) chan uint64

ChanUInt64 returns a channel to receive all inputs before close.

func ChanUInt64FuncErr ¶

func ChanUInt64FuncErr(act func() (uint64, error)) <-chan uint64

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

func ChanUInt64FuncNok ¶

func ChanUInt64FuncNok(act func() (uint64, bool)) <-chan uint64

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

func ChanUInt64Slice ¶

func ChanUInt64Slice(inp ...[]uint64) chan uint64

ChanUInt64Slice returns a channel to receive all inputs before close.

func ChanUInt8 ¶

func ChanUInt8(inp ...uint8) chan uint8

ChanUInt8 returns a channel to receive all inputs before close.

func ChanUInt8FuncErr ¶

func ChanUInt8FuncErr(act func() (uint8, error)) <-chan uint8

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

func ChanUInt8FuncNok ¶

func ChanUInt8FuncNok(act func() (uint8, bool)) <-chan uint8

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

func ChanUInt8Slice ¶

func ChanUInt8Slice(inp ...[]uint8) chan uint8

ChanUInt8Slice returns a channel to receive all inputs before close.

func ChanUIntFuncErr ¶

func ChanUIntFuncErr(act func() (uint, error)) <-chan uint

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

func ChanUIntFuncNok ¶

func ChanUIntFuncNok(act func() (uint, bool)) <-chan uint

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

func ChanUIntSlice ¶

func ChanUIntSlice(inp ...[]uint) chan uint

ChanUIntSlice returns a channel to receive all inputs before close.

func DoneFloat32 ¶

func DoneFloat32(inp <-chan float32) chan struct{}

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

func DoneFloat32Func ¶

func DoneFloat32Func(inp <-chan float32, act func(a float32)) chan struct{}

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

func DoneFloat32Slice ¶

func DoneFloat32Slice(inp <-chan float32) chan []float32

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

func DoneFloat64 ¶

func DoneFloat64(inp <-chan float64) chan struct{}

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

func DoneFloat64Func ¶

func DoneFloat64Func(inp <-chan float64, act func(a float64)) chan struct{}

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

func DoneFloat64Slice ¶

func DoneFloat64Slice(inp <-chan float64) chan []float64

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

func DoneInt ¶

func DoneInt(inp <-chan int) chan struct{}

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

func DoneInt16 ¶

func DoneInt16(inp <-chan int16) chan struct{}

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

func DoneInt16Func ¶

func DoneInt16Func(inp <-chan int16, act func(a int16)) chan struct{}

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

func DoneInt16Slice ¶

func DoneInt16Slice(inp <-chan int16) chan []int16

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

func DoneInt32 ¶

func DoneInt32(inp <-chan int32) chan struct{}

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

func DoneInt32Func ¶

func DoneInt32Func(inp <-chan int32, act func(a int32)) chan struct{}

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

func DoneInt32Slice ¶

func DoneInt32Slice(inp <-chan int32) chan []int32

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

func DoneInt64 ¶

func DoneInt64(inp <-chan int64) chan struct{}

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

func DoneInt64Func ¶

func DoneInt64Func(inp <-chan int64, act func(a int64)) chan struct{}

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

func DoneInt64Slice ¶

func DoneInt64Slice(inp <-chan int64) chan []int64

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

func DoneInt8 ¶

func DoneInt8(inp <-chan int8) chan struct{}

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

func DoneInt8Func ¶

func DoneInt8Func(inp <-chan int8, act func(a int8)) chan struct{}

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

func DoneInt8Slice ¶

func DoneInt8Slice(inp <-chan int8) chan []int8

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

func DoneIntFunc ¶

func DoneIntFunc(inp <-chan int, act func(a int)) chan struct{}

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

func DoneIntSlice ¶

func DoneIntSlice(inp <-chan int) chan []int

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

func DoneString ¶

func DoneString(inp <-chan string) chan struct{}

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

func DoneStringFunc ¶

func DoneStringFunc(inp <-chan string, act func(a string)) chan struct{}

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

func DoneStringSlice ¶

func DoneStringSlice(inp <-chan string) chan []string

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

func DoneUInt ¶

func DoneUInt(inp <-chan uint) chan struct{}

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

func DoneUInt16 ¶

func DoneUInt16(inp <-chan uint16) chan struct{}

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

func DoneUInt16Func ¶

func DoneUInt16Func(inp <-chan uint16, act func(a uint16)) chan struct{}

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

func DoneUInt16Slice ¶

func DoneUInt16Slice(inp <-chan uint16) chan []uint16

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

func DoneUInt32 ¶

func DoneUInt32(inp <-chan uint32) chan struct{}

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

func DoneUInt32Func ¶

func DoneUInt32Func(inp <-chan uint32, act func(a uint32)) chan struct{}

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

func DoneUInt32Slice ¶

func DoneUInt32Slice(inp <-chan uint32) chan []uint32

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

func DoneUInt64 ¶

func DoneUInt64(inp <-chan uint64) chan struct{}

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

func DoneUInt64Func ¶

func DoneUInt64Func(inp <-chan uint64, act func(a uint64)) chan struct{}

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

func DoneUInt64Slice ¶

func DoneUInt64Slice(inp <-chan uint64) chan []uint64

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

func DoneUInt8 ¶

func DoneUInt8(inp <-chan uint8) chan struct{}

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

func DoneUInt8Func ¶

func DoneUInt8Func(inp <-chan uint8, act func(a uint8)) chan struct{}

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

func DoneUInt8Slice ¶

func DoneUInt8Slice(inp <-chan uint8) chan []uint8

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

func DoneUIntFunc ¶

func DoneUIntFunc(inp <-chan uint, act func(a uint)) chan struct{}

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

func DoneUIntSlice ¶

func DoneUIntSlice(inp <-chan uint) chan []uint

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

func Float32Daisy ¶

func Float32Daisy(inp <-chan float32, tube Float32Tube) (out <-chan float32)

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

func Float32DaisyChain ¶

func Float32DaisyChain(inp <-chan float32, tubes ...Float32Tube) (out <-chan float32)

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

func Float64Daisy ¶

func Float64Daisy(inp <-chan float64, tube Float64Tube) (out <-chan float64)

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

func Float64DaisyChain ¶

func Float64DaisyChain(inp <-chan float64, tubes ...Float64Tube) (out <-chan float64)

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

func Int16Daisy ¶

func Int16Daisy(inp <-chan int16, tube Int16Tube) (out <-chan int16)

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

func Int16DaisyChain ¶

func Int16DaisyChain(inp <-chan int16, tubes ...Int16Tube) (out <-chan int16)

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

func Int32Daisy ¶

func Int32Daisy(inp <-chan int32, tube Int32Tube) (out <-chan int32)

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

func Int32DaisyChain ¶

func Int32DaisyChain(inp <-chan int32, tubes ...Int32Tube) (out <-chan int32)

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

func Int64Daisy ¶

func Int64Daisy(inp <-chan int64, tube Int64Tube) (out <-chan int64)

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

func Int64DaisyChain ¶

func Int64DaisyChain(inp <-chan int64, tubes ...Int64Tube) (out <-chan int64)

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

func Int8Daisy ¶

func Int8Daisy(inp <-chan int8, tube Int8Tube) (out <-chan int8)

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

func Int8DaisyChain ¶

func Int8DaisyChain(inp <-chan int8, tubes ...Int8Tube) (out <-chan int8)

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

func IntDaisy ¶

func IntDaisy(inp <-chan int, tube IntTube) (out <-chan int)

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

func IntDaisyChain ¶

func IntDaisyChain(inp <-chan int, tubes ...IntTube) (out <-chan int)

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

func JoinFloat32 ¶

func JoinFloat32(out chan<- float32, inp ...float32) chan struct{}

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

func JoinFloat32Chan ¶

func JoinFloat32Chan(out chan<- float32, inp <-chan float32) chan struct{}

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

func JoinFloat32Slice ¶

func JoinFloat32Slice(out chan<- float32, inp ...[]float32) chan struct{}

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

func JoinFloat64 ¶

func JoinFloat64(out chan<- float64, inp ...float64) chan struct{}

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

func JoinFloat64Chan ¶

func JoinFloat64Chan(out chan<- float64, inp <-chan float64) chan struct{}

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

func JoinFloat64Slice ¶

func JoinFloat64Slice(out chan<- float64, inp ...[]float64) chan struct{}

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

func JoinInt ¶

func JoinInt(out chan<- int, inp ...int) chan struct{}

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

func JoinInt16 ¶

func JoinInt16(out chan<- int16, inp ...int16) chan struct{}

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

func JoinInt16Chan ¶

func JoinInt16Chan(out chan<- int16, inp <-chan int16) chan struct{}

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

func JoinInt16Slice ¶

func JoinInt16Slice(out chan<- int16, inp ...[]int16) chan struct{}

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

func JoinInt32 ¶

func JoinInt32(out chan<- int32, inp ...int32) chan struct{}

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

func JoinInt32Chan ¶

func JoinInt32Chan(out chan<- int32, inp <-chan int32) chan struct{}

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

func JoinInt32Slice ¶

func JoinInt32Slice(out chan<- int32, inp ...[]int32) chan struct{}

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

func JoinInt64 ¶

func JoinInt64(out chan<- int64, inp ...int64) chan struct{}

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

func JoinInt64Chan ¶

func JoinInt64Chan(out chan<- int64, inp <-chan int64) chan struct{}

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

func JoinInt64Slice ¶

func JoinInt64Slice(out chan<- int64, inp ...[]int64) chan struct{}

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

func JoinInt8 ¶

func JoinInt8(out chan<- int8, inp ...int8) chan struct{}

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

func JoinInt8Chan ¶

func JoinInt8Chan(out chan<- int8, inp <-chan int8) chan struct{}

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

func JoinInt8Slice ¶

func JoinInt8Slice(out chan<- int8, inp ...[]int8) chan struct{}

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

func JoinIntChan ¶

func JoinIntChan(out chan<- int, inp <-chan int) chan struct{}

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

func JoinIntSlice ¶

func JoinIntSlice(out chan<- int, inp ...[]int) chan struct{}

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

func JoinString ¶

func JoinString(out chan<- string, inp ...string) chan struct{}

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

func JoinStringChan ¶

func JoinStringChan(out chan<- string, inp <-chan string) chan struct{}

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

func JoinStringSlice ¶

func JoinStringSlice(out chan<- string, inp ...[]string) chan struct{}

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

func JoinUInt ¶

func JoinUInt(out chan<- uint, inp ...uint) chan struct{}

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

func JoinUInt16 ¶

func JoinUInt16(out chan<- uint16, inp ...uint16) chan struct{}

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

func JoinUInt16Chan ¶

func JoinUInt16Chan(out chan<- uint16, inp <-chan uint16) chan struct{}

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

func JoinUInt16Slice ¶

func JoinUInt16Slice(out chan<- uint16, inp ...[]uint16) chan struct{}

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

func JoinUInt32 ¶

func JoinUInt32(out chan<- uint32, inp ...uint32) chan struct{}

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

func JoinUInt32Chan ¶

func JoinUInt32Chan(out chan<- uint32, inp <-chan uint32) chan struct{}

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

func JoinUInt32Slice ¶

func JoinUInt32Slice(out chan<- uint32, inp ...[]uint32) chan struct{}

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

func JoinUInt64 ¶

func JoinUInt64(out chan<- uint64, inp ...uint64) chan struct{}

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

func JoinUInt64Chan ¶

func JoinUInt64Chan(out chan<- uint64, inp <-chan uint64) chan struct{}

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

func JoinUInt64Slice ¶

func JoinUInt64Slice(out chan<- uint64, inp ...[]uint64) chan struct{}

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

func JoinUInt8 ¶

func JoinUInt8(out chan<- uint8, inp ...uint8) chan struct{}

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

func JoinUInt8Chan ¶

func JoinUInt8Chan(out chan<- uint8, inp <-chan uint8) chan struct{}

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

func JoinUInt8Slice ¶

func JoinUInt8Slice(out chan<- uint8, inp ...[]uint8) chan struct{}

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

func JoinUIntChan ¶

func JoinUIntChan(out chan<- uint, inp <-chan uint) chan struct{}

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

func JoinUIntSlice ¶

func JoinUIntSlice(out chan<- uint, inp ...[]uint) chan struct{}

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

func MakeFloat32Chan ¶

func MakeFloat32Chan() chan float32

MakeFloat32Chan returns a new open channel (simply a 'chan float32' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipeFloat32Buffer) the channel is unbuffered.

func MakeFloat64Chan ¶

func MakeFloat64Chan() chan float64

MakeFloat64Chan returns a new open channel (simply a 'chan float64' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipeFloat64Buffer) the channel is unbuffered.

func MakeInt16Chan ¶

func MakeInt16Chan() chan int16

MakeInt16Chan returns a new open channel (simply a 'chan int16' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipeInt16Buffer) the channel is unbuffered.

func MakeInt32Chan ¶

func MakeInt32Chan() chan int32

MakeInt32Chan returns a new open channel (simply a 'chan int32' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipeInt32Buffer) the channel is unbuffered.

func MakeInt64Chan ¶

func MakeInt64Chan() chan int64

MakeInt64Chan returns a new open channel (simply a 'chan int64' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipeInt64Buffer) the channel is unbuffered.

func MakeInt8Chan ¶

func MakeInt8Chan() chan int8

MakeInt8Chan returns a new open channel (simply a 'chan int8' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipeInt8Buffer) the channel is unbuffered.

func MakeIntChan ¶

func MakeIntChan() chan int

MakeIntChan returns a new open channel (simply a 'chan int' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipeIntBuffer) the channel is unbuffered.

func MakeStringChan ¶

func MakeStringChan() chan string

MakeStringChan returns a new open channel (simply a 'chan string' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipeStringBuffer) the channel is unbuffered.

func MakeUInt16Chan ¶

func MakeUInt16Chan() chan uint16

MakeUInt16Chan returns a new open channel (simply a 'chan uint16' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipeUInt16Buffer) the channel is unbuffered.

func MakeUInt32Chan ¶

func MakeUInt32Chan() chan uint32

MakeUInt32Chan returns a new open channel (simply a 'chan uint32' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipeUInt32Buffer) the channel is unbuffered.

func MakeUInt64Chan ¶

func MakeUInt64Chan() chan uint64

MakeUInt64Chan returns a new open channel (simply a 'chan uint64' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipeUInt64Buffer) the channel is unbuffered.

func MakeUInt8Chan ¶

func MakeUInt8Chan() chan uint8

MakeUInt8Chan returns a new open channel (simply a 'chan uint8' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipeUInt8Buffer) the channel is unbuffered.

func MakeUIntChan ¶

func MakeUIntChan() chan uint

MakeUIntChan returns a new open channel (simply a 'chan uint' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipeUIntBuffer) the channel is unbuffered.

func MergeFloat32 ¶

func MergeFloat32(inps ...<-chan float32) (out <-chan float32)

MergeFloat32 returns a channel to receive all inputs sorted and free of duplicates. Each input channel needs to be ascending; sorted and free of duplicates.

Note: If no inputs are given, a closed Float32channel is returned.

func MergeFloat64 ¶

func MergeFloat64(inps ...<-chan float64) (out <-chan float64)

MergeFloat64 returns a channel to receive all inputs sorted and free of duplicates. Each input channel needs to be ascending; sorted and free of duplicates.

Note: If no inputs are given, a closed Float64channel is returned.

func MergeInt ¶

func MergeInt(inps ...<-chan int) (out <-chan int)

MergeInt returns a channel to receive all inputs sorted and free of duplicates. Each input channel needs to be ascending; sorted and free of duplicates.

Note: If no inputs are given, a closed Intchannel is returned.

func MergeInt16 ¶

func MergeInt16(inps ...<-chan int16) (out <-chan int16)

MergeInt16 returns a channel to receive all inputs sorted and free of duplicates. Each input channel needs to be ascending; sorted and free of duplicates.

Note: If no inputs are given, a closed Int16channel is returned.

func MergeInt32 ¶

func MergeInt32(inps ...<-chan int32) (out <-chan int32)

MergeInt32 returns a channel to receive all inputs sorted and free of duplicates. Each input channel needs to be ascending; sorted and free of duplicates.

Note: If no inputs are given, a closed Int32channel is returned.

func MergeInt64 ¶

func MergeInt64(inps ...<-chan int64) (out <-chan int64)

MergeInt64 returns a channel to receive all inputs sorted and free of duplicates. Each input channel needs to be ascending; sorted and free of duplicates.

Note: If no inputs are given, a closed Int64channel is returned.

func MergeInt8 ¶

func MergeInt8(inps ...<-chan int8) (out <-chan int8)

MergeInt8 returns a channel to receive all inputs sorted and free of duplicates. Each input channel needs to be ascending; sorted and free of duplicates.

Note: If no inputs are given, a closed Int8channel is returned.

func MergeString ¶

func MergeString(inps ...<-chan string) (out <-chan string)

MergeString returns a channel to receive all inputs sorted and free of duplicates. Each input channel needs to be ascending; sorted and free of duplicates.

Note: If no inputs are given, a closed Stringchannel is returned.

func MergeUInt ¶

func MergeUInt(inps ...<-chan uint) (out <-chan uint)

MergeUInt returns a channel to receive all inputs sorted and free of duplicates. Each input channel needs to be ascending; sorted and free of duplicates.

Note: If no inputs are given, a closed UIntchannel is returned.

func MergeUInt16 ¶

func MergeUInt16(inps ...<-chan uint16) (out <-chan uint16)

MergeUInt16 returns a channel to receive all inputs sorted and free of duplicates. Each input channel needs to be ascending; sorted and free of duplicates.

Note: If no inputs are given, a closed UInt16channel is returned.

func MergeUInt32 ¶

func MergeUInt32(inps ...<-chan uint32) (out <-chan uint32)

MergeUInt32 returns a channel to receive all inputs sorted and free of duplicates. Each input channel needs to be ascending; sorted and free of duplicates.

Note: If no inputs are given, a closed UInt32channel is returned.

func MergeUInt64 ¶

func MergeUInt64(inps ...<-chan uint64) (out <-chan uint64)

MergeUInt64 returns a channel to receive all inputs sorted and free of duplicates. Each input channel needs to be ascending; sorted and free of duplicates.

Note: If no inputs are given, a closed UInt64channel is returned.

func MergeUInt8 ¶

func MergeUInt8(inps ...<-chan uint8) (out <-chan uint8)

MergeUInt8 returns a channel to receive all inputs sorted and free of duplicates. Each input channel needs to be ascending; sorted and free of duplicates.

Note: If no inputs are given, a closed UInt8channel is returned.

func PipeFloat32Buffer ¶

func PipeFloat32Buffer(inp <-chan float32, cap int) chan float32

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

func PipeFloat32Fork ¶

func PipeFloat32Fork(inp <-chan float32) (chan float32, chan float32)

PipeFloat32Fork 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 PipeFloat32Func ¶

func PipeFloat32Func(inp <-chan float32, act func(a float32) float32) chan float32

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

func PipeFloat64Buffer ¶

func PipeFloat64Buffer(inp <-chan float64, cap int) chan float64

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

func PipeFloat64Fork ¶

func PipeFloat64Fork(inp <-chan float64) (chan float64, chan float64)

PipeFloat64Fork 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 PipeFloat64Func ¶

func PipeFloat64Func(inp <-chan float64, act func(a float64) float64) chan float64

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

func PipeInt16Buffer ¶

func PipeInt16Buffer(inp <-chan int16, cap int) chan int16

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

func PipeInt16Fork ¶

func PipeInt16Fork(inp <-chan int16) (chan int16, chan int16)

PipeInt16Fork 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 PipeInt16Func ¶

func PipeInt16Func(inp <-chan int16, act func(a int16) int16) chan int16

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

func PipeInt32Buffer ¶

func PipeInt32Buffer(inp <-chan int32, cap int) chan int32

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

func PipeInt32Fork ¶

func PipeInt32Fork(inp <-chan int32) (chan int32, chan int32)

PipeInt32Fork 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 PipeInt32Func ¶

func PipeInt32Func(inp <-chan int32, act func(a int32) int32) chan int32

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

func PipeInt64Buffer ¶

func PipeInt64Buffer(inp <-chan int64, cap int) chan int64

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

func PipeInt64Fork ¶

func PipeInt64Fork(inp <-chan int64) (chan int64, chan int64)

PipeInt64Fork 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 PipeInt64Func ¶

func PipeInt64Func(inp <-chan int64, act func(a int64) int64) chan int64

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

func PipeInt8Buffer ¶

func PipeInt8Buffer(inp <-chan int8, cap int) chan int8

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

func PipeInt8Fork ¶

func PipeInt8Fork(inp <-chan int8) (chan int8, chan int8)

PipeInt8Fork 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 PipeInt8Func ¶

func PipeInt8Func(inp <-chan int8, act func(a int8) int8) chan int8

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

func PipeIntBuffer ¶

func PipeIntBuffer(inp <-chan int, cap int) chan int

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

func PipeIntFork ¶

func PipeIntFork(inp <-chan int) (chan int, chan int)

PipeIntFork 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 PipeIntFunc ¶

func PipeIntFunc(inp <-chan int, act func(a int) int) chan int

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

func PipeStringBuffer ¶

func PipeStringBuffer(inp <-chan string, cap int) chan string

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

func PipeStringFork ¶

func PipeStringFork(inp <-chan string) (chan string, chan string)

PipeStringFork 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 PipeStringFunc ¶

func PipeStringFunc(inp <-chan string, act func(a string) string) chan string

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

func PipeUInt16Buffer ¶

func PipeUInt16Buffer(inp <-chan uint16, cap int) chan uint16

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

func PipeUInt16Fork ¶

func PipeUInt16Fork(inp <-chan uint16) (chan uint16, chan uint16)

PipeUInt16Fork 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 PipeUInt16Func ¶

func PipeUInt16Func(inp <-chan uint16, act func(a uint16) uint16) chan uint16

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

func PipeUInt32Buffer ¶

func PipeUInt32Buffer(inp <-chan uint32, cap int) chan uint32

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

func PipeUInt32Fork ¶

func PipeUInt32Fork(inp <-chan uint32) (chan uint32, chan uint32)

PipeUInt32Fork 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 PipeUInt32Func ¶

func PipeUInt32Func(inp <-chan uint32, act func(a uint32) uint32) chan uint32

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

func PipeUInt64Buffer ¶

func PipeUInt64Buffer(inp <-chan uint64, cap int) chan uint64

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

func PipeUInt64Fork ¶

func PipeUInt64Fork(inp <-chan uint64) (chan uint64, chan uint64)

PipeUInt64Fork 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 PipeUInt64Func ¶

func PipeUInt64Func(inp <-chan uint64, act func(a uint64) uint64) chan uint64

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

func PipeUInt8Buffer ¶

func PipeUInt8Buffer(inp <-chan uint8, cap int) chan uint8

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

func PipeUInt8Fork ¶

func PipeUInt8Fork(inp <-chan uint8) (chan uint8, chan uint8)

PipeUInt8Fork 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 PipeUInt8Func ¶

func PipeUInt8Func(inp <-chan uint8, act func(a uint8) uint8) chan uint8

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

func PipeUIntBuffer ¶

func PipeUIntBuffer(inp <-chan uint, cap int) chan uint

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

func PipeUIntFork ¶

func PipeUIntFork(inp <-chan uint) (chan uint, chan uint)

PipeUIntFork 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 PipeUIntFunc ¶

func PipeUIntFunc(inp <-chan uint, act func(a uint) uint) chan uint

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

func SendProxyFloat32 ¶

func SendProxyFloat32(out chan<- float32) chan<- float32

SendProxyFloat32 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 SendProxyFloat64 ¶

func SendProxyFloat64(out chan<- float64) chan<- float64

SendProxyFloat64 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 SendProxyInt ¶

func SendProxyInt(out chan<- int) chan<- int

SendProxyInt 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 SendProxyInt16 ¶

func SendProxyInt16(out chan<- int16) chan<- int16

SendProxyInt16 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 SendProxyInt32 ¶

func SendProxyInt32(out chan<- int32) chan<- int32

SendProxyInt32 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 SendProxyInt64 ¶

func SendProxyInt64(out chan<- int64) chan<- int64

SendProxyInt64 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 SendProxyInt8 ¶

func SendProxyInt8(out chan<- int8) chan<- int8

SendProxyInt8 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 SendProxyString ¶

func SendProxyString(out chan<- string) chan<- string

SendProxyString 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 SendProxyUInt ¶

func SendProxyUInt(out chan<- uint) chan<- uint

SendProxyUInt 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 SendProxyUInt16 ¶

func SendProxyUInt16(out chan<- uint16) chan<- uint16

SendProxyUInt16 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 SendProxyUInt32 ¶

func SendProxyUInt32(out chan<- uint32) chan<- uint32

SendProxyUInt32 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 SendProxyUInt64 ¶

func SendProxyUInt64(out chan<- uint64) chan<- uint64

SendProxyUInt64 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 SendProxyUInt8 ¶

func SendProxyUInt8(out chan<- uint8) chan<- uint8

SendProxyUInt8 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 StringDaisy ¶

func StringDaisy(inp <-chan string, tube StringTube) (out <-chan string)

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

func StringDaisyChain ¶

func StringDaisyChain(inp <-chan string, tubes ...StringTube) (out <-chan string)

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

func UInt16Daisy ¶

func UInt16Daisy(inp <-chan uint16, tube UInt16Tube) (out <-chan uint16)

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

func UInt16DaisyChain ¶

func UInt16DaisyChain(inp <-chan uint16, tubes ...UInt16Tube) (out <-chan uint16)

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

func UInt32Daisy ¶

func UInt32Daisy(inp <-chan uint32, tube UInt32Tube) (out <-chan uint32)

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

func UInt32DaisyChain ¶

func UInt32DaisyChain(inp <-chan uint32, tubes ...UInt32Tube) (out <-chan uint32)

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

func UInt64Daisy ¶

func UInt64Daisy(inp <-chan uint64, tube UInt64Tube) (out <-chan uint64)

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

func UInt64DaisyChain ¶

func UInt64DaisyChain(inp <-chan uint64, tubes ...UInt64Tube) (out <-chan uint64)

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

func UInt8Daisy ¶

func UInt8Daisy(inp <-chan uint8, tube UInt8Tube) (out <-chan uint8)

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

func UInt8DaisyChain ¶

func UInt8DaisyChain(inp <-chan uint8, tubes ...UInt8Tube) (out <-chan uint8)

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

func UIntDaisy ¶

func UIntDaisy(inp <-chan uint, tube UIntTube) (out <-chan uint)

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

func UIntDaisyChain ¶

func UIntDaisyChain(inp <-chan uint, tubes ...UIntTube) (out <-chan uint)

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

Types ¶

type BasicInfo ¶

type BasicInfo int

BasicInfo is a set of flags describing properties of a basic type.

const (
	IsBoolean BasicInfo = 1 << iota
	IsInteger
	IsUnsigned
	IsFloat
	IsComplex
	IsString
	IsUntyped

	IsOrdered   = IsInteger | IsFloat | IsString
	IsNumeric   = IsInteger | IsFloat | IsComplex
	IsConstType = IsBoolean | IsNumeric | IsString
)

Properties of basic types.

type BasicKind ¶

type BasicKind int

BasicKind describes the kind of basic type.

type Float32Tube ¶

type Float32Tube func(inp <-chan float32, out <-chan float32)

Float32Tube is the signature for a pipe function.

type Float64Tube ¶

type Float64Tube func(inp <-chan float64, out <-chan float64)

Float64Tube is the signature for a pipe function.

type Int16Tube ¶

type Int16Tube func(inp <-chan int16, out <-chan int16)

Int16Tube is the signature for a pipe function.

type Int32Tube ¶

type Int32Tube func(inp <-chan int32, out <-chan int32)

Int32Tube is the signature for a pipe function.

type Int64Tube ¶

type Int64Tube func(inp <-chan int64, out <-chan int64)

Int64Tube is the signature for a pipe function.

type Int8Tube ¶

type Int8Tube func(inp <-chan int8, out <-chan int8)

Int8Tube is the signature for a pipe function.

type IntTube ¶

type IntTube func(inp <-chan int, out <-chan int)

IntTube is the signature for a pipe function.

type StringTube ¶

type StringTube func(inp <-chan string, out <-chan string)

StringTube is the signature for a pipe function.

type UInt16Tube ¶

type UInt16Tube func(inp <-chan uint16, out <-chan uint16)

UInt16Tube is the signature for a pipe function.

type UInt32Tube ¶

type UInt32Tube func(inp <-chan uint32, out <-chan uint32)

UInt32Tube is the signature for a pipe function.

type UInt64Tube ¶

type UInt64Tube func(inp <-chan uint64, out <-chan uint64)

UInt64Tube is the signature for a pipe function.

type UInt8Tube ¶

type UInt8Tube func(inp <-chan uint8, out <-chan uint8)

UInt8Tube is the signature for a pipe function.

type UIntTube ¶

type UIntTube func(inp <-chan uint, out <-chan uint)

UIntTube is the signature for a pipe function.

Source Files ¶

View all Source files

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL