IsComplex

Documentation

Index

• type BasicInfo
• type BasicKind
• type Chan
• type Complex64Chan
• type Complex64ROnlyChan
• type Complex64SOnlyChan
• type DCh
  • func MakeDemandBuff(cap int) *DCh
  • func MakeDemandChan() *DCh
  • func (c *DCh) Provide(dat complex128)
  • func (c *DCh) Request() (dat complex128)
  • func (c *DCh) Try() (dat complex128, open bool)
• type DChComplex64
  • func MakeDemandComplex64Buff(cap int) *DChComplex64
  • func MakeDemandComplex64Chan() *DChComplex64
  • func (c *DChComplex64) ProvideComplex64(dat complex64)
  • func (c *DChComplex64) RequestComplex64() (dat complex64)
  • func (c *DChComplex64) TryComplex64() (dat complex64, open bool)
• type ROnlyChan
• type SOnlyChan

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

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

func (*DCh) Request

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

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

func (*DCh) Try

func (c *DCh) Try() (dat complex128, 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 DChComplex64

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

DChComplex64 is a demand channel

func MakeDemandComplex64Buff

func MakeDemandComplex64Buff(cap int) *DChComplex64

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

func MakeDemandComplex64Chan

func MakeDemandComplex64Chan() *DChComplex64

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

func (*DChComplex64) ProvideComplex64

func (c *DChComplex64) ProvideComplex64(dat complex64)

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

func (*DChComplex64) RequestComplex64

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

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

func (*DChComplex64) TryComplex64

func (c *DChComplex64) 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 ROnlyChan

type ROnlyChan interface {
	Request() (dat complex128)        // the receive function - aka "My := <-MyROnlyChan"
	Try() (dat complex128, 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 complex128) // the send function - aka "MyKind <- some "
}

SOnlyChan represents a send-only channel