IsUnsigned

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

Variables

This section is empty.

Functions

func Chan 

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

Chan returns a channel to receive all inputs before close.

func ChanFuncErr 

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

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

func ChanFuncNok 

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

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

func ChanSlice 

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

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

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

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

func DaisyChain 

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

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

func Done 

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

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

func DoneFunc 

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

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

func DoneSlice 

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

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

func Join(out chan<- uint, inp ...uint) (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<- uint, inp <-chan uint) (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 JoinSlice 

func JoinSlice(out chan<- uint, inp ...[]uint) (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 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 MakeChan 

func MakeChan() (out chan uint)

MakeChan returns a new open channel (simply a 'chan uint' 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 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 Merge 

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

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 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 uint, cap int) (out <-chan uint)

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

func PipeFork 

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

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

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

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

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

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 Tube 

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

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.

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.