IsInteger

package
v0.0.0-...-5012a73 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 20, 2019 License: MIT Imports: 1 Imported by: 0

Documentation

Index

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) chan int

Chan returns a channel to receive all inputs before close.

func ChanFuncErr 

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

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

func ChanInt16 

func ChanInt16(inp ...int16) chan int16

ChanInt16 returns a channel to receive all inputs before close.

func ChanInt16FuncErr 

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

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

func ChanInt16FuncNok 

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

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

func ChanInt16Slice 

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

ChanInt16Slice returns a channel to receive all inputs before close.

func ChanInt32 

func ChanInt32(inp ...int32) chan int32

ChanInt32 returns a channel to receive all inputs before close.

func ChanInt32FuncErr 

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

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

func ChanInt32FuncNok 

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

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

func ChanInt32Slice 

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

ChanInt32Slice returns a channel to receive all inputs before close.

func ChanInt64 

func ChanInt64(inp ...int64) chan int64

ChanInt64 returns a channel to receive all inputs before close.

func ChanInt64FuncErr 

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

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

func ChanInt64FuncNok 

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

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

func ChanInt64Slice 

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

ChanInt64Slice returns a channel to receive all inputs before close.

func ChanInt8 

func ChanInt8(inp ...int8) chan int8

ChanInt8 returns a channel to receive all inputs before close.

func ChanInt8FuncErr 

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

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

func ChanInt8FuncNok 

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

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

func ChanInt8Slice 

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

ChanInt8Slice returns a channel to receive all inputs before close.

func ChanSlice 

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

ChanSlice returns a channel to receive all inputs before close.

func ChanUInt 

func ChanUInt(inp ...uint) chan uint

ChanUInt returns a channel to receive all inputs before close.

func ChanUInt16 

func ChanUInt16(inp ...uint16) chan uint16

ChanUInt16 returns a channel to receive all inputs before close.

func ChanUInt16FuncErr 

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

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

func ChanUInt16FuncNok 

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

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

func ChanUInt16Slice 

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

ChanUInt16Slice returns a channel to receive all inputs before close.

func ChanUInt32 

func ChanUInt32(inp ...uint32) chan uint32

ChanUInt32 returns a channel to receive all inputs before close.

func ChanUInt32FuncErr 

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

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

func ChanUInt32FuncNok 

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

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

func ChanUInt32Slice 

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

ChanUInt32Slice returns a channel to receive all inputs before close.

func ChanUInt64 

func ChanUInt64(inp ...uint64) chan uint64

ChanUInt64 returns a channel to receive all inputs before close.

func ChanUInt64FuncErr 

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

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

func ChanUInt64FuncNok 

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

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

func ChanUInt64Slice 

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

ChanUInt64Slice returns a channel to receive all inputs before close.

func ChanUInt8 

func ChanUInt8(inp ...uint8) chan uint8

ChanUInt8 returns a channel to receive all inputs before close.

func ChanUInt8FuncErr 

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

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

func ChanUInt8FuncNok 

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

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

func ChanUInt8Slice 

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

ChanUInt8Slice returns a channel to receive all inputs before close.

func ChanUIntFuncErr 

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

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

func ChanUIntFuncNok 

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

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

func ChanUIntSlice 

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

ChanUIntSlice returns a channel to receive all inputs before close.

func 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) 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)) 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) chan struct{}

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

func DoneInt16Func 

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

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

func DoneInt16Slice 

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

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

func DoneInt32 

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

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

func DoneInt32Func 

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

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

func DoneInt32Slice 

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

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

func DoneInt64 

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

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

func DoneInt64Func 

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

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

func DoneInt64Slice 

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

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

func DoneInt8 

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

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

func DoneInt8Func 

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

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

func DoneInt8Slice 

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

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

func DoneSlice 

func DoneSlice(inp <-chan int) 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) chan struct{}

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

func DoneUInt16 

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

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

func DoneUInt16Func 

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

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

func DoneUInt16Slice 

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

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

func DoneUInt32 

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

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

func DoneUInt32Func 

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

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

func DoneUInt32Slice 

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

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

func DoneUInt64 

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

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

func DoneUInt64Func 

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

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

func DoneUInt64Slice 

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

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

func DoneUInt8 

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

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

func DoneUInt8Func 

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

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

func DoneUInt8Slice 

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

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

func DoneUIntFunc 

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

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

func DoneUIntSlice 

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

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

func 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) 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) 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) chan struct{}

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

func JoinInt16Chan 

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

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

func JoinInt16Slice 

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

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

func JoinInt32 

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

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

func JoinInt32Chan 

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

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

func JoinInt32Slice 

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

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

func JoinInt64 

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

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

func JoinInt64Chan 

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

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

func JoinInt64Slice 

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

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

func JoinInt8 

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

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

func JoinInt8Chan 

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

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

func JoinInt8Slice 

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

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

func JoinSlice 

func JoinSlice(out chan<- int, inp ...[]int) 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) chan struct{}

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

func JoinUInt16 

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

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

func JoinUInt16Chan 

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

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

func JoinUInt16Slice 

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

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

func JoinUInt32 

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

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

func JoinUInt32Chan 

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

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

func JoinUInt32Slice 

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

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

func JoinUInt64 

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

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

func JoinUInt64Chan 

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

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

func JoinUInt64Slice 

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

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

func JoinUInt8 

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

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

func JoinUInt8Chan 

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

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

func JoinUInt8Slice 

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

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

func JoinUIntChan 

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

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

func JoinUIntSlice 

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

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

func MakeChan 

func MakeChan() 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() chan int16

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

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

This is useful to easily create corresponding variables such as 

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

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

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

func MakeInt32Chan 

func MakeInt32Chan() chan int32

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

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

This is useful to easily create corresponding variables such as 

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

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

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

func MakeInt64Chan 

func MakeInt64Chan() chan int64

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

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

This is useful to easily create corresponding variables such as 

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

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

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

func MakeInt8Chan 

func MakeInt8Chan() chan int8

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

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

This is useful to easily create corresponding variables such as 

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

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

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

func MakeUInt16Chan 

func MakeUInt16Chan() chan uint16

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

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

This is useful to easily create corresponding variables such as 

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

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

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

func MakeUInt32Chan 

func MakeUInt32Chan() chan uint32

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

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

This is useful to easily create corresponding variables such as 

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

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

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

func MakeUInt64Chan 

func MakeUInt64Chan() chan uint64

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

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

This is useful to easily create corresponding variables such as 

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

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

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

func MakeUInt8Chan 

func MakeUInt8Chan() chan uint8

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

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

This is useful to easily create corresponding variables such as 

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

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

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

func MakeUIntChan 

func MakeUIntChan() chan uint

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

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

This is useful to easily create corresponding variables such as 

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

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

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

func 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) chan int

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

func PipeFork 

func PipeFork(inp <-chan int) (chan int, 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) 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) chan int16

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

func PipeInt16Fork 

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

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

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

func PipeInt16Func 

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

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

func PipeInt32Buffer 

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

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

func PipeInt32Fork 

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

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

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

func PipeInt32Func 

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

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

func PipeInt64Buffer 

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

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

func PipeInt64Fork 

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

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

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

func PipeInt64Func 

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

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

func PipeInt8Buffer 

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

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

func PipeInt8Fork 

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

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

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

func PipeInt8Func 

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

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

func PipeUInt16Buffer 

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

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

func PipeUInt16Fork 

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

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

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

func PipeUInt16Func 

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

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

func PipeUInt32Buffer 

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

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

func PipeUInt32Fork 

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

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

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

func PipeUInt32Func 

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

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

func PipeUInt64Buffer 

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

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

func PipeUInt64Fork 

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

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

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

func PipeUInt64Func 

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

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

func PipeUInt8Buffer 

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

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

func PipeUInt8Fork 

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

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

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

func PipeUInt8Func 

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

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

func PipeUIntBuffer 

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

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

func PipeUIntFork 

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

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

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

func PipeUIntFunc 

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

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

func 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

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.