IsFloat

Documentation

Index

• type BasicInfo
• type BasicKind
• type Chan
• type DCh
  • func MakeDemandBuff(cap int) *DCh
  • func MakeDemandChan() *DCh
  • func (c *DCh) Provide(dat float64)
  • func (c *DCh) Request() (dat float64)
  • func (c *DCh) Try() (dat float64, open bool)
• type DChFloat32
  • func MakeDemandFloat32Buff(cap int) *DChFloat32
  • func MakeDemandFloat32Chan() *DChFloat32
  • func (c *DChFloat32) ProvideFloat32(dat float32)
  • func (c *DChFloat32) RequestFloat32() (dat float32)
  • func (c *DChFloat32) TryFloat32() (dat float32, open bool)
• type Float32Chan
• type Float32ROnlyChan
• type Float32SOnlyChan
• type ROnlyChan
• type SCh
  • func MakeSupplyBuff(cap int) *SCh
  • func MakeSupplyChan() *SCh
  • func (c *SCh) Provide(dat float64)
  • func (c *SCh) Request() (dat float64)
  • func (c *SCh) Try() (dat float64, open bool)
• type SChFloat32
  • func MakeSupplyFloat32Buff(cap int) *SChFloat32
  • func MakeSupplyFloat32Chan() *SChFloat32
  • func (c *SChFloat32) ProvideFloat32(dat float32)
  • func (c *SChFloat32) RequestFloat32() (dat float32)
  • func (c *SChFloat32) TryFloat32() (dat float32, open bool)
• 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 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 float64)

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

func (*DCh) Request

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

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

func (*DCh) Try

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

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

ROnlyChan represents a receive-only channel

type SCh

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

SCh is a supply channel

func MakeSupplyBuff

func MakeSupplyBuff(cap int) *SCh

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

func MakeSupplyChan

func MakeSupplyChan() *SCh

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

func (*SCh) Provide

func (c *SCh) Provide(dat float64)

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

func (*SCh) Request

func (c *SCh) Request() (dat float64)

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

func (*SCh) Try

func (c *SCh) Try() (dat float64, 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 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 SOnlyChan

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

SOnlyChan represents a send-only channel