compare

Sep 2, 2026

Changes in this version

+ var DefaultValuesComparator atomic.Pointer[CommonComparator]

+ func FilterTypes(typs ...reflect.Type) func(typ reflect.Type) bool

+ type ArrayComparator struct

+ MaxDifferences int

+ func NewArrayComparator(vc ValuesComparator) *ArrayComparator

+ func (vc *ArrayComparator) CompareValues(st *State, v1, v2 reflect.Value) (res Result, handled bool)

+ func (vc *ArrayComparator) Supports(typ reflect.Type) ValuesComparator

+ type BoolComparator struct

+ func NewBoolComparator() *BoolComparator

+ func (vc *BoolComparator) CompareValues(st *State, v1, v2 reflect.Value) (res Result, handled bool)

+ func (vc *BoolComparator) Supports(typ reflect.Type) ValuesComparator

+ type ByTypeComparators map[reflect.Type]ValuesComparator

+ func NewByTypeComparators() ByTypeComparators

+ func (vcs ByTypeComparators) CompareValues(st *State, v1, v2 reflect.Value) (res Result, handled bool)

+ type BytesComparator struct

+ func NewBytesComparator() *BytesComparator

+ func (vc *BytesComparator) CompareValues(st *State, v1, v2 reflect.Value) (res Result, handled bool)

+ func (vc *BytesComparator) Supports(typ reflect.Type) ValuesComparator

+ type CanInterfaceComparator struct

+ func NewCanInterfaceComparator(vc ValuesComparator) *CanInterfaceComparator

+ func (vc *CanInterfaceComparator) CompareValues(st *State, v1, v2 reflect.Value) (res Result, handled bool)

+ type ChanComparator struct

+ func NewChanComparator() *ChanComparator

+ func (vc *ChanComparator) CompareValues(st *State, v1, v2 reflect.Value) (res Result, handled bool)

+ func (vc *ChanComparator) Supports(typ reflect.Type) ValuesComparator

+ type CommonComparator struct

+ ByType ByTypeComparators

+ Bytes *BytesComparator

+ CanInterface *CanInterfaceComparator

+ Compare *FilterComparator[*CompareComparator]

+ Equal *FilterComparator[*EqualComparator]

+ Kind *KindComparator

+ MaxDepth *MaxDepthComparator

+ Recursion *RecursionComparator

+ ReflectValue *ReflectValueComparator

+ Support *SupportComparator

+ ValuesComparators ValuesComparators

+ func NewCommonComparator() *CommonComparator

+ func (vc *CommonComparator) CompareValues(st *State, v1, v2 reflect.Value) (res Result, handled bool)

+ func (vc *CommonComparator) Supports(typ reflect.Type) ValuesComparator

type Comparator

+ ValuesComparator ValuesComparator

+ type CompareComparator struct

+ CompareNames []string

+ func NewCompareComparator() *CompareComparator

+ func (vc *CompareComparator) CompareValues(st *State, v1, v2 reflect.Value) (res Result, handled bool)

+ func (vc *CompareComparator) Supports(typ reflect.Type) ValuesComparator

+ type ComplexComparator struct

+ NaNEqual bool

+ SignedZeroEqual bool

+ func NewComplexComparator() *ComplexComparator

+ func (vc *ComplexComparator) CompareValues(st *State, v1, v2 reflect.Value) (res Result, handled bool)

+ func (vc *ComplexComparator) Supports(typ reflect.Type) ValuesComparator

type Difference

+ func (d Difference) AppendText(b []byte) ([]byte, error)

+ func (d Difference) AppendTo(b []byte) []byte

+ func (d Difference) String() string

+ type EqualComparator struct

+ Names []string

+ func NewEqualComparator() *EqualComparator

+ func (vc *EqualComparator) CompareValues(st *State, v1, v2 reflect.Value) (res Result, handled bool)

+ func (vc *EqualComparator) Supports(typ reflect.Type) ValuesComparator

+ type FilterComparator struct

+ Filter func(typ reflect.Type) bool

+ ValuesComparator VC

+ func NewFilterComparator[VC ValuesComparator](vc VC, f func(typ reflect.Type) bool) *FilterComparator[VC]

+ func (vc *FilterComparator[VC]) CompareValues(st *State, v1, v2 reflect.Value) (res Result, handled bool)

+ func (vc *FilterComparator[VC]) Supports(typ reflect.Type) ValuesComparator

+ type FloatComparator struct

+ NaNEqual bool

+ SignedZeroEqual bool

+ func NewFloatComparator() *FloatComparator

+ func (vc *FloatComparator) CompareValues(st *State, v1, v2 reflect.Value) (res Result, handled bool)

+ func (vc *FloatComparator) Supports(typ reflect.Type) ValuesComparator

+ type FuncComparator struct

+ func NewFuncComparator() *FuncComparator

+ func (vc *FuncComparator) CompareValues(st *State, v1, v2 reflect.Value) (res Result, handled bool)

+ func (vc *FuncComparator) Supports(typ reflect.Type) ValuesComparator

+ type IntComparator struct

+ func NewIntComparator() *IntComparator

+ func (vc *IntComparator) CompareValues(st *State, v1, v2 reflect.Value) (res Result, handled bool)

+ func (vc *IntComparator) Supports(typ reflect.Type) ValuesComparator

+ type InterfaceComparator struct

+ func NewInterfaceComparator(vc ValuesComparator) *InterfaceComparator

+ func (vc *InterfaceComparator) CompareValues(st *State, v1, v2 reflect.Value) (res Result, handled bool)

+ func (vc *InterfaceComparator) Supports(typ reflect.Type) ValuesComparator

+ type KindComparator struct

+ Array *ArrayComparator

+ Bool *BoolComparator

+ Chan *ChanComparator

+ Complex *ComplexComparator

+ Float *FloatComparator

+ Func *FuncComparator

+ Int *IntComparator

+ Interface *InterfaceComparator

+ Map *MapComparator

+ Pointer *PointerComparator

+ Slice *SliceComparator

+ String *StringComparator

+ Struct *StructComparator

+ Uint *UintComparator

+ UnsafePointer *UnsafePointerComparator

+ ValuesComparators [kindsCount]ValuesComparator

+ func NewKindComparator(vc ValuesComparator) *KindComparator

+ func (kvc *KindComparator) CompareValues(st *State, v1, v2 reflect.Value) (res Result, handled bool)

+ func (kvc *KindComparator) Supports(typ reflect.Type) ValuesComparator

+ type MapComparator struct

+ MaxDifferences int

+ func NewMapComparator(vc ValuesComparator) *MapComparator

+ func (vc *MapComparator) CompareValues(st *State, v1, v2 reflect.Value) (res Result, handled bool)

+ func (vc *MapComparator) Supports(typ reflect.Type) ValuesComparator

+ type MaxDepthComparator struct

+ Max int

+ Report bool

+ func NewMaxDepthComparator(vc ValuesComparator) *MaxDepthComparator

+ func (vc *MaxDepthComparator) CompareValues(st *State, v1, v2 reflect.Value) (res Result, handled bool)

type Path

+ func (p Path) AppendText(b []byte) ([]byte, error)

+ func (p Path) AppendTo(b []byte) []byte

type PathElem

+ Key *any

+ Name *string

+ Pointer bool

+ func (e PathElem) AppendText(b []byte) ([]byte, error)

+ func (e PathElem) AppendTo(b []byte) []byte

+ type PointerComparator struct

+ func NewPointerComparator(vc ValuesComparator) *PointerComparator

+ func (vc *PointerComparator) CompareValues(st *State, v1, v2 reflect.Value) (res Result, handled bool)

+ func (vc *PointerComparator) Supports(typ reflect.Type) ValuesComparator

+ type RecursionComparator struct

+ func NewRecursionComparator(vc ValuesComparator) *RecursionComparator

+ func (vc *RecursionComparator) CompareValues(st *State, v1, v2 reflect.Value) (res Result, handled bool)

+ type ReflectValueComparator struct

+ func NewReflectValueComparator(vc ValuesComparator) *ReflectValueComparator

+ func (vc *ReflectValueComparator) CompareValues(st *State, v1, v2 reflect.Value) (res Result, handled bool)

+ func (vc *ReflectValueComparator) Supports(typ reflect.Type) ValuesComparator

type Result

+ func Res(msg string, v1, v2 any) Result

+ func (r Result) AppendPathElem(e PathElem)

+ func (r Result) AppendText(b []byte) ([]byte, error)

+ func (r Result) AppendTo(b []byte) []byte

+ func (r Result) String() string

+ type SliceComparator struct

+ MaxDifferences int

+ func NewSliceComparator(vc ValuesComparator) *SliceComparator

+ func (vc *SliceComparator) CompareValues(st *State, v1, v2 reflect.Value) (res Result, handled bool)

+ func (vc *SliceComparator) Supports(typ reflect.Type) ValuesComparator

type State

+ func (st *State) Reset()

+ type StringComparator struct

+ func NewStringComparator() *StringComparator

+ func (vc *StringComparator) CompareValues(st *State, v1, v2 reflect.Value) (res Result, handled bool)

+ func (vc *StringComparator) Supports(typ reflect.Type) ValuesComparator

+ type StructComparator struct

+ func NewStructComparator(vc ValuesComparator) *StructComparator

+ func (vc *StructComparator) CompareValues(st *State, v1, v2 reflect.Value) (res Result, handled bool)

+ func (vc *StructComparator) Supports(typ reflect.Type) ValuesComparator

+ type SupportChecker interface

+ Supports func(typ reflect.Type) ValuesComparator

+ type SupportCheckerFunc func(typ reflect.Type) ValuesComparator

+ func (f SupportCheckerFunc) Supports(typ reflect.Type) ValuesComparator

+ type SupportCheckerValuesComparator struct

+ type SupportComparator struct

+ Checkers []SupportChecker

+ func NewSupportComparator() *SupportComparator

+ func (vc *SupportComparator) CompareValues(st *State, v1, v2 reflect.Value) (res Result, handled bool)

+ type UintComparator struct

+ func NewUintComparator() *UintComparator

+ func (vc *UintComparator) CompareValues(st *State, v1, v2 reflect.Value) (res Result, handled bool)

+ func (vc *UintComparator) Supports(typ reflect.Type) ValuesComparator

+ type UnsafePointerComparator struct

+ func NewUnsafePointerComparator() *UnsafePointerComparator

+ func (vc *UnsafePointerComparator) CompareValues(st *State, v1, v2 reflect.Value) (res Result, handled bool)

+ func (vc *UnsafePointerComparator) Supports(typ reflect.Type) ValuesComparator

+ type ValuesComparator interface

+ CompareValues func(st *State, v1, v2 reflect.Value) (res Result, handled bool)

+ type ValuesComparatorFunc func(st *State, v1, v2 reflect.Value) (res Result, handled bool)

+ func (f ValuesComparatorFunc) CompareValues(st *State, v1, v2 reflect.Value) (res Result, handled bool)

+ type ValuesComparators []ValuesComparator

+ func (vcs ValuesComparators) CompareValues(st *State, v1, v2 reflect.Value) (res Result, handled bool)

+ type VisitedEntry struct

+ Addr1 uintptr

+ Addr2 uintptr

+ Type reflect.Type

Oct 12, 2023

Changes in this version

type Comparator

+ MaxDepth int

+ type State struct

+ Depth int

+ Visited []Visited

+ type Visited struct

+ V1 uintptr

+ V2 uintptr

Sep 18, 2023

Changes in this version

type Path

+ func (p Path) Format(s fmt.State, verb rune)

type PathElem

+ func (e PathElem) Format(s fmt.State, verb rune)

Sep 18, 2023

Changes in this version

+ var DefaultComparator = NewComparator()

+ type Comparator struct

+ Funcs []Func

+ MapMaxDifferences int

+ SliceMaxDifferences int

+ func NewComparator() *Comparator

+ func (c *Comparator) Compare(v1, v2 any) Result

type Func

+ func NewBytesEqualFunc() Func

+ func NewMethodCmpFunc() Func

+ func NewMethodEqualFunc() Func

+ func NewReflectValueFunc() Func

Aug 29, 2023

Changes in this version

type PathElem

+ Index *int

+ Map *string

+ Struct *string

Aug 18, 2023

Changes in this version

+ type IndexedPathElem struct

+ Index int

+ func (e IndexedPathElem) String() string

+ type MapPathElem struct

+ Key string

+ func (e MapPathElem) String() string

type Path

+ func (p Path) String() string

+ type PathElem interface

+ String func() string

+ type StructPathElem struct

+ Field string

+ func (e StructPathElem) String() string

Aug 27, 2018

Changes in this version

+ var MaxSliceDifferences = 10

+ func PathString(p Path) string

+ func RegisterFunc(f Func)

+ func RegisterMethodEqual(name string)

+ type Difference struct

+ Message string

+ Path Path

+ V1 interface{}

+ V2 interface{}

+ func (d Difference) Format(s fmt.State, verb rune)

+ type Func func(v1, v2 reflect.Value) (r Result, stop bool)

+ type IndexedPath struct

+ Index int

+ Next Path

+ func (p IndexedPath) PathNext() Path

+ func (p IndexedPath) PathString() string

+ func (p IndexedPath) String() string

+ type MapPath struct

+ Key string

+ Next Path

+ func (p MapPath) PathNext() Path

+ func (p MapPath) PathString() string

+ func (p MapPath) String() string

+ type Path interface

+ PathNext func() Path

+ PathString func() string

+ type Result []Difference

+ func Compare(v1, v2 interface{}) Result

+ func (r Result) Format(s fmt.State, verb rune)

+ func (r Result) Merge(rm Result) Result

+ type StructPath struct

+ Field string

+ Next Path

+ func (p StructPath) PathNext() Path

+ func (p StructPath) PathString() string

+ func (p StructPath) String() string