Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

over

package

Go to main page

Versions in this module

v0

v0.2.5

Aug 11, 2020

v0.2.4

May 4, 2020

v0.2.3

Apr 29, 2020

Changes in this version

+ var ErrUnsupportedIndex = errors.New("bad index type")

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

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

+ type Set interface

+ Set func(interface{}) error

+ type SetImpl struct

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

+ type String interface

+ type StringImpl struct

+ func (a *StringImpl) String() string

v0.2.2

Apr 26, 2020

Changes in this version

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

+ var AssignReflectType = reflect.TypeOf(new(Assign)).Elem()

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

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

+ var ErrMethodNotImplemented = errors.New("method not implemented")

+ var ErrNoMatch = errors.New("values doesn't match")

+ var ErrOutOfRange = errors.New("index out of range")

+ 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()

+ type Add interface

+ Add func(interface{}) (interface{}, error)

+ Or func(interface{}) (interface{}, error)

+ Sub func(interface{}) (interface{}, error)

+ type AddImpl struct

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

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

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

+ type Assign interface

+ Assign func(interface{}) error

+ type AssignImpl struct

+ func (a *AssignImpl) Assign(_ interface{}) error

+ type Binary interface

+ Binary func() bool

+ type BinaryImpl struct

+ func (b *BinaryImpl) Binary() bool

+ type Comparison interface

+ Distinct func(interface{}) error

+ Equals func(interface{}) error

+ Greater func(interface{}) error

+ GreaterEquals func(interface{}) error

+ Less func(interface{}) error

+ LessEquals func(interface{}) error

+ type ComparisonImpl struct

+ 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 interface

+ Index func(interface{}) (interface{}, error)

+ type IndexImpl struct

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

+ type Len interface

+ Len func() int64

+ type LenImpl struct

+ func (l *LenImpl) Len() int64

+ type Mem interface

+ New func() (interface{}, error)

+ type MemImpl struct

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

+ type Multiply interface

+ And func(interface{}) (interface{}, error)

+ Div func(interface{}) (interface{}, error)

+ Left func(interface{}) (interface{}, error)

+ Mod func(interface{}) (interface{}, error)

+ Mul func(interface{}) (interface{}, error)

+ Right func(interface{}) (interface{}, error)

+ type MultiplyImpl struct

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