Type is the resulting type after performing the path step.

Equal reports whether the two trees are structurally identical. Nested textRecord.Diff and textRecord.Comment fields are compared.

Comparer returns an [Option] that determines whether two values are equal to each other. The comparer f must be a function "func(T, T) bool" and is i

Len reports the length in bytes of a single-line version of the tree. Nested textRecord.Diff and textRecord.Comment fields are ignored.

Index returns the ith step in the Path and supports negative indexing. A negative index starts counting from the tail of the Path such that -1 refers

IsNil reports whether the pointer is nil.

FilterPath returns a new [Option] where opt is only evaluated if filter f returns true for the current [Path] in the value tree. This filter is calle

Transformer returns an [Option] that applies a transformation function that converts values of a certain type into that of another. The transformer f

TODO(≥go1.18): Use any instead of interface{}. Equal reports whether x and y are equal by recursively applying the following rules in the given order

FilterValues returns a new [Option] where opt is only evaluated if filter f, which is a function of the form "func(T, T) bool", returns true for the c

Name is the name of the [Transformer].

Ignore is an [Option] that causes all comparisons to be ignored. This value is intended to be combined with [FilterPath] or [FilterValues]. It is an e

IsType reports whether the reflect.Type is of the specified function type.

NameOf returns the name of the function value.

Last returns the last [PathStep] in the Path. If the path is empty, this returns a non-nil [PathStep] that reports a nil [PathStep.Type].

Values is the resulting values after performing the path step. The type of each valid value is guaranteed to be identical to Type. In some cases, one

AllowUnexported returns an [Option] that allows [Equal] to forcibly introspect unexported fields of the specified struct types. See [Exporter] for th

Diff returns a human-readable report of the differences between two values: y - x. It returns an empty string if and only if Equal returns true for th

Difference reports whether two lists of lengths nx and ny are equal given the definition of equality provided as f. This function returns an edit-scr

Key is the value of the map key.

PointerOf returns a Pointer from v, which must be a reflect.Ptr, reflect.Slice, or reflect.Map.

Pop ascends from pointers vx and vy.

Push indicates intent to descend into pointers vx and vy where visited reports whether either has been seen before. If visited before, equal reports w

Similar indicates whether two symbols are similar and may be represented by using the Modified type. As a special case, we consider binary comparisons

TypeString is nearly identical to reflect.Type.String, but has an additional option to specify that full type names be used.

filter applies all filters and returns the option that remains. Each option may only read s.curPath and call s.callTTBFunc. An Options is returned on

AppendEllipsis appends a new ellipsis node to the list if none already exists at the end. If cs is non-zero it coalesces the statistics with the previ

FormatType prints the type as if it were wrapping s. This may return s as-is depending on the current type and TypeMode mode.

IgnoreUnexported returns an [cmp.Option] that only ignores the immediate unexported fields of a struct, including anonymous fields of unexported types

Option returns the originally constructed [Transformer] option. The == operator can be used to detect the exact option used.

SortKeys sorts a list of map keys, deduplicating keys if necessary. The type of each value must be comparable.

compareByte returns a Result where the result is Equal if x == y, similar if x and y differ only in casing, and different otherwise.

formatExpandedTo formats the contents of the tree as a multi-line string to the provided buffer. In order for column alignment to operate well, format

formatHex prints u as a hexadecimal integer in Go notation.

formatPointer prints the address of the pointer.

TODO(≥go1.18): Define a generic function that boxes a value on the heap.

stats returns a histogram of the number of each type of edit operation.

BoolResult returns a Result that is either Equal or not Equal.

CanFormatDiffSlice reports whether we support custom formatting for nodes that are slices of primitive kinds or strings.

EquateErrors returns a [cmp.Comparer] option that determines errors to be equal if [errors.Is] reports them to match. The [AnyError] error can be used

FormatDiff converts a valueNode tree into a textNode tree, where the later is a textual representation of the differences detected in the former.

FormatDiffSlice prints a diff for the slices (or strings) represented by v. This provides custom-tailored logic to make printing of differences in tex

FormatValue prints the reflect.Value, taking extra care to avoid descending into pointers already in ptrs. As pointers are visited, ptrs is also updat

IgnoreFields returns an [cmp.Option] that ignores fields of the given names on a single struct type. It respects the names of exported fields that are

IgnoreInterfaces returns an [cmp.Option] that ignores all values or references of values assignable to certain interface types. These interfaces are s

Next increments the state and reports whether a check should be performed. Checks occur every Nth function call, where N is a triangular number: 0

Reporter is an [Option] that can be passed to [Equal]. When [Equal] traverses the value trees, it calls PushStep as it descends into each node in the

String returns the string representation of the text tree. It is not guaranteed that len(x.String()) == x.Len(), nor that x.String() == y.String() imp

flattenOptions copies all options in src to dst as a flat list. Only coreOptions and Options containing coreOptions are allowed.

formatCompactTo formats the contents of the tree as a single-line string to the provided buffer. Any nested textRecord.Diff and textRecord.Comment fie

formatMapKey formats v as if it were a map key. The result is guaranteed to be a single line.

formatString prints s as a double-quoted or backtick-quoted string.

isExported reports whether the identifier is exported.

isExported reports whether the identifier is exported.

makeAddressable returns a value that is always addressable. It returns the input verbatim if it is already addressable, otherwise it creates a new val

normalizeOption normalizes the input options such that all Options groups are flattened and groups with a single element are reduced to that element.

retrieveUnexportedField uses unsafe to forcibly retrieve any field from a struct such that the value has read-write permissions. The parent struct, v

rootStep constructs the first path step. If x and y have differing types, then they are stored within an empty interface type.

statelessCompare compares two values and returns the result. This function is stateless in that it does not alter the current result, or output to any

verbosityPreset modifies the verbosity settings given an index between 0 and maxVerbosityPreset, inclusive.

AcyclicTransformer returns a [cmp.Transformer] with a filter applied that ensures that the transformer cannot be recursively applied upon its own outp

ByFunc reports whether a [Comparer] function determined equality.

ByIgnore reports whether the node is equal because it was ignored. This never reports true if [Result.Equal] reports false.

ByMethod reports whether the Equal method determined equality.

Check scans the Path for any recursive transformers and panics when any recursive transformers are detected. Note that the presence of a recursive Tra

Dist is the Levenshtein distance and is guaranteed to be 0 if and only if lists X and Y are equal.

EquateApprox returns a [cmp.Comparer] option that determines float32 or float64 values to be equal if they are within a relative fraction or absolute

EquateApproxTime returns a [cmp.Comparer] option that determines two non-zero [time.Time] values to be equal if they are within some margin of one ano

EquateComparable returns a [cmp.Option] that determines equality of comparable types by directly comparing them using the == operator in Go. The types

EquateEmpty returns a [cmp.Comparer] option that determines all maps and slices with a length of zero to be equal, regardless of whether they are nil.

EquateNaNs returns a [cmp.Comparer] option that determines float32 and float64 NaN values to be equal. EquateNaNs can be used in conjunction with [Eq