over

Documentation

Index

• Variables
• type Add
• type AddImpl
  • func (a *AddImpl) Add(_ interface{}) (interface{}, error)
  • func (a *AddImpl) Or(_ interface{}) (interface{}, error)
  • func (a *AddImpl) Sub(_ interface{}) (interface{}, error)
• type Binary
• type BinaryImpl
  • func (b *BinaryImpl) Binary() bool
• type Comparison
• type ComparisonImpl
  • func (c *ComparisonImpl) Distinct(_ interface{}) error
  • func (c *ComparisonImpl) Equals(_ interface{}) error
  • func (c *ComparisonImpl) Greater(_ interface{}) error
  • func (c *ComparisonImpl) GreaterEquals(_ interface{}) error
  • func (c *ComparisonImpl) Less(_ interface{}) error
  • func (c *ComparisonImpl) LessEquals(_ interface{}) error
• type Index
• type IndexImpl
  • func (s *IndexImpl) Index(_ interface{}) (interface{}, error)
• type Len
• type LenImpl
  • func (l *LenImpl) Len() int64
• type Mem
• type MemImpl
  • func (m *MemImpl) New() (interface{}, error)
• type Multiply
• type MultiplyImpl
  • func (a *MultiplyImpl) And(_ interface{}) (interface{}, error)
  • func (a *MultiplyImpl) Div(_ interface{}) (interface{}, error)
  • func (a *MultiplyImpl) Left(_ interface{}) (interface{}, error)
  • func (a *MultiplyImpl) Mod(_ interface{}) (interface{}, error)
  • func (a *MultiplyImpl) Mul(_ interface{}) (interface{}, error)
  • func (a *MultiplyImpl) Right(_ interface{}) (interface{}, error)
• type Set
• type SetImpl
  • func (a *SetImpl) Set(_ interface{}) error
• type String
• type StringImpl
  • func (a *StringImpl) String() string

Variables

var (
	ErrMethodNotImplemented = errors.New("method not implemented")
	ErrNoMatch              = errors.New("values doesn't match")
)

var (
	ErrOutOfRange       = errors.New("index out of range")
	ErrUnsupportedIndex = errors.New("bad index type")
)

var AddReflectType = reflect.TypeOf(new(Add)).Elem()

var BinaryReflectType = reflect.TypeOf(new(Binary)).Elem()

var ComparisonReflectType = reflect.TypeOf(new(Comparison)).Elem()

var IndexReflectType = reflect.TypeOf(new(Index)).Elem()

var LenReflectType = reflect.TypeOf(new(Len)).Elem()

var MemReflectType = reflect.TypeOf(new(Mem)).Elem()

var MultiplyReflectType = reflect.TypeOf(new(Multiply)).Elem()

var SetReflectType = reflect.TypeOf(new(Set)).Elem()

var StringReflectType = reflect.TypeOf(new(String)).Elem()

Types

type Add

type Add interface {
	// Add + or ++
	Add(interface{}) (interface{}, error)
	// Sub - or --
	Sub(interface{}) (interface{}, error)
	// Or |
	Or(interface{}) (interface{}, error)
}

type AddImpl

type AddImpl struct{}

func (*AddImpl) Add

func (a *AddImpl) Add(_ interface{}) (interface{}, error)

func (*AddImpl) Or

func (a *AddImpl) Or(_ interface{}) (interface{}, error)

func (*AddImpl) Sub

func (a *AddImpl) Sub(_ interface{}) (interface{}, error)

type Binary

type Binary interface {
	// Binary && or || or if
	Binary() bool
}

type BinaryImpl

type BinaryImpl struct{}

func (*BinaryImpl) Binary

func (b *BinaryImpl) Binary() bool

type Comparison

type Comparison interface {
	// Equals ==
	Equals(interface{}) error
	// Distinct !=
	Distinct(interface{}) error
	// Less <
	Less(interface{}) error
	// LessEquals <=
	LessEquals(interface{}) error
	// Greater >
	Greater(interface{}) error
	// GreaterEquals >=
	GreaterEquals(interface{}) error
}

type ComparisonImpl

type ComparisonImpl struct{}

func (*ComparisonImpl) Distinct

func (c *ComparisonImpl) Distinct(_ interface{}) error

func (*ComparisonImpl) Equals

func (c *ComparisonImpl) Equals(_ interface{}) error

func (*ComparisonImpl) Greater

func (c *ComparisonImpl) Greater(_ interface{}) error

func (*ComparisonImpl) GreaterEquals

func (c *ComparisonImpl) GreaterEquals(_ interface{}) error

func (*ComparisonImpl) Less

func (c *ComparisonImpl) Less(_ interface{}) error

func (*ComparisonImpl) LessEquals

func (c *ComparisonImpl) LessEquals(_ interface{}) error

type Index

type Index interface {
	// Index []
	Index(interface{}) (interface{}, error)
	Len
}

type IndexImpl

type IndexImpl struct{}

func (*IndexImpl) Index

func (s *IndexImpl) Index(_ interface{}) (interface{}, error)

type Len

type Len interface {
	// Len len()
	Len() int64
}

type LenImpl

type LenImpl struct{}

func (*LenImpl) Len

func (l *LenImpl) Len() int64

type Mem

type Mem interface {
	// New new
	New() (interface{}, error)
}

type MemImpl

type MemImpl struct{}

func (*MemImpl) New

func (m *MemImpl) New() (interface{}, error)

type Multiply

type Multiply interface {
	// Mul *
	Mul(interface{}) (interface{}, error)
	// Div /
	Div(interface{}) (interface{}, error)
	// Mod %
	Mod(interface{}) (interface{}, error)
	// Left <<
	Left(interface{}) (interface{}, error)
	// Right >>
	Right(interface{}) (interface{}, error)
	// And &
	And(interface{}) (interface{}, error)
}

type MultiplyImpl

type MultiplyImpl struct{}

func (*MultiplyImpl) And

func (a *MultiplyImpl) And(_ interface{}) (interface{}, error)

func (*MultiplyImpl) Div

func (a *MultiplyImpl) Div(_ interface{}) (interface{}, error)

func (*MultiplyImpl) Left

func (a *MultiplyImpl) Left(_ interface{}) (interface{}, error)

func (*MultiplyImpl) Mod

func (a *MultiplyImpl) Mod(_ interface{}) (interface{}, error)

func (*MultiplyImpl) Mul

func (a *MultiplyImpl) Mul(_ interface{}) (interface{}, error)

func (*MultiplyImpl) Right

func (a *MultiplyImpl) Right(_ interface{}) (interface{}, error)

type Set

type Set interface {
	// Set =
	Set(interface{}) error
}

type SetImpl

type SetImpl struct{}

func (*SetImpl) Set

func (a *SetImpl) Set(_ interface{}) error

type String

type String interface {
	// String()
	fmt.Stringer
}

type StringImpl

type StringImpl struct{}

func (*StringImpl) String

func (a *StringImpl) String() string