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

type Chan interface {
	ROnlyChan // aka "<-chan" - receive only
	SOnlyChan // aka "chan<-" - send only
}

Chan represents a bidirectional channel

type DCh 

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

DCh is a demand channel

func MakeDemandBuff 

func MakeDemandBuff(cap int) *DCh

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

func MakeDemandChan 

func MakeDemandChan() *DCh

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

func (*DCh) Provide 

func (c *DCh) Provide(dat int)

Provide is the send function - aka "MyKind <- some "

func (*DCh) Request 

func (c *DCh) Request() (dat int)

Request is the receive function - aka "some <- MyKind"

func (*DCh) Try 

func (c *DCh) Try() (dat int, open bool)

Try is the comma-ok multi-valued form of Request and reports whether a received value was sent before the 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 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 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 ROnlyChan 

type ROnlyChan interface {
	Request() (dat int)        // the receive function - aka "My := <-MyROnlyChan"
	Try() (dat int, open bool) // the multi-valued comma-ok receive function - aka "My, ok := <-MyROnlyChan"
}

ROnlyChan represents a receive-only channel

type SOnlyChan 

type SOnlyChan interface {
	Provide(dat int) // the send function - aka "MyKind <- some "
}

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