IsOrdered

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 DChFloat32 

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

DChFloat32 is a demand channel

func MakeDemandFloat32Buff 

func MakeDemandFloat32Buff(cap int) *DChFloat32

MakeDemandFloat32Buff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandFloat32Chan 

func MakeDemandFloat32Chan() *DChFloat32

MakeDemandFloat32Chan returns a (pointer to a) fresh unbuffered demand channel

func (*DChFloat32) ProvideFloat32 

func (c *DChFloat32) ProvideFloat32(dat float32)

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

func (*DChFloat32) RequestFloat32 

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

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

func (*DChFloat32) TryFloat32 

func (c *DChFloat32) 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 DChFloat64 

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

DChFloat64 is a demand channel

func MakeDemandFloat64Buff 

func MakeDemandFloat64Buff(cap int) *DChFloat64

MakeDemandFloat64Buff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandFloat64Chan 

func MakeDemandFloat64Chan() *DChFloat64

MakeDemandFloat64Chan returns a (pointer to a) fresh unbuffered demand channel

func (*DChFloat64) ProvideFloat64 

func (c *DChFloat64) ProvideFloat64(dat float64)

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

func (*DChFloat64) RequestFloat64 

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

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

func (*DChFloat64) TryFloat64 

func (c *DChFloat64) 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 DChInt 

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

DChInt is a demand channel

func MakeDemandIntBuff 

func MakeDemandIntBuff(cap int) *DChInt

MakeDemandIntBuff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandIntChan 

func MakeDemandIntChan() *DChInt

MakeDemandIntChan returns a (pointer to a) fresh unbuffered demand channel

func (*DChInt) ProvideInt 

func (c *DChInt) ProvideInt(dat int)

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

func (*DChInt) RequestInt 

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

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

func (*DChInt) TryInt 

func (c *DChInt) 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 DChInt16 

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

DChInt16 is a demand channel

func MakeDemandInt16Buff 

func MakeDemandInt16Buff(cap int) *DChInt16

MakeDemandInt16Buff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandInt16Chan 

func MakeDemandInt16Chan() *DChInt16

MakeDemandInt16Chan returns a (pointer to a) fresh unbuffered demand channel

func (*DChInt16) ProvideInt16 

func (c *DChInt16) ProvideInt16(dat int16)

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

func (*DChInt16) RequestInt16 

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

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

func (*DChInt16) TryInt16 

func (c *DChInt16) 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 DChInt32 

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

DChInt32 is a demand channel

func MakeDemandInt32Buff 

func MakeDemandInt32Buff(cap int) *DChInt32

MakeDemandInt32Buff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandInt32Chan 

func MakeDemandInt32Chan() *DChInt32

MakeDemandInt32Chan returns a (pointer to a) fresh unbuffered demand channel

func (*DChInt32) ProvideInt32 

func (c *DChInt32) ProvideInt32(dat int32)

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

func (*DChInt32) RequestInt32 

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

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

func (*DChInt32) TryInt32 

func (c *DChInt32) 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 DChInt64 

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

DChInt64 is a demand channel

func MakeDemandInt64Buff 

func MakeDemandInt64Buff(cap int) *DChInt64

MakeDemandInt64Buff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandInt64Chan 

func MakeDemandInt64Chan() *DChInt64

MakeDemandInt64Chan returns a (pointer to a) fresh unbuffered demand channel

func (*DChInt64) ProvideInt64 

func (c *DChInt64) ProvideInt64(dat int64)

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

func (*DChInt64) RequestInt64 

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

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

func (*DChInt64) TryInt64 

func (c *DChInt64) 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 DChInt8 

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

DChInt8 is a demand channel

func MakeDemandInt8Buff 

func MakeDemandInt8Buff(cap int) *DChInt8

MakeDemandInt8Buff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandInt8Chan 

func MakeDemandInt8Chan() *DChInt8

MakeDemandInt8Chan returns a (pointer to a) fresh unbuffered demand channel

func (*DChInt8) ProvideInt8 

func (c *DChInt8) ProvideInt8(dat int8)

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

func (*DChInt8) RequestInt8 

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

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

func (*DChInt8) TryInt8 

func (c *DChInt8) 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 DChString 

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

DChString is a demand channel

func MakeDemandStringBuff 

func MakeDemandStringBuff(cap int) *DChString

MakeDemandStringBuff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandStringChan 

func MakeDemandStringChan() *DChString

MakeDemandStringChan returns a (pointer to a) fresh unbuffered demand channel

func (*DChString) ProvideString 

func (c *DChString) ProvideString(dat string)

ProvideString is the send function - aka "MyKind <- some String"

func (*DChString) RequestString 

func (c *DChString) RequestString() (dat string)

RequestString is the receive function - aka "some String <- MyKind"

func (*DChString) TryString 

func (c *DChString) TryString() (dat string, open bool)

TryString is the comma-ok multi-valued form of RequestString and reports whether a received value was sent before the String channel was closed.

type DChUInt 

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

DChUInt is a demand channel

func MakeDemandUIntBuff 

func MakeDemandUIntBuff(cap int) *DChUInt

MakeDemandUIntBuff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandUIntChan 

func MakeDemandUIntChan() *DChUInt

MakeDemandUIntChan returns a (pointer to a) fresh unbuffered demand channel

func (*DChUInt) ProvideUInt 

func (c *DChUInt) ProvideUInt(dat uint)

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

func (*DChUInt) RequestUInt 

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

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

func (*DChUInt) TryUInt 

func (c *DChUInt) 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 DChUInt16 

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

DChUInt16 is a demand channel

func MakeDemandUInt16Buff 

func MakeDemandUInt16Buff(cap int) *DChUInt16

MakeDemandUInt16Buff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandUInt16Chan 

func MakeDemandUInt16Chan() *DChUInt16

MakeDemandUInt16Chan returns a (pointer to a) fresh unbuffered demand channel

func (*DChUInt16) ProvideUInt16 

func (c *DChUInt16) ProvideUInt16(dat uint16)

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

func (*DChUInt16) RequestUInt16 

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

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

func (*DChUInt16) TryUInt16 

func (c *DChUInt16) 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 DChUInt32 

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

DChUInt32 is a demand channel

func MakeDemandUInt32Buff 

func MakeDemandUInt32Buff(cap int) *DChUInt32

MakeDemandUInt32Buff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandUInt32Chan 

func MakeDemandUInt32Chan() *DChUInt32

MakeDemandUInt32Chan returns a (pointer to a) fresh unbuffered demand channel

func (*DChUInt32) ProvideUInt32 

func (c *DChUInt32) ProvideUInt32(dat uint32)

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

func (*DChUInt32) RequestUInt32 

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

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

func (*DChUInt32) TryUInt32 

func (c *DChUInt32) 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 DChUInt64 

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

DChUInt64 is a demand channel

func MakeDemandUInt64Buff 

func MakeDemandUInt64Buff(cap int) *DChUInt64

MakeDemandUInt64Buff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandUInt64Chan 

func MakeDemandUInt64Chan() *DChUInt64

MakeDemandUInt64Chan returns a (pointer to a) fresh unbuffered demand channel

func (*DChUInt64) ProvideUInt64 

func (c *DChUInt64) ProvideUInt64(dat uint64)

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

func (*DChUInt64) RequestUInt64 

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

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

func (*DChUInt64) TryUInt64 

func (c *DChUInt64) 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 DChUInt8 

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

DChUInt8 is a demand channel

func MakeDemandUInt8Buff 

func MakeDemandUInt8Buff(cap int) *DChUInt8

MakeDemandUInt8Buff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandUInt8Chan 

func MakeDemandUInt8Chan() *DChUInt8

MakeDemandUInt8Chan returns a (pointer to a) fresh unbuffered demand channel

func (*DChUInt8) ProvideUInt8 

func (c *DChUInt8) ProvideUInt8(dat uint8)

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

func (*DChUInt8) RequestUInt8 

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

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

func (*DChUInt8) TryUInt8 

func (c *DChUInt8) 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 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 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 SChString 

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

SChString is a supply channel

func MakeSupplyStringBuff 

func MakeSupplyStringBuff(cap int) *SChString

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

func MakeSupplyStringChan 

func MakeSupplyStringChan() *SChString

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

func (*SChString) ProvideString 

func (c *SChString) ProvideString(dat string)

ProvideString is the send function - aka "MyKind <- some String"

func (*SChString) RequestString 

func (c *SChString) RequestString() (dat string)

RequestString is the receive function - aka "some String <- MyKind"

func (*SChString) TryString 

func (c *SChString) TryString() (dat string, open bool)

TryString is the comma-ok multi-valued form of RequestString and reports whether a received value was sent before the String 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 StringChan 

type StringChan interface {
	StringROnlyChan // aka "<-chan" - receive only
	StringSOnlyChan // aka "chan<-" - send only
}

StringChan represents a bidirectional channel

type StringROnlyChan 

type StringROnlyChan interface {
	RequestString() (dat string)        // the receive function - aka "MyString := <-MyStringROnlyChan"
	TryString() (dat string, open bool) // the multi-valued comma-ok receive function - aka "MyString, ok := <-MyStringROnlyChan"
}

StringROnlyChan represents a receive-only channel

type StringSOnlyChan 

type StringSOnlyChan interface {
	ProvideString(dat string) // the send function - aka "MyKind <- some String"
}

StringSOnlyChan represents a send-only channel

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.