IsNumeric

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: 0 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

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 Complex128Chan 

type Complex128Chan interface {
	Complex128ROnlyChan // aka "<-chan" - receive only
	Complex128SOnlyChan // aka "chan<-" - send only
}

Complex128Chan represents a bidirectional channel

type Complex128ROnlyChan 

type Complex128ROnlyChan interface {
	RequestComplex128() (dat complex128)        // the receive function - aka "MyComplex128 := <-MyComplex128ROnlyChan"
	TryComplex128() (dat complex128, open bool) // the multi-valued comma-ok receive function - aka "MyComplex128, ok := <-MyComplex128ROnlyChan"
}

Complex128ROnlyChan represents a receive-only channel

type Complex128SOnlyChan 

type Complex128SOnlyChan interface {
	ProvideComplex128(dat complex128) // the send function - aka "MyKind <- some Complex128"
}

Complex128SOnlyChan represents a send-only channel

type Complex64Chan 

type Complex64Chan interface {
	Complex64ROnlyChan // aka "<-chan" - receive only
	Complex64SOnlyChan // aka "chan<-" - send only
}

Complex64Chan represents a bidirectional channel

type Complex64ROnlyChan 

type Complex64ROnlyChan interface {
	RequestComplex64() (dat complex64)        // the receive function - aka "MyComplex64 := <-MyComplex64ROnlyChan"
	TryComplex64() (dat complex64, open bool) // the multi-valued comma-ok receive function - aka "MyComplex64, ok := <-MyComplex64ROnlyChan"
}

Complex64ROnlyChan represents a receive-only channel

type Complex64SOnlyChan 

type Complex64SOnlyChan interface {
	ProvideComplex64(dat complex64) // the send function - aka "MyKind <- some Complex64"
}

Complex64SOnlyChan represents a send-only channel

type Float32Chan 

type Float32Chan interface {
	Float32ROnlyChan // aka "<-chan" - receive only
	Float32SOnlyChan // aka "chan<-" - send only
}

Float32Chan represents a bidirectional channel

type Float32ROnlyChan 

type Float32ROnlyChan interface {
	RequestFloat32() (dat float32)        // the receive function - aka "MyFloat32 := <-MyFloat32ROnlyChan"
	TryFloat32() (dat float32, open bool) // the multi-valued comma-ok receive function - aka "MyFloat32, ok := <-MyFloat32ROnlyChan"
}

Float32ROnlyChan represents a receive-only channel

type Float32SOnlyChan 

type Float32SOnlyChan interface {
	ProvideFloat32(dat float32) // the send function - aka "MyKind <- some Float32"
}

Float32SOnlyChan represents a send-only channel

type Float64Chan 

type Float64Chan interface {
	Float64ROnlyChan // aka "<-chan" - receive only
	Float64SOnlyChan // aka "chan<-" - send only
}

Float64Chan represents a bidirectional channel

type Float64ROnlyChan 

type Float64ROnlyChan interface {
	RequestFloat64() (dat float64)        // the receive function - aka "MyFloat64 := <-MyFloat64ROnlyChan"
	TryFloat64() (dat float64, open bool) // the multi-valued comma-ok receive function - aka "MyFloat64, ok := <-MyFloat64ROnlyChan"
}

Float64ROnlyChan represents a receive-only channel

type Float64SOnlyChan 

type Float64SOnlyChan interface {
	ProvideFloat64(dat float64) // the send function - aka "MyKind <- some Float64"
}

Float64SOnlyChan represents a send-only channel

type Int16Chan 

type Int16Chan interface {
	Int16ROnlyChan // aka "<-chan" - receive only
	Int16SOnlyChan // aka "chan<-" - send only
}

Int16Chan represents a bidirectional channel

type Int16ROnlyChan 

type Int16ROnlyChan interface {
	RequestInt16() (dat int16)        // the receive function - aka "MyInt16 := <-MyInt16ROnlyChan"
	TryInt16() (dat int16, open bool) // the multi-valued comma-ok receive function - aka "MyInt16, ok := <-MyInt16ROnlyChan"
}

Int16ROnlyChan represents a receive-only channel

type Int16SOnlyChan 

type Int16SOnlyChan interface {
	ProvideInt16(dat int16) // the send function - aka "MyKind <- some Int16"
}

Int16SOnlyChan represents a send-only channel

type Int32Chan 

type Int32Chan interface {
	Int32ROnlyChan // aka "<-chan" - receive only
	Int32SOnlyChan // aka "chan<-" - send only
}

Int32Chan represents a bidirectional channel

type Int32ROnlyChan 

type Int32ROnlyChan interface {
	RequestInt32() (dat int32)        // the receive function - aka "MyInt32 := <-MyInt32ROnlyChan"
	TryInt32() (dat int32, open bool) // the multi-valued comma-ok receive function - aka "MyInt32, ok := <-MyInt32ROnlyChan"
}

Int32ROnlyChan represents a receive-only channel

type Int32SOnlyChan 

type Int32SOnlyChan interface {
	ProvideInt32(dat int32) // the send function - aka "MyKind <- some Int32"
}

Int32SOnlyChan represents a send-only channel

type Int64Chan 

type Int64Chan interface {
	Int64ROnlyChan // aka "<-chan" - receive only
	Int64SOnlyChan // aka "chan<-" - send only
}

Int64Chan represents a bidirectional channel

type Int64ROnlyChan 

type Int64ROnlyChan interface {
	RequestInt64() (dat int64)        // the receive function - aka "MyInt64 := <-MyInt64ROnlyChan"
	TryInt64() (dat int64, open bool) // the multi-valued comma-ok receive function - aka "MyInt64, ok := <-MyInt64ROnlyChan"
}

Int64ROnlyChan represents a receive-only channel

type Int64SOnlyChan 

type Int64SOnlyChan interface {
	ProvideInt64(dat int64) // the send function - aka "MyKind <- some Int64"
}

Int64SOnlyChan represents a send-only channel

type Int8Chan 

type Int8Chan interface {
	Int8ROnlyChan // aka "<-chan" - receive only
	Int8SOnlyChan // aka "chan<-" - send only
}

Int8Chan represents a bidirectional channel

type Int8ROnlyChan 

type Int8ROnlyChan interface {
	RequestInt8() (dat int8)        // the receive function - aka "MyInt8 := <-MyInt8ROnlyChan"
	TryInt8() (dat int8, open bool) // the multi-valued comma-ok receive function - aka "MyInt8, ok := <-MyInt8ROnlyChan"
}

Int8ROnlyChan represents a receive-only channel

type Int8SOnlyChan 

type Int8SOnlyChan interface {
	ProvideInt8(dat int8) // the send function - aka "MyKind <- some Int8"
}

Int8SOnlyChan represents a send-only channel

type IntChan 

type IntChan interface {
	IntROnlyChan // aka "<-chan" - receive only
	IntSOnlyChan // aka "chan<-" - send only
}

IntChan represents a bidirectional channel

type IntROnlyChan 

type IntROnlyChan interface {
	RequestInt() (dat int)        // the receive function - aka "MyInt := <-MyIntROnlyChan"
	TryInt() (dat int, open bool) // the multi-valued comma-ok receive function - aka "MyInt, ok := <-MyIntROnlyChan"
}

IntROnlyChan represents a receive-only channel

type IntSOnlyChan 

type IntSOnlyChan interface {
	ProvideInt(dat int) // the send function - aka "MyKind <- some Int"
}

IntSOnlyChan represents a send-only channel

type SChComplex128 

type SChComplex128 struct {
	// contains filtered or unexported fields
}

SChComplex128 is a supply channel

func MakeSupplyComplex128Buff 

func MakeSupplyComplex128Buff(cap int) *SChComplex128

MakeSupplyComplex128Buff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyComplex128Chan 

func MakeSupplyComplex128Chan() *SChComplex128

MakeSupplyComplex128Chan returns a (pointer to a) fresh unbuffered supply channel

func (*SChComplex128) ProvideComplex128 

func (c *SChComplex128) ProvideComplex128(dat complex128)

ProvideComplex128 is the send function - aka "MyKind <- some Complex128"

func (*SChComplex128) RequestComplex128 

func (c *SChComplex128) RequestComplex128() (dat complex128)

RequestComplex128 is the receive function - aka "some Complex128 <- MyKind"

func (*SChComplex128) TryComplex128 

func (c *SChComplex128) TryComplex128() (dat complex128, open bool)

TryComplex128 is the comma-ok multi-valued form of RequestComplex128 and reports whether a received value was sent before the Complex128 channel was closed.

type SChComplex64 

type SChComplex64 struct {
	// contains filtered or unexported fields
}

SChComplex64 is a supply channel

func MakeSupplyComplex64Buff 

func MakeSupplyComplex64Buff(cap int) *SChComplex64

MakeSupplyComplex64Buff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyComplex64Chan 

func MakeSupplyComplex64Chan() *SChComplex64

MakeSupplyComplex64Chan returns a (pointer to a) fresh unbuffered supply channel

func (*SChComplex64) ProvideComplex64 

func (c *SChComplex64) ProvideComplex64(dat complex64)

ProvideComplex64 is the send function - aka "MyKind <- some Complex64"

func (*SChComplex64) RequestComplex64 

func (c *SChComplex64) RequestComplex64() (dat complex64)

RequestComplex64 is the receive function - aka "some Complex64 <- MyKind"

func (*SChComplex64) TryComplex64 

func (c *SChComplex64) TryComplex64() (dat complex64, open bool)

TryComplex64 is the comma-ok multi-valued form of RequestComplex64 and reports whether a received value was sent before the Complex64 channel was closed.

type SChFloat32 

type SChFloat32 struct {
	// contains filtered or unexported fields
}

SChFloat32 is a supply channel

func MakeSupplyFloat32Buff 

func MakeSupplyFloat32Buff(cap int) *SChFloat32

MakeSupplyFloat32Buff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyFloat32Chan 

func MakeSupplyFloat32Chan() *SChFloat32

MakeSupplyFloat32Chan returns a (pointer to a) fresh unbuffered supply channel

func (*SChFloat32) ProvideFloat32 

func (c *SChFloat32) ProvideFloat32(dat float32)

ProvideFloat32 is the send function - aka "MyKind <- some Float32"

func (*SChFloat32) RequestFloat32 

func (c *SChFloat32) RequestFloat32() (dat float32)

RequestFloat32 is the receive function - aka "some Float32 <- MyKind"

func (*SChFloat32) TryFloat32 

func (c *SChFloat32) TryFloat32() (dat float32, open bool)

TryFloat32 is the comma-ok multi-valued form of RequestFloat32 and reports whether a received value was sent before the Float32 channel was closed.

type SChFloat64 

type SChFloat64 struct {
	// contains filtered or unexported fields
}

SChFloat64 is a supply channel

func MakeSupplyFloat64Buff 

func MakeSupplyFloat64Buff(cap int) *SChFloat64

MakeSupplyFloat64Buff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyFloat64Chan 

func MakeSupplyFloat64Chan() *SChFloat64

MakeSupplyFloat64Chan returns a (pointer to a) fresh unbuffered supply channel

func (*SChFloat64) ProvideFloat64 

func (c *SChFloat64) ProvideFloat64(dat float64)

ProvideFloat64 is the send function - aka "MyKind <- some Float64"

func (*SChFloat64) RequestFloat64 

func (c *SChFloat64) RequestFloat64() (dat float64)

RequestFloat64 is the receive function - aka "some Float64 <- MyKind"

func (*SChFloat64) TryFloat64 

func (c *SChFloat64) TryFloat64() (dat float64, open bool)

TryFloat64 is the comma-ok multi-valued form of RequestFloat64 and reports whether a received value was sent before the Float64 channel was closed.

type SChInt 

type SChInt struct {
	// contains filtered or unexported fields
}

SChInt is a supply channel

func MakeSupplyIntBuff 

func MakeSupplyIntBuff(cap int) *SChInt

MakeSupplyIntBuff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyIntChan 

func MakeSupplyIntChan() *SChInt

MakeSupplyIntChan returns a (pointer to a) fresh unbuffered supply channel

func (*SChInt) ProvideInt 

func (c *SChInt) ProvideInt(dat int)

ProvideInt is the send function - aka "MyKind <- some Int"

func (*SChInt) RequestInt 

func (c *SChInt) RequestInt() (dat int)

RequestInt is the receive function - aka "some Int <- MyKind"

func (*SChInt) TryInt 

func (c *SChInt) TryInt() (dat int, open bool)

TryInt is the comma-ok multi-valued form of RequestInt and reports whether a received value was sent before the Int channel was closed.

type SChInt16 

type SChInt16 struct {
	// contains filtered or unexported fields
}

SChInt16 is a supply channel

func MakeSupplyInt16Buff 

func MakeSupplyInt16Buff(cap int) *SChInt16

MakeSupplyInt16Buff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyInt16Chan 

func MakeSupplyInt16Chan() *SChInt16

MakeSupplyInt16Chan returns a (pointer to a) fresh unbuffered supply channel

func (*SChInt16) ProvideInt16 

func (c *SChInt16) ProvideInt16(dat int16)

ProvideInt16 is the send function - aka "MyKind <- some Int16"

func (*SChInt16) RequestInt16 

func (c *SChInt16) RequestInt16() (dat int16)

RequestInt16 is the receive function - aka "some Int16 <- MyKind"

func (*SChInt16) TryInt16 

func (c *SChInt16) TryInt16() (dat int16, open bool)

TryInt16 is the comma-ok multi-valued form of RequestInt16 and reports whether a received value was sent before the Int16 channel was closed.

type SChInt32 

type SChInt32 struct {
	// contains filtered or unexported fields
}

SChInt32 is a supply channel

func MakeSupplyInt32Buff 

func MakeSupplyInt32Buff(cap int) *SChInt32

MakeSupplyInt32Buff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyInt32Chan 

func MakeSupplyInt32Chan() *SChInt32

MakeSupplyInt32Chan returns a (pointer to a) fresh unbuffered supply channel

func (*SChInt32) ProvideInt32 

func (c *SChInt32) ProvideInt32(dat int32)

ProvideInt32 is the send function - aka "MyKind <- some Int32"

func (*SChInt32) RequestInt32 

func (c *SChInt32) RequestInt32() (dat int32)

RequestInt32 is the receive function - aka "some Int32 <- MyKind"

func (*SChInt32) TryInt32 

func (c *SChInt32) TryInt32() (dat int32, open bool)

TryInt32 is the comma-ok multi-valued form of RequestInt32 and reports whether a received value was sent before the Int32 channel was closed.

type SChInt64 

type SChInt64 struct {
	// contains filtered or unexported fields
}

SChInt64 is a supply channel

func MakeSupplyInt64Buff 

func MakeSupplyInt64Buff(cap int) *SChInt64

MakeSupplyInt64Buff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyInt64Chan 

func MakeSupplyInt64Chan() *SChInt64

MakeSupplyInt64Chan returns a (pointer to a) fresh unbuffered supply channel

func (*SChInt64) ProvideInt64 

func (c *SChInt64) ProvideInt64(dat int64)

ProvideInt64 is the send function - aka "MyKind <- some Int64"

func (*SChInt64) RequestInt64 

func (c *SChInt64) RequestInt64() (dat int64)

RequestInt64 is the receive function - aka "some Int64 <- MyKind"

func (*SChInt64) TryInt64 

func (c *SChInt64) TryInt64() (dat int64, open bool)

TryInt64 is the comma-ok multi-valued form of RequestInt64 and reports whether a received value was sent before the Int64 channel was closed.

type SChInt8 

type SChInt8 struct {
	// contains filtered or unexported fields
}

SChInt8 is a supply channel

func MakeSupplyInt8Buff 

func MakeSupplyInt8Buff(cap int) *SChInt8

MakeSupplyInt8Buff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyInt8Chan 

func MakeSupplyInt8Chan() *SChInt8

MakeSupplyInt8Chan returns a (pointer to a) fresh unbuffered supply channel

func (*SChInt8) ProvideInt8 

func (c *SChInt8) ProvideInt8(dat int8)

ProvideInt8 is the send function - aka "MyKind <- some Int8"

func (*SChInt8) RequestInt8 

func (c *SChInt8) RequestInt8() (dat int8)

RequestInt8 is the receive function - aka "some Int8 <- MyKind"

func (*SChInt8) TryInt8 

func (c *SChInt8) TryInt8() (dat int8, open bool)

TryInt8 is the comma-ok multi-valued form of RequestInt8 and reports whether a received value was sent before the Int8 channel was closed.

type SChUInt 

type SChUInt struct {
	// contains filtered or unexported fields
}

SChUInt is a supply channel

func MakeSupplyUIntBuff 

func MakeSupplyUIntBuff(cap int) *SChUInt

MakeSupplyUIntBuff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyUIntChan 

func MakeSupplyUIntChan() *SChUInt

MakeSupplyUIntChan returns a (pointer to a) fresh unbuffered supply channel

func (*SChUInt) ProvideUInt 

func (c *SChUInt) ProvideUInt(dat uint)

ProvideUInt is the send function - aka "MyKind <- some UInt"

func (*SChUInt) RequestUInt 

func (c *SChUInt) RequestUInt() (dat uint)

RequestUInt is the receive function - aka "some UInt <- MyKind"

func (*SChUInt) TryUInt 

func (c *SChUInt) TryUInt() (dat uint, open bool)

TryUInt is the comma-ok multi-valued form of RequestUInt and reports whether a received value was sent before the UInt channel was closed.

type SChUInt16 

type SChUInt16 struct {
	// contains filtered or unexported fields
}

SChUInt16 is a supply channel

func MakeSupplyUInt16Buff 

func MakeSupplyUInt16Buff(cap int) *SChUInt16

MakeSupplyUInt16Buff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyUInt16Chan 

func MakeSupplyUInt16Chan() *SChUInt16

MakeSupplyUInt16Chan returns a (pointer to a) fresh unbuffered supply channel

func (*SChUInt16) ProvideUInt16 

func (c *SChUInt16) ProvideUInt16(dat uint16)

ProvideUInt16 is the send function - aka "MyKind <- some UInt16"

func (*SChUInt16) RequestUInt16 

func (c *SChUInt16) RequestUInt16() (dat uint16)

RequestUInt16 is the receive function - aka "some UInt16 <- MyKind"

func (*SChUInt16) TryUInt16 

func (c *SChUInt16) TryUInt16() (dat uint16, open bool)

TryUInt16 is the comma-ok multi-valued form of RequestUInt16 and reports whether a received value was sent before the UInt16 channel was closed.

type SChUInt32 

type SChUInt32 struct {
	// contains filtered or unexported fields
}

SChUInt32 is a supply channel

func MakeSupplyUInt32Buff 

func MakeSupplyUInt32Buff(cap int) *SChUInt32

MakeSupplyUInt32Buff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyUInt32Chan 

func MakeSupplyUInt32Chan() *SChUInt32

MakeSupplyUInt32Chan returns a (pointer to a) fresh unbuffered supply channel

func (*SChUInt32) ProvideUInt32 

func (c *SChUInt32) ProvideUInt32(dat uint32)

ProvideUInt32 is the send function - aka "MyKind <- some UInt32"

func (*SChUInt32) RequestUInt32 

func (c *SChUInt32) RequestUInt32() (dat uint32)

RequestUInt32 is the receive function - aka "some UInt32 <- MyKind"

func (*SChUInt32) TryUInt32 

func (c *SChUInt32) TryUInt32() (dat uint32, open bool)

TryUInt32 is the comma-ok multi-valued form of RequestUInt32 and reports whether a received value was sent before the UInt32 channel was closed.

type SChUInt64 

type SChUInt64 struct {
	// contains filtered or unexported fields
}

SChUInt64 is a supply channel

func MakeSupplyUInt64Buff 

func MakeSupplyUInt64Buff(cap int) *SChUInt64

MakeSupplyUInt64Buff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyUInt64Chan 

func MakeSupplyUInt64Chan() *SChUInt64

MakeSupplyUInt64Chan returns a (pointer to a) fresh unbuffered supply channel

func (*SChUInt64) ProvideUInt64 

func (c *SChUInt64) ProvideUInt64(dat uint64)

ProvideUInt64 is the send function - aka "MyKind <- some UInt64"

func (*SChUInt64) RequestUInt64 

func (c *SChUInt64) RequestUInt64() (dat uint64)

RequestUInt64 is the receive function - aka "some UInt64 <- MyKind"

func (*SChUInt64) TryUInt64 

func (c *SChUInt64) TryUInt64() (dat uint64, open bool)

TryUInt64 is the comma-ok multi-valued form of RequestUInt64 and reports whether a received value was sent before the UInt64 channel was closed.

type SChUInt8 

type SChUInt8 struct {
	// contains filtered or unexported fields
}

SChUInt8 is a supply channel

func MakeSupplyUInt8Buff 

func MakeSupplyUInt8Buff(cap int) *SChUInt8

MakeSupplyUInt8Buff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyUInt8Chan 

func MakeSupplyUInt8Chan() *SChUInt8

MakeSupplyUInt8Chan returns a (pointer to a) fresh unbuffered supply channel

func (*SChUInt8) ProvideUInt8 

func (c *SChUInt8) ProvideUInt8(dat uint8)

ProvideUInt8 is the send function - aka "MyKind <- some UInt8"

func (*SChUInt8) RequestUInt8 

func (c *SChUInt8) RequestUInt8() (dat uint8)

RequestUInt8 is the receive function - aka "some UInt8 <- MyKind"

func (*SChUInt8) TryUInt8 

func (c *SChUInt8) TryUInt8() (dat uint8, open bool)

TryUInt8 is the comma-ok multi-valued form of RequestUInt8 and reports whether a received value was sent before the UInt8 channel was closed.

type UInt16Chan 

type UInt16Chan interface {
	UInt16ROnlyChan // aka "<-chan" - receive only
	UInt16SOnlyChan // aka "chan<-" - send only
}

UInt16Chan represents a bidirectional channel

type UInt16ROnlyChan 

type UInt16ROnlyChan interface {
	RequestUInt16() (dat uint16)        // the receive function - aka "MyUInt16 := <-MyUInt16ROnlyChan"
	TryUInt16() (dat uint16, open bool) // the multi-valued comma-ok receive function - aka "MyUInt16, ok := <-MyUInt16ROnlyChan"
}

UInt16ROnlyChan represents a receive-only channel

type UInt16SOnlyChan 

type UInt16SOnlyChan interface {
	ProvideUInt16(dat uint16) // the send function - aka "MyKind <- some UInt16"
}

UInt16SOnlyChan represents a send-only channel

type UInt32Chan 

type UInt32Chan interface {
	UInt32ROnlyChan // aka "<-chan" - receive only
	UInt32SOnlyChan // aka "chan<-" - send only
}

UInt32Chan represents a bidirectional channel

type UInt32ROnlyChan 

type UInt32ROnlyChan interface {
	RequestUInt32() (dat uint32)        // the receive function - aka "MyUInt32 := <-MyUInt32ROnlyChan"
	TryUInt32() (dat uint32, open bool) // the multi-valued comma-ok receive function - aka "MyUInt32, ok := <-MyUInt32ROnlyChan"
}

UInt32ROnlyChan represents a receive-only channel

type UInt32SOnlyChan 

type UInt32SOnlyChan interface {
	ProvideUInt32(dat uint32) // the send function - aka "MyKind <- some UInt32"
}

UInt32SOnlyChan represents a send-only channel

type UInt64Chan 

type UInt64Chan interface {
	UInt64ROnlyChan // aka "<-chan" - receive only
	UInt64SOnlyChan // aka "chan<-" - send only
}

UInt64Chan represents a bidirectional channel

type UInt64ROnlyChan 

type UInt64ROnlyChan interface {
	RequestUInt64() (dat uint64)        // the receive function - aka "MyUInt64 := <-MyUInt64ROnlyChan"
	TryUInt64() (dat uint64, open bool) // the multi-valued comma-ok receive function - aka "MyUInt64, ok := <-MyUInt64ROnlyChan"
}

UInt64ROnlyChan represents a receive-only channel

type UInt64SOnlyChan 

type UInt64SOnlyChan interface {
	ProvideUInt64(dat uint64) // the send function - aka "MyKind <- some UInt64"
}

UInt64SOnlyChan represents a send-only channel

type UInt8Chan 

type UInt8Chan interface {
	UInt8ROnlyChan // aka "<-chan" - receive only
	UInt8SOnlyChan // aka "chan<-" - send only
}

UInt8Chan represents a bidirectional channel

type UInt8ROnlyChan 

type UInt8ROnlyChan interface {
	RequestUInt8() (dat uint8)        // the receive function - aka "MyUInt8 := <-MyUInt8ROnlyChan"
	TryUInt8() (dat uint8, open bool) // the multi-valued comma-ok receive function - aka "MyUInt8, ok := <-MyUInt8ROnlyChan"
}

UInt8ROnlyChan represents a receive-only channel

type UInt8SOnlyChan 

type UInt8SOnlyChan interface {
	ProvideUInt8(dat uint8) // the send function - aka "MyKind <- some UInt8"
}

UInt8SOnlyChan represents a send-only channel

type UIntChan 

type UIntChan interface {
	UIntROnlyChan // aka "<-chan" - receive only
	UIntSOnlyChan // aka "chan<-" - send only
}

UIntChan represents a bidirectional channel

type UIntROnlyChan 

type UIntROnlyChan interface {
	RequestUInt() (dat uint)        // the receive function - aka "MyUInt := <-MyUIntROnlyChan"
	TryUInt() (dat uint, open bool) // the multi-valued comma-ok receive function - aka "MyUInt, ok := <-MyUIntROnlyChan"
}

UIntROnlyChan represents a receive-only channel

type UIntSOnlyChan 

type UIntSOnlyChan interface {
	ProvideUInt(dat uint) // the send function - aka "MyKind <- some UInt"
}

UIntSOnlyChan represents a send-only channel

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.