IsString

Documentation

Index

• type BasicInfo
• type BasicKind
• type Chan
• type ROnlyChan
• type ReaderChan
• type ReaderROnlyChan
• type ReaderSOnlyChan
• type ReplacerChan
• type ReplacerROnlyChan
• type ReplacerSOnlyChan
• type SCh
  • func MakeSupplyBuff(cap int) *SCh
  • func MakeSupplyChan() *SCh
  • func (c *SCh) Provide(dat string)
  • func (c *SCh) Request() (dat string)
  • func (c *SCh) Try() (dat string, open bool)
• type SChReader
  • func MakeSupplyReaderBuff(cap int) *SChReader
  • func MakeSupplyReaderChan() *SChReader
  • func (c *SChReader) ProvideReader(dat *strings.Reader)
  • func (c *SChReader) RequestReader() (dat *strings.Reader)
  • func (c *SChReader) TryReader() (dat *strings.Reader, open bool)
• type SChReplacer
  • func MakeSupplyReplacerBuff(cap int) *SChReplacer
  • func MakeSupplyReplacerChan() *SChReplacer
  • func (c *SChReplacer) ProvideReplacer(dat *strings.Replacer)
  • func (c *SChReplacer) RequestReplacer() (dat *strings.Replacer)
  • func (c *SChReplacer) TryReplacer() (dat *strings.Replacer, open bool)
• type SChStringS
  • func MakeSupplyStringSBuff(cap int) *SChStringS
  • func MakeSupplyStringSChan() *SChStringS
  • func (c *SChStringS) ProvideStringS(dat []string)
  • func (c *SChStringS) RequestStringS() (dat []string)
  • func (c *SChStringS) TryStringS() (dat []string, open bool)
• type SOnlyChan
• type StringSChan
• type StringSROnlyChan
• type StringSSOnlyChan

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 ROnlyChan

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

ROnlyChan represents a receive-only channel

type ReaderChan

type ReaderChan interface {
	ReaderROnlyChan // aka "<-chan" - receive only
	ReaderSOnlyChan // aka "chan<-" - send only
}

ReaderChan represents a bidirectional channel

type ReaderROnlyChan

type ReaderROnlyChan interface {
	RequestReader() (dat *strings.Reader)        // the receive function - aka "MyReader := <-MyReaderROnlyChan"
	TryReader() (dat *strings.Reader, open bool) // the multi-valued comma-ok receive function - aka "MyReader, ok := <-MyReaderROnlyChan"
}

ReaderROnlyChan represents a receive-only channel

type ReaderSOnlyChan

type ReaderSOnlyChan interface {
	ProvideReader(dat *strings.Reader) // the send function - aka "MyKind <- some Reader"
}

ReaderSOnlyChan represents a send-only channel

type ReplacerChan

type ReplacerChan interface {
	ReplacerROnlyChan // aka "<-chan" - receive only
	ReplacerSOnlyChan // aka "chan<-" - send only
}

ReplacerChan represents a bidirectional channel

type ReplacerROnlyChan

type ReplacerROnlyChan interface {
	RequestReplacer() (dat *strings.Replacer)        // the receive function - aka "MyReplacer := <-MyReplacerROnlyChan"
	TryReplacer() (dat *strings.Replacer, open bool) // the multi-valued comma-ok receive function - aka "MyReplacer, ok := <-MyReplacerROnlyChan"
}

ReplacerROnlyChan represents a receive-only channel

type ReplacerSOnlyChan

type ReplacerSOnlyChan interface {
	ProvideReplacer(dat *strings.Replacer) // the send function - aka "MyKind <- some Replacer"
}

ReplacerSOnlyChan represents a send-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 string)

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

func (*SCh) Request

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

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

func (*SCh) Try

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

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

SChReader is a supply channel

func MakeSupplyReaderBuff

func MakeSupplyReaderBuff(cap int) *SChReader

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

func MakeSupplyReaderChan

func MakeSupplyReaderChan() *SChReader

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

func (*SChReader) ProvideReader

func (c *SChReader) ProvideReader(dat *strings.Reader)

ProvideReader is the send function - aka "MyKind <- some Reader"

func (*SChReader) RequestReader

func (c *SChReader) RequestReader() (dat *strings.Reader)

RequestReader is the receive function - aka "some Reader <- MyKind"

func (*SChReader) TryReader

func (c *SChReader) TryReader() (dat *strings.Reader, open bool)

TryReader is the comma-ok multi-valued form of RequestReader and reports whether a received value was sent before the Reader channel was closed.

type SChReplacer

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

SChReplacer is a supply channel

func MakeSupplyReplacerBuff

func MakeSupplyReplacerBuff(cap int) *SChReplacer

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

func MakeSupplyReplacerChan

func MakeSupplyReplacerChan() *SChReplacer

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

func (*SChReplacer) ProvideReplacer

func (c *SChReplacer) ProvideReplacer(dat *strings.Replacer)

ProvideReplacer is the send function - aka "MyKind <- some Replacer"

func (*SChReplacer) RequestReplacer

func (c *SChReplacer) RequestReplacer() (dat *strings.Replacer)

RequestReplacer is the receive function - aka "some Replacer <- MyKind"

func (*SChReplacer) TryReplacer

func (c *SChReplacer) TryReplacer() (dat *strings.Replacer, open bool)

TryReplacer is the comma-ok multi-valued form of RequestReplacer and reports whether a received value was sent before the Replacer channel was closed.

type SChStringS

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

SChStringS is a supply channel

func MakeSupplyStringSBuff

func MakeSupplyStringSBuff(cap int) *SChStringS

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

func MakeSupplyStringSChan

func MakeSupplyStringSChan() *SChStringS

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

func (*SChStringS) ProvideStringS

func (c *SChStringS) ProvideStringS(dat []string)

ProvideStringS is the send function - aka "MyKind <- some StringS"

func (*SChStringS) RequestStringS

func (c *SChStringS) RequestStringS() (dat []string)

RequestStringS is the receive function - aka "some StringS <- MyKind"

func (*SChStringS) TryStringS

func (c *SChStringS) TryStringS() (dat []string, open bool)

TryStringS is the comma-ok multi-valued form of RequestStringS and reports whether a received value was sent before the StringS channel was closed.

type SOnlyChan

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

SOnlyChan represents a send-only channel

type StringSChan

type StringSChan interface {
	StringSROnlyChan // aka "<-chan" - receive only
	StringSSOnlyChan // aka "chan<-" - send only
}

StringSChan represents a bidirectional channel

type StringSROnlyChan

type StringSROnlyChan interface {
	RequestStringS() (dat []string)        // the receive function - aka "MyStringS := <-MyStringSROnlyChan"
	TryStringS() (dat []string, open bool) // the multi-valued comma-ok receive function - aka "MyStringS, ok := <-MyStringSROnlyChan"
}

StringSROnlyChan represents a receive-only channel

type StringSSOnlyChan

type StringSSOnlyChan interface {
	ProvideStringS(dat []string) // the send function - aka "MyKind <- some StringS"
}

StringSSOnlyChan represents a send-only channel