IsInteger

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 Chan(inp ...int) (out <-chan int)
func ChanFuncErr(act func() (int, error)) (out <-chan int)
func ChanFuncNok(act func() (int, bool)) (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 ChanSlice(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 Daisy(inp <-chan int, tube Tube) (out <-chan int)
func DaisyChain(inp <-chan int, tubes ...Tube) (out <-chan int)
func Done(inp <-chan int) (done <-chan struct{})
func DoneFunc(inp <-chan int, act func(a int)) (out <-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 DoneSlice(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 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 Join(out chan<- int, inp ...int) (done <-chan struct{})
func JoinChan(out chan<- int, inp <-chan 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 JoinSlice(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 MakeChan() (out chan int)
func MakeInt16Chan() (out chan int16)
func MakeInt32Chan() (out chan int32)
func MakeInt64Chan() (out chan int64)
func MakeInt8Chan() (out chan int8)
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 Merge(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 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 PipeBuffer(inp <-chan int, cap int) (out <-chan int)
func PipeFork(inp <-chan int) (out1, out2 <-chan int)
func PipeFunc(inp <-chan int, act func(a int) int) (out <-chan int)
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 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 SendProxy(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 Int16Tube
type Int32Tube
type Int64Tube
type Int8Tube
type Tube
type UInt16Tube
type UInt32Tube
type UInt64Tube
type UInt8Tube
type UIntTube

Constants ¶

View Source

const CAP = 10

CAP is the capacity of the buffered proxy channel

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 QUE = 16

QUE 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 Chan ¶

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

Chan returns a channel to receive all inputs before close.

func ChanFuncErr ¶

func ChanFuncErr(act func() (int, error)) (out <-chan int)

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

func ChanFuncNok ¶

func ChanFuncNok(act func() (int, bool)) (out <-chan int)

ChanFuncNok returns a channel to receive all results of act until nok 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 ChanSlice ¶

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

ChanSlice 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 Daisy ¶

func Daisy(inp <-chan int, tube Tube) (out <-chan int)

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

func DaisyChain ¶

func DaisyChain(inp <-chan int, tubes ...Tube) (out <-chan int)

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

func Done ¶

func Done(inp <-chan int) (done <-chan struct{})

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

func DoneFunc ¶

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

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

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

func DoneSlice(inp <-chan int) (done <-chan []int)

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

func 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 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 Join ¶

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

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

func JoinChan ¶

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

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

func 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 JoinSlice ¶

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

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

func 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 MakeChan ¶

func MakeChan() (out chan int)

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

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

This is useful to easily create corresponding variables such as

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

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

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

func 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 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 Merge ¶

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

Merge 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 channel 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 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 PipeBuffer ¶

func PipeBuffer(inp <-chan int, cap int) (out <-chan int)

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

func PipeFork ¶

func PipeFork(inp <-chan int) (out1, out2 <-chan int)

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

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

func PipeFunc ¶

func PipeFunc(inp <-chan int, act func(a int) int) (out <-chan int)

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

func 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 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 SendProxy ¶

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

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

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

func 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 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 Tube ¶

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

Tube 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