IsNumeric

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
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/GoLangsam/AnyType

Links

Open Source Insights

Documentation ¶

Index ¶

Constants
func ChanComplex128(inp ...complex128) (out <-chan complex128)
func ChanComplex128FuncErr(act func() (complex128, error)) (out <-chan complex128)
func ChanComplex128FuncNok(act func() (complex128, bool)) (out <-chan complex128)
func ChanComplex128Slice(inp ...[]complex128) (out <-chan complex128)
func ChanComplex64(inp ...complex64) (out <-chan complex64)
func ChanComplex64FuncErr(act func() (complex64, error)) (out <-chan complex64)
func ChanComplex64FuncNok(act func() (complex64, bool)) (out <-chan complex64)
func ChanComplex64Slice(inp ...[]complex64) (out <-chan complex64)
func ChanFloat32(inp ...float32) (out <-chan float32)
func ChanFloat32FuncErr(act func() (float32, error)) (out <-chan float32)
func ChanFloat32FuncNok(act func() (float32, bool)) (out <-chan float32)
func ChanFloat32Slice(inp ...[]float32) (out <-chan float32)
func ChanFloat64(inp ...float64) (out <-chan float64)
func ChanFloat64FuncErr(act func() (float64, error)) (out <-chan float64)
func ChanFloat64FuncNok(act func() (float64, bool)) (out <-chan float64)
func ChanFloat64Slice(inp ...[]float64) (out <-chan float64)
func ChanInt(inp ...int) (out <-chan int)
func ChanInt16(inp ...int16) (out <-chan int16)
func ChanInt16FuncErr(act func() (int16, error)) (out <-chan int16)
func ChanInt16FuncNok(act func() (int16, bool)) (out <-chan int16)
func ChanInt16Slice(inp ...[]int16) (out <-chan int16)
func ChanInt32(inp ...int32) (out <-chan int32)
func ChanInt32FuncErr(act func() (int32, error)) (out <-chan int32)
func ChanInt32FuncNok(act func() (int32, bool)) (out <-chan int32)
func ChanInt32Slice(inp ...[]int32) (out <-chan int32)
func ChanInt64(inp ...int64) (out <-chan int64)
func ChanInt64FuncErr(act func() (int64, error)) (out <-chan int64)
func ChanInt64FuncNok(act func() (int64, bool)) (out <-chan int64)
func ChanInt64Slice(inp ...[]int64) (out <-chan int64)
func ChanInt8(inp ...int8) (out <-chan int8)
func ChanInt8FuncErr(act func() (int8, error)) (out <-chan int8)
func ChanInt8FuncNok(act func() (int8, bool)) (out <-chan int8)
func ChanInt8Slice(inp ...[]int8) (out <-chan int8)
func ChanIntFuncErr(act func() (int, error)) (out <-chan int)
func ChanIntFuncNok(act func() (int, bool)) (out <-chan int)
func ChanIntSlice(inp ...[]int) (out <-chan int)
func ChanUInt(inp ...uint) (out <-chan uint)
func ChanUInt16(inp ...uint16) (out <-chan uint16)
func ChanUInt16FuncErr(act func() (uint16, error)) (out <-chan uint16)
func ChanUInt16FuncNok(act func() (uint16, bool)) (out <-chan uint16)
func ChanUInt16Slice(inp ...[]uint16) (out <-chan uint16)
func ChanUInt32(inp ...uint32) (out <-chan uint32)
func ChanUInt32FuncErr(act func() (uint32, error)) (out <-chan uint32)
func ChanUInt32FuncNok(act func() (uint32, bool)) (out <-chan uint32)
func ChanUInt32Slice(inp ...[]uint32) (out <-chan uint32)
func ChanUInt64(inp ...uint64) (out <-chan uint64)
func ChanUInt64FuncErr(act func() (uint64, error)) (out <-chan uint64)
func ChanUInt64FuncNok(act func() (uint64, bool)) (out <-chan uint64)
func ChanUInt64Slice(inp ...[]uint64) (out <-chan uint64)
func ChanUInt8(inp ...uint8) (out <-chan uint8)
func ChanUInt8FuncErr(act func() (uint8, error)) (out <-chan uint8)
func ChanUInt8FuncNok(act func() (uint8, bool)) (out <-chan uint8)
func ChanUInt8Slice(inp ...[]uint8) (out <-chan uint8)
func ChanUIntFuncErr(act func() (uint, error)) (out <-chan uint)
func ChanUIntFuncNok(act func() (uint, bool)) (out <-chan uint)
func ChanUIntSlice(inp ...[]uint) (out <-chan uint)
func Complex128Daisy(inp <-chan complex128, tube Complex128Tube) (out <-chan complex128)
func Complex128DaisyChain(inp <-chan complex128, tubes ...Complex128Tube) (out <-chan complex128)
func Complex64Daisy(inp <-chan complex64, tube Complex64Tube) (out <-chan complex64)
func Complex64DaisyChain(inp <-chan complex64, tubes ...Complex64Tube) (out <-chan complex64)
func DoneComplex128(inp <-chan complex128) (done <-chan struct{})
func DoneComplex128Func(inp <-chan complex128, act func(a complex128)) (out <-chan struct{})
func DoneComplex128Slice(inp <-chan complex128) (done <-chan ([]complex128))
func DoneComplex64(inp <-chan complex64) (done <-chan struct{})
func DoneComplex64Func(inp <-chan complex64, act func(a complex64)) (out <-chan struct{})
func DoneComplex64Slice(inp <-chan complex64) (done <-chan ([]complex64))
func DoneFloat32(inp <-chan float32) (done <-chan struct{})
func DoneFloat32Func(inp <-chan float32, act func(a float32)) (out <-chan struct{})
func DoneFloat32Slice(inp <-chan float32) (done <-chan ([]float32))
func DoneFloat64(inp <-chan float64) (done <-chan struct{})
func DoneFloat64Func(inp <-chan float64, act func(a float64)) (out <-chan struct{})
func DoneFloat64Slice(inp <-chan float64) (done <-chan ([]float64))
func DoneInt(inp <-chan int) (done <-chan struct{})
func DoneInt16(inp <-chan int16) (done <-chan struct{})
func DoneInt16Func(inp <-chan int16, act func(a int16)) (out <-chan struct{})
func DoneInt16Slice(inp <-chan int16) (done <-chan ([]int16))
func DoneInt32(inp <-chan int32) (done <-chan struct{})
func DoneInt32Func(inp <-chan int32, act func(a int32)) (out <-chan struct{})
func DoneInt32Slice(inp <-chan int32) (done <-chan ([]int32))
func DoneInt64(inp <-chan int64) (done <-chan struct{})
func DoneInt64Func(inp <-chan int64, act func(a int64)) (out <-chan struct{})
func DoneInt64Slice(inp <-chan int64) (done <-chan ([]int64))
func DoneInt8(inp <-chan int8) (done <-chan struct{})
func DoneInt8Func(inp <-chan int8, act func(a int8)) (out <-chan struct{})
func DoneInt8Slice(inp <-chan int8) (done <-chan ([]int8))
func DoneIntFunc(inp <-chan int, act func(a int)) (out <-chan struct{})
func DoneIntSlice(inp <-chan int) (done <-chan ([]int))
func DoneUInt(inp <-chan uint) (done <-chan struct{})
func DoneUInt16(inp <-chan uint16) (done <-chan struct{})
func DoneUInt16Func(inp <-chan uint16, act func(a uint16)) (out <-chan struct{})
func DoneUInt16Slice(inp <-chan uint16) (done <-chan ([]uint16))
func DoneUInt32(inp <-chan uint32) (done <-chan struct{})
func DoneUInt32Func(inp <-chan uint32, act func(a uint32)) (out <-chan struct{})
func DoneUInt32Slice(inp <-chan uint32) (done <-chan ([]uint32))
func DoneUInt64(inp <-chan uint64) (done <-chan struct{})
func DoneUInt64Func(inp <-chan uint64, act func(a uint64)) (out <-chan struct{})
func DoneUInt64Slice(inp <-chan uint64) (done <-chan ([]uint64))
func DoneUInt8(inp <-chan uint8) (done <-chan struct{})
func DoneUInt8Func(inp <-chan uint8, act func(a uint8)) (out <-chan struct{})
func DoneUInt8Slice(inp <-chan uint8) (done <-chan ([]uint8))
func DoneUIntFunc(inp <-chan uint, act func(a uint)) (out <-chan struct{})
func DoneUIntSlice(inp <-chan uint) (done <-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 JoinComplex128(out chan<- complex128, inp ...complex128) (done <-chan struct{})
func JoinComplex128Chan(out chan<- complex128, inp <-chan complex128) (done <-chan struct{})
func JoinComplex128Slice(out chan<- complex128, inp ...[]complex128) (done <-chan struct{})
func JoinComplex64(out chan<- complex64, inp ...complex64) (done <-chan struct{})
func JoinComplex64Chan(out chan<- complex64, inp <-chan complex64) (done <-chan struct{})
func JoinComplex64Slice(out chan<- complex64, inp ...[]complex64) (done <-chan struct{})
func JoinFloat32(out chan<- float32, inp ...float32) (done <-chan struct{})
func JoinFloat32Chan(out chan<- float32, inp <-chan float32) (done <-chan struct{})
func JoinFloat32Slice(out chan<- float32, inp ...[]float32) (done <-chan struct{})
func JoinFloat64(out chan<- float64, inp ...float64) (done <-chan struct{})
func JoinFloat64Chan(out chan<- float64, inp <-chan float64) (done <-chan struct{})
func JoinFloat64Slice(out chan<- float64, inp ...[]float64) (done <-chan struct{})
func JoinInt(out chan<- int, inp ...int) (done <-chan struct{})
func JoinInt16(out chan<- int16, inp ...int16) (done <-chan struct{})
func JoinInt16Chan(out chan<- int16, inp <-chan int16) (done <-chan struct{})
func JoinInt16Slice(out chan<- int16, inp ...[]int16) (done <-chan struct{})
func JoinInt32(out chan<- int32, inp ...int32) (done <-chan struct{})
func JoinInt32Chan(out chan<- int32, inp <-chan int32) (done <-chan struct{})
func JoinInt32Slice(out chan<- int32, inp ...[]int32) (done <-chan struct{})
func JoinInt64(out chan<- int64, inp ...int64) (done <-chan struct{})
func JoinInt64Chan(out chan<- int64, inp <-chan int64) (done <-chan struct{})
func JoinInt64Slice(out chan<- int64, inp ...[]int64) (done <-chan struct{})
func JoinInt8(out chan<- int8, inp ...int8) (done <-chan struct{})
func JoinInt8Chan(out chan<- int8, inp <-chan int8) (done <-chan struct{})
func JoinInt8Slice(out chan<- int8, inp ...[]int8) (done <-chan struct{})
func JoinIntChan(out chan<- int, inp <-chan int) (done <-chan struct{})
func JoinIntSlice(out chan<- int, inp ...[]int) (done <-chan struct{})
func JoinUInt(out chan<- uint, inp ...uint) (done <-chan struct{})
func JoinUInt16(out chan<- uint16, inp ...uint16) (done <-chan struct{})
func JoinUInt16Chan(out chan<- uint16, inp <-chan uint16) (done <-chan struct{})
func JoinUInt16Slice(out chan<- uint16, inp ...[]uint16) (done <-chan struct{})
func JoinUInt32(out chan<- uint32, inp ...uint32) (done <-chan struct{})
func JoinUInt32Chan(out chan<- uint32, inp <-chan uint32) (done <-chan struct{})
func JoinUInt32Slice(out chan<- uint32, inp ...[]uint32) (done <-chan struct{})
func JoinUInt64(out chan<- uint64, inp ...uint64) (done <-chan struct{})
func JoinUInt64Chan(out chan<- uint64, inp <-chan uint64) (done <-chan struct{})
func JoinUInt64Slice(out chan<- uint64, inp ...[]uint64) (done <-chan struct{})
func JoinUInt8(out chan<- uint8, inp ...uint8) (done <-chan struct{})
func JoinUInt8Chan(out chan<- uint8, inp <-chan uint8) (done <-chan struct{})
func JoinUInt8Slice(out chan<- uint8, inp ...[]uint8) (done <-chan struct{})
func JoinUIntChan(out chan<- uint, inp <-chan uint) (done <-chan struct{})
func JoinUIntSlice(out chan<- uint, inp ...[]uint) (done <-chan struct{})
func MakeComplex128Chan() (out chan complex128)
func MakeComplex64Chan() (out chan complex64)
func MakeFloat32Chan() (out chan float32)
func MakeFloat64Chan() (out chan float64)
func MakeInt16Chan() (out chan int16)
func MakeInt32Chan() (out chan int32)
func MakeInt64Chan() (out chan int64)
func MakeInt8Chan() (out chan int8)
func MakeIntChan() (out chan int)
func MakeUInt16Chan() (out chan uint16)
func MakeUInt32Chan() (out chan uint32)
func MakeUInt64Chan() (out chan uint64)
func MakeUInt8Chan() (out chan uint8)
func MakeUIntChan() (out chan uint)
func PipeComplex128Buffer(inp <-chan complex128, cap int) (out <-chan complex128)
func PipeComplex128Fork(inp <-chan complex128) (out1, out2 <-chan complex128)
func PipeComplex128Func(inp <-chan complex128, act func(a complex128) complex128) (out <-chan complex128)
func PipeComplex64Buffer(inp <-chan complex64, cap int) (out <-chan complex64)
func PipeComplex64Fork(inp <-chan complex64) (out1, out2 <-chan complex64)
func PipeComplex64Func(inp <-chan complex64, act func(a complex64) complex64) (out <-chan complex64)
func PipeFloat32Buffer(inp <-chan float32, cap int) (out <-chan float32)
func PipeFloat32Fork(inp <-chan float32) (out1, out2 <-chan float32)
func PipeFloat32Func(inp <-chan float32, act func(a float32) float32) (out <-chan float32)
func PipeFloat64Buffer(inp <-chan float64, cap int) (out <-chan float64)
func PipeFloat64Fork(inp <-chan float64) (out1, out2 <-chan float64)
func PipeFloat64Func(inp <-chan float64, act func(a float64) float64) (out <-chan float64)
func PipeInt16Buffer(inp <-chan int16, cap int) (out <-chan int16)
func PipeInt16Fork(inp <-chan int16) (out1, out2 <-chan int16)
func PipeInt16Func(inp <-chan int16, act func(a int16) int16) (out <-chan int16)
func PipeInt32Buffer(inp <-chan int32, cap int) (out <-chan int32)
func PipeInt32Fork(inp <-chan int32) (out1, out2 <-chan int32)
func PipeInt32Func(inp <-chan int32, act func(a int32) int32) (out <-chan int32)
func PipeInt64Buffer(inp <-chan int64, cap int) (out <-chan int64)
func PipeInt64Fork(inp <-chan int64) (out1, out2 <-chan int64)
func PipeInt64Func(inp <-chan int64, act func(a int64) int64) (out <-chan int64)
func PipeInt8Buffer(inp <-chan int8, cap int) (out <-chan int8)
func PipeInt8Fork(inp <-chan int8) (out1, out2 <-chan int8)
func PipeInt8Func(inp <-chan int8, act func(a int8) int8) (out <-chan int8)
func PipeIntBuffer(inp <-chan int, cap int) (out <-chan int)
func PipeIntFork(inp <-chan int) (out1, out2 <-chan int)
func PipeIntFunc(inp <-chan int, act func(a int) int) (out <-chan int)
func PipeUInt16Buffer(inp <-chan uint16, cap int) (out <-chan uint16)
func PipeUInt16Fork(inp <-chan uint16) (out1, out2 <-chan uint16)
func PipeUInt16Func(inp <-chan uint16, act func(a uint16) uint16) (out <-chan uint16)
func PipeUInt32Buffer(inp <-chan uint32, cap int) (out <-chan uint32)
func PipeUInt32Fork(inp <-chan uint32) (out1, out2 <-chan uint32)
func PipeUInt32Func(inp <-chan uint32, act func(a uint32) uint32) (out <-chan uint32)
func PipeUInt64Buffer(inp <-chan uint64, cap int) (out <-chan uint64)
func PipeUInt64Fork(inp <-chan uint64) (out1, out2 <-chan uint64)
func PipeUInt64Func(inp <-chan uint64, act func(a uint64) uint64) (out <-chan uint64)
func PipeUInt8Buffer(inp <-chan uint8, cap int) (out <-chan uint8)
func PipeUInt8Fork(inp <-chan uint8) (out1, out2 <-chan uint8)
func PipeUInt8Func(inp <-chan uint8, act func(a uint8) uint8) (out <-chan uint8)
func PipeUIntBuffer(inp <-chan uint, cap int) (out <-chan uint)
func PipeUIntFork(inp <-chan uint) (out1, out2 <-chan uint)
func PipeUIntFunc(inp <-chan uint, act func(a uint) uint) (out <-chan uint)
func SendProxyComplex128(out chan<- complex128) chan<- complex128
func SendProxyComplex64(out chan<- complex64) chan<- complex64
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 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 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 Complex128Tube
type Complex64Tube
type Float32Tube
type Float64Tube
type Int16Tube
type Int32Tube
type Int64Tube
type Int8Tube
type IntTube
type UInt16Tube
type UInt32Tube
type UInt64Tube
type UInt8Tube
type UIntTube

Constants ¶

View Source

const Complex128CAP = 10

Complex128CAP is the capacity of the buffered proxy channel

View Source

const Complex128QUE = 16

Complex128QUE is the allocated size of the circular queue

View Source

const Complex64CAP = 10

Complex64CAP is the capacity of the buffered proxy channel

View Source

const Complex64QUE = 16

Complex64QUE is the allocated size of the circular queue

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 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 ChanComplex128 ¶

func ChanComplex128(inp ...complex128) (out <-chan complex128)

ChanComplex128 returns a channel to receive all inputs before close.

func ChanComplex128FuncErr ¶

func ChanComplex128FuncErr(act func() (complex128, error)) (out <-chan complex128)

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

func ChanComplex128FuncNok ¶

func ChanComplex128FuncNok(act func() (complex128, bool)) (out <-chan complex128)

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

func ChanComplex128Slice ¶

func ChanComplex128Slice(inp ...[]complex128) (out <-chan complex128)

ChanComplex128Slice returns a channel to receive all inputs before close.

func ChanComplex64 ¶

func ChanComplex64(inp ...complex64) (out <-chan complex64)

ChanComplex64 returns a channel to receive all inputs before close.

func ChanComplex64FuncErr ¶

func ChanComplex64FuncErr(act func() (complex64, error)) (out <-chan complex64)

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

func ChanComplex64FuncNok ¶

func ChanComplex64FuncNok(act func() (complex64, bool)) (out <-chan complex64)

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

func ChanComplex64Slice ¶

func ChanComplex64Slice(inp ...[]complex64) (out <-chan complex64)

ChanComplex64Slice returns a channel to receive all inputs before close.

func ChanFloat32 ¶

func ChanFloat32(inp ...float32) (out <-chan float32)

ChanFloat32 returns a channel to receive all inputs before close.

func ChanFloat32FuncErr ¶

func ChanFloat32FuncErr(act func() (float32, error)) (out <-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)) (out <-chan float32)

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

func ChanFloat32Slice ¶

func ChanFloat32Slice(inp ...[]float32) (out <-chan float32)

ChanFloat32Slice returns a channel to receive all inputs before close.

func ChanFloat64 ¶

func ChanFloat64(inp ...float64) (out <-chan float64)

ChanFloat64 returns a channel to receive all inputs before close.

func ChanFloat64FuncErr ¶

func ChanFloat64FuncErr(act func() (float64, error)) (out <-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)) (out <-chan float64)

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

func ChanFloat64Slice ¶

func ChanFloat64Slice(inp ...[]float64) (out <-chan float64)

ChanFloat64Slice returns a channel to receive all inputs before close.

func ChanInt ¶

func ChanInt(inp ...int) (out <-chan int)

ChanInt returns a channel to receive all inputs before close.

func ChanInt16 ¶

func ChanInt16(inp ...int16) (out <-chan int16)

ChanInt16 returns a channel to receive all inputs before close.

func ChanInt16FuncErr ¶

func ChanInt16FuncErr(act func() (int16, error)) (out <-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)) (out <-chan int16)

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

func ChanInt16Slice ¶

func ChanInt16Slice(inp ...[]int16) (out <-chan int16)

ChanInt16Slice returns a channel to receive all inputs before close.

func ChanInt32 ¶

func ChanInt32(inp ...int32) (out <-chan int32)

ChanInt32 returns a channel to receive all inputs before close.

func ChanInt32FuncErr ¶

func ChanInt32FuncErr(act func() (int32, error)) (out <-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)) (out <-chan int32)

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

func ChanInt32Slice ¶

func ChanInt32Slice(inp ...[]int32) (out <-chan int32)

ChanInt32Slice returns a channel to receive all inputs before close.

func ChanInt64 ¶

func ChanInt64(inp ...int64) (out <-chan int64)

ChanInt64 returns a channel to receive all inputs before close.

func ChanInt64FuncErr ¶

func ChanInt64FuncErr(act func() (int64, error)) (out <-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)) (out <-chan int64)

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

func ChanInt64Slice ¶

func ChanInt64Slice(inp ...[]int64) (out <-chan int64)

ChanInt64Slice returns a channel to receive all inputs before close.

func ChanInt8 ¶

func ChanInt8(inp ...int8) (out <-chan int8)

ChanInt8 returns a channel to receive all inputs before close.

func ChanInt8FuncErr ¶

func ChanInt8FuncErr(act func() (int8, error)) (out <-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)) (out <-chan int8)

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

func ChanInt8Slice ¶

func ChanInt8Slice(inp ...[]int8) (out <-chan int8)

ChanInt8Slice returns a channel to receive all inputs before close.

func ChanIntFuncErr ¶

func ChanIntFuncErr(act func() (int, error)) (out <-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)) (out <-chan int)

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

func ChanIntSlice ¶

func ChanIntSlice(inp ...[]int) (out <-chan int)

ChanIntSlice returns a channel to receive all inputs before close.

func ChanUInt ¶

func ChanUInt(inp ...uint) (out <-chan uint)

ChanUInt returns a channel to receive all inputs before close.

func ChanUInt16 ¶

func ChanUInt16(inp ...uint16) (out <-chan uint16)

ChanUInt16 returns a channel to receive all inputs before close.

func ChanUInt16FuncErr ¶

func ChanUInt16FuncErr(act func() (uint16, error)) (out <-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)) (out <-chan uint16)

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

func ChanUInt16Slice ¶

func ChanUInt16Slice(inp ...[]uint16) (out <-chan uint16)

ChanUInt16Slice returns a channel to receive all inputs before close.

func ChanUInt32 ¶

func ChanUInt32(inp ...uint32) (out <-chan uint32)

ChanUInt32 returns a channel to receive all inputs before close.

func ChanUInt32FuncErr ¶

func ChanUInt32FuncErr(act func() (uint32, error)) (out <-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)) (out <-chan uint32)

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

func ChanUInt32Slice ¶

func ChanUInt32Slice(inp ...[]uint32) (out <-chan uint32)

ChanUInt32Slice returns a channel to receive all inputs before close.

func ChanUInt64 ¶

func ChanUInt64(inp ...uint64) (out <-chan uint64)

ChanUInt64 returns a channel to receive all inputs before close.

func ChanUInt64FuncErr ¶

func ChanUInt64FuncErr(act func() (uint64, error)) (out <-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)) (out <-chan uint64)

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

func ChanUInt64Slice ¶

func ChanUInt64Slice(inp ...[]uint64) (out <-chan uint64)

ChanUInt64Slice returns a channel to receive all inputs before close.

func ChanUInt8 ¶

func ChanUInt8(inp ...uint8) (out <-chan uint8)

ChanUInt8 returns a channel to receive all inputs before close.

func ChanUInt8FuncErr ¶

func ChanUInt8FuncErr(act func() (uint8, error)) (out <-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)) (out <-chan uint8)

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

func ChanUInt8Slice ¶

func ChanUInt8Slice(inp ...[]uint8) (out <-chan uint8)

ChanUInt8Slice returns a channel to receive all inputs before close.

func ChanUIntFuncErr ¶

func ChanUIntFuncErr(act func() (uint, error)) (out <-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)) (out <-chan uint)

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

func ChanUIntSlice ¶

func ChanUIntSlice(inp ...[]uint) (out <-chan uint)

ChanUIntSlice returns a channel to receive all inputs before close.

func Complex128Daisy ¶

func Complex128Daisy(inp <-chan complex128, tube Complex128Tube) (out <-chan complex128)

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

func Complex128DaisyChain ¶

func Complex128DaisyChain(inp <-chan complex128, tubes ...Complex128Tube) (out <-chan complex128)

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

func Complex64Daisy ¶

func Complex64Daisy(inp <-chan complex64, tube Complex64Tube) (out <-chan complex64)

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

func Complex64DaisyChain ¶

func Complex64DaisyChain(inp <-chan complex64, tubes ...Complex64Tube) (out <-chan complex64)

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

func DoneComplex128 ¶

func DoneComplex128(inp <-chan complex128) (done <-chan struct{})

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

func DoneComplex128Func ¶

func DoneComplex128Func(inp <-chan complex128, act func(a complex128)) (out <-chan struct{})

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

func DoneComplex128Slice ¶

func DoneComplex128Slice(inp <-chan complex128) (done <-chan ([]complex128))

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

func DoneComplex64 ¶

func DoneComplex64(inp <-chan complex64) (done <-chan struct{})

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

func DoneComplex64Func ¶

func DoneComplex64Func(inp <-chan complex64, act func(a complex64)) (out <-chan struct{})

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

func DoneComplex64Slice ¶

func DoneComplex64Slice(inp <-chan complex64) (done <-chan ([]complex64))

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

func DoneFloat32 ¶

func DoneFloat32(inp <-chan float32) (done <-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)) (out <-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) (done <-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) (done <-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)) (out <-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) (done <-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) (done <-chan struct{})

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

func DoneInt16 ¶

func DoneInt16(inp <-chan int16) (done <-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)) (out <-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) (done <-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) (done <-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)) (out <-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) (done <-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) (done <-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)) (out <-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) (done <-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) (done <-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)) (out <-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) (done <-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)) (out <-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) (done <-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 DoneUInt ¶

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

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

func DoneUInt16 ¶

func DoneUInt16(inp <-chan uint16) (done <-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)) (out <-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) (done <-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) (done <-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)) (out <-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) (done <-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) (done <-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)) (out <-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) (done <-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) (done <-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)) (out <-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) (done <-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)) (out <-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) (done <-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 JoinComplex128 ¶

func JoinComplex128(out chan<- complex128, inp ...complex128) (done <-chan struct{})

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

func JoinComplex128Chan ¶

func JoinComplex128Chan(out chan<- complex128, inp <-chan complex128) (done <-chan struct{})

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

func JoinComplex128Slice ¶

func JoinComplex128Slice(out chan<- complex128, inp ...[]complex128) (done <-chan struct{})

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

func JoinComplex64 ¶

func JoinComplex64(out chan<- complex64, inp ...complex64) (done <-chan struct{})

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

func JoinComplex64Chan ¶

func JoinComplex64Chan(out chan<- complex64, inp <-chan complex64) (done <-chan struct{})

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

func JoinComplex64Slice ¶

func JoinComplex64Slice(out chan<- complex64, inp ...[]complex64) (done <-chan struct{})

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

func JoinFloat32 ¶

func JoinFloat32(out chan<- float32, inp ...float32) (done <-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) (done <-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) (done <-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) (done <-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) (done <-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) (done <-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) (done <-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) (done <-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) (done <-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) (done <-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) (done <-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) (done <-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) (done <-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) (done <-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) (done <-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) (done <-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) (done <-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) (done <-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) (done <-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) (done <-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) (done <-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 JoinUInt ¶

func JoinUInt(out chan<- uint, inp ...uint) (done <-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) (done <-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) (done <-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) (done <-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) (done <-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) (done <-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) (done <-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) (done <-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) (done <-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) (done <-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) (done <-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) (done <-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) (done <-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) (done <-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) (done <-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 MakeComplex128Chan ¶

func MakeComplex128Chan() (out chan complex128)

MakeComplex128Chan returns a new open channel (simply a 'chan complex128' that is).

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

This is useful to easily create corresponding variables such as

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

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

func MakeComplex64Chan ¶

func MakeComplex64Chan() (out chan complex64)

MakeComplex64Chan returns a new open channel (simply a 'chan complex64' that is).

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

This is useful to easily create corresponding variables such as

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

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

func MakeFloat32Chan ¶

func MakeFloat32Chan() (out 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() (out 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() (out 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() (out 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() (out 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() (out 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() (out 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 MakeUInt16Chan ¶

func MakeUInt16Chan() (out 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() (out 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() (out 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() (out 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() (out 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 PipeComplex128Buffer ¶

func PipeComplex128Buffer(inp <-chan complex128, cap int) (out <-chan complex128)

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

func PipeComplex128Fork ¶

func PipeComplex128Fork(inp <-chan complex128) (out1, out2 <-chan complex128)

PipeComplex128Fork 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 PipeComplex128Func ¶

func PipeComplex128Func(inp <-chan complex128, act func(a complex128) complex128) (out <-chan complex128)

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

func PipeComplex64Buffer ¶

func PipeComplex64Buffer(inp <-chan complex64, cap int) (out <-chan complex64)

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

func PipeComplex64Fork ¶

func PipeComplex64Fork(inp <-chan complex64) (out1, out2 <-chan complex64)

PipeComplex64Fork 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 PipeComplex64Func ¶

func PipeComplex64Func(inp <-chan complex64, act func(a complex64) complex64) (out <-chan complex64)

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

func PipeFloat32Buffer ¶

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

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

func PipeFloat32Fork ¶

func PipeFloat32Fork(inp <-chan float32) (out1, out2 <-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) (out <-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) (out <-chan float64)

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

func PipeFloat64Fork ¶

func PipeFloat64Fork(inp <-chan float64) (out1, out2 <-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) (out <-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) (out <-chan int16)

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

func PipeInt16Fork ¶

func PipeInt16Fork(inp <-chan int16) (out1, out2 <-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) (out <-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) (out <-chan int32)

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

func PipeInt32Fork ¶

func PipeInt32Fork(inp <-chan int32) (out1, out2 <-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) (out <-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) (out <-chan int64)

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

func PipeInt64Fork ¶

func PipeInt64Fork(inp <-chan int64) (out1, out2 <-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) (out <-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) (out <-chan int8)

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

func PipeInt8Fork ¶

func PipeInt8Fork(inp <-chan int8) (out1, out2 <-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) (out <-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) (out <-chan int)

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

func PipeIntFork ¶

func PipeIntFork(inp <-chan int) (out1, out2 <-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) (out <-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 PipeUInt16Buffer ¶

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

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

func PipeUInt16Fork ¶

func PipeUInt16Fork(inp <-chan uint16) (out1, out2 <-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) (out <-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) (out <-chan uint32)

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

func PipeUInt32Fork ¶

func PipeUInt32Fork(inp <-chan uint32) (out1, out2 <-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) (out <-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) (out <-chan uint64)

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

func PipeUInt64Fork ¶

func PipeUInt64Fork(inp <-chan uint64) (out1, out2 <-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) (out <-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) (out <-chan uint8)

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

func PipeUInt8Fork ¶

func PipeUInt8Fork(inp <-chan uint8) (out1, out2 <-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) (out <-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) (out <-chan uint)

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

func PipeUIntFork ¶

func PipeUIntFork(inp <-chan uint) (out1, out2 <-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) (out <-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 SendProxyComplex128 ¶

func SendProxyComplex128(out chan<- complex128) chan<- complex128

SendProxyComplex128 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 SendProxyComplex64 ¶

func SendProxyComplex64(out chan<- complex64) chan<- complex64

SendProxyComplex64 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 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 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 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 Complex128Tube ¶

type Complex128Tube func(inp <-chan complex128, out <-chan complex128)

Complex128Tube is the signature for a pipe function.

type Complex64Tube ¶

type Complex64Tube func(inp <-chan complex64, out <-chan complex64)

Complex64Tube is the signature for a pipe function.

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