data

package
v0.0.0-...-8971788 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 7, 2020 License: MIT Imports: 11 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	Not       OpStr = "¬"
	And             = "&&"
	Or              = "||"
	Xor             = "^"
	AndNot          = "&^"
	ShiftL          = "<<"
	ShiftR          = ">>"
	Add             = "+"
	Substract       = "-"
	Multiply        = "×"
	QuoRatio        = "÷"
	QuoModul        = "%"
	Quotient        = "/"
	Power           = "^"
	Greater         = ">"
	Lesser          = "<"
	Equal           = "="
	Leq             = "≤"
	Geq             = "≥"
)
View Source 
const (
	Nil TyNat = 1 << iota
	Bool
	Int8
	Int16
	Int32
	Int
	BigInt
	Uint8
	Uint16
	Uint32
	Uint
	Flt32
	Float
	BigFlt
	Ratio
	Imag64
	Imag
	Time
	Duration
	Byte
	Rune
	Flag
	String
	Bytes
	Error // let's do something sophisticated here...
	////
	Pair
	Slice
	Unboxed
	Map
	////
	Function
	Literal
	Type // marks most signifficant native type & data of type bitflag

	// TYPE CLASSES
	// precedence type classes define argument types functions that accept
	// a set of possible input types
	Natives = Nil | Bool | Int8 | Int16 | Int32 | Int | BigInt | Uint8 |
		Uint16 | Uint32 | Uint | Flt32 | Float | BigFlt | Ratio | Imag64 |
		Imag | Time | Duration | Byte | Rune | Bytes | String | Error

	Bitwise    = Naturals | Byte | Type
	Booleans   = Bool | Bitwise
	Naturals   = Uint | Uint8 | Uint16 | Uint32
	Integers   = Int | Int8 | Int16 | Int32 | BigInt
	Rationals  = Naturals | Integers | Ratio
	Reals      = Float | Flt32 | BigFlt
	Big        = BigInt | BigFlt | Ratio
	Imaginarys = Imag | Imag64
	Numbers    = Rationals | Reals | Imaginarys
	Letters    = String | Rune | Bytes
	Equals     = Numbers | Letters

	Compositions = Pair | Unboxed | Slice | Map

	Parametric = Natives | Compositions

	Functional = Literal | Function | Type

	Sets = Natives | Bitwise | Booleans | Naturals | Integers | Rationals |
		Reals | Imaginarys | Numbers | Letters | Equals | Compositions |
		Parametric | Functional

	MASK         TyNat = 0xFFFFFFFFFFFFFFFF
	MASK_NATIVES       = MASK ^ Natives
)

Variables

View Source 
var TypeConversionTable = [][]func(arg Native) Native{

	[]func(arg Native) Native{
		func(Native) Native { return NilVal{} },
		func(Native) Native { return BoolVal(false) },
		func(Native) Native { return Int8Val(0) },
		func(Native) Native { return Int16Val(0) },
		func(Native) Native { return Int32Val(0) },
		func(Native) Native { return IntVal(0) },
		func(Native) Native { return IntVal(0).BigInt() },
		func(Native) Native { return Uint8Val(0) },
		func(Native) Native { return Uint16Val(0) },
		func(Native) Native { return Uint32Val(0) },
		func(Native) Native { return UintVal(0) },
		func(Native) Native { return Flt32Val(0.0) },
		func(Native) Native { return FltVal(0.0) },
		func(Native) Native { return FltVal(0.0).BigFlt() },
		func(Native) Native { return IntVal(0).Ratio() },
		func(Native) Native { return IntVal(0).Imag().Imag64() },
		func(Native) Native { return IntVal(0).Imag() },
		func(Native) Native { return TimeVal{} },
		func(arg Native) Native { return DuraVal(0) },
		func(arg Native) Native { return ByteVal(0) },
		func(arg Native) Native { return RuneVal(0) },
		func(arg Native) Native { return BitFlag(0) },
		func(arg Native) Native { return StrVal("") },
		func(arg Native) Native { return BytesVal{} },
		func(arg Native) Native { return ErrorVal{} },
	},

	[]func(arg Native) Native{
		func(arg Native) Native { return NilVal{} },
		func(arg Native) Native { return arg },
		func(arg Native) Native { return arg.(BoolVal).Int().Int8() },
		func(arg Native) Native { return arg.(BoolVal).Int().Int16() },
		func(arg Native) Native { return arg.(BoolVal).Int().Int32() },
		func(arg Native) Native { return arg.(BoolVal).Int() },
		func(arg Native) Native { return arg.(BoolVal).Int().BigInt() },
		func(arg Native) Native { return arg.(BoolVal).Uint().Uint8() },
		func(arg Native) Native { return arg.(BoolVal).Uint().Uint16() },
		func(arg Native) Native { return arg.(BoolVal).Uint().Uint32() },
		func(arg Native) Native { return arg.(BoolVal).Uint() },
		func(arg Native) Native { return arg.(BoolVal).Int().Float().Flt32() },
		func(arg Native) Native { return arg.(BoolVal).Int().Float() },
		func(arg Native) Native { return arg.(BoolVal).Int().Float().BigFlt() },
		func(arg Native) Native { return arg.(BoolVal).Int().Ratio() },
		func(arg Native) Native { return arg.(BoolVal).Int().Imag().Imag64() },
		func(arg Native) Native { return arg.(BoolVal).Int().Imag() },
		func(arg Native) Native {
			if arg.(BoolVal).Bool() {
				return TimeVal(time.Now())
			}
			return TimeVal{}
		},
		func(arg Native) Native {
			if arg.(BoolVal).Bool() {
				return DuraVal(1)
			}
			return DuraVal(0)
		},
		func(arg Native) Native { return arg.(BoolVal).Int().Byte() },
		func(arg Native) Native { return arg.(BoolVal).Int().Rune() },
		func(arg Native) Native { return arg.(BoolVal).Int().Flag() },
		func(arg Native) Native { return StrVal(arg.(BoolVal).String()) },
		func(arg Native) Native { return StrVal(arg.(BoolVal).String()).Bytes() },
		func(arg Native) Native {
			if arg.(BoolVal).Bool() {
				return NewError(
					fmt.Errorf(
						"error occured during convertion from bool"))
			}
			return ErrorVal{}
		},
	},

	[]func(arg Native) Native{
		func(arg Native) Native { return NilVal{} },
		func(arg Native) Native {
			if arg.(Int8Val) > Int8Val(0) {
				return BoolVal(true)
			}
			return BoolVal(false)
		},
		func(arg Native) Native { return arg },
		func(arg Native) Native { return Int16Val(arg.(Int8Val)) },
		func(arg Native) Native { return Int32Val(arg.(Int8Val)) },
		func(arg Native) Native { return IntVal(arg.(Int8Val)) },
		func(arg Native) Native { return IntVal(arg.(Int8Val)).BigInt() },
		func(arg Native) Native { return UintVal(arg.(Int8Val)) },
		func(arg Native) Native { return Uint16Val(arg.(Int8Val)) },
		func(arg Native) Native { return Uint32Val(arg.(Int8Val)) },
		func(arg Native) Native { return UintVal(arg.(Int8Val)) },
		func(arg Native) Native { return Flt32Val(arg.(Uint8Val)) },
		func(arg Native) Native { return FltVal(arg.(Int8Val)) },
		func(arg Native) Native { return FltVal(arg.(Int8Val)).BigFlt() },
		func(arg Native) Native { return IntVal(arg.(Int8Val)).Ratio() },
		func(arg Native) Native { return IntVal(arg.(Int8Val)).Imag().Imag64() },
		func(arg Native) Native { return IntVal(arg.(Int8Val)).Imag() },
		func(arg Native) Native {
			if arg.(Int8Val) > 0 {
				return TimeVal(time.Now())
			}
			return TimeVal{}
		},
		func(arg Native) Native { return DuraVal(arg.(Int8Val)) },
		func(arg Native) Native { return IntVal(arg.(Int8Val)).Byte() },
		func(arg Native) Native { return IntVal(arg.(Int8Val)).Rune() },
		func(arg Native) Native { return IntVal(arg.(Int8Val)).Flag() },
		func(arg Native) Native { return StrVal(arg.(Int8Val).String()) },
		func(arg Native) Native { return StrVal(arg.(Int8Val).String()).Bytes() },
		func(arg Native) Native {
			if arg.(BoolVal).Bool() {
				return NewError(
					fmt.Errorf(
						"error occured during convertion from int8"))
			}
			return ErrorVal{}
		},
	},

	[]func(arg Native) Native{
		func(arg Native) Native { return NilVal{} },
		func(arg Native) Native {
			if arg.(Int16Val) > Int16Val(0) {
				return BoolVal(true)
			}
			return BoolVal(false)
		},
		func(arg Native) Native { return arg },
		func(arg Native) Native { return Int16Val(arg.(Int16Val)) },
		func(arg Native) Native { return Int32Val(arg.(Int16Val)) },
		func(arg Native) Native { return IntVal(arg.(Int16Val)) },
		func(arg Native) Native { return IntVal(arg.(Int16Val)).BigInt() },
		func(arg Native) Native { return UintVal(arg.(Int16Val)) },
		func(arg Native) Native { return Uint16Val(arg.(Int16Val)) },
		func(arg Native) Native { return Uint32Val(arg.(Int16Val)) },
		func(arg Native) Native { return UintVal(arg.(Int16Val)) },
		func(arg Native) Native { return Flt32Val(arg.(Uint16Val)) },
		func(arg Native) Native { return FltVal(arg.(Int16Val)) },
		func(arg Native) Native { return FltVal(arg.(Int16Val)).BigFlt() },
		func(arg Native) Native { return IntVal(arg.(Int16Val)).Ratio() },
		func(arg Native) Native { return IntVal(arg.(Int16Val)).Imag().Imag64() },
		func(arg Native) Native { return IntVal(arg.(Int16Val)).Imag() },
		func(arg Native) Native {
			if arg.(Int16Val) > 0 {
				return TimeVal(time.Now())
			}
			return TimeVal{}
		},
		func(arg Native) Native { return DuraVal(arg.(Int16Val)) },
		func(arg Native) Native { return IntVal(arg.(Int16Val)).Byte() },
		func(arg Native) Native { return IntVal(arg.(Int16Val)).Rune() },
		func(arg Native) Native { return IntVal(arg.(Int16Val)).Flag() },
		func(arg Native) Native { return StrVal(arg.(Int16Val).String()) },
		func(arg Native) Native { return StrVal(arg.(Int16Val).String()).Bytes() },
		func(arg Native) Native {
			if arg.(BoolVal).Bool() {
				return NewError(
					fmt.Errorf(
						"error occured during convertion from int16"))
			}
			return ErrorVal{}
		},
	},

	[]func(arg Native) Native{
		func(arg Native) Native { return NilVal{} },
		func(arg Native) Native {
			if arg.(Int32Val) > Int32Val(0) {
				return BoolVal(true)
			}
			return BoolVal(false)
		},
		func(arg Native) Native { return arg },
		func(arg Native) Native { return Int16Val(arg.(Int32Val)) },
		func(arg Native) Native { return Int32Val(arg.(Int32Val)) },
		func(arg Native) Native { return IntVal(arg.(Int32Val)) },
		func(arg Native) Native { return IntVal(arg.(Int32Val)).BigInt() },
		func(arg Native) Native { return Uint8Val(arg.(Int32Val)) },
		func(arg Native) Native { return Uint16Val(arg.(Int32Val)) },
		func(arg Native) Native { return Uint32Val(arg.(Int32Val)) },
		func(arg Native) Native { return UintVal(arg.(Int32Val)) },
		func(arg Native) Native { return Flt32Val(arg.(Uint32Val)) },
		func(arg Native) Native { return FltVal(arg.(Int32Val)) },
		func(arg Native) Native { return FltVal(arg.(Int32Val)).BigFlt() },
		func(arg Native) Native { return IntVal(arg.(Int32Val)).Ratio() },
		func(arg Native) Native { return IntVal(arg.(Int32Val)).Imag().Imag64() },
		func(arg Native) Native { return IntVal(arg.(Int32Val)).Imag() },
		func(arg Native) Native {
			if arg.(Int32Val) > 0 {
				return TimeVal(time.Now())
			}
			return TimeVal{}
		},
		func(arg Native) Native { return DuraVal(arg.(Int32Val)) },
		func(arg Native) Native { return IntVal(arg.(Int32Val)).Byte() },
		func(arg Native) Native { return IntVal(arg.(Int32Val)).Rune() },
		func(arg Native) Native { return IntVal(arg.(Int32Val)).Flag() },
		func(arg Native) Native { return StrVal(arg.(Int32Val).String()) },
		func(arg Native) Native { return StrVal(arg.(Int32Val).String()).Bytes() },
		func(arg Native) Native {
			if arg.(BoolVal).Bool() {
				return NewError(
					fmt.Errorf(
						"error occured during convertion from int32"))
			}
			return ErrorVal{}
		},
	},

	[]func(arg Native) Native{
		func(arg Native) Native { return NilVal{} },
		func(arg Native) Native {
			if arg.(IntVal) > IntVal(0) {
				return BoolVal(true)
			}
			return BoolVal(false)
		},
		func(arg Native) Native { return arg },
		func(arg Native) Native { return Int16Val(arg.(IntVal)) },
		func(arg Native) Native { return Int32Val(arg.(IntVal)) },
		func(arg Native) Native { return IntVal(arg.(IntVal)) },
		func(arg Native) Native { return IntVal(arg.(IntVal)).BigInt() },
		func(arg Native) Native { return Uint8Val(arg.(IntVal)) },
		func(arg Native) Native { return Uint16Val(arg.(IntVal)) },
		func(arg Native) Native { return Uint32Val(arg.(IntVal)) },
		func(arg Native) Native { return UintVal(arg.(IntVal)) },
		func(arg Native) Native { return FltVal(arg.(IntVal)) },
		func(arg Native) Native { return FltVal(arg.(IntVal)) },
		func(arg Native) Native { return FltVal(arg.(IntVal)).BigFlt() },
		func(arg Native) Native { return IntVal(arg.(IntVal)).Ratio() },
		func(arg Native) Native { return IntVal(arg.(IntVal)).Imag().Imag64() },
		func(arg Native) Native { return IntVal(arg.(IntVal)).Imag() },
		func(arg Native) Native {
			if arg.(IntVal) > 0 {
				return TimeVal(time.Now())
			}
			return TimeVal{}
		},
		func(arg Native) Native { return DuraVal(arg.(IntVal)) },
		func(arg Native) Native { return IntVal(arg.(IntVal)).Byte() },
		func(arg Native) Native { return IntVal(arg.(IntVal)).Rune() },
		func(arg Native) Native { return IntVal(arg.(IntVal)).Flag() },
		func(arg Native) Native { return StrVal(arg.(IntVal).String()) },
		func(arg Native) Native { return StrVal(arg.(IntVal).String()).Bytes() },
		func(arg Native) Native {
			if arg.(BoolVal).Bool() {
				return NewError(
					fmt.Errorf(
						"error occured during convertion from int"))
			}
			return ErrorVal{}
		},
	},

	[]func(arg Native) Native{
		func(arg Native) Native { return NilVal{} },
		func(arg Native) Native {
			if arg.(BigIntVal).Int() > IntVal(0) {
				return BoolVal(true)
			}
			return BoolVal(false)
		},
		func(arg Native) Native { return arg },
		func(arg Native) Native { return Int16Val(arg.(BigIntVal).Int()) },
		func(arg Native) Native { return Int32Val(arg.(BigIntVal).Int()) },
		func(arg Native) Native { return IntVal(arg.(BigIntVal).Int()) },
		func(arg Native) Native { return IntVal(arg.(BigIntVal).Int()).BigInt() },
		func(arg Native) Native { return Uint8Val(arg.(BigIntVal).Int()) },
		func(arg Native) Native { return Uint16Val(arg.(BigIntVal).Int()) },
		func(arg Native) Native { return Uint32Val(arg.(BigIntVal).Int()) },
		func(arg Native) Native { return UintVal(arg.(BigIntVal).Int()) },
		func(arg Native) Native { return FltVal(arg.(BigIntVal).Int()) },
		func(arg Native) Native { return FltVal(arg.(BigIntVal).Int()) },
		func(arg Native) Native { return FltVal(arg.(BigIntVal).Int()).BigFlt() },
		func(arg Native) Native { return IntVal(arg.(BigIntVal).Int()).Ratio() },
		func(arg Native) Native { return IntVal(arg.(BigIntVal).Int()).Imag().Imag64() },
		func(arg Native) Native { return IntVal(arg.(BigIntVal).Int()).Imag() },
		func(arg Native) Native {
			if arg.(BigIntVal).Int() > 0 {
				return TimeVal(time.Now())
			}
			return TimeVal{}
		},
		func(arg Native) Native { return DuraVal(arg.(BigIntVal).Int()) },
		func(arg Native) Native { return IntVal(arg.(BigIntVal).Int()).Byte() },
		func(arg Native) Native { return IntVal(arg.(BigIntVal).Int()).Rune() },
		func(arg Native) Native { return IntVal(arg.(BigIntVal).Int()).Flag() },
		func(arg Native) Native { return StrVal(arg.(BigIntVal).Int().String()) },
		func(arg Native) Native { return StrVal(arg.(BigIntVal).Int().String()).Bytes() },
		func(arg Native) Native {
			if arg.(BoolVal).Bool() {
				return NewError(
					fmt.Errorf(
						"error occured during convertion from bigint"))
			}
			return ErrorVal{}
		},
	},

	[]func(arg Native) Native{
		func(arg Native) Native { return NilVal{} },
		func(arg Native) Native {
			if arg.(Uint8Val) > Uint8Val(0) {
				return BoolVal(true)
			}
			return BoolVal(false)
		},
		func(arg Native) Native { return arg },
		func(arg Native) Native { return Uint16Val(arg.(Uint8Val)) },
		func(arg Native) Native { return Uint32Val(arg.(Uint8Val)) },
		func(arg Native) Native { return UintVal(arg.(Uint8Val)) },
		func(arg Native) Native { return UintVal(arg.(Uint8Val)).BigInt() },
		func(arg Native) Native { return UintVal(arg.(Uint8Val)) },
		func(arg Native) Native { return Uint16Val(arg.(Uint8Val)) },
		func(arg Native) Native { return Uint32Val(arg.(Uint8Val)) },
		func(arg Native) Native { return UintVal(arg.(Uint8Val)) },
		func(arg Native) Native { return Flt32Val(arg.(Uint8Val)) },
		func(arg Native) Native { return FltVal(arg.(Uint8Val)) },
		func(arg Native) Native { return FltVal(arg.(Uint8Val)).BigFlt() },
		func(arg Native) Native { return UintVal(arg.(Uint8Val)).Ratio() },
		func(arg Native) Native { return UintVal(arg.(Uint8Val)).Imag().Imag64() },
		func(arg Native) Native { return UintVal(arg.(Uint8Val)).Imag() },
		func(arg Native) Native {
			if arg.(Uint8Val) > 0 {
				return TimeVal(time.Now())
			}
			return TimeVal{}
		},
		func(arg Native) Native { return DuraVal(arg.(Uint8Val)) },
		func(arg Native) Native { return ByteVal(arg.(Uint8Val)) },
		func(arg Native) Native { return RuneVal(UintVal(arg.(Uint8Val))) },
		func(arg Native) Native { return BitFlag(UintVal(arg.(Uint8Val))) },
		func(arg Native) Native { return StrVal(arg.(Uint8Val).String()) },
		func(arg Native) Native { return StrVal(arg.(Uint8Val).String()).Bytes() },
		func(arg Native) Native {
			if arg.(BoolVal).Bool() {
				return NewError(
					fmt.Errorf(
						"error occured during convertion from uint8"))
			}
			return ErrorVal{}
		},
	},

	[]func(arg Native) Native{
		func(arg Native) Native { return NilVal{} },
		func(arg Native) Native {
			if arg.(Uint16Val) > Uint16Val(0) {
				return BoolVal(true)
			}
			return BoolVal(false)
		},
		func(arg Native) Native { return Int8Val(arg.(Uint16Val)) },
		func(arg Native) Native { return Int16Val(arg.(Uint16Val)) },
		func(arg Native) Native { return Int32Val(arg.(Uint16Val)) },
		func(arg Native) Native { return IntVal(arg.(Uint16Val)) },
		func(arg Native) Native { return IntVal(arg.(Uint16Val)).BigInt() },
		func(arg Native) Native { return Uint8Val(arg.(Uint16Val)) },
		func(arg Native) Native { return arg.(Uint16Val) },
		func(arg Native) Native { return Uint32Val(arg.(Uint16Val)) },
		func(arg Native) Native { return UintVal(arg.(Uint16Val)) },
		func(arg Native) Native { return Flt32Val(arg.(Uint16Val)) },
		func(arg Native) Native { return FltVal(arg.(Uint16Val)) },
		func(arg Native) Native { return FltVal(arg.(Uint16Val)).BigFlt() },
		func(arg Native) Native { return UintVal(arg.(Uint16Val)).Ratio() },
		func(arg Native) Native { return UintVal(arg.(Uint16Val)).Imag().Imag64() },
		func(arg Native) Native { return UintVal(arg.(Uint16Val)).Imag() },
		func(arg Native) Native {
			if arg.(Uint16Val) > 0 {
				return TimeVal(time.Now())
			}
			return TimeVal{}
		},
		func(arg Native) Native { return DuraVal(arg.(Uint16Val)) },
		func(arg Native) Native { return ByteVal(arg.(Uint16Val)) },
		func(arg Native) Native { return RuneVal(UintVal(arg.(Uint16Val))) },
		func(arg Native) Native { return BitFlag(UintVal(arg.(Uint16Val))) },
		func(arg Native) Native { return StrVal(arg.(Uint16Val).String()) },
		func(arg Native) Native { return StrVal(arg.(Uint16Val).String()).Bytes() },
		func(arg Native) Native {
			if arg.(BoolVal).Bool() {
				return NewError(
					fmt.Errorf(
						"error occured during convertion from uint16"))
			}
			return ErrorVal{}
		},
	},

	[]func(arg Native) Native{
		func(arg Native) Native { return NilVal{} },
		func(arg Native) Native {
			if arg.(Uint32Val) > Uint32Val(0) {
				return BoolVal(true)
			}
			return BoolVal(false)
		},
		func(arg Native) Native { return IntVal(arg.(Uint32Val)) },
		func(arg Native) Native { return IntVal(arg.(Uint32Val)) },
		func(arg Native) Native { return IntVal(arg.(Uint32Val)) },
		func(arg Native) Native { return IntVal(arg.(Uint32Val)) },
		func(arg Native) Native { return IntVal(arg.(Uint32Val)).BigInt() },
		func(arg Native) Native { return Uint8Val(arg.(Uint32Val)) },
		func(arg Native) Native { return Uint16Val(arg.(Uint32Val)) },
		func(arg Native) Native { return Uint32Val(arg.(Uint32Val)) },
		func(arg Native) Native { return UintVal(arg.(Uint32Val)) },
		func(arg Native) Native { return Flt32Val(arg.(Uint32Val)) },
		func(arg Native) Native { return FltVal(arg.(Uint32Val)) },
		func(arg Native) Native { return FltVal(arg.(Uint32Val)).BigFlt() },
		func(arg Native) Native { return UintVal(arg.(Uint32Val)).Ratio() },
		func(arg Native) Native { return UintVal(arg.(Uint32Val)).Imag().Imag64() },
		func(arg Native) Native { return UintVal(arg.(Uint32Val)).Imag() },
		func(arg Native) Native {
			if arg.(Uint32Val) > 0 {
				return TimeVal(time.Now())
			}
			return TimeVal{}
		},
		func(arg Native) Native { return DuraVal(arg.(Uint32Val)) },
		func(arg Native) Native { return ByteVal(arg.(Uint32Val)) },
		func(arg Native) Native { return RuneVal(UintVal(arg.(Uint32Val))) },
		func(arg Native) Native { return BitFlag(UintVal(arg.(Uint32Val))) },
		func(arg Native) Native { return StrVal(arg.(Uint32Val).String()) },
		func(arg Native) Native { return StrVal(arg.(Uint32Val).String()).Bytes() },
		func(arg Native) Native {
			if arg.(BoolVal).Bool() {
				return NewError(
					fmt.Errorf(
						"error occured during convertion from uint32"))
			}
			return ErrorVal{}
		},
	},

	[]func(arg Native) Native{
		func(arg Native) Native { return NilVal{} },
		func(arg Native) Native {
			if arg.(UintVal) > UintVal(0) {
				return BoolVal(true)
			}
			return BoolVal(false)
		},
		func(arg Native) Native { return IntVal(arg.(UintVal)) },
		func(arg Native) Native { return IntVal(arg.(UintVal)) },
		func(arg Native) Native { return IntVal(arg.(UintVal)) },
		func(arg Native) Native { return IntVal(arg.(UintVal)) },
		func(arg Native) Native { return IntVal(arg.(UintVal)).BigInt() },
		func(arg Native) Native { return Uint8Val(arg.(UintVal)) },
		func(arg Native) Native { return Uint16Val(arg.(UintVal)) },
		func(arg Native) Native { return Uint32Val(arg.(UintVal)) },
		func(arg Native) Native { return UintVal(arg.(UintVal)) },
		func(arg Native) Native { return Flt32Val(arg.(UintVal)) },
		func(arg Native) Native { return FltVal(arg.(UintVal)) },
		func(arg Native) Native { return FltVal(arg.(UintVal)).BigFlt() },
		func(arg Native) Native { return UintVal(arg.(UintVal)).Ratio() },
		func(arg Native) Native { return UintVal(arg.(UintVal)).Imag().Imag64() },
		func(arg Native) Native { return UintVal(arg.(UintVal)).Imag() },
		func(arg Native) Native {
			if arg.(UintVal) > 0 {
				return TimeVal(time.Now())
			}
			return TimeVal{}
		},
		func(arg Native) Native { return DuraVal(arg.(UintVal)) },
		func(arg Native) Native { return ByteVal(arg.(UintVal)) },
		func(arg Native) Native { return RuneVal(UintVal(arg.(UintVal))) },
		func(arg Native) Native { return BitFlag(UintVal(arg.(UintVal))) },
		func(arg Native) Native { return StrVal(arg.(UintVal).String()) },
		func(arg Native) Native { return StrVal(arg.(UintVal).String()).Bytes() },
		func(arg Native) Native {
			if arg.(BoolVal).Bool() {
				return NewError(
					fmt.Errorf(
						"error occured during convertion from uint"))
			}
			return ErrorVal{}
		},
	},

	[]func(arg Native) Native{
		func(arg Native) Native { return NilVal{} },
		func(arg Native) Native {
			if arg.(Flt32Val) > Flt32Val(0) {
				return BoolVal(true)
			}
			return BoolVal(false)
		},
		func(arg Native) Native { return IntVal(arg.(Flt32Val)) },
		func(arg Native) Native { return IntVal(arg.(Flt32Val)) },
		func(arg Native) Native { return IntVal(arg.(Flt32Val)) },
		func(arg Native) Native { return IntVal(arg.(Flt32Val)) },
		func(arg Native) Native { return IntVal(arg.(Flt32Val)).BigInt() },
		func(arg Native) Native { return Uint8Val(arg.(Flt32Val)) },
		func(arg Native) Native { return Uint16Val(arg.(Flt32Val)) },
		func(arg Native) Native { return Uint32Val(arg.(Flt32Val)) },
		func(arg Native) Native { return UintVal(arg.(Flt32Val)) },
		func(arg Native) Native { return Flt32Val(arg.(Flt32Val)) },
		func(arg Native) Native { return arg.(Flt32Val) },
		func(arg Native) Native { return FltVal(arg.(Flt32Val)).BigFlt() },
		func(arg Native) Native { return UintVal(arg.(Flt32Val)).Ratio() },
		func(arg Native) Native { return UintVal(arg.(Flt32Val)).Imag().Imag64() },
		func(arg Native) Native { return UintVal(arg.(Flt32Val)).Imag() },
		func(arg Native) Native {
			if arg.(Flt32Val) > 0 {
				return TimeVal(time.Now())
			}
			return TimeVal{}
		},
		func(arg Native) Native { return DuraVal(arg.(Flt32Val)) },
		func(arg Native) Native { return ByteVal(arg.(Flt32Val)) },
		func(arg Native) Native { return RuneVal(UintVal(arg.(Flt32Val))) },
		func(arg Native) Native { return BitFlag(UintVal(arg.(Flt32Val))) },
		func(arg Native) Native { return StrVal(arg.(Flt32Val).String()) },
		func(arg Native) Native { return StrVal(arg.(Flt32Val).String()).Bytes() },
		func(arg Native) Native {
			if arg.(BoolVal).Bool() {
				return NewError(
					fmt.Errorf(
						"error occured during convertion from uint"))
			}
			return ErrorVal{}
		},
	},

	[]func(arg Native) Native{
		func(arg Native) Native { return NilVal{} },
		func(arg Native) Native {
			if arg.(FltVal) > FltVal(0) {
				return BoolVal(true)
			}
			return BoolVal(false)
		},
		func(arg Native) Native { return IntVal(arg.(FltVal)) },
		func(arg Native) Native { return IntVal(arg.(FltVal)) },
		func(arg Native) Native { return IntVal(arg.(FltVal)) },
		func(arg Native) Native { return IntVal(arg.(FltVal)) },
		func(arg Native) Native { return IntVal(arg.(FltVal)).BigInt() },
		func(arg Native) Native { return Uint8Val(arg.(FltVal)) },
		func(arg Native) Native { return Uint16Val(arg.(FltVal)) },
		func(arg Native) Native { return Uint32Val(arg.(FltVal)) },
		func(arg Native) Native { return UintVal(arg.(FltVal)) },
		func(arg Native) Native { return Flt32Val(arg.(FltVal)) },
		func(arg Native) Native { return arg.(FltVal) },
		func(arg Native) Native { return FltVal(arg.(FltVal)).BigFlt() },
		func(arg Native) Native { return UintVal(arg.(FltVal)).Ratio() },
		func(arg Native) Native { return UintVal(arg.(FltVal)).Imag().Imag64() },
		func(arg Native) Native { return UintVal(arg.(FltVal)).Imag() },
		func(arg Native) Native {
			if arg.(FltVal) > 0 {
				return TimeVal(time.Now())
			}
			return TimeVal{}
		},
		func(arg Native) Native { return DuraVal(arg.(FltVal)) },
		func(arg Native) Native { return ByteVal(arg.(FltVal)) },
		func(arg Native) Native { return RuneVal(UintVal(arg.(FltVal))) },
		func(arg Native) Native { return BitFlag(UintVal(arg.(FltVal))) },
		func(arg Native) Native { return StrVal(arg.(FltVal).String()) },
		func(arg Native) Native { return StrVal(arg.(FltVal).String()).Bytes() },
		func(arg Native) Native {
			if arg.(BoolVal).Bool() {
				return NewError(
					fmt.Errorf(
						"error occured during convertion from uint"))
			}
			return ErrorVal{}
		},
	},

	[]func(arg Native) Native{
		func(arg Native) Native { return NilVal{} },
		func(arg Native) Native {
			if arg.(BigFltVal).GoBigInt().Cmp(IntVal(0).BigInt().GoBigInt()) != 0 {
				return BoolVal(true)
			}
			return BoolVal(false)
		},
		func(arg Native) Native { return IntVal(arg.(BigFltVal).Int()) },
		func(arg Native) Native { return IntVal(arg.(BigFltVal).Int()) },
		func(arg Native) Native { return IntVal(arg.(BigFltVal).Int()) },
		func(arg Native) Native { return IntVal(arg.(BigFltVal).Int()) },
		func(arg Native) Native { return IntVal(arg.(BigFltVal).Int()).BigInt() },
		func(arg Native) Native { return Uint8Val(arg.(BigFltVal).Uint()) },
		func(arg Native) Native { return Uint16Val(arg.(BigFltVal).Uint()) },
		func(arg Native) Native { return Uint32Val(arg.(BigFltVal).Uint()) },
		func(arg Native) Native { return UintVal(arg.(BigFltVal).Uint()) },
		func(arg Native) Native { return arg.(BigFltVal).Float().Flt32() },
		func(arg Native) Native { return arg.(BigFltVal).Float() },
		func(arg Native) Native { return FltVal(arg.(BigFltVal).Int()).BigFlt() },
		func(arg Native) Native { return (*RatioVal)(arg.(BigFltVal).Ratio()) },
		func(arg Native) Native { return arg.(BigFltVal).Float().Imag().Imag64() },
		func(arg Native) Native { return arg.(BigFltVal).Float().Imag() },
		func(arg Native) Native {
			if arg.(BigFltVal).Int() > 0 {
				return TimeVal(time.Now())
			}
			return TimeVal{}
		},
		func(arg Native) Native { return DuraVal(arg.(BigFltVal).Int()) },
		func(arg Native) Native { return ByteVal(arg.(BigFltVal).Int()) },
		func(arg Native) Native { return RuneVal(UintVal(arg.(BigFltVal).Int())) },
		func(arg Native) Native { return BitFlag(UintVal(arg.(BigFltVal).Int())) },
		func(arg Native) Native { return StrVal(arg.(BigFltVal).Int().String()) },
		func(arg Native) Native { return StrVal(arg.(BigFltVal).Int().String()).Bytes() },
		func(arg Native) Native {
			if arg.(BoolVal).Bool() {
				return NewError(
					fmt.Errorf(
						"error occured during convertion from uint"))
			}
			return ErrorVal{}
		},
	},

	[]func(arg Native) Native{
		func(arg Native) Native { return NilVal{} },
		func(arg Native) Native {
			if arg.(RatioVal).GoBigInt().Cmp(IntVal(0).BigInt().GoBigInt()) != 0 {
				return BoolVal(true)
			}
			return BoolVal(false)
		},
		func(arg Native) Native { return IntVal(arg.(RatioVal).Int()) },
		func(arg Native) Native { return IntVal(arg.(RatioVal).Int()) },
		func(arg Native) Native { return IntVal(arg.(RatioVal).Int()) },
		func(arg Native) Native { return arg.(RatioVal).Int() },
		func(arg Native) Native { return IntVal(arg.(RatioVal).Int()).BigInt() },
		func(arg Native) Native { return Uint8Val(arg.(RatioVal).Uint()) },
		func(arg Native) Native { return Uint16Val(arg.(RatioVal).Uint()) },
		func(arg Native) Native { return Uint32Val(arg.(RatioVal).Uint()) },
		func(arg Native) Native { return UintVal(arg.(RatioVal).Uint()) },
		func(arg Native) Native { return arg.(RatioVal).Float().Flt32() },
		func(arg Native) Native { return arg.(RatioVal).Float() },
		func(arg Native) Native { return FltVal(arg.(RatioVal).Int()).BigFlt() },
		func(arg Native) Native { return arg.(RatioVal) },
		func(arg Native) Native { return arg.(RatioVal).Float().Imag().Imag64() },
		func(arg Native) Native { return arg.(RatioVal).Float().Imag() },
		func(arg Native) Native {
			if arg.(RatioVal).Int() > 0 {
				return TimeVal(time.Now())
			}
			return TimeVal{}
		},
		func(arg Native) Native { return DuraVal(arg.(RatioVal).Int()) },
		func(arg Native) Native { return ByteVal(arg.(RatioVal).Int()) },
		func(arg Native) Native { return RuneVal(UintVal(arg.(RatioVal).Int())) },
		func(arg Native) Native { return BitFlag(UintVal(arg.(RatioVal).Int())) },
		func(arg Native) Native { return StrVal(arg.(RatioVal).Int().String()) },
		func(arg Native) Native { return StrVal(arg.(RatioVal).Int().String()).Bytes() },
		func(arg Native) Native {
			if arg.(BoolVal).Bool() {
				return NewError(
					fmt.Errorf(
						"error occured during convertion from uint"))
			}
			return ErrorVal{}
		},
	},

	[]func(arg Native) Native{
		func(arg Native) Native { return NilVal{} },
		func(arg Native) Native {
			if arg.(Imag64Val) != Imag64Val(complex64(0)) {
				return BoolVal(true)
			}
			return BoolVal(false)
		},
		func(arg Native) Native { return ImagVal(arg.(Imag64Val)) },
		func(arg Native) Native { return ImagVal(arg.(Imag64Val)) },
		func(arg Native) Native { return ImagVal(arg.(Imag64Val)) },
		func(arg Native) Native { return ImagVal(arg.(Imag64Val)) },
		func(arg Native) Native { return ImagVal(arg.(Imag64Val)).BigInt() },
		func(arg Native) Native { return Uint8Val(ImagVal(arg.(Imag64Val)).Uint()) },
		func(arg Native) Native { return Uint16Val(ImagVal(arg.(Imag64Val)).Uint()) },
		func(arg Native) Native { return Uint32Val(ImagVal(arg.(Imag64Val)).Uint()) },
		func(arg Native) Native { return UintVal(ImagVal(arg.(Imag64Val)).Uint()) },
		func(arg Native) Native { return Flt32Val(ImagVal(arg.(Imag64Val)).Float()) },
		func(arg Native) Native { return FltVal(ImagVal(arg.(Imag64Val)).Float()) },
		func(arg Native) Native { return FltVal(ImagVal(arg.(Imag64Val)).Float()).BigFlt() },
		func(arg Native) Native { return ImagVal(arg.(Imag64Val)).Float().Ratio() },
		func(arg Native) Native { return arg.(Imag64Val) },
		func(arg Native) Native { return ImagVal(arg.(Imag64Val)) },
		func(arg Native) Native {
			if ImagVal(arg.(Imag64Val)).Int() > 0 {
				return TimeVal(time.Now())
			}
			return TimeVal{}
		},
		func(arg Native) Native { return DuraVal(ImagVal(arg.(Imag64Val)).Int()) },
		func(arg Native) Native { return DuraVal(ImagVal(arg.(Imag64Val)).Int()) },
		func(arg Native) Native { return RuneVal(ImagVal(arg.(Imag64Val)).Int()) },
		func(arg Native) Native { return BitFlag(ImagVal(arg.(Imag64Val)).Int()) },
		func(arg Native) Native { return StrVal(ImagVal(arg.(Imag64Val)).Int().String()) },
		func(arg Native) Native { return StrVal(ImagVal(arg.(Imag64Val)).Int().String()).Bytes() },
		func(arg Native) Native {
			if arg.(BoolVal).Bool() {
				return NewError(
					fmt.Errorf(
						"error occured during convertion from uint"))
			}
			return ErrorVal{}
		},
	},

	[]func(arg Native) Native{
		func(arg Native) Native { return NilVal{} },
		func(arg Native) Native {
			if arg.(ImagVal) != ImagVal(complex128(0)) {
				return BoolVal(true)
			}
			return BoolVal(false)
		},
		func(arg Native) Native { return IntVal(arg.(ImagVal).Int()) },
		func(arg Native) Native { return IntVal(arg.(ImagVal).Int()) },
		func(arg Native) Native { return IntVal(arg.(ImagVal).Int()) },
		func(arg Native) Native { return arg.(ImagVal).Int() },
		func(arg Native) Native { return IntVal(arg.(ImagVal).Int()).BigInt() },
		func(arg Native) Native { return Uint8Val(arg.(ImagVal).Uint()) },
		func(arg Native) Native { return Uint16Val(arg.(ImagVal).Uint()) },
		func(arg Native) Native { return Uint32Val(arg.(ImagVal).Uint()) },
		func(arg Native) Native { return UintVal(arg.(ImagVal).Uint()) },
		func(arg Native) Native { return arg.(ImagVal).Float().Flt32() },
		func(arg Native) Native { return arg.(ImagVal).Float() },
		func(arg Native) Native { return FltVal(arg.(ImagVal).Int()).BigFlt() },
		func(arg Native) Native { return arg.(ImagVal) },
		func(arg Native) Native { return arg.(ImagVal).Float().Imag().Imag64() },
		func(arg Native) Native { return arg.(ImagVal).Float().Imag() },
		func(arg Native) Native {
			if arg.(ImagVal).Int() > 0 {
				return TimeVal(time.Now())
			}
			return TimeVal{}
		},
		func(arg Native) Native { return DuraVal(arg.(ImagVal).Int()) },
		func(arg Native) Native { return ByteVal(arg.(ImagVal).Int()) },
		func(arg Native) Native { return RuneVal(UintVal(arg.(ImagVal).Int())) },
		func(arg Native) Native { return BitFlag(UintVal(arg.(ImagVal).Int())) },
		func(arg Native) Native { return StrVal(arg.(ImagVal).Int().String()) },
		func(arg Native) Native { return StrVal(arg.(ImagVal).Int().String()).Bytes() },
		func(arg Native) Native {
			if arg.(BoolVal).Bool() {
				return NewError(
					fmt.Errorf(
						"error occured during convertion from uint"))
			}
			return ErrorVal{}
		},
	},

	[]func(arg Native) Native{
		func(arg Native) Native { return NilVal{} },
		func(arg Native) Native {
			if arg.(TimeVal).Time().Before(time.Now()) {
				return BoolVal(true)
			}
			return BoolVal(false)
		},
		func(arg Native) Native { return IntVal(arg.(TimeVal).Int()) },
		func(arg Native) Native { return IntVal(arg.(TimeVal).Int()) },
		func(arg Native) Native { return IntVal(arg.(TimeVal).Int()) },
		func(arg Native) Native { return arg.(TimeVal).Int() },
		func(arg Native) Native { return IntVal(arg.(TimeVal).Int()).BigInt() },
		func(arg Native) Native { return Uint8Val(arg.(TimeVal).Uint()) },
		func(arg Native) Native { return Uint16Val(arg.(TimeVal).Uint()) },
		func(arg Native) Native { return Uint32Val(arg.(TimeVal).Uint()) },
		func(arg Native) Native { return UintVal(arg.(TimeVal).Uint()) },
		func(arg Native) Native { return arg.(TimeVal).Float().Flt32() },
		func(arg Native) Native { return arg.(TimeVal).Float() },
		func(arg Native) Native { return FltVal(arg.(TimeVal).Int()).BigFlt() },
		func(arg Native) Native { return arg.(TimeVal).Ratio() },
		func(arg Native) Native { return Imag64Val(arg.(TimeVal).Imag()) },
		func(arg Native) Native { return arg.(TimeVal).Imag() },
		func(arg Native) Native { return arg.(TimeVal) },
		func(arg Native) Native {
			if time.Now().Before(arg.(TimeVal).Time()) {
				return DuraVal(arg.(TimeVal).Time().Sub(time.Now()))
			}
			return DuraVal(time.Now().Sub(arg.(TimeVal).Time()))
		},
		func(arg Native) Native { return ByteVal([]byte(arg.(TimeVal).String())[0]) },
		func(arg Native) Native { return RuneVal([]rune(arg.(TimeVal).String())[0]) },
		func(arg Native) Native { return BitFlag(UintVal(arg.(TimeVal).Int())) },
		func(arg Native) Native { return StrVal(arg.(TimeVal).String()) },
		func(arg Native) Native { return BytesVal([]byte(arg.(TimeVal).String())) },
		func(arg Native) Native {
			if arg.(BoolVal).Bool() {
				return NewError(
					fmt.Errorf(
						"error occured during convertion from uint"))
			}
			return ErrorVal{}
		},
	},

	[]func(arg Native) Native{
		func(arg Native) Native { return NilVal{} },
		func(arg Native) Native {
			if arg.(DuraVal) > 0 {
				return BoolVal(true)
			}
			return BoolVal(false)
		},
		func(arg Native) Native { return IntVal(arg.(DuraVal).Int()) },
		func(arg Native) Native { return IntVal(arg.(DuraVal).Int()) },
		func(arg Native) Native { return IntVal(arg.(DuraVal).Int()) },
		func(arg Native) Native { return arg.(DuraVal).Int() },
		func(arg Native) Native { return IntVal(arg.(DuraVal).Int()).BigInt() },
		func(arg Native) Native { return Uint8Val(arg.(DuraVal).Uint()) },
		func(arg Native) Native { return Uint16Val(arg.(DuraVal).Uint()) },
		func(arg Native) Native { return Uint32Val(arg.(DuraVal).Uint()) },
		func(arg Native) Native { return UintVal(arg.(DuraVal).Uint()) },
		func(arg Native) Native { return arg.(DuraVal).Float().Flt32() },
		func(arg Native) Native { return arg.(DuraVal).Float() },
		func(arg Native) Native { return FltVal(arg.(DuraVal).Int()).BigFlt() },
		func(arg Native) Native { return arg.(DuraVal).Ratio() },
		func(arg Native) Native { return Imag64Val(arg.(DuraVal).Imag()) },
		func(arg Native) Native { return arg.(DuraVal).Imag() },
		func(arg Native) Native {
			if arg.(DuraVal).Int() > 0 {
				return TimeVal(time.Now())
			}
			return TimeVal{}
		},
		func(arg Native) Native { return arg.(DuraVal) },
		func(arg Native) Native { return ByteVal([]byte(arg.(DuraVal).String())[0]) },
		func(arg Native) Native { return RuneVal([]rune(arg.(DuraVal).String())[0]) },
		func(arg Native) Native { return BitFlag(UintVal(arg.(DuraVal).Int())) },
		func(arg Native) Native { return StrVal(arg.(DuraVal).String()) },
		func(arg Native) Native { return BytesVal([]byte(arg.(DuraVal).String())) },
		func(arg Native) Native {
			if arg.(BoolVal).Bool() {
				return NewError(
					fmt.Errorf(
						"error occured during convertion from uint"))
			}
			return ErrorVal{}
		},
	},

	[]func(arg Native) Native{
		func(arg Native) Native { return NilVal{} },
		func(arg Native) Native {
			if arg.(ByteVal).GoByte() > byte(0) {
				return BoolVal(true)
			}
			return BoolVal(false)
		},
		func(arg Native) Native { return IntVal(arg.(ByteVal).Int()) },
		func(arg Native) Native { return IntVal(arg.(ByteVal).Int()) },
		func(arg Native) Native { return IntVal(arg.(ByteVal).Int()) },
		func(arg Native) Native { return arg.(ByteVal).Int() },
		func(arg Native) Native { return IntVal(arg.(ByteVal).Int()).BigInt() },
		func(arg Native) Native { return Uint8Val(arg.(ByteVal).Uint()) },
		func(arg Native) Native { return Uint16Val(arg.(ByteVal).Uint()) },
		func(arg Native) Native { return Uint32Val(arg.(ByteVal).Uint()) },
		func(arg Native) Native { return UintVal(arg.(ByteVal).Uint()) },
		func(arg Native) Native { return arg.(ByteVal).Float().Flt32() },
		func(arg Native) Native { return arg.(ByteVal).Float() },
		func(arg Native) Native { return FltVal(arg.(ByteVal).Int()).BigFlt() },
		func(arg Native) Native { return arg.(ByteVal).Ratio() },
		func(arg Native) Native { return Imag64Val(arg.(ByteVal).Imag()) },
		func(arg Native) Native { return arg.(ByteVal).Imag() },
		func(arg Native) Native {
			if arg.(ByteVal).Int() > 0 {
				return TimeVal(time.Now())
			}
			return TimeVal{}
		},
		func(arg Native) Native { return arg.(ByteVal) },
		func(arg Native) Native { return arg.(ByteVal) },
		func(arg Native) Native { return RuneVal(rune(arg.(ByteVal))) },
		func(arg Native) Native { return BitFlag(UintVal(arg.(ByteVal))) },
		func(arg Native) Native { return StrVal(string(arg.(ByteVal))) },
		func(arg Native) Native { return BytesVal([]byte{arg.(ByteVal).GoByte()}) },
		func(arg Native) Native {
			if arg.(BoolVal).Bool() {
				return NewError(
					fmt.Errorf(
						"error occured during convertion from uint"))
			}
			return ErrorVal{}
		},
	},

	[]func(arg Native) Native{
		func(arg Native) Native { return NilVal{} },
		func(arg Native) Native {
			if rune(arg.(RuneVal)) > rune(0) {
				return BoolVal(true)
			}
			return BoolVal(false)
		},
		func(arg Native) Native { return IntVal(int(arg.(RuneVal))) },
		func(arg Native) Native { return IntVal(int(arg.(RuneVal))) },
		func(arg Native) Native { return IntVal(int(arg.(RuneVal))) },
		func(arg Native) Native { return IntVal(int(arg.(RuneVal))) },
		func(arg Native) Native { return IntVal(int(arg.(RuneVal))).BigInt() },
		func(arg Native) Native { return Uint8Val(uint(arg.(RuneVal))) },
		func(arg Native) Native { return Uint16Val(uint(arg.(RuneVal))) },
		func(arg Native) Native { return Uint32Val(uint(arg.(RuneVal))) },
		func(arg Native) Native { return UintVal(uint(arg.(RuneVal))) },
		func(arg Native) Native { return FltVal(float64(arg.(RuneVal))).Flt32() },
		func(arg Native) Native { return FltVal(arg.(RuneVal)) },
		func(arg Native) Native { return FltVal(float64(arg.(RuneVal))).BigFlt() },
		func(arg Native) Native { return IntVal(int(arg.(RuneVal))).Ratio() },
		func(arg Native) Native { return Imag64Val(IntVal(int(arg.(RuneVal))).Imag()) },
		func(arg Native) Native { return IntVal(int(arg.(RuneVal))).Imag() },
		func(arg Native) Native {
			if int(arg.(RuneVal)) > 0 {
				return TimeVal(time.Now())
			}
			return TimeVal{}
		},
		func(arg Native) Native { return arg.(RuneVal) },
		func(arg Native) Native { return arg.(RuneVal) },
		func(arg Native) Native { return RuneVal(rune(arg.(RuneVal))) },
		func(arg Native) Native { return BitFlag(UintVal(arg.(RuneVal))) },
		func(arg Native) Native { return StrVal(string(arg.(RuneVal))) },
		func(arg Native) Native { return BytesVal([]byte{byte(rune(arg.(RuneVal)))}) },
		func(arg Native) Native {
			if arg.(BoolVal).Bool() {
				return NewError(
					fmt.Errorf(
						"error occured during convertion from uint"))
			}
			return ErrorVal{}
		},
	},

	[]func(arg Native) Native{
		func(arg Native) Native { return NilVal{} },
		func(arg Native) Native {
			if rune(arg.(BitFlag)) > rune(0) {
				return BoolVal(true)
			}
			return BoolVal(false)
		},
		func(arg Native) Native { return IntVal(int(arg.(BitFlag))) },
		func(arg Native) Native { return IntVal(int(arg.(BitFlag))) },
		func(arg Native) Native { return IntVal(int(arg.(BitFlag))) },
		func(arg Native) Native { return IntVal(int(arg.(BitFlag))) },
		func(arg Native) Native { return IntVal(int(arg.(BitFlag))).BigInt() },
		func(arg Native) Native { return Uint8Val(uint(arg.(BitFlag))) },
		func(arg Native) Native { return Uint16Val(uint(arg.(BitFlag))) },
		func(arg Native) Native { return Uint32Val(uint(arg.(BitFlag))) },
		func(arg Native) Native { return UintVal(uint(arg.(BitFlag))) },
		func(arg Native) Native { return FltVal(float64(arg.(BitFlag))).Flt32() },
		func(arg Native) Native { return FltVal(arg.(BitFlag)) },
		func(arg Native) Native { return FltVal(float64(arg.(BitFlag))).BigFlt() },
		func(arg Native) Native { return IntVal(int(arg.(BitFlag))).Ratio() },
		func(arg Native) Native { return Imag64Val(IntVal(int(arg.(BitFlag))).Imag()) },
		func(arg Native) Native { return IntVal(int(arg.(BitFlag))).Imag() },
		func(arg Native) Native {
			if int(arg.(BitFlag)) > 0 {
				return TimeVal(time.Now())
			}
			return TimeVal{}
		},
		func(arg Native) Native { return arg.(BitFlag) },
		func(arg Native) Native { return arg.(BitFlag) },
		func(arg Native) Native { return RuneVal(rune(arg.(BitFlag))) },
		func(arg Native) Native { return BitFlag(UintVal(arg.(BitFlag))) },
		func(arg Native) Native { return StrVal(string(arg.(BitFlag))) },
		func(arg Native) Native { return BytesVal([]byte{byte(rune(arg.(BitFlag)))}) },
		func(arg Native) Native {
			if arg.(BoolVal).Bool() {
				return NewError(
					fmt.Errorf(
						"error occured during convertion from uint"))
			}
			return ErrorVal{}
		},
	},

	[]func(arg Native) Native{
		func(arg Native) Native { return NilVal{} },
		func(arg Native) Native { return arg.(StrVal).ReadBoolVal() },
		func(arg Native) Native {
			if i := arg.(StrVal).ReadIntVal(); i.Type().Match(Int) {
				return Int8Val(i.(IntVal).Int())
			}
			return NewNil()
		},
		func(arg Native) Native {
			if i := arg.(StrVal).ReadIntVal(); i.Type().Match(Int) {
				return Int16Val(i.(IntVal).Int())
			}
			return NewNil()
		},
		func(arg Native) Native {
			if i := arg.(StrVal).ReadIntVal(); i.Type().Match(Int) {
				return Int32Val(i.(IntVal).Int())
			}
			return NewNil()
		},
		func(arg Native) Native {
			if i := arg.(StrVal).ReadIntVal(); i.Type().Match(Int) {
				return IntVal(i.(IntVal).Int())
			}
			return NewNil()
		},
		func(arg Native) Native {
			if i := arg.(StrVal).ReadIntVal(); i.Type().Match(Int) {
				return (*BigIntVal)(big.NewInt(int64(i.(IntVal))))
			}
			return NewNil()
		},
		func(arg Native) Native {
			if i := arg.(StrVal).ReadUintVal(); i.Type().Match(Uint) {
				return Uint8Val(i.(UintVal).Uint())
			}
			return NewNil()
		},
		func(arg Native) Native {
			if i := arg.(StrVal).ReadUintVal(); i.Type().Match(Uint) {
				return Uint16Val(i.(UintVal).Uint())
			}
			return NewNil()
		},
		func(arg Native) Native {
			if i := arg.(StrVal).ReadUintVal(); i.Type().Match(Uint) {
				return Uint32Val(i.(UintVal).Uint())
			}
			return NewNil()
		},
		func(arg Native) Native {
			if i := arg.(StrVal).ReadUintVal(); i.Type().Match(Uint) {
				return UintVal(i.(UintVal).Uint())
			}
			return NewNil()
		},
		func(arg Native) Native {
			if i := arg.(StrVal).ReadFloatVal(); i.Type().Match(Float) {
				return Flt32Val(i.(FltVal).Float())
			}
			return NewNil()
		},
		func(arg Native) Native {
			if i := arg.(StrVal).ReadFloatVal(); i.Type().Match(Float) {
				return (*BigFltVal)(big.NewFloat(float64(i.(FltVal))))
			}
			return NewNil()
		},
		func(arg Native) Native {
			if i := arg.(StrVal).ReadFloatVal(); i.Type().Match(Float) {
				return (*BigFltVal)(big.NewFloat(float64(i.(FltVal))))
			}
			return NewNil()
		},
		func(arg Native) Native { return IntVal(int(arg.(BitFlag))).Ratio() },
		func(arg Native) Native { return Imag64Val(IntVal(int(arg.(BitFlag))).Imag()) },
		func(arg Native) Native { return IntVal(int(arg.(BitFlag))).Imag() },
		func(arg Native) Native {
			if int(arg.(BitFlag)) > 0 {
				return TimeVal(time.Now())
			}
			return TimeVal{}
		},
		func(arg Native) Native { return arg.(BitFlag) },
		func(arg Native) Native { return ByteVal([]byte(string(arg.(StrVal)))[0]) },
		func(arg Native) Native { return RuneVal([]rune(string(arg.(StrVal)))[0]) },
		func(arg Native) Native { return RuneVal([]rune(string(arg.(StrVal)))[0]) },
		func(arg Native) Native { return arg.(StrVal) },
		func(arg Native) Native { return BytesVal([]byte(string(arg.(StrVal)))) },
		func(arg Native) Native {
			return NewError(
				fmt.Errorf(
					"error occured during convertion from uint"))
			return ErrorVal{}
		},
	},

	[]func(arg Native) Native{
		func(Native) Native { return NilVal{} },
		func(Native) Native { return BoolVal(false) },
		func(Native) Native { return Int8Val(0) },
		func(Native) Native { return Int16Val(0) },
		func(Native) Native { return Int32Val(0) },
		func(Native) Native { return IntVal(0) },
		func(Native) Native { return IntVal(0).BigInt() },
		func(Native) Native { return Uint8Val(0) },
		func(Native) Native { return Uint16Val(0) },
		func(Native) Native { return Uint32Val(0) },
		func(Native) Native { return UintVal(0) },
		func(Native) Native { return Flt32Val(0.0) },
		func(Native) Native { return FltVal(0.0) },
		func(Native) Native { return FltVal(0.0).BigFlt() },
		func(Native) Native { return IntVal(0).Ratio() },
		func(Native) Native { return IntVal(0).Imag().Imag64() },
		func(Native) Native { return IntVal(0).Imag() },
		func(Native) Native { return TimeVal{} },
		func(arg Native) Native { return DuraVal(0) },
		func(arg Native) Native { return ByteVal(0) },
		func(arg Native) Native { return RuneVal(0) },
		func(arg Native) Native { return BitFlag(0) },
		func(arg Native) Native { return StrVal("") },
		func(arg Native) Native { return BytesVal{} },
		func(arg Native) Native { return ErrorVal{} },
	},
}

Functions

func ElemEmpty 

func ElemEmpty(d Native) bool

func FlagCount 

func FlagCount(t Typed) int

func FlagLeast 

func FlagLeast(t Typed) int

func FlagLength 

func FlagLength(t Typed) int

func FlagMatch 

func FlagMatch(t Typed, v Typed) bool

func FlagMost 

func FlagMost(t Typed) int

func SliceAll 

func SliceAll(c DataSlice, fn func(i int, d Native) bool) bool

func SliceAny 

func SliceAny(c DataSlice, fn func(i int, d Native) bool) bool

func SliceClear 

func SliceClear(s DataSlice)

func SliceDeCap 

func SliceDeCap(s DataSlice) (h Native, t DataSlice)

func SliceEmpty 

func SliceEmpty(s DataSlice) bool

func SliceLen 

func SliceLen(s DataSlice) int

func SliceNext 

func SliceNext(s DataSlice) (v Native, i DataSlice)

ITERATOR

func SlicePop 

func SlicePop(s DataSlice) (Native, DataSlice)

func SlicePull 

func SlicePull(s DataSlice) (Native, DataSlice)

func SliceSplit 

func SliceSplit(s DataSlice, i int) (DataSlice, DataSlice)

func StringBitFlag 

func StringBitFlag(v BitFlag) string

func StringChainTable 

func StringChainTable(v ...[]Native) string

func StringSlice 

func StringSlice(sep, ldelim, rdelim string, s ...Native) string

stringer for ordered chains, without any further specification.

Types

type BigFltVal 

type BigFltVal big.Float

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (BigFltVal) Add 

func (v BigFltVal) Add(arg BigFltVal) BigFltVal

operators

func (BigFltVal) BigFlt 

func (v BigFltVal) BigFlt() *BigFltVal

func (BigFltVal) BigInt 

func (v BigFltVal) BigInt() *BigIntVal

func (BigFltVal) Bool 

func (v BigFltVal) Bool() BoolVal

func (BigFltVal) Cmp 

func (v BigFltVal) Cmp(arg BigFltVal) int

comparators

func (BigFltVal) Copy 

func (v BigFltVal) Copy() Native

func (BigFltVal) Equal 

func (v BigFltVal) Equal(arg BigFltVal) bool

func (BigFltVal) Float 

func (v BigFltVal) Float() FltVal

func (*BigFltVal) Float64 

func (v *BigFltVal) Float64() int64

/ BIG FLOAT VALUE

func (BigFltVal) GoBigFlt 

func (v BigFltVal) GoBigFlt() *big.Float

func (BigFltVal) GoBigInt 

func (v BigFltVal) GoBigInt() *big.Int

func (BigFltVal) GoFlt 

func (v BigFltVal) GoFlt() float64

func (BigFltVal) GoImag 

func (v BigFltVal) GoImag() complex128

func (BigFltVal) GoInt 

func (v BigFltVal) GoInt() int

func (BigFltVal) GoRat 

func (v BigFltVal) GoRat() *big.Rat

func (BigFltVal) GoUint 

func (v BigFltVal) GoUint() uint

func (BigFltVal) Greater 

func (v BigFltVal) Greater(arg BigFltVal) bool

func (BigFltVal) Ident 

func (v BigFltVal) Ident() BigFltVal

func (BigFltVal) Idx 

func (v BigFltVal) Idx() int

func (BigFltVal) Imag 

func (v BigFltVal) Imag() ImagVal

func (BigFltVal) Int 

func (v BigFltVal) Int() IntVal

func (BigFltVal) Lesser 

func (v BigFltVal) Lesser(arg BigFltVal) bool

func (BigFltVal) MarshalBinary 

func (v BigFltVal) MarshalBinary() ([]byte, error)

func (BigFltVal) Multipy 

func (v BigFltVal) Multipy(arg BigFltVal) BigFltVal

func (BigFltVal) Null 

func (v BigFltVal) Null() BigFltVal

func (BigFltVal) Quotient 

func (v BigFltVal) Quotient(arg BigFltVal) BigFltVal

func (BigFltVal) Ratio 

func (v BigFltVal) Ratio() *RatioVal

func (BigFltVal) String 

func (v BigFltVal) String() string

func (BigFltVal) Substract 

func (v BigFltVal) Substract(arg BigFltVal) BigFltVal

func (BigFltVal) Type 

func (v BigFltVal) Type() TyNat

func (BigFltVal) Uint 

func (v BigFltVal) Uint() UintVal

type BigFltVec 

type BigFltVec []*big.Float

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (BigFltVec) Copy 

func (v BigFltVec) Copy() Native

func (BigFltVec) Empty 

func (v BigFltVec) Empty() bool

func (BigFltVec) Get 

func (v BigFltVec) Get(i Native) Native

func (BigFltVec) GetInt 

func (v BigFltVec) GetInt(i int) Native

func (BigFltVec) Len 

func (v BigFltVec) Len() int

func (BigFltVec) Native 

func (v BigFltVec) Native(i int) *big.Float

func (BigFltVec) Null 

func (v BigFltVec) Null() Native

func (BigFltVec) Range 

func (v BigFltVec) Range(i, j int) Sliceable

func (BigFltVec) RangeNative 

func (v BigFltVec) RangeNative(i, j int) []*big.Float

func (BigFltVec) Slice 

func (v BigFltVec) Slice() []Native

func (BigFltVec) String 

func (v BigFltVec) String() string

func (BigFltVec) Type 

func (v BigFltVec) Type() TyNat

func (BigFltVec) TypeElem 

func (v BigFltVec) TypeElem() Typed

type BigIntVal 

type BigIntVal big.Int

COMPOSED GOLANG TYPES

func (BigIntVal) Add 

func (v BigIntVal) Add(arg BigIntVal) BigIntVal

operators

func (BigIntVal) And 

func (v BigIntVal) And(arg BigIntVal) BigIntVal

func (BigIntVal) AndNot 

func (v BigIntVal) AndNot(arg BigIntVal) BigIntVal

func (BigIntVal) BigFlt 

func (v BigIntVal) BigFlt() *BigFltVal

func (BigIntVal) BigInt 

func (v BigIntVal) BigInt() *BigIntVal

func (BigIntVal) Bool 

func (v BigIntVal) Bool() BoolVal

func (BigIntVal) Cmp 

func (v BigIntVal) Cmp(arg BigIntVal) int

comparators

func (BigIntVal) Copy 

func (v BigIntVal) Copy() Native

func (BigIntVal) Equal 

func (v BigIntVal) Equal(arg BigIntVal) bool

func (BigIntVal) Float 

func (v BigIntVal) Float() FltVal

func (BigIntVal) GoBigFlt 

func (v BigIntVal) GoBigFlt() *big.Float

func (BigIntVal) GoBigInt 

func (v BigIntVal) GoBigInt() *big.Int

func (BigIntVal) GoFlt 

func (v BigIntVal) GoFlt() float64

func (BigIntVal) GoImag 

func (v BigIntVal) GoImag() complex128

func (BigIntVal) GoInt 

func (v BigIntVal) GoInt() int

func (BigIntVal) GoRat 

func (v BigIntVal) GoRat() *big.Rat

func (BigIntVal) GoUint 

func (v BigIntVal) GoUint() uint

func (BigIntVal) Greater 

func (v BigIntVal) Greater(arg BigIntVal) bool

func (BigIntVal) Ident 

func (v BigIntVal) Ident() BigIntVal

func (BigIntVal) Idx 

func (v BigIntVal) Idx() int

func (BigIntVal) Imag 

func (v BigIntVal) Imag() ImagVal

func (BigIntVal) Int 

func (v BigIntVal) Int() IntVal

func (*BigIntVal) Int64 

func (v *BigIntVal) Int64() int64

/ BIG INT VALUE

func (BigIntVal) Lesser 

func (v BigIntVal) Lesser(arg BigIntVal) bool

func (BigIntVal) MarshalBinary 

func (v BigIntVal) MarshalBinary() ([]byte, error)

func (BigIntVal) Multipy 

func (v BigIntVal) Multipy(arg BigIntVal) BigIntVal

func (BigIntVal) Not 

func (v BigIntVal) Not() BigIntVal

func (BigIntVal) Null 

func (v BigIntVal) Null() BigIntVal

func (BigIntVal) Or 

func (v BigIntVal) Or(arg BigIntVal) BigIntVal

func (BigIntVal) Power 

func (v BigIntVal) Power(arg BigIntVal) BigIntVal

func (BigIntVal) Quotient 

func (v BigIntVal) Quotient(arg BigIntVal) BigIntVal

func (BigIntVal) String 

func (v BigIntVal) String() string

func (BigIntVal) Substract 

func (v BigIntVal) Substract(arg BigIntVal) BigIntVal

func (BigIntVal) Type 

func (v BigIntVal) Type() TyNat

func (BigIntVal) Uint 

func (v BigIntVal) Uint() UintVal

func (BigIntVal) Xor 

func (v BigIntVal) Xor(arg BigIntVal) BigIntVal

type BigIntVec 

type BigIntVec []*big.Int

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (BigIntVec) Copy 

func (v BigIntVec) Copy() Native

func (BigIntVec) Empty 

func (v BigIntVec) Empty() bool

func (BigIntVec) Get 

func (v BigIntVec) Get(i Native) Native

func (BigIntVec) GetInt 

func (v BigIntVec) GetInt(i int) Native

func (BigIntVec) Len 

func (v BigIntVec) Len() int

func (BigIntVec) Native 

func (v BigIntVec) Native(i int) *big.Int

func (BigIntVec) Null 

func (v BigIntVec) Null() Native

func (BigIntVec) Range 

func (v BigIntVec) Range(i, j int) Sliceable

func (BigIntVec) RangeNative 

func (v BigIntVec) RangeNative(i, j int) []*big.Int

func (BigIntVec) Slice 

func (v BigIntVec) Slice() []Native

func (BigIntVec) String 

func (v BigIntVec) String() string

func (BigIntVec) Type 

func (v BigIntVec) Type() TyNat

func (BigIntVec) TypeElem 

func (v BigIntVec) TypeElem() Typed

type BinaryMarshaler 

type BinaryMarshaler interface {
	MarshalBinary() ([]byte, error)
}

type BitFlag 

type BitFlag uint

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func FlagConcat 

func FlagConcat(t Typed, v Typed) BitFlag

func FlagHigh 

func FlagHigh(t Typed) BitFlag

func FlagMask 

func FlagMask(t Typed, v Typed) BitFlag

func FlagReverse 

func FlagReverse(t Typed) BitFlag

func FlagRotate 

func FlagRotate(t Typed, n int) BitFlag

func FlagToggle 

func FlagToggle(t Typed, v Typed) BitFlag

func SliceAttrType 

func SliceAttrType(s DataSlice) BitFlag

func (BitFlag) Concat 

func (v BitFlag) Concat(f Typed) Typed

func (BitFlag) Copy 

func (v BitFlag) Copy() Native

func (BitFlag) Count 

func (v BitFlag) Count() int

func (BitFlag) Decompose 

func (v BitFlag) Decompose() []Typed

func (BitFlag) Flag 

func (v BitFlag) Flag() BitFlag

func (BitFlag) High 

func (v BitFlag) High(f Typed) Typed

func (BitFlag) Ident 

func (v BitFlag) Ident() BitFlag

func (BitFlag) Index 

func (v BitFlag) Index() int

func (BitFlag) Int 

func (v BitFlag) Int() IntVal

func (BitFlag) Kind 

func (v BitFlag) Kind() Uint8Val

// BOUND TYPE FLAG METHODS ////

func (BitFlag) Least 

func (v BitFlag) Least() int

func (BitFlag) Len 

func (v BitFlag) Len() int

func (BitFlag) Low 

func (v BitFlag) Low(f Typed) Typed

func (BitFlag) MarshalBinary 

func (v BitFlag) MarshalBinary() ([]byte, error)

provide serialization for all native types.

func (BitFlag) Mask 

func (v BitFlag) Mask(f Typed) Typed

func (BitFlag) Match 

func (v BitFlag) Match(f Typed) bool

func (BitFlag) Most 

func (v BitFlag) Most() int

func (BitFlag) Null 

func (v BitFlag) Null() BitFlag

func (BitFlag) Reverse 

func (v BitFlag) Reverse() Typed

func (BitFlag) Rotate 

func (v BitFlag) Rotate(n int) Typed

func (BitFlag) String 

func (v BitFlag) String() string

serializes bitflag to a string representation of the bitwise OR operation on a list of principle flags, that yielded this flag

func (BitFlag) Toggle 

func (v BitFlag) Toggle(f Typed) Typed

func (BitFlag) Type 

func (v BitFlag) Type() TyNat

/ bind the corresponding Type Method to every type

func (BitFlag) TypeName 

func (v BitFlag) TypeName() string

func (BitFlag) Uint 

func (v BitFlag) Uint() UintVal

type BoolVal 

type BoolVal bool

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (BoolVal) And 

func (v BoolVal) And(arg BoolVal) BoolVal

func (BoolVal) BigFlt 

func (v BoolVal) BigFlt() *BigFltVal

func (BoolVal) BigInt 

func (v BoolVal) BigInt() *BigIntVal

func (BoolVal) Bool 

func (v BoolVal) Bool() bool

func (BoolVal) Copy 

func (v BoolVal) Copy() Native

func (BoolVal) Equal 

func (v BoolVal) Equal(arg BoolVal) bool

comparators

func (BoolVal) Float 

func (v BoolVal) Float() FltVal

func (BoolVal) GoBigFlt 

func (v BoolVal) GoBigFlt() *big.Float

func (BoolVal) GoBigInt 

func (v BoolVal) GoBigInt() *big.Int

func (BoolVal) GoFlt 

func (v BoolVal) GoFlt() float64

func (BoolVal) GoImag 

func (v BoolVal) GoImag() complex128

func (BoolVal) GoInt 

func (v BoolVal) GoInt() int

func (BoolVal) GoRat 

func (v BoolVal) GoRat() *big.Rat

BOOL VALUE

func (BoolVal) GoUint 

func (v BoolVal) GoUint() uint

func (BoolVal) Greater 

func (v BoolVal) Greater(arg BoolVal) bool

func (BoolVal) Ident 

func (v BoolVal) Ident() BoolVal

func (BoolVal) Idx 

func (v BoolVal) Idx() int

func (BoolVal) Imag 

func (v BoolVal) Imag() ImagVal

func (BoolVal) Int 

func (v BoolVal) Int() IntVal

func (BoolVal) IntVal 

func (v BoolVal) IntVal() IntVal

func (BoolVal) Lesser 

func (v BoolVal) Lesser(arg BoolVal) bool

func (BoolVal) MarshalBinary 

func (v BoolVal) MarshalBinary() ([]byte, error)

func (BoolVal) Not 

func (v BoolVal) Not() BoolVal

operators

func (BoolVal) Null 

func (v BoolVal) Null() BoolVal

func (BoolVal) Or 

func (v BoolVal) Or(arg BoolVal) BoolVal

func (BoolVal) Ratio 

func (v BoolVal) Ratio() *RatioVal

func (BoolVal) String 

func (v BoolVal) String() string

func (BoolVal) Type 

func (v BoolVal) Type() TyNat

func (BoolVal) Uint 

func (v BoolVal) Uint() UintVal

func (BoolVal) Unit 

func (v BoolVal) Unit() Native

type BoolVec 

type BoolVec []bool

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (BoolVec) Copy 

func (v BoolVec) Copy() Native

func (BoolVec) Empty 

func (v BoolVec) Empty() bool

func (BoolVec) Get 

func (v BoolVec) Get(i Native) Native

func (BoolVec) GetInt 

func (v BoolVec) GetInt(i int) Native

func (BoolVec) Len 

func (v BoolVec) Len() int

func (BoolVec) Native 

func (v BoolVec) Native(i int) bool

func (BoolVec) Null 

func (v BoolVec) Null() Native

func (BoolVec) Range 

func (v BoolVec) Range(i, j int) Sliceable

func (BoolVec) RangeNative 

func (v BoolVec) RangeNative(i, j int) []bool

func (BoolVec) Slice 

func (v BoolVec) Slice() []Native

func (BoolVec) String 

func (v BoolVec) String() string

func (BoolVec) Type 

func (v BoolVec) Type() TyNat

func (BoolVec) TypeElem 

func (v BoolVec) TypeElem() Typed

type Boolean 

type Boolean interface {
	Bool() BoolVal
	GoBool() bool
}

type ByteVal 

type ByteVal byte

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (ByteVal) And 

func (v ByteVal) And(arg ByteVal) ByteVal

operators

func (ByteVal) AndNot 

func (v ByteVal) AndNot(arg ByteVal) ByteVal

func (ByteVal) BigFlt 

func (v ByteVal) BigFlt() *BigFltVal

func (ByteVal) BigInt 

func (v ByteVal) BigInt() *BigIntVal

func (ByteVal) Bool 

func (v ByteVal) Bool() bool

/ BYTE VALUE

func (ByteVal) Byte 

func (v ByteVal) Byte() ByteVal

func (ByteVal) Bytes 

func (v ByteVal) Bytes() BytesVal

func (ByteVal) Concat 

func (v ByteVal) Concat(arg ByteVal) BytesVal

func (ByteVal) Copy 

func (v ByteVal) Copy() Native

func (ByteVal) Equal 

func (v ByteVal) Equal(arg ByteVal) bool

comparators

func (ByteVal) Float 

func (v ByteVal) Float() FltVal

func (ByteVal) GoBigFlt 

func (v ByteVal) GoBigFlt() *big.Float

func (ByteVal) GoBigInt 

func (v ByteVal) GoBigInt() *big.Int

func (ByteVal) GoByte 

func (v ByteVal) GoByte() byte

func (ByteVal) GoFlt 

func (v ByteVal) GoFlt() float64

func (ByteVal) GoImag 

func (v ByteVal) GoImag() complex128

func (ByteVal) GoInt 

func (v ByteVal) GoInt() int

func (ByteVal) GoRat 

func (v ByteVal) GoRat() *big.Rat

func (ByteVal) GoUint 

func (v ByteVal) GoUint() uint

func (ByteVal) Greater 

func (v ByteVal) Greater(arg ByteVal) bool

func (ByteVal) Ident 

func (v ByteVal) Ident() ByteVal

func (ByteVal) Idx 

func (v ByteVal) Idx() int

func (ByteVal) Imag 

func (v ByteVal) Imag() ImagVal

func (ByteVal) Int 

func (v ByteVal) Int() IntVal

func (ByteVal) Len 

func (v ByteVal) Len() IntVal

func (ByteVal) Lesser 

func (v ByteVal) Lesser(arg ByteVal) bool

func (ByteVal) MarshalBinary 

func (v ByteVal) MarshalBinary() ([]byte, error)

func (ByteVal) Not 

func (v ByteVal) Not() ByteVal

func (ByteVal) Null 

func (v ByteVal) Null() ByteVal

func (ByteVal) Or 

func (v ByteVal) Or(arg ByteVal) ByteVal

func (ByteVal) Ratio 

func (v ByteVal) Ratio() *RatioVal

func (ByteVal) Rune 

func (v ByteVal) Rune() RuneVal

func (ByteVal) String 

func (v ByteVal) String() string

func (ByteVal) Type 

func (v ByteVal) Type() TyNat

func (ByteVal) Uint 

func (v ByteVal) Uint() UintVal

func (ByteVal) Unit 

func (v ByteVal) Unit() Native

func (ByteVal) Xor 

func (v ByteVal) Xor(arg ByteVal) ByteVal

type ByteVec 

type ByteVec []byte

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (ByteVec) Bytes 

func (v ByteVec) Bytes() BytesVal

func (ByteVec) Copy 

func (v ByteVec) Copy() Native

func (*ByteVec) Cut 

func (v *ByteVec) Cut(i, j int)

func (*ByteVec) Delete 

func (v *ByteVec) Delete(i int)

func (ByteVec) Empty 

func (v ByteVec) Empty() bool

func (ByteVec) Get 

func (v ByteVec) Get(i Native) Native

func (ByteVec) GetInt 

func (v ByteVec) GetInt(i int) Native

func (*ByteVec) Insert 

func (v *ByteVec) Insert(i, j int, b byte)

func (*ByteVec) InsertSlice 

func (v *ByteVec) InsertSlice(i, j int, b ...byte)

func (ByteVec) Len 

func (v ByteVec) Len() int

func (ByteVec) Native 

func (v ByteVec) Native(i int) byte

func (ByteVec) Null 

func (v ByteVec) Null() Native

func (ByteVec) Range 

func (v ByteVec) Range(i, j int) Sliceable

func (ByteVec) RangeNative 

func (v ByteVec) RangeNative(i, j int) []byte

func (*ByteVec) Set 

func (v *ByteVec) Set(i int, b byte)

func (ByteVec) Slice 

func (v ByteVec) Slice() []Native

func (ByteVec) String 

func (v ByteVec) String() string

// NATIVE SLICES /////

func (ByteVec) Type 

func (v ByteVec) Type() TyNat

func (ByteVec) TypeElem 

func (v ByteVec) TypeElem() Typed

type BytesVal 

type BytesVal []byte

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (BytesVal) Bool 

func (v BytesVal) Bool() BoolVal

func (BytesVal) ByteBuffer 

func (v BytesVal) ByteBuffer() *bytes.Buffer

func (BytesVal) ByteReader 

func (v BytesVal) ByteReader() io.ByteReader

func (BytesVal) Bytes 

func (v BytesVal) Bytes() ByteVec

func (BytesVal) Concat 

func (v BytesVal) Concat(args ...ByteVal) BytesVal

func (BytesVal) Copy 

func (v BytesVal) Copy() Native

func (BytesVal) GoBytes 

func (v BytesVal) GoBytes() []byte

func (BytesVal) GoRunes 

func (v BytesVal) GoRunes() []rune

func (BytesVal) Ident 

func (v BytesVal) Ident() BytesVal

func (BytesVal) IntNative 

func (v BytesVal) IntNative() Native

func (BytesVal) Len 

func (v BytesVal) Len() IntVal

func (BytesVal) MarshalBinary 

func (v BytesVal) MarshalBinary() ([]byte, error)

func (BytesVal) Null 

func (v BytesVal) Null() BytesVal

func (BytesVal) RuneVec 

func (v BytesVal) RuneVec() RuneVec

func (BytesVal) StrVal 

func (v BytesVal) StrVal() StrVal

func (BytesVal) String 

func (v BytesVal) String() string

/ BYTE SLICE VALUE conversions

func (BytesVal) Type 

func (v BytesVal) Type() TyNat

func (BytesVal) UintNative 

func (v BytesVal) UintNative() Native

func (BytesVal) Unit 

func (v BytesVal) Unit() BytesVal

type BytesVec 

type BytesVec [][]byte

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (BytesVec) Copy 

func (v BytesVec) Copy() Native

func (BytesVec) Empty 

func (v BytesVec) Empty() bool

func (BytesVec) Get 

func (v BytesVec) Get(i Native) Native

func (BytesVec) GetInt 

func (v BytesVec) GetInt(i int) Native

func (BytesVec) Len 

func (v BytesVec) Len() int

func (BytesVec) Native 

func (v BytesVec) Native(i int) []byte

func (BytesVec) Null 

func (v BytesVec) Null() Native

func (BytesVec) Range 

func (v BytesVec) Range(i, j int) Sliceable

func (BytesVec) RangeNative 

func (v BytesVec) RangeNative(i, j int) [][]byte

func (BytesVec) Slice 

func (v BytesVec) Slice() []Native

func (BytesVec) String 

func (v BytesVec) String() string

func (BytesVec) Type 

func (v BytesVec) Type() TyNat

func (BytesVec) TypeElem 

func (v BytesVec) TypeElem() Typed

type Composed 

type Composed interface {
	Native
	Empty() bool //<-- no more nil pointers & 'out of index'!
}

collections are expected nothing more, but to know, if they are empty

type CompoundError 

type CompoundError func() []error

func NewCompoundError 

func NewCompoundError(errs ...error) CompoundError

func (CompoundError) Error 

func (e CompoundError) Error() string

type DataSlice 

type DataSlice []Native

SLICE OF GENERIC VALUES

func NewSlice 

func NewSlice(args ...Native) DataSlice

create slice from typed native instances

func SliceAdd 

func SliceAdd(s DataSlice, v ...Native) DataSlice

FIFO STACK

func SliceAppend 

func SliceAppend(s DataSlice, v ...Native) DataSlice

func SliceCon 

func SliceCon(s DataSlice, v Native) DataSlice

func SliceCut 

func SliceCut(s DataSlice, i, j int) DataSlice

func SliceDelete 

func SliceDelete(s DataSlice, i int) DataSlice

func SliceFilter 

func SliceFilter(c DataSlice, fn func(i int, d Native) bool) DataSlice

func SliceInsert 

func SliceInsert(s DataSlice, i int, v Native) DataSlice

func SliceInsertVector 

func SliceInsertVector(s DataSlice, i int, v ...Native) DataSlice

func SliceMap 

func SliceMap(c DataSlice, fn func(i int, d Native) Native) DataSlice

func SlicePush 

func SlicePush(s DataSlice, v Native) DataSlice

func SlicePut 

func SlicePut(s DataSlice, v Native) DataSlice

LIFO QUEUE

func SliceReverse 

func SliceReverse(c DataSlice) DataSlice

func SliceSet 

func SliceSet(s DataSlice, i int, v Native) DataSlice

MUTABLE SLICE

func SliceSetRev 

func SliceSetRev(s DataSlice, i int, v Native) DataSlice

reversed Get method to mutate elements on stacks and tuples, since their order is reversed for improved performance

func SliceSort 

func SliceSort(c DataSlice, compT TyNat) DataSlice

func SliceSwap 

func SliceSwap(c DataSlice, i, j int) DataSlice

func (DataSlice) Append 

func (c DataSlice) Append(n ...Native)

func (DataSlice) Bottom 

func (s DataSlice) Bottom() (h Native)

yields last element

func (DataSlice) ContainedTypes 

func (c DataSlice) ContainedTypes() BitFlag

func (DataSlice) Copy 

func (c DataSlice) Copy() Native

func (DataSlice) Empty 

func (s DataSlice) Empty() bool

COLLECTION

func (DataSlice) Get 

func (v DataSlice) Get(i Native) Native

func (DataSlice) GetInt 

func (v DataSlice) GetInt(i int) Native

func (DataSlice) Head 

func (s DataSlice) Head() (h Native)

yields first element

func (DataSlice) IdxRev 

func (c DataSlice) IdxRev(i int) int

reversed index to access stacks and tuples, since their order is reversed for improved performance

func (DataSlice) Len 

func (v DataSlice) Len() int

func (DataSlice) Null 

func (c DataSlice) Null() Native

func (DataSlice) Range 

func (v DataSlice) Range(s, e int) Sliceable

func (DataSlice) Search 

func (c DataSlice) Search(comp Native) Native

func (DataSlice) Set 

func (v DataSlice) Set(i Native, d Native)

func (DataSlice) SetInt 

func (v DataSlice) SetInt(i int, d Native)

func (DataSlice) Shift 

func (s DataSlice) Shift() (head Native, tail DataSlice)

func (DataSlice) Slice 

func (v DataSlice) Slice() []Native

SLICE ->

func (DataSlice) Sort 

func (c DataSlice) Sort(compT TyNat)

func (DataSlice) String 

func (v DataSlice) String() string

// DATA SLICES /////

func (DataSlice) Swap 

func (c DataSlice) Swap(i, j int)

func (DataSlice) Tail 

func (s DataSlice) Tail() (c DataSlice)

yields all elements except the first

func (DataSlice) Type 

func (c DataSlice) Type() TyNat

returns type flag by OR concatenating the Slice type to the concatenated type flags of it's members

func (DataSlice) TypeElem 

func (c DataSlice) TypeElem() Typed

type Destructable 

type Destructable interface {
	Clear()
}

garbage collectability

type Discrete 

type Discrete interface {
	GoBytes() []byte
	Unit() Native
}

implemented by types an empty instance is defined for

type DuraVal 

type DuraVal time.Duration

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (DuraVal) BigFlt 

func (v DuraVal) BigFlt() *BigFltVal

func (DuraVal) BigInt 

func (v DuraVal) BigInt() *BigIntVal

func (DuraVal) Bool 

func (v DuraVal) Bool() BoolVal

func (DuraVal) Copy 

func (v DuraVal) Copy() Native

func (DuraVal) Duration 

func (v DuraVal) Duration() time.Duration

func (DuraVal) Equal 

func (v DuraVal) Equal(arg DuraVal) bool

comparators

func (DuraVal) Float 

func (v DuraVal) Float() FltVal

func (DuraVal) GoBigFlt 

func (v DuraVal) GoBigFlt() *big.Float

func (DuraVal) GoBigInt 

func (v DuraVal) GoBigInt() *big.Int

func (DuraVal) GoFlt 

func (v DuraVal) GoFlt() float64

func (DuraVal) GoImag 

func (v DuraVal) GoImag() complex128

func (DuraVal) GoInt 

func (v DuraVal) GoInt() int

func (DuraVal) GoRat 

func (v DuraVal) GoRat() *big.Rat

func (DuraVal) GoUint 

func (v DuraVal) GoUint() uint

func (DuraVal) Greater 

func (v DuraVal) Greater(arg DuraVal) bool

func (DuraVal) Ident 

func (v DuraVal) Ident() DuraVal

func (DuraVal) Idx 

func (v DuraVal) Idx() int

/ DURATION VALUE

func (DuraVal) Imag 

func (v DuraVal) Imag() ImagVal

func (DuraVal) Int 

func (v DuraVal) Int() IntVal

func (DuraVal) IntVal 

func (v DuraVal) IntVal() IntVal

func (DuraVal) Lesser 

func (v DuraVal) Lesser(arg DuraVal) bool

func (DuraVal) MarshalBinary 

func (v DuraVal) MarshalBinary() ([]byte, error)

func (DuraVal) Null 

func (v DuraVal) Null() DuraVal

func (DuraVal) Ratio 

func (v DuraVal) Ratio() *RatioVal

func (DuraVal) String 

func (v DuraVal) String() string

func (DuraVal) Type 

func (v DuraVal) Type() TyNat

func (DuraVal) Uint 

func (v DuraVal) Uint() UintVal

func (DuraVal) UintVal 

func (v DuraVal) UintVal() UintVal

type DuraVec 

type DuraVec []time.Duration

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (DuraVec) Copy 

func (v DuraVec) Copy() Native

func (DuraVec) Empty 

func (v DuraVec) Empty() bool

func (DuraVec) Get 

func (v DuraVec) Get(i Native) Native

func (DuraVec) GetInt 

func (v DuraVec) GetInt(i int) Native

func (DuraVec) Len 

func (v DuraVec) Len() int

func (DuraVec) Native 

func (v DuraVec) Native(i int) time.Duration

func (DuraVec) Null 

func (v DuraVec) Null() Native

func (DuraVec) Range 

func (v DuraVec) Range(i, j int) Sliceable

func (DuraVec) RangeNative 

func (v DuraVec) RangeNative(i, j int) []time.Duration

func (DuraVec) Slice 

func (v DuraVec) Slice() []Native

func (DuraVec) String 

func (v DuraVec) String() string

func (DuraVec) Type 

func (v DuraVec) Type() TyNat

func (DuraVec) TypeElem 

func (v DuraVec) TypeElem() Typed

type ErrorVal 

type ErrorVal struct{ E error }

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func NewError 

func NewError(errs ...error) ErrorVal

func NewErrorFromString 

func NewErrorFromString(str string) ErrorVal

func (ErrorVal) Copy 

func (v ErrorVal) Copy() Native

func (ErrorVal) Error 

func (v ErrorVal) Error() ErrorVal

func (ErrorVal) Ident 

func (v ErrorVal) Ident() ErrorVal

func (ErrorVal) MarshalBinary 

func (v ErrorVal) MarshalBinary() ([]byte, error)

func (ErrorVal) Null 

func (v ErrorVal) Null() ErrorVal

func (ErrorVal) String 

func (v ErrorVal) String() string

func (ErrorVal) Type 

func (v ErrorVal) Type() TyNat

type ErrorVec 

type ErrorVec []error

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (ErrorVec) Copy 

func (v ErrorVec) Copy() Native

func (ErrorVec) Empty 

func (v ErrorVec) Empty() bool

func (ErrorVec) Get 

func (v ErrorVec) Get(i Native) Native

func (ErrorVec) GetInt 

func (v ErrorVec) GetInt(i int) Native

func (ErrorVec) Len 

func (v ErrorVec) Len() int

func (ErrorVec) Native 

func (v ErrorVec) Native(i int) struct{ e error }

func (ErrorVec) Null 

func (v ErrorVec) Null() Native

func (ErrorVec) Range 

func (v ErrorVec) Range(i, j int) Sliceable

func (ErrorVec) RangeNative 

func (v ErrorVec) RangeNative(i, j int) []error

func (ErrorVec) Slice 

func (v ErrorVec) Slice() []Native

func (ErrorVec) String 

func (v ErrorVec) String() string

func (ErrorVec) Type 

func (v ErrorVec) Type() TyNat

func (ErrorVec) TypeElem 

func (v ErrorVec) TypeElem() Typed

type Expression 

type Expression func(...Native) Native

FUNCTION VALUE

func (Expression) Copy 

func (v Expression) Copy() Native

func (Expression) Eval 

func (v Expression) Eval(args ...Native) Native

func (Expression) Ident 

func (v Expression) Ident() Expression

func (Expression) String 

func (v Expression) String() string

func (Expression) Type 

func (v Expression) Type() TyNat

type FlagSet 

type FlagSet []BitFlag

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (FlagSet) Copy 

func (v FlagSet) Copy() Native

func (FlagSet) Empty 

func (v FlagSet) Empty() bool

func (FlagSet) Get 

func (v FlagSet) Get(i Native) Native

func (FlagSet) GetInt 

func (v FlagSet) GetInt(i int) Native

func (FlagSet) Len 

func (v FlagSet) Len() int

func (FlagSet) Native 

func (v FlagSet) Native(i int) BitFlag

func (FlagSet) Null 

func (v FlagSet) Null() Native

func (FlagSet) Range 

func (v FlagSet) Range(i, j int) Sliceable

func (FlagSet) RangeNative 

func (v FlagSet) RangeNative(i, j int) []BitFlag

func (FlagSet) Slice 

func (v FlagSet) Slice() []Native

func (FlagSet) String 

func (v FlagSet) String() string

func (FlagSet) Type 

func (v FlagSet) Type() TyNat

func (FlagSet) TypeElem 

func (v FlagSet) TypeElem() Typed

type FlagSlice 

type FlagSlice []BitFlag

SLICE OF BIT FLAGS

func (FlagSlice) Copy 

func (v FlagSlice) Copy() Native

func (FlagSlice) Flag 

func (v FlagSlice) Flag() TyNat

func (FlagSlice) MarshalBinary 

func (v FlagSlice) MarshalBinary() ([]byte, error)

func (FlagSlice) Null 

func (v FlagSlice) Null() FlagSlice

yields a null value of the methods type

type Flagged 

type Flagged interface {
	Flag() BitFlag
}

type Flt32Val 

type Flt32Val float32

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (Flt32Val) Add 

func (v Flt32Val) Add(arg Flt32Val) Flt32Val

func (Flt32Val) AddR 

func (v Flt32Val) AddR(arg FltVal) FltVal

func (Flt32Val) BigFlt 

func (v Flt32Val) BigFlt() *BigFltVal

func (Flt32Val) BigInt 

func (v Flt32Val) BigInt() *BigIntVal

func (Flt32Val) Bool 

func (v Flt32Val) Bool() BoolVal

func (Flt32Val) Copy 

func (v Flt32Val) Copy() Native

func (Flt32Val) Dec 

func (v Flt32Val) Dec() FltVal

func (Flt32Val) Equal 

func (v Flt32Val) Equal(arg Flt32Val) bool

comparators

func (Flt32Val) EqualR 

func (v Flt32Val) EqualR(arg FltVal) bool

comparators

func (Flt32Val) Float 

func (v Flt32Val) Float() FltVal

func (Flt32Val) Flt32 

func (v Flt32Val) Flt32() Flt32Val

func (Flt32Val) GoBigFlt 

func (v Flt32Val) GoBigFlt() *big.Float

func (Flt32Val) GoBigInt 

func (v Flt32Val) GoBigInt() *big.Int

func (Flt32Val) GoFlt 

func (v Flt32Val) GoFlt() float64

func (Flt32Val) GoImag 

func (v Flt32Val) GoImag() complex128

func (Flt32Val) GoInt 

func (v Flt32Val) GoInt() int

func (Flt32Val) GoRat 

func (v Flt32Val) GoRat() *big.Rat

func (Flt32Val) GoUint 

func (v Flt32Val) GoUint() uint

func (Flt32Val) Greater 

func (v Flt32Val) Greater(arg Flt32Val) bool

func (Flt32Val) GreaterR 

func (v Flt32Val) GreaterR(arg FltVal) bool

func (Flt32Val) Ident 

func (v Flt32Val) Ident() Flt32Val

func (Flt32Val) Idx 

func (v Flt32Val) Idx() int

func (Flt32Val) Imag 

func (v Flt32Val) Imag() ImagVal

func (Flt32Val) Inc 

func (v Flt32Val) Inc() FltVal

operators

func (Flt32Val) Int 

func (v Flt32Val) Int() IntVal

func (Flt32Val) Lesser 

func (v Flt32Val) Lesser(arg Flt32Val) bool

func (Flt32Val) LesserR 

func (v Flt32Val) LesserR(arg FltVal) bool

func (Flt32Val) MarshalBinary 

func (v Flt32Val) MarshalBinary() ([]byte, error)

func (Flt32Val) Multipy 

func (v Flt32Val) Multipy(arg Flt32Val) Flt32Val

func (Flt32Val) MultipyR 

func (v Flt32Val) MultipyR(arg FltVal) FltVal

func (Flt32Val) Negate 

func (v Flt32Val) Negate() Flt32Val

operators

func (Flt32Val) NegateR 

func (v Flt32Val) NegateR() FltVal

func (Flt32Val) Null 

func (v Flt32Val) Null() Flt32Val

func (Flt32Val) Quotient 

func (v Flt32Val) Quotient(arg Flt32Val) Flt32Val

func (Flt32Val) QuotientR 

func (v Flt32Val) QuotientR(arg FltVal) FltVal

func (Flt32Val) Ratio 

func (v Flt32Val) Ratio() *RatioVal

func (Flt32Val) String 

func (v Flt32Val) String() string

func (Flt32Val) Substract 

func (v Flt32Val) Substract(arg Flt32Val) Flt32Val

func (Flt32Val) SubstractR 

func (v Flt32Val) SubstractR(arg FltVal) FltVal

func (Flt32Val) Truth 

func (v Flt32Val) Truth() Native

func (Flt32Val) Type 

func (v Flt32Val) Type() TyNat

func (Flt32Val) Uint 

func (v Flt32Val) Uint() UintVal

func (Flt32Val) Unit 

func (v Flt32Val) Unit() Native

REAL VALUE

type Flt32Vec 

type Flt32Vec []float32

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (Flt32Vec) Copy 

func (v Flt32Vec) Copy() Native

func (Flt32Vec) Empty 

func (v Flt32Vec) Empty() bool

func (Flt32Vec) Get 

func (v Flt32Vec) Get(i Native) Native

func (Flt32Vec) GetInt 

func (v Flt32Vec) GetInt(i int) Native

func (Flt32Vec) Len 

func (v Flt32Vec) Len() int

func (Flt32Vec) Native 

func (v Flt32Vec) Native(i int) float32

func (Flt32Vec) Null 

func (v Flt32Vec) Null() Native

func (Flt32Vec) Range 

func (v Flt32Vec) Range(i, j int) Sliceable

func (Flt32Vec) RangeNative 

func (v Flt32Vec) RangeNative(i, j int) []float32

func (Flt32Vec) Slice 

func (v Flt32Vec) Slice() []Native

func (Flt32Vec) String 

func (v Flt32Vec) String() string

func (Flt32Vec) Type 

func (v Flt32Vec) Type() TyNat

func (Flt32Vec) TypeElem 

func (v Flt32Vec) TypeElem() Typed

type FltVal 

type FltVal float64

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (FltVal) Add 

func (v FltVal) Add(arg FltVal) FltVal

func (FltVal) AddR 

func (v FltVal) AddR(arg FltVal) FltVal

func (FltVal) BigFlt 

func (v FltVal) BigFlt() *BigFltVal

func (FltVal) BigInt 

func (v FltVal) BigInt() *BigIntVal

func (FltVal) Bool 

func (v FltVal) Bool() BoolVal

func (FltVal) Copy 

func (v FltVal) Copy() Native

func (FltVal) Dec 

func (v FltVal) Dec() FltVal

func (FltVal) Equal 

func (v FltVal) Equal(arg FltVal) bool

comparators

func (FltVal) EqualR 

func (v FltVal) EqualR(arg FltVal) bool

comparators

func (FltVal) Float 

func (v FltVal) Float() FltVal

func (FltVal) Flt32 

func (v FltVal) Flt32() Flt32Val

func (FltVal) GoBigFlt 

func (v FltVal) GoBigFlt() *big.Float

func (FltVal) GoBigInt 

func (v FltVal) GoBigInt() *big.Int

func (FltVal) GoFlt 

func (v FltVal) GoFlt() float64

func (FltVal) GoImag 

func (v FltVal) GoImag() complex128

func (FltVal) GoInt 

func (v FltVal) GoInt() int

func (FltVal) GoRat 

func (v FltVal) GoRat() *big.Rat

func (FltVal) GoUint 

func (v FltVal) GoUint() uint

func (FltVal) Greater 

func (v FltVal) Greater(arg FltVal) bool

func (FltVal) GreaterR 

func (v FltVal) GreaterR(arg FltVal) bool

func (FltVal) Ident 

func (v FltVal) Ident() FltVal

func (FltVal) Idx 

func (v FltVal) Idx() int

func (FltVal) Imag 

func (v FltVal) Imag() ImagVal

func (FltVal) Inc 

func (v FltVal) Inc() FltVal

operators

func (FltVal) Int 

func (v FltVal) Int() IntVal

func (FltVal) Lesser 

func (v FltVal) Lesser(arg FltVal) bool

func (FltVal) LesserR 

func (v FltVal) LesserR(arg FltVal) bool

func (FltVal) MarshalBinary 

func (v FltVal) MarshalBinary() ([]byte, error)

func (FltVal) Multipy 

func (v FltVal) Multipy(arg FltVal) FltVal

func (FltVal) MultipyR 

func (v FltVal) MultipyR(arg FltVal) FltVal

func (FltVal) Negate 

func (v FltVal) Negate() FltVal

operators

func (FltVal) NegateR 

func (v FltVal) NegateR() FltVal

func (FltVal) Null 

func (v FltVal) Null() FltVal

func (FltVal) Quotient 

func (v FltVal) Quotient(arg FltVal) FltVal

func (FltVal) QuotientR 

func (v FltVal) QuotientR(arg FltVal) FltVal

func (FltVal) Ratio 

func (v FltVal) Ratio() *RatioVal

func (FltVal) String 

func (v FltVal) String() string

func (FltVal) Substract 

func (v FltVal) Substract(arg FltVal) FltVal

func (FltVal) SubstractR 

func (v FltVal) SubstractR(arg FltVal) FltVal

func (FltVal) Truth 

func (v FltVal) Truth() Native

func (FltVal) Type 

func (v FltVal) Type() TyNat

func (FltVal) Uint 

func (v FltVal) Uint() UintVal

func (FltVal) Unit 

func (v FltVal) Unit() Native

REAL VALUE

type FltVec 

type FltVec []float64

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (FltVec) Copy 

func (v FltVec) Copy() Native

func (FltVec) Empty 

func (v FltVec) Empty() bool

func (FltVec) Get 

func (v FltVec) Get(i Native) Native

func (FltVec) GetInt 

func (v FltVec) GetInt(i int) Native

func (FltVec) Len 

func (v FltVec) Len() int

func (FltVec) Native 

func (v FltVec) Native(i int) float64

func (FltVec) Null 

func (v FltVec) Null() Native

func (FltVec) Range 

func (v FltVec) Range(i, j int) Sliceable

func (FltVec) RangeNative 

func (v FltVec) RangeNative(i, j int) []float64

func (FltVec) Slice 

func (v FltVec) Slice() []Native

func (FltVec) String 

func (v FltVec) String() string

func (FltVec) Type 

func (v FltVec) Type() TyNat

func (FltVec) TypeElem 

func (v FltVec) TypeElem() Typed

type Imag64Val 

type Imag64Val complex64

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (Imag64Val) BigFlt 

func (v Imag64Val) BigFlt() *BigFltVal

func (Imag64Val) BigInt 

func (v Imag64Val) BigInt() *BigIntVal

func (Imag64Val) Bool 

func (v Imag64Val) Bool() BoolVal

func (Imag64Val) Both 

func (v Imag64Val) Both() (Native, Native)

func (Imag64Val) BothFloat 

func (v Imag64Val) BothFloat() (FltVal, FltVal)

func (Imag64Val) Copy 

func (v Imag64Val) Copy() Native

func (Imag64Val) Equal 

func (v Imag64Val) Equal(arg Imag64Val) bool

func (Imag64Val) EqualI 

func (v Imag64Val) EqualI(arg ImagVal) bool

func (Imag64Val) Float 

func (v Imag64Val) Float() FltVal

func (Imag64Val) GoBigFlt 

func (v Imag64Val) GoBigFlt() *big.Float

func (Imag64Val) GoBigInt 

func (v Imag64Val) GoBigInt() *big.Int

func (Imag64Val) GoFlt 

func (v Imag64Val) GoFlt() float64

func (Imag64Val) GoImag 

func (v Imag64Val) GoImag() complex128

func (Imag64Val) GoInt 

func (v Imag64Val) GoInt() int

func (Imag64Val) GoRat 

func (v Imag64Val) GoRat() *big.Rat

func (Imag64Val) GoUint 

func (v Imag64Val) GoUint() uint

func (Imag64Val) Ident 

func (v Imag64Val) Ident() Imag64Val

func (Imag64Val) Idx 

func (v Imag64Val) Idx() int

IMAGINARY VALUE

func (Imag64Val) Imag 

func (v Imag64Val) Imag() ImagVal

func (Imag64Val) Imag64 

func (v Imag64Val) Imag64() Imag64Val

func (Imag64Val) Imaginary 

func (v Imag64Val) Imaginary() FltVal

func (Imag64Val) Int 

func (v Imag64Val) Int() IntVal

func (Imag64Val) IntVal 

func (v Imag64Val) IntVal() IntVal

func (Imag64Val) Left 

func (v Imag64Val) Left() Native

func (Imag64Val) MarshalBinary 

func (v Imag64Val) MarshalBinary() ([]byte, error)

func (Imag64Val) Null 

func (v Imag64Val) Null() Imag64Val

func (Imag64Val) Ratio 

func (v Imag64Val) Ratio() *big.Rat

func (Imag64Val) Real 

func (v Imag64Val) Real() FltVal

func (Imag64Val) Right 

func (v Imag64Val) Right() Native

func (Imag64Val) String 

func (v Imag64Val) String() string

func (Imag64Val) Type 

func (v Imag64Val) Type() TyNat

func (Imag64Val) Uint 

func (v Imag64Val) Uint() UintVal

func (Imag64Val) Unit 

func (v Imag64Val) Unit() Native

type Imag64Vec 

type Imag64Vec []complex64

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (Imag64Vec) Copy 

func (v Imag64Vec) Copy() Native

func (Imag64Vec) Empty 

func (v Imag64Vec) Empty() bool

func (Imag64Vec) Get 

func (v Imag64Vec) Get(i Native) Native

func (Imag64Vec) GetInt 

func (v Imag64Vec) GetInt(i int) Native

func (Imag64Vec) Len 

func (v Imag64Vec) Len() int

func (Imag64Vec) Native 

func (v Imag64Vec) Native(i int) complex64

func (Imag64Vec) Null 

func (v Imag64Vec) Null() Native

func (Imag64Vec) Range 

func (v Imag64Vec) Range(i, j int) Sliceable

func (Imag64Vec) RangeNative 

func (v Imag64Vec) RangeNative(i, j int) []complex64

func (Imag64Vec) Slice 

func (v Imag64Vec) Slice() []Native

func (Imag64Vec) String 

func (v Imag64Vec) String() string

func (Imag64Vec) Type 

func (v Imag64Vec) Type() TyNat

func (Imag64Vec) TypeElem 

func (v Imag64Vec) TypeElem() Typed

type ImagVal 

type ImagVal complex128

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (ImagVal) BigFlt 

func (v ImagVal) BigFlt() *BigFltVal

func (ImagVal) BigInt 

func (v ImagVal) BigInt() *BigIntVal

func (ImagVal) Bool 

func (v ImagVal) Bool() BoolVal

func (ImagVal) Both 

func (v ImagVal) Both() (Native, Native)

func (ImagVal) BothFloat 

func (v ImagVal) BothFloat() (FltVal, FltVal)

func (ImagVal) Copy 

func (v ImagVal) Copy() Native

func (ImagVal) Equal 

func (v ImagVal) Equal(arg ImagVal) bool

func (ImagVal) EqualI 

func (v ImagVal) EqualI(arg ImagVal) bool

func (ImagVal) Float 

func (v ImagVal) Float() FltVal

func (ImagVal) GoBigFlt 

func (v ImagVal) GoBigFlt() *big.Float

func (ImagVal) GoBigInt 

func (v ImagVal) GoBigInt() *big.Int

func (ImagVal) GoFlt 

func (v ImagVal) GoFlt() float64

func (ImagVal) GoImag 

func (v ImagVal) GoImag() complex128

func (ImagVal) GoInt 

func (v ImagVal) GoInt() int

func (ImagVal) GoRat 

func (v ImagVal) GoRat() *big.Rat

func (ImagVal) GoUint 

func (v ImagVal) GoUint() uint

func (ImagVal) Ident 

func (v ImagVal) Ident() ImagVal

func (ImagVal) Idx 

func (v ImagVal) Idx() int

IMAGINARY VALUE

func (ImagVal) Imag 

func (v ImagVal) Imag() ImagVal

func (ImagVal) Imag64 

func (v ImagVal) Imag64() Imag64Val

func (ImagVal) Imaginary 

func (v ImagVal) Imaginary() FltVal

func (ImagVal) Int 

func (v ImagVal) Int() IntVal

func (ImagVal) IntVal 

func (v ImagVal) IntVal() IntVal

func (ImagVal) Left 

func (v ImagVal) Left() Native

func (ImagVal) MarshalBinary 

func (v ImagVal) MarshalBinary() ([]byte, error)

func (ImagVal) Null 

func (v ImagVal) Null() ImagVal

func (ImagVal) Ratio 

func (v ImagVal) Ratio() *big.Rat

func (ImagVal) Real 

func (v ImagVal) Real() FltVal

func (ImagVal) Right 

func (v ImagVal) Right() Native

func (ImagVal) String 

func (v ImagVal) String() string

func (ImagVal) Type 

func (v ImagVal) Type() TyNat

func (ImagVal) Uint 

func (v ImagVal) Uint() UintVal

func (ImagVal) Unit 

func (v ImagVal) Unit() Native

type ImagVec 

type ImagVec []complex128

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (ImagVec) Copy 

func (v ImagVec) Copy() Native

func (ImagVec) Empty 

func (v ImagVec) Empty() bool

func (ImagVec) Get 

func (v ImagVec) Get(i Native) Native

func (ImagVec) GetInt 

func (v ImagVec) GetInt(i int) Native

func (ImagVec) Len 

func (v ImagVec) Len() int

func (ImagVec) Native 

func (v ImagVec) Native(i int) complex128

func (ImagVec) Null 

func (v ImagVec) Null() Native

func (ImagVec) Range 

func (v ImagVec) Range(i, j int) Sliceable

func (ImagVec) RangeNative 

func (v ImagVec) RangeNative(i, j int) []complex128

func (ImagVec) Slice 

func (v ImagVec) Slice() []Native

func (ImagVec) String 

func (v ImagVec) String() string

func (ImagVec) Type 

func (v ImagVec) Type() TyNat

func (ImagVec) TypeElem 

func (v ImagVec) TypeElem() Typed

type Imaginary 

type Imaginary interface {
	Imag() ImagVal
	GoImag() complex128
}

type Int8Val 

type Int8Val int8

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (Int8Val) Add 

func (v Int8Val) Add(arg Int8Val) Int8Val

func (Int8Val) AddI 

func (v Int8Val) AddI(arg IntVal) IntVal

func (Int8Val) And 

func (v Int8Val) And(arg Int8Val) Int8Val

func (Int8Val) AndI 

func (v Int8Val) AndI(arg IntVal) IntVal

func (Int8Val) AndNot 

func (v Int8Val) AndNot(arg Int8Val) Int8Val

func (Int8Val) AndNotI 

func (v Int8Val) AndNotI(arg IntVal) IntVal

func (Int8Val) BigFlt 

func (v Int8Val) BigFlt() *BigFltVal

func (Int8Val) BigInt 

func (v Int8Val) BigInt() *BigIntVal

func (Int8Val) Bool 

func (v Int8Val) Bool() BoolVal

func (Int8Val) Byte 

func (v Int8Val) Byte() Native

func (Int8Val) Copy 

func (v Int8Val) Copy() Native

func (Int8Val) Dec 

func (v Int8Val) Dec() IntVal

func (Int8Val) Equal 

func (v Int8Val) Equal(arg Int8Val) bool

comparators

func (Int8Val) EqualI 

func (v Int8Val) EqualI(arg IntVal) bool

comparators

func (Int8Val) Flag 

func (v Int8Val) Flag() Native

func (Int8Val) Float 

func (v Int8Val) Float() FltVal

func (Int8Val) GoBigFlt 

func (v Int8Val) GoBigFlt() *big.Float

func (Int8Val) GoBigInt 

func (v Int8Val) GoBigInt() *big.Int

func (Int8Val) GoFlt 

func (v Int8Val) GoFlt() float64

func (Int8Val) GoImag 

func (v Int8Val) GoImag() complex128

func (Int8Val) GoInt 

func (v Int8Val) GoInt() int

INTEGER VALUE Int8Val

func (Int8Val) GoRat 

func (v Int8Val) GoRat() *big.Rat

func (Int8Val) GoUint 

func (v Int8Val) GoUint() uint

func (Int8Val) Greater 

func (v Int8Val) Greater(arg Int8Val) bool

func (Int8Val) GreaterI 

func (v Int8Val) GreaterI(arg IntVal) bool

func (Int8Val) Ident 

func (v Int8Val) Ident() Int8Val

func (Int8Val) Idx 

func (v Int8Val) Idx() int

func (Int8Val) Imag 

func (v Int8Val) Imag() ImagVal

func (Int8Val) Inc 

func (v Int8Val) Inc() IntVal

operators arithmetic

func (Int8Val) Int 

func (v Int8Val) Int() IntVal

func (Int8Val) Int8 

func (v Int8Val) Int8() Int8Val

func (Int8Val) Int16 

func (v Int8Val) Int16() Int16Val

func (Int8Val) Int32 

func (v Int8Val) Int32() Int32Val

func (Int8Val) Lesser 

func (v Int8Val) Lesser(arg Int8Val) bool

func (Int8Val) LesserI 

func (v Int8Val) LesserI(arg IntVal) bool

func (Int8Val) MarshalBinary 

func (v Int8Val) MarshalBinary() ([]byte, error)

func (Int8Val) Multipy 

func (v Int8Val) Multipy(arg Int8Val) Int8Val

func (Int8Val) MultipyI 

func (v Int8Val) MultipyI(arg IntVal) IntVal

func (Int8Val) Negate 

func (v Int8Val) Negate() Int8Val

operators arithmetic

func (Int8Val) NegateI 

func (v Int8Val) NegateI() IntVal

func (Int8Val) Not 

func (v Int8Val) Not() Int8Val

operators

func (Int8Val) NotI 

func (v Int8Val) NotI() IntVal

operators

func (Int8Val) Null 

func (v Int8Val) Null() Int8Val

func (Int8Val) Or 

func (v Int8Val) Or(arg Int8Val) Int8Val

func (Int8Val) OrI 

func (v Int8Val) OrI(arg IntVal) IntVal

func (Int8Val) Power 

func (v Int8Val) Power(arg Int8Val) Int8Val

func (Int8Val) PowerI 

func (v Int8Val) PowerI(arg IntVal) IntVal

func (Int8Val) Quotient 

func (v Int8Val) Quotient(arg Int8Val) Int8Val

func (Int8Val) QuotientI 

func (v Int8Val) QuotientI(arg IntVal) IntVal

func (Int8Val) Ratio 

func (v Int8Val) Ratio() *RatioVal

func (Int8Val) Rune 

func (v Int8Val) Rune() Native

func (Int8Val) String 

func (v Int8Val) String() string

func (Int8Val) Substract 

func (v Int8Val) Substract(arg Int8Val) Int8Val

func (Int8Val) SubstractI 

func (v Int8Val) SubstractI(arg IntVal) IntVal

func (Int8Val) Truth 

func (v Int8Val) Truth() Native

func (Int8Val) Type 

func (v Int8Val) Type() TyNat

func (Int8Val) Uint 

func (v Int8Val) Uint() UintVal

func (Int8Val) Unit 

func (v Int8Val) Unit() Native

func (Int8Val) Xor 

func (v Int8Val) Xor(arg Int8Val) Int8Val

func (Int8Val) XorI 

func (v Int8Val) XorI(arg IntVal) IntVal

type Int8Vec 

type Int8Vec []int8

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (Int8Vec) Copy 

func (v Int8Vec) Copy() Native

func (Int8Vec) Empty 

func (v Int8Vec) Empty() bool

func (Int8Vec) Get 

func (v Int8Vec) Get(i Native) Native

func (Int8Vec) GetInt 

func (v Int8Vec) GetInt(i int) Native

func (Int8Vec) Len 

func (v Int8Vec) Len() int

func (Int8Vec) Native 

func (v Int8Vec) Native(i int) int8

func (Int8Vec) Null 

func (v Int8Vec) Null() Native

func (Int8Vec) Range 

func (v Int8Vec) Range(i, j int) Sliceable

func (Int8Vec) RangeNative 

func (v Int8Vec) RangeNative(i, j int) []int8

func (Int8Vec) Slice 

func (v Int8Vec) Slice() []Native

func (Int8Vec) String 

func (v Int8Vec) String() string

func (Int8Vec) Type 

func (v Int8Vec) Type() TyNat

func (Int8Vec) TypeElem 

func (v Int8Vec) TypeElem() Typed

type Int16Val 

type Int16Val int16

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (Int16Val) Add 

func (v Int16Val) Add(arg Int16Val) Int16Val

func (Int16Val) And 

func (v Int16Val) And(arg Int16Val) Int16Val

func (Int16Val) AndNot 

func (v Int16Val) AndNot(arg Int16Val) Int16Val

func (Int16Val) BigFlt 

func (v Int16Val) BigFlt() *BigFltVal

func (Int16Val) BigInt 

func (v Int16Val) BigInt() *BigIntVal

func (Int16Val) Bool 

func (v Int16Val) Bool() BoolVal

func (Int16Val) Byte 

func (v Int16Val) Byte() Native

func (Int16Val) Copy 

func (v Int16Val) Copy() Native

func (Int16Val) Dec 

func (v Int16Val) Dec() IntVal

func (Int16Val) Equal 

func (v Int16Val) Equal(arg Int16Val) bool

comparators

func (Int16Val) Flag 

func (v Int16Val) Flag() Native

func (Int16Val) Float 

func (v Int16Val) Float() FltVal

func (Int16Val) GoBigFlt 

func (v Int16Val) GoBigFlt() *big.Float

func (Int16Val) GoBigInt 

func (v Int16Val) GoBigInt() *big.Int

func (Int16Val) GoFlt 

func (v Int16Val) GoFlt() float64

func (Int16Val) GoImag 

func (v Int16Val) GoImag() complex128

func (Int16Val) GoInt 

func (v Int16Val) GoInt() int

Int16Val

func (Int16Val) GoRat 

func (v Int16Val) GoRat() *big.Rat

func (Int16Val) GoUint 

func (v Int16Val) GoUint() uint

func (Int16Val) Greater 

func (v Int16Val) Greater(arg Int16Val) bool

func (Int16Val) Ident 

func (v Int16Val) Ident() Int16Val

func (Int16Val) Idx 

func (v Int16Val) Idx() int

func (Int16Val) Imag 

func (v Int16Val) Imag() ImagVal

func (Int16Val) Inc 

func (v Int16Val) Inc() IntVal

func (Int16Val) Int 

func (v Int16Val) Int() IntVal

func (Int16Val) Int8 

func (v Int16Val) Int8() Int8Val

func (Int16Val) Int16 

func (v Int16Val) Int16() Int16Val

func (Int16Val) Int32 

func (v Int16Val) Int32() Int32Val

func (Int16Val) Lesser 

func (v Int16Val) Lesser(arg Int16Val) bool

func (Int16Val) MarshalBinary 

func (v Int16Val) MarshalBinary() ([]byte, error)

func (Int16Val) Multipy 

func (v Int16Val) Multipy(arg Int16Val) Int16Val

func (Int16Val) Negate 

func (v Int16Val) Negate() Int16Val

func (Int16Val) Not 

func (v Int16Val) Not() Int16Val

operators

func (Int16Val) Null 

func (v Int16Val) Null() Int16Val

func (Int16Val) Or 

func (v Int16Val) Or(arg Int16Val) Int16Val

func (Int16Val) Power 

func (v Int16Val) Power(arg Int16Val) Int16Val

func (Int16Val) Quotient 

func (v Int16Val) Quotient(arg Int16Val) Int16Val

func (Int16Val) Ratio 

func (v Int16Val) Ratio() *RatioVal

func (Int16Val) Rune 

func (v Int16Val) Rune() Native

func (Int16Val) String 

func (v Int16Val) String() string

func (Int16Val) Substract 

func (v Int16Val) Substract(arg Int16Val) Int16Val

func (Int16Val) Truth 

func (v Int16Val) Truth() Native

func (Int16Val) Type 

func (v Int16Val) Type() TyNat

func (Int16Val) Uint 

func (v Int16Val) Uint() UintVal

func (Int16Val) Unit 

func (v Int16Val) Unit() Native

func (Int16Val) Xor 

func (v Int16Val) Xor(arg Int16Val) Int16Val

type Int16Vec 

type Int16Vec []int16

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (Int16Vec) Copy 

func (v Int16Vec) Copy() Native

func (Int16Vec) Empty 

func (v Int16Vec) Empty() bool

func (Int16Vec) Get 

func (v Int16Vec) Get(i Native) Native

func (Int16Vec) GetInt 

func (v Int16Vec) GetInt(i int) Native

func (Int16Vec) Len 

func (v Int16Vec) Len() int

func (Int16Vec) Native 

func (v Int16Vec) Native(i int) int16

func (Int16Vec) Null 

func (v Int16Vec) Null() Native

func (Int16Vec) Range 

func (v Int16Vec) Range(i, j int) Sliceable

func (Int16Vec) RangeNative 

func (v Int16Vec) RangeNative(i, j int) []int16

func (Int16Vec) Slice 

func (v Int16Vec) Slice() []Native

func (Int16Vec) String 

func (v Int16Vec) String() string

func (Int16Vec) Type 

func (v Int16Vec) Type() TyNat

func (Int16Vec) TypeElem 

func (v Int16Vec) TypeElem() Typed

type Int32Val 

type Int32Val int32

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (Int32Val) Add 

func (v Int32Val) Add(arg Int32Val) Int32Val

func (Int32Val) AddI 

func (v Int32Val) AddI(arg IntVal) IntVal

func (Int32Val) And 

func (v Int32Val) And(arg Int32Val) Int32Val

func (Int32Val) AndI 

func (v Int32Val) AndI(arg IntVal) IntVal

func (Int32Val) AndNot 

func (v Int32Val) AndNot(arg Int32Val) Int32Val

func (Int32Val) AndNotI 

func (v Int32Val) AndNotI(arg IntVal) IntVal

func (Int32Val) BigFlt 

func (v Int32Val) BigFlt() *BigFltVal

func (Int32Val) BigInt 

func (v Int32Val) BigInt() *BigIntVal

func (Int32Val) Bool 

func (v Int32Val) Bool() BoolVal

func (Int32Val) Byte 

func (v Int32Val) Byte() Native

func (Int32Val) Copy 

func (v Int32Val) Copy() Native

func (Int32Val) Dec 

func (v Int32Val) Dec() IntVal

func (Int32Val) Equal 

func (v Int32Val) Equal(arg Int32Val) bool

comparators

func (Int32Val) EqualI 

func (v Int32Val) EqualI(arg IntVal) bool

comparators

func (Int32Val) Flag 

func (v Int32Val) Flag() Native

func (Int32Val) Float 

func (v Int32Val) Float() FltVal

func (Int32Val) GoBigFlt 

func (v Int32Val) GoBigFlt() *big.Float

func (Int32Val) GoBigInt 

func (v Int32Val) GoBigInt() *big.Int

func (Int32Val) GoFlt 

func (v Int32Val) GoFlt() float64

func (Int32Val) GoImag 

func (v Int32Val) GoImag() complex128

func (Int32Val) GoInt 

func (v Int32Val) GoInt() int

Int32Val

func (Int32Val) GoRat 

func (v Int32Val) GoRat() *big.Rat

func (Int32Val) GoUint 

func (v Int32Val) GoUint() uint

func (Int32Val) Greater 

func (v Int32Val) Greater(arg Int32Val) bool

func (Int32Val) GreaterI 

func (v Int32Val) GreaterI(arg IntVal) bool

func (Int32Val) Ident 

func (v Int32Val) Ident() Int32Val

func (Int32Val) Idx 

func (v Int32Val) Idx() int

func (Int32Val) Imag 

func (v Int32Val) Imag() ImagVal

func (Int32Val) Inc 

func (v Int32Val) Inc() IntVal

operators arithmetic

func (Int32Val) Int 

func (v Int32Val) Int() IntVal

func (Int32Val) Int8Val 

func (v Int32Val) Int8Val() Int8Val

func (Int32Val) Int16 

func (v Int32Val) Int16() Int16Val

func (Int32Val) Int32 

func (v Int32Val) Int32() Int32Val

func (Int32Val) Lesser 

func (v Int32Val) Lesser(arg Int32Val) bool

func (Int32Val) LesserI 

func (v Int32Val) LesserI(arg IntVal) bool

func (Int32Val) MarshalBinary 

func (v Int32Val) MarshalBinary() ([]byte, error)

func (Int32Val) Multipy 

func (v Int32Val) Multipy(arg Int32Val) Int32Val

func (Int32Val) MultipyI 

func (v Int32Val) MultipyI(arg IntVal) IntVal

func (Int32Val) Negate 

func (v Int32Val) Negate() Int32Val

func (Int32Val) NegateI 

func (v Int32Val) NegateI() IntVal

operators arithmetic

func (Int32Val) Not 

func (v Int32Val) Not() Int32Val

operators

func (Int32Val) NotI 

func (v Int32Val) NotI() IntVal

operators

func (Int32Val) Null 

func (v Int32Val) Null() Int32Val

func (Int32Val) Or 

func (v Int32Val) Or(arg Int32Val) Int32Val

func (Int32Val) OrI 

func (v Int32Val) OrI(arg IntVal) IntVal

func (Int32Val) Power 

func (v Int32Val) Power(arg Int32Val) Int32Val

func (Int32Val) PowerI 

func (v Int32Val) PowerI(arg IntVal) IntVal

func (Int32Val) Quotient 

func (v Int32Val) Quotient(arg Int32Val) Int32Val

func (Int32Val) QuotientI 

func (v Int32Val) QuotientI(arg IntVal) IntVal

func (Int32Val) Ratio 

func (v Int32Val) Ratio() *RatioVal

func (Int32Val) Rune 

func (v Int32Val) Rune() Native

func (Int32Val) String 

func (v Int32Val) String() string

func (Int32Val) Substract 

func (v Int32Val) Substract(arg Int32Val) Int32Val

func (Int32Val) SubstractI 

func (v Int32Val) SubstractI(arg IntVal) IntVal

func (Int32Val) Truth 

func (v Int32Val) Truth() Native

func (Int32Val) Type 

func (v Int32Val) Type() TyNat

func (Int32Val) Uint 

func (v Int32Val) Uint() UintVal

func (Int32Val) Unit 

func (v Int32Val) Unit() Native

func (Int32Val) Xor 

func (v Int32Val) Xor(arg Int32Val) Int32Val

func (Int32Val) XorI 

func (v Int32Val) XorI(arg IntVal) IntVal

type Int32Vec 

type Int32Vec []int32

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (Int32Vec) Copy 

func (v Int32Vec) Copy() Native

func (Int32Vec) Empty 

func (v Int32Vec) Empty() bool

func (Int32Vec) Get 

func (v Int32Vec) Get(i Native) Native

func (Int32Vec) GetInt 

func (v Int32Vec) GetInt(i int) Native

func (Int32Vec) Len 

func (v Int32Vec) Len() int

func (Int32Vec) Native 

func (v Int32Vec) Native(i int) int32

func (Int32Vec) Null 

func (v Int32Vec) Null() Native

func (Int32Vec) Range 

func (v Int32Vec) Range(i, j int) Sliceable

func (Int32Vec) RangeNative 

func (v Int32Vec) RangeNative(i, j int) []int32

func (Int32Vec) Slice 

func (v Int32Vec) Slice() []Native

func (Int32Vec) String 

func (v Int32Vec) String() string

func (Int32Vec) Type 

func (v Int32Vec) Type() TyNat

func (Int32Vec) TypeElem 

func (v Int32Vec) TypeElem() Typed

type IntVal 

type IntVal int

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (IntVal) Add 

func (v IntVal) Add(arg IntVal) IntVal

func (IntVal) AddI 

func (v IntVal) AddI(arg IntVal) IntVal

func (IntVal) And 

func (v IntVal) And(arg IntVal) IntVal

func (IntVal) AndI 

func (v IntVal) AndI(arg IntVal) IntVal

func (IntVal) AndNot 

func (v IntVal) AndNot(arg IntVal) IntVal

func (IntVal) AndNotI 

func (v IntVal) AndNotI(arg IntVal) IntVal

func (IntVal) BigFlt 

func (v IntVal) BigFlt() *BigFltVal

func (IntVal) BigInt 

func (v IntVal) BigInt() *BigIntVal

func (IntVal) Bool 

func (v IntVal) Bool() BoolVal

func (IntVal) Byte 

func (v IntVal) Byte() Native

func (IntVal) Copy 

func (v IntVal) Copy() Native

func (IntVal) Dec 

func (v IntVal) Dec() IntVal

func (IntVal) Equal 

func (v IntVal) Equal(arg IntVal) bool

comparators

func (IntVal) EqualI 

func (v IntVal) EqualI(arg IntVal) bool

comparators

func (IntVal) Flag 

func (v IntVal) Flag() Native

func (IntVal) Float 

func (v IntVal) Float() FltVal

func (IntVal) GoBigFlt 

func (v IntVal) GoBigFlt() *big.Float

func (IntVal) GoBigInt 

func (v IntVal) GoBigInt() *big.Int

func (IntVal) GoFlt 

func (v IntVal) GoFlt() float64

func (IntVal) GoImag 

func (v IntVal) GoImag() complex128

func (IntVal) GoInt 

func (v IntVal) GoInt() int

IntVal conversions

func (IntVal) GoRat 

func (v IntVal) GoRat() *big.Rat

func (IntVal) GoUint 

func (v IntVal) GoUint() uint

func (IntVal) Greater 

func (v IntVal) Greater(arg IntVal) bool

func (IntVal) GreaterI 

func (v IntVal) GreaterI(arg IntVal) bool

func (IntVal) Ident 

func (v IntVal) Ident() IntVal

func (IntVal) Idx 

func (v IntVal) Idx() int

func (IntVal) Imag 

func (v IntVal) Imag() ImagVal

func (IntVal) Inc 

func (v IntVal) Inc() IntVal

operators

func (IntVal) Int 

func (v IntVal) Int() IntVal

func (IntVal) Int8 

func (v IntVal) Int8() IntVal

func (IntVal) Int16 

func (v IntVal) Int16() Int16Val

func (IntVal) Int32 

func (v IntVal) Int32() Int32Val

func (IntVal) IntVal 

func (v IntVal) IntVal() IntVal

func (IntVal) Lesser 

func (v IntVal) Lesser(arg IntVal) bool

func (IntVal) LesserI 

func (v IntVal) LesserI(arg IntVal) bool

func (IntVal) MarshalBinary 

func (v IntVal) MarshalBinary() ([]byte, error)

func (IntVal) Multipy 

func (v IntVal) Multipy(arg IntVal) IntVal

func (IntVal) MultipyI 

func (v IntVal) MultipyI(arg IntVal) IntVal

func (IntVal) Negate 

func (v IntVal) Negate() IntVal

func (IntVal) NegateI 

func (v IntVal) NegateI() IntVal

func (IntVal) Not 

func (v IntVal) Not() IntVal

operators

func (IntVal) NotI 

func (v IntVal) NotI() IntVal

func (IntVal) Null 

func (v IntVal) Null() IntVal

func (IntVal) Or 

func (v IntVal) Or(arg IntVal) IntVal

func (IntVal) OrI 

func (v IntVal) OrI(arg IntVal) IntVal

func (IntVal) Power 

func (v IntVal) Power(arg IntVal) IntVal

func (IntVal) PowerI 

func (v IntVal) PowerI(arg IntVal) IntVal

func (IntVal) Quotient 

func (v IntVal) Quotient(arg IntVal) IntVal

func (IntVal) QuotientI 

func (v IntVal) QuotientI(arg IntVal) IntVal

func (IntVal) Ratio 

func (v IntVal) Ratio() *RatioVal

func (IntVal) Rune 

func (v IntVal) Rune() Native

func (IntVal) String 

func (v IntVal) String() string

func (IntVal) Substract 

func (v IntVal) Substract(arg IntVal) IntVal

func (IntVal) SubstractI 

func (v IntVal) SubstractI(arg IntVal) IntVal

func (IntVal) Truth 

func (v IntVal) Truth() Native

func (IntVal) Type 

func (v IntVal) Type() TyNat

func (IntVal) Uint 

func (v IntVal) Uint() UintVal

func (IntVal) Unit 

func (v IntVal) Unit() Native

func (IntVal) Xor 

func (v IntVal) Xor(arg IntVal) IntVal

func (IntVal) XorI 

func (v IntVal) XorI(arg IntVal) IntVal

type IntVec 

type IntVec []int

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (IntVec) Copy 

func (v IntVec) Copy() Native

func (IntVec) Empty 

func (v IntVec) Empty() bool

func (IntVec) Get 

func (v IntVec) Get(i Native) Native

func (IntVec) GetInt 

func (v IntVec) GetInt(i int) Native

func (IntVec) Len 

func (v IntVec) Len() int

func (IntVec) Native 

func (v IntVec) Native(i int) int

func (IntVec) Null 

func (v IntVec) Null() Native

func (IntVec) Range 

func (v IntVec) Range(i, j int) Sliceable

func (IntVec) RangeNative 

func (v IntVec) RangeNative(i, j int) []int

func (IntVec) Slice 

func (v IntVec) Slice() []Native

func (IntVec) String 

func (v IntVec) String() string

func (IntVec) Type 

func (v IntVec) Type() TyNat

func (IntVec) TypeElem 

func (v IntVec) TypeElem() Typed

type Integer 

type Integer interface {
	Int() IntVal
	BigInt() *BigIntVal
	GoInt() int
	Idx() int
}

type IntegerAriOps 

type IntegerAriOps interface {
	Inc() Integer
	Dec() Integer
	AddI(arg UintVal) UintVal
	SubstractI(arg UintVal) UintVal
	MultipyI(arg UintVal) UintVal
	PowerI(arg UintVal) UintVal
	QuotientI(arg UintVal) UintVal
	QuoRatioI(arg UintVal) *RatioVal
}

type IntegerBoolOps 

type IntegerBoolOps interface {
	NotI() IntVal
	AndI(arg IntVal) IntVal
	XorI(arg IntVal) IntVal
	OrI(arg IntVal) IntVal
	AndNotI(arg IntVal) IntVal
}

type IntegerComparators 

type IntegerComparators interface {
	EqualI(arg IntVal) bool
	LesserI(arg IntVal) bool
	GreaterI(arg IntVal) bool
}

type InterfaceSlice 

type InterfaceSlice []interface{}

SLICES OF UNALIASED NATIVE GOLANG VALUES

func (InterfaceSlice) Get 

func (v InterfaceSlice) Get(i Native) interface{}

func (InterfaceSlice) GetInt 

func (v InterfaceSlice) GetInt(i int) interface{}

type Iter 

type Iter func() (Native, Iter)

func ConIter 

func ConIter(c DataSlice) Iter

type KindOfFlag 

type KindOfFlag interface {
	Kind() Uint8Val
}

type Letter 

type Letter interface {
	GoRune() rune
	GoByte() byte
}

type MapFlag 

type MapFlag map[BitFlag]Native

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (MapFlag) Data 

func (s MapFlag) Data() []Native

func (MapFlag) Delete 

func (s MapFlag) Delete(acc Native) bool

func (MapFlag) Fields 

func (s MapFlag) Fields() []Paired

func (MapFlag) First 

func (s MapFlag) First() Paired

func (MapFlag) Get 

func (s MapFlag) Get(acc Native) (Native, bool)

func (MapFlag) Has 

func (s MapFlag) Has(acc Native) bool

func (MapFlag) Keys 

func (s MapFlag) Keys() []Native

func (MapFlag) Len 

func (s MapFlag) Len() int

func (MapFlag) Set 

func (s MapFlag) Set(acc Native, dat Native) Mapped

func (MapFlag) Slice 

func (s MapFlag) Slice() []Native

func (MapFlag) String 

func (s MapFlag) String() string

func (MapFlag) Type 

func (s MapFlag) Type() TyNat

func (MapFlag) TypeKey 

func (s MapFlag) TypeKey() Typed

func (MapFlag) TypeValue 

func (s MapFlag) TypeValue() Typed

type MapFloat 

type MapFloat map[FltVal]Native

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (MapFloat) Data 

func (s MapFloat) Data() []Native

func (MapFloat) Delete 

func (s MapFloat) Delete(acc Native) bool

func (MapFloat) Fields 

func (s MapFloat) Fields() []Paired

func (MapFloat) First 

func (s MapFloat) First() Paired

func (MapFloat) Get 

func (s MapFloat) Get(acc Native) (Native, bool)

func (MapFloat) GetFlt 

func (s MapFloat) GetFlt(flt float64) (Native, bool)

func (MapFloat) Has 

func (s MapFloat) Has(acc Native) bool

func (MapFloat) HasFlt 

func (s MapFloat) HasFlt(flt float64) bool

func (MapFloat) Keys 

func (s MapFloat) Keys() []Native

func (MapFloat) Len 

func (s MapFloat) Len() int

func (MapFloat) Set 

func (s MapFloat) Set(acc Native, dat Native) Mapped

func (MapFloat) SetFlt 

func (s MapFloat) SetFlt(flt float64, dat Native) Mapped

func (MapFloat) Slice 

func (s MapFloat) Slice() []Native

func (MapFloat) String 

func (s MapFloat) String() string

func (MapFloat) Type 

func (s MapFloat) Type() TyNat

func (MapFloat) TypeKey 

func (s MapFloat) TypeKey() Typed

func (MapFloat) TypeValue 

func (s MapFloat) TypeValue() Typed

type MapInt 

type MapInt map[IntVal]Native

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (MapInt) Data 

func (s MapInt) Data() []Native

func (MapInt) Delete 

func (s MapInt) Delete(acc Native) bool

func (MapInt) Fields 

func (s MapInt) Fields() []Paired

func (MapInt) First 

func (s MapInt) First() Paired

func (MapInt) Get 

func (s MapInt) Get(acc Native) (Native, bool)

func (MapInt) GetIdx 

func (s MapInt) GetIdx(idx int) (Native, bool)

func (MapInt) Has 

func (s MapInt) Has(acc Native) bool

func (MapInt) HasInt 

func (s MapInt) HasInt(idx int) bool

func (MapInt) Keys 

func (s MapInt) Keys() []Native

func (MapInt) Len 

func (s MapInt) Len() int

func (MapInt) Set 

func (s MapInt) Set(acc Native, dat Native) Mapped

func (MapInt) SetIdx 

func (s MapInt) SetIdx(idx int, dat Native) Mapped

func (MapInt) Slice 

func (s MapInt) Slice() []Native

func (MapInt) String 

func (s MapInt) String() string

// NATIVE SETS /////

func (MapInt) Type 

func (s MapInt) Type() TyNat

func (MapInt) TypeKey 

func (s MapInt) TypeKey() Typed

func (MapInt) TypeValue 

func (s MapInt) TypeValue() Typed

type MapString 

type MapString map[StrVal]Native

SETS OF NATIVES

func (MapString) Data 

func (s MapString) Data() []Native

func (MapString) Delete 

func (s MapString) Delete(acc Native) bool

func (MapString) Fields 

func (s MapString) Fields() []Paired

func (MapString) First 

func (s MapString) First() Paired

func (MapString) Get 

func (s MapString) Get(acc Native) (Native, bool)

func (MapString) GetStr 

func (s MapString) GetStr(key string) (Native, bool)

func (MapString) Has 

func (s MapString) Has(acc Native) bool

func (MapString) HasStr 

func (s MapString) HasStr(key string) bool

func (MapString) Keys 

func (s MapString) Keys() []Native

func (MapString) Len 

func (s MapString) Len() int

func (MapString) Set 

func (s MapString) Set(acc Native, dat Native) Mapped

func (MapString) SetStr 

func (s MapString) SetStr(key string, dat Native) Mapped

func (MapString) Slice 

func (s MapString) Slice() []Native

func (MapString) String 

func (s MapString) String() string

func (MapString) Type 

func (s MapString) Type() TyNat

func (MapString) TypeKey 

func (s MapString) TypeKey() Typed

func (MapString) TypeValue 

func (s MapString) TypeValue() Typed

type MapUint 

type MapUint map[UintVal]Native

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (MapUint) Data 

func (s MapUint) Data() []Native

func (MapUint) Delete 

func (s MapUint) Delete(acc Native) bool

func (MapUint) Fields 

func (s MapUint) Fields() []Paired

func (MapUint) First 

func (s MapUint) First() Paired

func (MapUint) Get 

func (s MapUint) Get(acc Native) (Native, bool)

func (MapUint) GetUint 

func (s MapUint) GetUint(idx uint) (Native, bool)

func (MapUint) Has 

func (s MapUint) Has(acc Native) bool

func (MapUint) HasUint 

func (s MapUint) HasUint(idx uint) bool

func (MapUint) Keys 

func (s MapUint) Keys() []Native

func (MapUint) Len 

func (s MapUint) Len() int

func (MapUint) Set 

func (s MapUint) Set(acc Native, dat Native) Mapped

func (MapUint) SetUint 

func (s MapUint) SetUint(idx uint, dat Native) Mapped

func (MapUint) Slice 

func (s MapUint) Slice() []Native

func (MapUint) String 

func (s MapUint) String() string

func (MapUint) Type 

func (s MapUint) Type() TyNat

func (MapUint) TypeKey 

func (s MapUint) TypeKey() Typed

func (MapUint) TypeValue 

func (s MapUint) TypeValue() Typed

type MapVal 

type MapVal map[Native]Native

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (MapVal) Data 

func (s MapVal) Data() []Native

func (MapVal) Delete 

func (s MapVal) Delete(acc Native) bool

func (MapVal) Fields 

func (s MapVal) Fields() []Paired

func (MapVal) First 

func (s MapVal) First() Paired

func (MapVal) Get 

func (s MapVal) Get(acc Native) (Native, bool)

func (MapVal) Has 

func (s MapVal) Has(acc Native) bool

func (MapVal) Keys 

func (s MapVal) Keys() []Native

func (MapVal) Len 

func (s MapVal) Len() int

func (MapVal) Set 

func (s MapVal) Set(acc Native, dat Native) Mapped

func (MapVal) Slice 

func (s MapVal) Slice() []Native

func (MapVal) String 

func (v MapVal) String() string

// SETS ////

func (MapVal) Type 

func (s MapVal) Type() TyNat

func (MapVal) TypeKey 

func (s MapVal) TypeKey() Typed

func (MapVal) TypeValue 

func (s MapVal) TypeValue() Typed

type Mapped 

type Mapped interface {
	Native
	Sliced
	Len() int
	First() Paired
	Keys() []Native
	Data() []Native
	Fields() []Paired
	Has(acc Native) bool
	Get(acc Native) (Native, bool)
	Set(Native, Native) Mapped
	Delete(acc Native) bool
	TypeKey() Typed
	TypeValue() Typed
}

mapped is the interface of all key accessable hash maps

func NewFLagMap 

func NewFLagMap(acc ...Paired) Mapped

func NewFloatMap 

func NewFloatMap(acc ...Paired) Mapped

func NewIntMap 

func NewIntMap(acc ...Paired) Mapped

func NewStringMap 

func NewStringMap(acc ...Paired) Mapped

func NewUintMap 

func NewUintMap(acc ...Paired) Mapped

func NewValMap 

func NewValMap(acc ...Paired) Mapped

////////////////////////////////////////////////////////////// // GENERIC ACCESSOR TYPED SET /

type Matched 

type Matched interface {
	Match(Typed) bool
}

type Mutable 

type Mutable interface {
	Sliceable
	Set(s, arg Native)
	SetInt(int, Native)
}

data mutability interface

type NameOfType 

type NameOfType interface {
	TypeName() string
}

type Native 

type Native interface {
	NativeTyped
	Stringer
}

the main interface, all native types need to implement.

func New 

func New(vals ...interface{}) Native

func NewData 

func NewData(args ...Native) Native

func NewEmpty 

func NewEmpty(flag BitFlag) (val Native)

func NewNull 

func NewNull(nat TyNat) Native

func NewUboxNull 

func NewUboxNull(nat TyNat) Native

returns a null value according to the native type passed in. if the flag turns out to be composed from multiple types, null value will be an instance of slice, pair, or map. otherwise an atomic native instance will be returned.

func SliceFirst 

func SliceFirst(s DataSlice) Native

BOOTOM & TOP

func SliceFoldL 

func SliceFoldL(
	c DataSlice, fn func(
		i int,
		data Native,
		accu Native,
	) Native,
	init Native) Native

// LIST OPERATIONS ///////

func SliceGet 

func SliceGet(s DataSlice, i int) Native

ACCESSABLE SLICE

func SliceGetRev 

func SliceGetRev(s DataSlice, i int) Native

reversed Get method to access elements on stacks and tuples, since their order is reversed for improved performance

func SliceHead 

func SliceHead(s DataSlice) (h Native)

TUPLE

func SliceLast 

func SliceLast(s DataSlice) Native

func SliceSearch 

func SliceSearch(c DataSlice, comp Native) Native

func SliceSearchRange 

func SliceSearchRange(c DataSlice, comp Native) []Native

func SliceSlice 

func SliceSlice(s DataSlice) []Native

SLICE

func SliceTail 

func SliceTail(s DataSlice) (c []Native)

func TypePrec 

func TypePrec(a, b Native) (x, y Native)

type NativeTyped 

type NativeTyped interface {
	Type() TyNat
}

type Natural 

type Natural interface {
	Uint() UintVal
	GoUint() uint
}

type NaturalAriOps 

type NaturalAriOps interface {
	Inc() Natural
	Dec() Natural
	AddU(arg UintVal) UintVal
	SubstractU(arg UintVal) UintVal
	MultipyU(arg UintVal) UintVal
	PowerU(arg UintVal) UintVal
	QuotientU(arg UintVal) UintVal
	QuoRatioU(arg UintVal) *RatioVal
}

type NaturalBoolOps 

type NaturalBoolOps interface {
	NotU() UintVal
	AndU(arg UintVal) UintVal
	XorU(arg UintVal) UintVal
	OrU(arg UintVal) UintVal
	AndNotU(arg UintVal) UintVal
}

type NaturalComparators 

type NaturalComparators interface {
	EqualU(arg UintVal) bool
	LesserU(arg UintVal) bool
	GreaterU(arg UintVal) bool
}

type NilVal 

type NilVal struct{}

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func NewNil 

func NewNil() NilVal

returns a nil value instance

func (NilVal) Copy 

func (NilVal) Copy() Native

provide a deep copy method

func (NilVal) Ident 

func (NilVal) Ident() NilVal

ident returns the instance as it's given type

func (NilVal) MarshalBinary 

func (v NilVal) MarshalBinary() ([]byte, error)

func (NilVal) Null 

func (v NilVal) Null() NilVal

func (NilVal) String 

func (NilVal) String() string

string nullables

func (NilVal) Type 

func (v NilVal) Type() TyNat

type NilVec 

type NilVec []struct{}

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (NilVec) Copy 

func (v NilVec) Copy() Native

func (NilVec) Empty 

func (v NilVec) Empty() bool

func (NilVec) Get 

func (v NilVec) Get(i Native) Native

func (NilVec) GetInt 

func (v NilVec) GetInt(i int) Native

func (NilVec) Len 

func (v NilVec) Len() int

func (NilVec) Native 

func (v NilVec) Native(i int) struct{}

func (NilVec) Null 

func (v NilVec) Null() Native

func (NilVec) Range 

func (v NilVec) Range(i, j int) Sliceable

func (NilVec) RangeNative 

func (v NilVec) RangeNative(i, j int) []struct{}

func (NilVec) Slice 

func (v NilVec) Slice() []Native

func (NilVec) String 

func (v NilVec) String() string

func (NilVec) Type 

func (v NilVec) Type() TyNat

func (NilVec) TypeElem 

func (v NilVec) TypeElem() Typed

type Numeral 

type Numeral interface {
	Native
	Natural
	Integer
	Real
	Rational
	Imaginary
}

type OpStr 

type OpStr string

type PairVal 

type PairVal struct{ L, R Native }

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (PairVal) Both 

func (p PairVal) Both() (Native, Native)

func (PairVal) Copy 

func (v PairVal) Copy() Native

func (PairVal) Left 

func (p PairVal) Left() Native

implements Paired flagged Pair

func (PairVal) MarshalBinary 

func (v PairVal) MarshalBinary() ([]byte, error)

func (PairVal) Null 

func (v PairVal) Null() PairVal

func (PairVal) Right 

func (p PairVal) Right() Native

func (PairVal) String 

func (p PairVal) String() string

// PAIRS ////

func (PairVal) Type 

func (p PairVal) Type() TyNat

func (PairVal) TypeKey 

func (p PairVal) TypeKey() TyNat

func (PairVal) TypeValue 

func (p PairVal) TypeValue() TyNat

type Paired 

type Paired interface {
	Native
	Left() Native
	Right() Native
	Both() (Native, Native)
	TypeKey() TyNat
	TypeValue() TyNat
}

paired holds key-value pairs intendet as set accessors

func NewPair 

func NewPair(l, r Native) Paired

type Printable 

type Printable interface {
	String() string
	GoBytes() []byte
	GoRunes() []rune
}

type RatioVal 

type RatioVal big.Rat

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (*RatioVal) Add 

func (v *RatioVal) Add(arg *RatioVal) *RatioVal

func (RatioVal) BigFlt 

func (v RatioVal) BigFlt() *BigFltVal

func (RatioVal) BigInt 

func (v RatioVal) BigInt() *BigIntVal

func (RatioVal) Bool 

func (v RatioVal) Bool() BoolVal

func (RatioVal) Both 

func (v RatioVal) Both() (Native, Native)

func (RatioVal) BothInt 

func (v RatioVal) BothInt() (IntVal, IntVal)

func (*RatioVal) Cmp 

func (v *RatioVal) Cmp(arg *RatioVal) int

comparators

func (RatioVal) Copy 

func (v RatioVal) Copy() Native

func (*RatioVal) Dec 

func (v *RatioVal) Dec() *RatioVal

func (RatioVal) Denominator 

func (v RatioVal) Denominator() IntVal

func (*RatioVal) Equal 

func (v *RatioVal) Equal(arg *RatioVal) bool

func (RatioVal) Float 

func (v RatioVal) Float() FltVal

func (RatioVal) GoBigFlt 

func (v RatioVal) GoBigFlt() *big.Float

func (RatioVal) GoBigInt 

func (v RatioVal) GoBigInt() *big.Int

func (RatioVal) GoFlt 

func (v RatioVal) GoFlt() float64

func (RatioVal) GoImag 

func (v RatioVal) GoImag() complex128

func (RatioVal) GoInt 

func (v RatioVal) GoInt() int

func (RatioVal) GoRat 

func (v RatioVal) GoRat() *big.Rat

func (RatioVal) GoUint 

func (v RatioVal) GoUint() uint

func (*RatioVal) Greater 

func (v *RatioVal) Greater(arg *RatioVal) bool

func (RatioVal) Ident 

func (v RatioVal) Ident() RatioVal

func (RatioVal) Idx 

func (v RatioVal) Idx() int

RATIONAL VALUE

func (RatioVal) Imag 

func (v RatioVal) Imag() ImagVal

func (*RatioVal) Inc 

func (v *RatioVal) Inc() *RatioVal

operators

func (RatioVal) Int 

func (v RatioVal) Int() IntVal

func (*RatioVal) Invert 

func (v *RatioVal) Invert() *RatioVal

func (RatioVal) Left 

func (v RatioVal) Left() Native

func (*RatioVal) Lesser 

func (v *RatioVal) Lesser(arg *RatioVal) bool

func (RatioVal) MarshalBinary 

func (v RatioVal) MarshalBinary() ([]byte, error)

func (*RatioVal) Multipy 

func (v *RatioVal) Multipy(arg *RatioVal) *RatioVal

func (*RatioVal) Negate 

func (v *RatioVal) Negate() *RatioVal

func (RatioVal) Null 

func (v RatioVal) Null() RatioVal

func (RatioVal) Numerator 

func (v RatioVal) Numerator() IntVal

func (*RatioVal) Quotient 

func (v *RatioVal) Quotient(arg *RatioVal) *RatioVal

func (RatioVal) Rat 

func (v RatioVal) Rat() *big.Rat

func (RatioVal) Ratio 

func (v RatioVal) Ratio() *RatioVal

func (RatioVal) Right 

func (v RatioVal) Right() Native

func (RatioVal) String 

func (v RatioVal) String() string

func (*RatioVal) Substract 

func (v *RatioVal) Substract(arg *RatioVal) *RatioVal

func (RatioVal) Truth 

func (v RatioVal) Truth() Native

func (RatioVal) Type 

func (v RatioVal) Type() TyNat

func (RatioVal) Uint 

func (v RatioVal) Uint() UintVal

func (RatioVal) Unit 

func (v RatioVal) Unit() Native

type RatioVec 

type RatioVec []*big.Rat

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (RatioVec) Copy 

func (v RatioVec) Copy() Native

func (RatioVec) Empty 

func (v RatioVec) Empty() bool

func (RatioVec) Get 

func (v RatioVec) Get(i Native) Native

func (RatioVec) GetInt 

func (v RatioVec) GetInt(i int) Native

func (RatioVec) Len 

func (v RatioVec) Len() int

func (RatioVec) Native 

func (v RatioVec) Native(i int) *big.Rat

func (RatioVec) Null 

func (v RatioVec) Null() Native

func (RatioVec) Range 

func (v RatioVec) Range(i, j int) Sliceable

func (RatioVec) RangeNative 

func (v RatioVec) RangeNative(i, j int) []*big.Rat

func (RatioVec) Slice 

func (v RatioVec) Slice() []Native

func (RatioVec) String 

func (v RatioVec) String() string

func (RatioVec) Type 

func (v RatioVec) Type() TyNat

func (RatioVec) TypeElem 

func (v RatioVec) TypeElem() Typed

type Rational 

type Rational interface {
	GoRat() *big.Rat
}

type RationalComparators 

type RationalComparators interface {
	Lesser(arg *RatioVal) bool
	Greater(arg *RatioVal) bool
	Equal(arg *RatioVal) bool
}

type RationalOps 

type RationalOps interface {
	Negate() *RatioVal
	Invert() *RatioVal
	Add(arg *RatioVal) *RatioVal
	Substract(arg *RatioVal) *RatioVal
	Multipy(arg *RatioVal) *RatioVal
	Quotient(arg *RatioVal) *RatioVal
}

type Raw 

type Raw interface {
	GoBytes() []byte
}

type Real 

type Real interface {
	Float() FltVal
	GoFlt() float64
}

type RealComparators 

type RealComparators interface {
	EqualR(arg FltVal) bool
	LesserR(arg FltVal) bool
	GreaterR(arg FltVal) bool
}

type RealOps 

type RealOps interface {
	NegateR() FltVal
	AddR(arg FltVal) FltVal
	SubstractR(arg FltVal) FltVal
	MultipyR(arg FltVal) FltVal
	QuotientR(arg FltVal) FltVal
}

type Reproduceable 

type Reproduceable interface {
	Copy() Native
}

deep copy

type RuneVal 

type RuneVal rune

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (RuneVal) Copy 

func (v RuneVal) Copy() Native

func (RuneVal) Ident 

func (v RuneVal) Ident() RuneVal

func (RuneVal) MarshalBinary 

func (v RuneVal) MarshalBinary() ([]byte, error)

func (RuneVal) Null 

func (v RuneVal) Null() RuneVal

func (RuneVal) String 

func (v RuneVal) String() string

func (RuneVal) Type 

func (v RuneVal) Type() TyNat

type RuneVec 

type RuneVec []rune

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (RuneVec) Copy 

func (v RuneVec) Copy() Native

func (RuneVec) Empty 

func (v RuneVec) Empty() bool

func (RuneVec) Get 

func (v RuneVec) Get(i Native) Native

func (RuneVec) GetInt 

func (v RuneVec) GetInt(i int) Native

func (RuneVec) Len 

func (v RuneVec) Len() int

func (RuneVec) Native 

func (v RuneVec) Native(i int) rune

func (RuneVec) Null 

func (v RuneVec) Null() Native

func (RuneVec) Range 

func (v RuneVec) Range(i, j int) Sliceable

func (RuneVec) RangeNative 

func (v RuneVec) RangeNative(i, j int) []rune

func (RuneVec) Slice 

func (v RuneVec) Slice() []Native

func (RuneVec) String 

func (v RuneVec) String() string

func (RuneVec) Type 

func (v RuneVec) Type() TyNat

func (RuneVec) TypeElem 

func (v RuneVec) TypeElem() Typed

type Sequential 

type Sequential interface {
	Composed
	Head() Native
	Tail() DataSlice
	Shift() (Native, DataSlice)
}

a slice know's it's length and can be represented in as indexable.

type Serializeable 

type Serializeable interface {
	MarshalBinary() (BytesVal, error)
}

type Sliceable 

type Sliceable interface {
	Sliced
	Composed
	Len() int
	Copy() Native
	Get(Native) Native
	GetInt(int) Native
	Range(s, e int) Sliceable
	TypeElem() Typed
}

indexable sequence methods

func NewUnboxed 

func NewUnboxed(flag TyNat, args ...Native) Sliceable

expects all arguments to match the type passed in as flag

func SliceToNatives 

func SliceToNatives(c DataSlice) Sliceable

/// CONVERT TO SLICE OF NATIVES ////////

type Sliced 

type Sliced interface {
	Slice() []Native
}

indexable sequence of native instances

type StrVal 

type StrVal string

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func FlagShow 

func FlagShow(f Typed) StrVal

func (StrVal) Add 

func (v StrVal) Add(arg StrVal) StrVal

func (StrVal) Bytes 

func (v StrVal) Bytes() BytesVal

func (StrVal) Compare 

func (v StrVal) Compare(arg StrVal) int

func (StrVal) Concat 

func (v StrVal) Concat(arg StrVal) StrVal

operators

func (StrVal) Contains 

func (v StrVal) Contains(arg StrVal) bool

func (StrVal) ContainsAny 

func (v StrVal) ContainsAny(arg StrVal) bool

func (StrVal) ContainsRune 

func (v StrVal) ContainsRune(arg RuneVal) bool

func (StrVal) Copy 

func (v StrVal) Copy() Native

func (StrVal) DurationNative 

func (v StrVal) DurationNative() Native

func (StrVal) Equal 

func (v StrVal) Equal(arg StrVal) bool

func (StrVal) EqualFold 

func (v StrVal) EqualFold(arg StrVal) bool

comparators

func (StrVal) Greater 

func (v StrVal) Greater(arg StrVal) bool

func (StrVal) HasPrefix 

func (v StrVal) HasPrefix(arg StrVal) bool

func (StrVal) HasSuffix 

func (v StrVal) HasSuffix(arg StrVal) bool

func (StrVal) Ident 

func (v StrVal) Ident() StrVal

func (StrVal) Key 

func (v StrVal) Key() string

func (StrVal) Len 

func (v StrVal) Len() IntVal

func (StrVal) Lesser 

func (v StrVal) Lesser(arg StrVal) bool

func (StrVal) MarshalBinary 

func (v StrVal) MarshalBinary() ([]byte, error)

func (StrVal) Null 

func (v StrVal) Null() StrVal

func (StrVal) NumberNative 

func (v StrVal) NumberNative() Native

func (StrVal) ReadBool 

func (v StrVal) ReadBool() (bool, error)

// PARSE VALUES FROM STRING / read methods expect a string lexeme, stripped of whitespace & parsabel as native value by strconv.

BOOL

func (StrVal) ReadBoolVal 

func (v StrVal) ReadBoolVal() Native

func (StrVal) ReadDuraVal 

func (v StrVal) ReadDuraVal() Native

func (StrVal) ReadDuration 

func (v StrVal) ReadDuration() (time.Duration, error)

DURATION

func (StrVal) ReadFloat 

func (v StrVal) ReadFloat() (float64, error)

FLOAT

func (StrVal) ReadFloatVal 

func (v StrVal) ReadFloatVal() Native

func (StrVal) ReadInt 

func (v StrVal) ReadInt() (int, error)

INTEGER

func (StrVal) ReadIntVal 

func (v StrVal) ReadIntVal() Native

func (StrVal) ReadTime 

func (v StrVal) ReadTime(layout string) (time.Time, error)

TIME

func (StrVal) ReadTimeVal 

func (v StrVal) ReadTimeVal(layout string) Native

func (StrVal) ReadUint 

func (v StrVal) ReadUint() (uint, error)

NATURAL

func (StrVal) ReadUintVal 

func (v StrVal) ReadUintVal() Native

func (StrVal) Runes 

func (v StrVal) Runes() RuneVec

func (StrVal) Split 

func (v StrVal) Split(arg StrVal) (val []StrVal)

func (StrVal) String 

func (v StrVal) String() string

/ STRING VALUE conversions

func (StrVal) StringBuffer 

func (v StrVal) StringBuffer() *strings.Reader

func (StrVal) TimeNative 

func (v StrVal) TimeNative(layout string) Native

func (StrVal) Type 

func (v StrVal) Type() TyNat

func (StrVal) Unit 

func (v StrVal) Unit() Native

type StrVec 

type StrVec []string

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (StrVec) Copy 

func (v StrVec) Copy() Native

func (StrVec) Empty 

func (v StrVec) Empty() bool

func (StrVec) Get 

func (v StrVec) Get(i Native) Native

func (StrVec) GetInt 

func (v StrVec) GetInt(i int) Native

func (StrVec) Join 

func (v StrVec) Join(arg StrVal) (val []StrVal)

func (StrVec) Len 

func (v StrVec) Len() int

func (StrVec) Native 

func (v StrVec) Native(i int) string

func (StrVec) Null 

func (v StrVec) Null() Native

func (StrVec) Range 

func (v StrVec) Range(i, j int) Sliceable

func (StrVec) RangeNative 

func (v StrVec) RangeNative(i, j int) []string

func (StrVec) Slice 

func (v StrVec) Slice() []Native

func (StrVec) String 

func (v StrVec) String() string

func (StrVec) Type 

func (v StrVec) Type() TyNat

func (StrVec) TypeElem 

func (v StrVec) TypeElem() Typed

type Stringer 

type Stringer interface {
	String() string
}

type Text 

type Text interface {
	String() StrVal
}

type TimeVal 

type TimeVal time.Time

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (TimeVal) ANSIC 

func (v TimeVal) ANSIC() StrVal

func (TimeVal) Add 

func (v TimeVal) Add(arg DuraVal) TimeVal

operators

func (TimeVal) BigFlt 

func (v TimeVal) BigFlt() *BigFltVal

func (TimeVal) BigInt 

func (v TimeVal) BigInt() *BigIntVal

func (TimeVal) Bool 

func (v TimeVal) Bool() BoolVal

func (TimeVal) Copy 

func (v TimeVal) Copy() Native

func (TimeVal) Equal 

func (v TimeVal) Equal(arg TimeVal) bool

func (TimeVal) Float 

func (v TimeVal) Float() FltVal

func (TimeVal) GoBigFlt 

func (v TimeVal) GoBigFlt() *big.Float

func (TimeVal) GoBigInt 

func (v TimeVal) GoBigInt() *big.Int

func (TimeVal) GoFlt 

func (v TimeVal) GoFlt() float64

func (TimeVal) GoImag 

func (v TimeVal) GoImag() complex128

func (TimeVal) GoInt 

func (v TimeVal) GoInt() int

func (TimeVal) GoRat 

func (v TimeVal) GoRat() *big.Rat

func (TimeVal) GoUint 

func (v TimeVal) GoUint() uint

func (TimeVal) Greater 

func (v TimeVal) Greater(arg TimeVal) bool

func (TimeVal) Ident 

func (v TimeVal) Ident() TimeVal

func (TimeVal) Idx 

func (v TimeVal) Idx() int

/ TIME VALUE

func (TimeVal) Imag 

func (v TimeVal) Imag() ImagVal

func (TimeVal) Int 

func (v TimeVal) Int() IntVal

func (TimeVal) IntVal 

func (v TimeVal) IntVal() IntVal

func (TimeVal) Lesser 

func (v TimeVal) Lesser(arg TimeVal) bool

comparators

func (TimeVal) MarshalBinary 

func (v TimeVal) MarshalBinary() ([]byte, error)

func (TimeVal) Null 

func (v TimeVal) Null() TimeVal

func (TimeVal) Ratio 

func (v TimeVal) Ratio() *RatioVal

func (TimeVal) String 

func (v TimeVal) String() string

func (TimeVal) Substract 

func (v TimeVal) Substract(arg DuraVal) TimeVal

func (TimeVal) Time 

func (v TimeVal) Time() time.Time

func (TimeVal) Type 

func (v TimeVal) Type() TyNat

func (TimeVal) Uint 

func (v TimeVal) Uint() UintVal

func (TimeVal) UintVal 

func (v TimeVal) UintVal() UintVal

type TimeVec 

type TimeVec []time.Time

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (TimeVec) Copy 

func (v TimeVec) Copy() Native

func (TimeVec) Empty 

func (v TimeVec) Empty() bool

func (TimeVec) Get 

func (v TimeVec) Get(i Native) Native

func (TimeVec) GetInt 

func (v TimeVec) GetInt(i int) Native

func (TimeVec) Len 

func (v TimeVec) Len() int

func (TimeVec) Native 

func (v TimeVec) Native(i int) time.Time

func (TimeVec) Null 

func (v TimeVec) Null() Native

func (TimeVec) Range 

func (v TimeVec) Range(i, j int) Sliceable

func (TimeVec) RangeNative 

func (v TimeVec) RangeNative(i, j int) []time.Time

func (TimeVec) Slice 

func (v TimeVec) Slice() []Native

func (TimeVec) String 

func (v TimeVec) String() string

func (TimeVec) Type 

func (v TimeVec) Type() TyNat

func (TimeVec) TypeElem 

func (v TimeVec) TypeElem() Typed

type TyNat 

type TyNat BitFlag

////// INTERNAL TYPE SYSTEM ///////////

intended to be accessable and extendable

func FetchTypes 

func FetchTypes() []TyNat

func (TyNat) Eval 

func (v TyNat) Eval() Native

func (TyNat) Flag 

func (v TyNat) Flag() BitFlag

func (TyNat) Kind 

func (t TyNat) Kind() Uint8Val

func (TyNat) Match 

func (v TyNat) Match(arg Typed) bool

func (TyNat) String 

func (i TyNat) String() string

func (TyNat) Type 

func (v TyNat) Type() TyNat

func (TyNat) TypeName 

func (t TyNat) TypeName() string

type Typed 

type Typed interface {
	KindOfFlag
	NameOfType
	Flagged
	Matched
	Stringer
}

typed needs to not have the NativeTyped interface, to stay interchangeable with types from other packages

func FlagDecompose 

func FlagDecompose(v Typed) []Typed

decomposes flag resulting from OR concatenation, to a slice of flags

func FlagLow 

func FlagLow(t Typed) Typed

type Uint8Val 

type Uint8Val uint8

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (Uint8Val) Add 

func (v Uint8Val) Add(arg Uint8Val) Uint8Val

operators arithmetic

func (Uint8Val) AddU 

func (v Uint8Val) AddU(arg UintVal) UintVal

func (Uint8Val) And 

func (v Uint8Val) And(arg Uint8Val) Uint8Val

func (Uint8Val) AndNot 

func (v Uint8Val) AndNot(arg Uint8Val) Uint8Val

func (Uint8Val) AndNotU 

func (v Uint8Val) AndNotU(arg UintVal) UintVal

func (Uint8Val) AndU 

func (v Uint8Val) AndU(arg UintVal) UintVal

func (Uint8Val) BigFlt 

func (v Uint8Val) BigFlt() *BigFltVal

func (Uint8Val) BigInt 

func (v Uint8Val) BigInt() *BigIntVal

func (Uint8Val) Bool 

func (v Uint8Val) Bool() BoolVal

func (Uint8Val) BoolVal 

func (v Uint8Val) BoolVal() Native

func (Uint8Val) Copy 

func (v Uint8Val) Copy() Native

func (Uint8Val) Dec 

func (v Uint8Val) Dec() UintVal

func (Uint8Val) Equal 

func (v Uint8Val) Equal(arg Uint8Val) bool

comparators

func (Uint8Val) EqualU 

func (v Uint8Val) EqualU(arg UintVal) bool

comparators

func (Uint8Val) Float 

func (v Uint8Val) Float() FltVal

func (Uint8Val) GoBigFlt 

func (v Uint8Val) GoBigFlt() *big.Float

func (Uint8Val) GoBigInt 

func (v Uint8Val) GoBigInt() *big.Int

func (Uint8Val) GoFlt 

func (v Uint8Val) GoFlt() float64

func (Uint8Val) GoImag 

func (v Uint8Val) GoImag() complex128

func (Uint8Val) GoInt 

func (v Uint8Val) GoInt() int

func (Uint8Val) GoRat 

func (v Uint8Val) GoRat() *big.Rat

func (Uint8Val) GoUint 

func (v Uint8Val) GoUint() uint

func (Uint8Val) Greater 

func (v Uint8Val) Greater(arg Uint8Val) bool

func (Uint8Val) GreaterU 

func (v Uint8Val) GreaterU(arg UintVal) bool

func (Uint8Val) Ident 

func (v Uint8Val) Ident() Uint8Val

func (Uint8Val) Idx 

func (v Uint8Val) Idx() int

NATURAL VALUE Uint8Val conversions

func (Uint8Val) Imag 

func (v Uint8Val) Imag() ImagVal

func (Uint8Val) Inc 

func (v Uint8Val) Inc() UintVal

operators arithmetic

func (Uint8Val) Int 

func (v Uint8Val) Int() IntVal

func (Uint8Val) IntVal 

func (v Uint8Val) IntVal() IntVal

func (Uint8Val) Lesser 

func (v Uint8Val) Lesser(arg Uint8Val) bool

func (Uint8Val) LesserU 

func (v Uint8Val) LesserU(arg UintVal) bool

func (Uint8Val) MarshalBinary 

func (v Uint8Val) MarshalBinary() ([]byte, error)

func (Uint8Val) Multipy 

func (v Uint8Val) Multipy(arg Uint8Val) Uint8Val

func (Uint8Val) MultipyU 

func (v Uint8Val) MultipyU(arg UintVal) UintVal

func (Uint8Val) Not 

func (v Uint8Val) Not() Uint8Val

operators bool

func (Uint8Val) NotU 

func (v Uint8Val) NotU() UintVal

operators

func (Uint8Val) Null 

func (v Uint8Val) Null() Uint8Val

func (Uint8Val) Or 

func (v Uint8Val) Or(arg Uint8Val) Uint8Val

func (Uint8Val) OrU 

func (v Uint8Val) OrU(arg UintVal) UintVal

func (Uint8Val) Power 

func (v Uint8Val) Power(arg Uint8Val) Uint8Val

func (Uint8Val) PowerU 

func (v Uint8Val) PowerU(arg UintVal) UintVal

func (Uint8Val) QuoRatio 

func (v Uint8Val) QuoRatio(arg Uint8Val) *RatioVal

func (Uint8Val) QuoRatioU 

func (v Uint8Val) QuoRatioU(arg UintVal) *RatioVal

func (Uint8Val) Quotient 

func (v Uint8Val) Quotient(arg Uint8Val) Uint8Val

func (Uint8Val) QuotientU 

func (v Uint8Val) QuotientU(arg UintVal) UintVal

func (Uint8Val) Ratio 

func (v Uint8Val) Ratio() *RatioVal

func (Uint8Val) String 

func (v Uint8Val) String() string

func (Uint8Val) Substract 

func (v Uint8Val) Substract(arg Uint8Val) Uint8Val

func (Uint8Val) SubstractU 

func (v Uint8Val) SubstractU(arg UintVal) UintVal

func (Uint8Val) Type 

func (v Uint8Val) Type() TyNat

func (Uint8Val) Uint 

func (v Uint8Val) Uint() UintVal

func (Uint8Val) Uint8 

func (v Uint8Val) Uint8() Uint8Val

func (Uint8Val) Uint16 

func (v Uint8Val) Uint16() Uint16Val

func (Uint8Val) Uint32 

func (v Uint8Val) Uint32() Uint32Val

func (Uint8Val) Unit 

func (v Uint8Val) Unit() Native

func (Uint8Val) Xor 

func (v Uint8Val) Xor(arg Uint8Val) Uint8Val

func (Uint8Val) XorU 

func (v Uint8Val) XorU(arg UintVal) UintVal

type Uint8Vec 

type Uint8Vec []uint8

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (Uint8Vec) Copy 

func (v Uint8Vec) Copy() Native

func (Uint8Vec) Empty 

func (v Uint8Vec) Empty() bool

func (Uint8Vec) Get 

func (v Uint8Vec) Get(i Native) Native

func (Uint8Vec) GetInt 

func (v Uint8Vec) GetInt(i int) Native

func (Uint8Vec) Len 

func (v Uint8Vec) Len() int

func (Uint8Vec) Native 

func (v Uint8Vec) Native(i int) uint8

func (Uint8Vec) Null 

func (v Uint8Vec) Null() Native

func (Uint8Vec) Range 

func (v Uint8Vec) Range(i, j int) Sliceable

func (Uint8Vec) RangeNative 

func (v Uint8Vec) RangeNative(i, j int) []uint8

func (Uint8Vec) Slice 

func (v Uint8Vec) Slice() []Native

func (Uint8Vec) String 

func (v Uint8Vec) String() string

func (Uint8Vec) Type 

func (v Uint8Vec) Type() TyNat

func (Uint8Vec) TypeElem 

func (v Uint8Vec) TypeElem() Typed

type Uint16Val 

type Uint16Val uint16

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (Uint16Val) Add 

func (v Uint16Val) Add(arg Uint16Val) Uint16Val

operators arithmetic

func (Uint16Val) AddU 

func (v Uint16Val) AddU(arg UintVal) UintVal

func (Uint16Val) And 

func (v Uint16Val) And(arg Uint16Val) Uint16Val

func (Uint16Val) AndNot 

func (v Uint16Val) AndNot(arg Uint16Val) Uint16Val

func (Uint16Val) AndNotU 

func (v Uint16Val) AndNotU(arg UintVal) UintVal

func (Uint16Val) AndU 

func (v Uint16Val) AndU(arg UintVal) UintVal

func (Uint16Val) BigFlt 

func (v Uint16Val) BigFlt() *BigFltVal

func (Uint16Val) BigInt 

func (v Uint16Val) BigInt() *BigIntVal

func (Uint16Val) Bool 

func (v Uint16Val) Bool() BoolVal

func (Uint16Val) BoolVal 

func (v Uint16Val) BoolVal() Native

func (Uint16Val) Copy 

func (v Uint16Val) Copy() Native

func (Uint16Val) Dec 

func (v Uint16Val) Dec() UintVal

func (Uint16Val) Equal 

func (v Uint16Val) Equal(arg Uint16Val) bool

comparators

func (Uint16Val) EqualU 

func (v Uint16Val) EqualU(arg UintVal) bool

comparators

func (Uint16Val) Float 

func (v Uint16Val) Float() FltVal

func (Uint16Val) GoBigFlt 

func (v Uint16Val) GoBigFlt() *big.Float

func (Uint16Val) GoBigInt 

func (v Uint16Val) GoBigInt() *big.Int

func (Uint16Val) GoFlt 

func (v Uint16Val) GoFlt() float64

func (Uint16Val) GoImag 

func (v Uint16Val) GoImag() complex128

func (Uint16Val) GoInt 

func (v Uint16Val) GoInt() int

func (Uint16Val) GoRat 

func (v Uint16Val) GoRat() *big.Rat

func (Uint16Val) GoUint 

func (v Uint16Val) GoUint() uint

func (Uint16Val) Greater 

func (v Uint16Val) Greater(arg Uint16Val) bool

func (Uint16Val) GreaterU 

func (v Uint16Val) GreaterU(arg UintVal) bool

func (Uint16Val) Ident 

func (v Uint16Val) Ident() Uint16Val

func (Uint16Val) Idx 

func (v Uint16Val) Idx() int

Uint16Val conversions

func (Uint16Val) Imag 

func (v Uint16Val) Imag() ImagVal

func (Uint16Val) Inc 

func (v Uint16Val) Inc() UintVal

operators arithmetic

func (Uint16Val) Int 

func (v Uint16Val) Int() IntVal

func (Uint16Val) IntVal 

func (v Uint16Val) IntVal() IntVal

func (Uint16Val) Lesser 

func (v Uint16Val) Lesser(arg Uint16Val) bool

func (Uint16Val) LesserU 

func (v Uint16Val) LesserU(arg UintVal) bool

func (Uint16Val) MarshalBinary 

func (v Uint16Val) MarshalBinary() ([]byte, error)

func (Uint16Val) Multipy 

func (v Uint16Val) Multipy(arg Uint16Val) Uint16Val

func (Uint16Val) MultipyU 

func (v Uint16Val) MultipyU(arg UintVal) UintVal

func (Uint16Val) Not 

func (v Uint16Val) Not() Uint16Val

operators

func (Uint16Val) NotU 

func (v Uint16Val) NotU() UintVal

operators

func (Uint16Val) Null 

func (v Uint16Val) Null() Uint16Val

func (Uint16Val) Or 

func (v Uint16Val) Or(arg Uint16Val) Uint16Val

func (Uint16Val) OrU 

func (v Uint16Val) OrU(arg UintVal) UintVal

func (Uint16Val) Power 

func (v Uint16Val) Power(arg Uint16Val) Uint16Val

func (Uint16Val) PowerU 

func (v Uint16Val) PowerU(arg UintVal) UintVal

func (Uint16Val) QuoRatio 

func (v Uint16Val) QuoRatio(arg Uint16Val) *RatioVal

func (Uint16Val) QuoRatioU 

func (v Uint16Val) QuoRatioU(arg UintVal) *RatioVal

func (Uint16Val) Quotient 

func (v Uint16Val) Quotient(arg Uint16Val) Uint16Val

func (Uint16Val) QuotientU 

func (v Uint16Val) QuotientU(arg UintVal) UintVal

func (Uint16Val) Ratio 

func (v Uint16Val) Ratio() *RatioVal

func (Uint16Val) String 

func (v Uint16Val) String() string

func (Uint16Val) Substract 

func (v Uint16Val) Substract(arg Uint16Val) Uint16Val

func (Uint16Val) SubstractU 

func (v Uint16Val) SubstractU(arg UintVal) UintVal

func (Uint16Val) Type 

func (v Uint16Val) Type() TyNat

func (Uint16Val) Uint 

func (v Uint16Val) Uint() UintVal

func (Uint16Val) Uint8 

func (v Uint16Val) Uint8() Uint8Val

func (Uint16Val) Uint16 

func (v Uint16Val) Uint16() Uint16Val

func (Uint16Val) Uint32 

func (v Uint16Val) Uint32() Uint32Val

func (Uint16Val) Unit 

func (v Uint16Val) Unit() Native

func (Uint16Val) Xor 

func (v Uint16Val) Xor(arg Uint16Val) Uint16Val

func (Uint16Val) XorU 

func (v Uint16Val) XorU(arg UintVal) UintVal

type Uint16Vec 

type Uint16Vec []uint16

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (Uint16Vec) Copy 

func (v Uint16Vec) Copy() Native

func (Uint16Vec) Empty 

func (v Uint16Vec) Empty() bool

func (Uint16Vec) Get 

func (v Uint16Vec) Get(i Native) Native

func (Uint16Vec) GetInt 

func (v Uint16Vec) GetInt(i int) Native

func (Uint16Vec) Len 

func (v Uint16Vec) Len() int

func (Uint16Vec) Native 

func (v Uint16Vec) Native(i int) uint16

func (Uint16Vec) Null 

func (v Uint16Vec) Null() Native

func (Uint16Vec) Range 

func (v Uint16Vec) Range(i, j int) Sliceable

func (Uint16Vec) RangeNative 

func (v Uint16Vec) RangeNative(i, j int) []uint16

func (Uint16Vec) Slice 

func (v Uint16Vec) Slice() []Native

func (Uint16Vec) String 

func (v Uint16Vec) String() string

func (Uint16Vec) Type 

func (v Uint16Vec) Type() TyNat

func (Uint16Vec) TypeElem 

func (v Uint16Vec) TypeElem() Typed

type Uint32Val 

type Uint32Val uint32

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (Uint32Val) Add 

func (v Uint32Val) Add(arg Uint32Val) Uint32Val

func (Uint32Val) AddU 

func (v Uint32Val) AddU(arg UintVal) UintVal

operators arithmetic

func (Uint32Val) And 

func (v Uint32Val) And(arg Uint32Val) Uint32Val

func (Uint32Val) AndNot 

func (v Uint32Val) AndNot(arg Uint32Val) Uint32Val

func (Uint32Val) AndNotU 

func (v Uint32Val) AndNotU(arg UintVal) UintVal

func (Uint32Val) AndU 

func (v Uint32Val) AndU(arg UintVal) UintVal

func (Uint32Val) BigFlt 

func (v Uint32Val) BigFlt() *BigFltVal

func (Uint32Val) BigInt 

func (v Uint32Val) BigInt() *BigIntVal

func (Uint32Val) Bool 

func (v Uint32Val) Bool() BoolVal

func (Uint32Val) BoolVal 

func (v Uint32Val) BoolVal() Native

func (Uint32Val) Copy 

func (v Uint32Val) Copy() Native

func (Uint32Val) Dec 

func (v Uint32Val) Dec() UintVal

func (Uint32Val) Equal 

func (v Uint32Val) Equal(arg Uint32Val) bool

comparators 32bit

func (Uint32Val) EqualU 

func (v Uint32Val) EqualU(arg UintVal) bool

comparators

func (Uint32Val) Float 

func (v Uint32Val) Float() FltVal

func (Uint32Val) GoBigFlt 

func (v Uint32Val) GoBigFlt() *big.Float

func (Uint32Val) GoBigInt 

func (v Uint32Val) GoBigInt() *big.Int

func (Uint32Val) GoFlt 

func (v Uint32Val) GoFlt() float64

func (Uint32Val) GoImag 

func (v Uint32Val) GoImag() complex128

func (Uint32Val) GoInt 

func (v Uint32Val) GoInt() int

func (Uint32Val) GoRat 

func (v Uint32Val) GoRat() *big.Rat

func (Uint32Val) GoUint 

func (v Uint32Val) GoUint() uint

func (Uint32Val) Greater 

func (v Uint32Val) Greater(arg Uint32Val) bool

func (Uint32Val) GreaterU 

func (v Uint32Val) GreaterU(arg UintVal) bool

func (Uint32Val) Ident 

func (v Uint32Val) Ident() Uint32Val

func (Uint32Val) Idx 

func (v Uint32Val) Idx() int

Uint32Val conversions

func (Uint32Val) Imag 

func (v Uint32Val) Imag() ImagVal

func (Uint32Val) Inc 

func (v Uint32Val) Inc() UintVal

operators arithmetic 32bit

func (Uint32Val) Int 

func (v Uint32Val) Int() IntVal

func (Uint32Val) IntVal 

func (v Uint32Val) IntVal() IntVal

func (Uint32Val) Lesser 

func (v Uint32Val) Lesser(arg Uint32Val) bool

func (Uint32Val) LesserU 

func (v Uint32Val) LesserU(arg UintVal) bool

func (Uint32Val) MarshalBinary 

func (v Uint32Val) MarshalBinary() ([]byte, error)

func (Uint32Val) Multipy 

func (v Uint32Val) Multipy(arg Uint32Val) Uint32Val

func (Uint32Val) MultipyU 

func (v Uint32Val) MultipyU(arg UintVal) UintVal

func (Uint32Val) Not 

func (v Uint32Val) Not() Uint32Val

operators 32bit

func (Uint32Val) NotU 

func (v Uint32Val) NotU() UintVal

operators

func (Uint32Val) Null 

func (v Uint32Val) Null() Uint32Val

func (Uint32Val) Or 

func (v Uint32Val) Or(arg Uint32Val) Uint32Val

func (Uint32Val) OrU 

func (v Uint32Val) OrU(arg UintVal) UintVal

func (Uint32Val) Power 

func (v Uint32Val) Power(arg Uint32Val) Uint32Val

func (Uint32Val) PowerU 

func (v Uint32Val) PowerU(arg UintVal) UintVal

func (Uint32Val) QuoRatio 

func (v Uint32Val) QuoRatio(arg Uint32Val) *RatioVal

func (Uint32Val) QuoRatioU 

func (v Uint32Val) QuoRatioU(arg UintVal) *RatioVal

func (Uint32Val) Quotien 

func (v Uint32Val) Quotien(arg Uint32Val) Uint32Val

func (Uint32Val) QuotientU 

func (v Uint32Val) QuotientU(arg UintVal) UintVal

func (Uint32Val) Ratio 

func (v Uint32Val) Ratio() *RatioVal

func (Uint32Val) String 

func (v Uint32Val) String() string

func (Uint32Val) Substract 

func (v Uint32Val) Substract(arg Uint32Val) Uint32Val

func (Uint32Val) SubstractU 

func (v Uint32Val) SubstractU(arg UintVal) UintVal

func (Uint32Val) Type 

func (v Uint32Val) Type() TyNat

func (Uint32Val) Uint 

func (v Uint32Val) Uint() UintVal

func (Uint32Val) Uint8 

func (v Uint32Val) Uint8() Uint8Val

func (Uint32Val) Uint16 

func (v Uint32Val) Uint16() Uint16Val

func (Uint32Val) Uint32 

func (v Uint32Val) Uint32() Uint32Val

func (Uint32Val) Unit 

func (v Uint32Val) Unit() Native

func (Uint32Val) Xor 

func (v Uint32Val) Xor(arg Uint32Val) Uint32Val

func (Uint32Val) XorU 

func (v Uint32Val) XorU(arg UintVal) UintVal

type Uint32Vec 

type Uint32Vec []uint32

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (Uint32Vec) Copy 

func (v Uint32Vec) Copy() Native

func (Uint32Vec) Empty 

func (v Uint32Vec) Empty() bool

func (Uint32Vec) Get 

func (v Uint32Vec) Get(i Native) Native

func (Uint32Vec) GetInt 

func (v Uint32Vec) GetInt(i int) Native

func (Uint32Vec) Len 

func (v Uint32Vec) Len() int

func (Uint32Vec) Native 

func (v Uint32Vec) Native(i int) uint32

func (Uint32Vec) Null 

func (v Uint32Vec) Null() Native

func (Uint32Vec) Range 

func (v Uint32Vec) Range(i, j int) Sliceable

func (Uint32Vec) RangeNative 

func (v Uint32Vec) RangeNative(i, j int) []uint32

func (Uint32Vec) Slice 

func (v Uint32Vec) Slice() []Native

func (Uint32Vec) String 

func (v Uint32Vec) String() string

func (Uint32Vec) Type 

func (v Uint32Vec) Type() TyNat

func (Uint32Vec) TypeElem 

func (v Uint32Vec) TypeElem() Typed

type UintVal 

type UintVal uint

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (UintVal) Add 

func (v UintVal) Add(arg UintVal) UintVal

operators arithmetic

func (UintVal) AddU 

func (v UintVal) AddU(arg UintVal) UintVal

func (UintVal) And 

func (v UintVal) And(arg UintVal) UintVal

func (UintVal) AndNot 

func (v UintVal) AndNot(arg UintVal) UintVal

func (UintVal) AndNotU 

func (v UintVal) AndNotU(arg UintVal) UintVal

func (UintVal) AndU 

func (v UintVal) AndU(arg UintVal) UintVal

func (UintVal) BigFlt 

func (v UintVal) BigFlt() *BigFltVal

func (UintVal) BigInt 

func (v UintVal) BigInt() *BigIntVal

func (UintVal) Bool 

func (v UintVal) Bool() BoolVal

func (UintVal) BoolVal 

func (v UintVal) BoolVal() Native

func (UintVal) Copy 

func (v UintVal) Copy() Native

func (UintVal) Dec 

func (v UintVal) Dec() UintVal

func (UintVal) Equal 

func (v UintVal) Equal(arg UintVal) bool

comparators

func (UintVal) EqualU 

func (v UintVal) EqualU(arg UintVal) bool

comparators

func (UintVal) Float 

func (v UintVal) Float() FltVal

func (UintVal) GoBigFlt 

func (v UintVal) GoBigFlt() *big.Float

func (UintVal) GoBigInt 

func (v UintVal) GoBigInt() *big.Int

func (UintVal) GoFlt 

func (v UintVal) GoFlt() float64

func (UintVal) GoImag 

func (v UintVal) GoImag() complex128

func (UintVal) GoInt 

func (v UintVal) GoInt() int

func (UintVal) GoRat 

func (v UintVal) GoRat() *big.Rat

func (UintVal) GoUint 

func (v UintVal) GoUint() uint

func (UintVal) Greater 

func (v UintVal) Greater(arg UintVal) bool

func (UintVal) GreaterU 

func (v UintVal) GreaterU(arg UintVal) bool

func (UintVal) Ident 

func (v UintVal) Ident() UintVal

func (UintVal) Idx 

func (v UintVal) Idx() int

UintVal conversions

func (UintVal) Imag 

func (v UintVal) Imag() ImagVal

func (UintVal) Inc 

func (v UintVal) Inc() UintVal

operators arithmetic

func (UintVal) Int 

func (v UintVal) Int() IntVal

func (UintVal) IntVal 

func (v UintVal) IntVal() IntVal

func (UintVal) Lesser 

func (v UintVal) Lesser(arg UintVal) bool

func (UintVal) LesserU 

func (v UintVal) LesserU(arg UintVal) bool

func (UintVal) MarshalBinary 

func (v UintVal) MarshalBinary() ([]byte, error)

func (UintVal) Multipy 

func (v UintVal) Multipy(arg UintVal) UintVal

func (UintVal) MultipyU 

func (v UintVal) MultipyU(arg UintVal) UintVal

func (UintVal) Not 

func (v UintVal) Not() UintVal

operators

func (UintVal) NotU 

func (v UintVal) NotU() UintVal

operators

func (UintVal) Null 

func (v UintVal) Null() UintVal

func (UintVal) Or 

func (v UintVal) Or(arg UintVal) UintVal

func (UintVal) OrU 

func (v UintVal) OrU(arg UintVal) UintVal

func (UintVal) Power 

func (v UintVal) Power(arg UintVal) UintVal

func (UintVal) PowerU 

func (v UintVal) PowerU(arg UintVal) UintVal

func (UintVal) QuoRatio 

func (v UintVal) QuoRatio(arg UintVal) *RatioVal

func (UintVal) QuoRatioU 

func (v UintVal) QuoRatioU(arg UintVal) *RatioVal

func (UintVal) Quotient 

func (v UintVal) Quotient(arg UintVal) UintVal

func (UintVal) QuotientU 

func (v UintVal) QuotientU(arg UintVal) UintVal

func (UintVal) Ratio 

func (v UintVal) Ratio() *RatioVal

func (UintVal) String 

func (v UintVal) String() string

func (UintVal) Substract 

func (v UintVal) Substract(arg UintVal) UintVal

func (UintVal) SubstractU 

func (v UintVal) SubstractU(arg UintVal) UintVal

func (UintVal) Type 

func (v UintVal) Type() TyNat

func (UintVal) Uint 

func (v UintVal) Uint() UintVal

func (UintVal) Uint8 

func (v UintVal) Uint8() Uint8Val

func (UintVal) Uint16 

func (v UintVal) Uint16() Uint16Val

func (UintVal) Uint32 

func (v UintVal) Uint32() Uint32Val

func (UintVal) Unit 

func (v UintVal) Unit() Native

func (UintVal) Xor 

func (v UintVal) Xor(arg UintVal) UintVal

func (UintVal) XorU 

func (v UintVal) XorU(arg UintVal) UintVal

type UintVec 

type UintVec []uint

////// INTERNAL TYPES ///////////// internal types are typealiases without any wrapping, or referencing getting in the way performancewise. types need to be aliased in the first place, to associate them with a bitflag, without having to actually asign, let alone attach it to the instance.

func (UintVec) Copy 

func (v UintVec) Copy() Native

func (UintVec) Empty 

func (v UintVec) Empty() bool

func (UintVec) Get 

func (v UintVec) Get(i Native) Native

func (UintVec) GetInt 

func (v UintVec) GetInt(i int) Native

func (UintVec) Len 

func (v UintVec) Len() int

func (UintVec) Native 

func (v UintVec) Native(i int) uint

func (UintVec) Null 

func (v UintVec) Null() Native

func (UintVec) Range 

func (v UintVec) Range(i, j int) Sliceable

func (UintVec) RangeNative 

func (v UintVec) RangeNative(i, j int) []uint

func (UintVec) Slice 

func (v UintVec) Slice() []Native

func (UintVec) String 

func (v UintVec) String() string

func (UintVec) Type 

func (v UintVec) Type() TyNat

func (UintVec) TypeElem 

func (v UintVec) TypeElem() Typed

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.