package diff

Import Path
	github.com/google/go-cmp/cmp/internal/diff (on go.dev)

Dependency Relation
	imports 3 packages, and imported by one package

Involved Source Files

	      debug_disable.go
	   #d diff.go
		Package diff implements an algorithm for producing edit-scripts.
		The edit-script is a sequence of operations needed to transform one list
		of symbols into another (or vice-versa). The edits allowed are insertions,
		deletions, and modifications. The summation of all edits is called the
		Levenshtein distance as this problem is well-known in computer science.

		This package prioritizes performance over accuracy. That is, the run time
		is more important than obtaining a minimal Levenshtein distance.
Package-Level Type Names (total 7, in which 4 are exported)

	/* sort exporteds by: alphabet | popularity */
	 type EditScript ([])
		EditScript represents the series of differences between two lists.

		Methods (total 5, in which 4 are exported)
			( EditScript) Dist() int
				Dist is the Levenshtein distance and is guaranteed to be 0 if and only if
				lists X and Y are equal.

			( EditScript) LenX() int
				LenX is the length of the X list.

			( EditScript) LenY() int
				LenY is the length of the Y list.

			( EditScript) String() string
				String returns a human-readable string representing the edit-script where
				Identity, UniqueX, UniqueY, and Modified are represented by the
				'.', 'X', 'Y', and 'M' characters, respectively.

			/* one unexported ... *//* one unexported: */
			( EditScript) stats() (s struct{NI, NX, NY, NM int})
				stats returns a histogram of the number of each type of edit operation.

		Implements (at least 5, in which 2 are exported)
			 EditScript : expvar.Var
			 EditScript : fmt.Stringer
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			 EditScript : github.com/aws/smithy-go/middleware.stringer
			 EditScript : context.stringer
			 EditScript : runtime.stringer
		As Outputs Of (at least one exported)
			func Difference(nx, ny int, f EqualFunc) (es EditScript)
		As Inputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func github.com/google/go-cmp/cmp.coalesceAdjacentEdits(name string, es EditScript) (groups []cmp.diffStats)

	 type EditType uint8 (basic type)
		EditType represents a single operation within an edit-script.

		As Types Of (total 4, all are exported)
			const Identity
			const Modified
			const UniqueX
			const UniqueY

	 type EqualFunc (func)
		EqualFunc reports whether the symbols at indexes ix and iy are equal.
		When called by Difference, the index is guaranteed to be within nx and ny.

		As Inputs Of (at least one exported)
			func Difference(nx, ny int, f EqualFunc) (es EditScript)

	 type Result (struct)
		Result is the result of comparison.
		NumSame is the number of sub-elements that are equal.
		NumDiff is the number of sub-elements that are not equal.

		Fields (total 2, both are exported)
			NumDiff int
			NumSame int
		Methods (total 2, both are exported)
			( Result) Equal() bool
				Equal indicates whether the symbols are equal. Two symbols are equal
				if and only if NumDiff == 0. If Equal, then they are also Similar.

			( Result) Similar() bool
				Similar indicates whether two symbols are similar and may be represented
				by using the Modified type. As a special case, we consider binary comparisons
				(i.e., those that return Result{1, 0} or Result{0, 1}) to be similar.

				The exact ratio of NumSame to NumDiff to determine similarity may change.

		As Outputs Of (at least one exported)
			func BoolResult(b bool) Result

	/* 3 unexporteds ... *//* 3 unexporteds: */
	 type debugger (struct)

		Methods (total 3, all are exported)
			( debugger) Begin(_, _ int, f EqualFunc, _, _ *EditScript) EqualFunc
			( debugger) Finish()
			( debugger) Update()
		As Types Of (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			  var debug

	 type path (struct)

		Fields (total 5, in which 2 are exported)
			point.X int
			point.Y int
			/* 3 unexporteds ... *//* 3 unexporteds: */
			dir int
				// +1 if forward, -1 if reverse

			es EditScript
			point point
				// Leading point of the EditScript path

		Methods (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			(*path) add(dx, dy int)
			(*path) append(t EditType)
			(*path) connect(dst point, f EqualFunc)
				connect appends any necessary Identity, Modified, UniqueX, or UniqueY types
				to the edit-script to connect p.point to dst.


	 type point (struct)

		Fields (total 2, both are exported)
			X int
			Y int
		Methods (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			(*point) add(dx, dy int)


Package-Level Functions (total 3, in which 2 are exported)

	 func BoolResult(b bool) Result
		BoolResult returns a Result that is either Equal or not Equal.

	 func Difference(nx, ny int, f EqualFunc) (es EditScript)
		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-script, which is a sequence of operations
		needed to convert one list into the other. The following invariants for
		the edit-script are maintained:
		  - eq == (es.Dist()==0)
		  - nx == es.LenX()
		  - ny == es.LenY()

		This algorithm is not guaranteed to be an optimal solution (i.e., one that
		produces an edit-script with a minimal Levenshtein distance). This algorithm
		favors performance over optimality. The exact output is not guaranteed to
		be stable and may change over time.

	/* one unexported ... *//* one unexported: */
	 func zigzag(x int) int
		zigzag maps a consecutive sequence of integers to a zig-zag sequence.

			[0 1 2 3 4 5 ...] => [0 -1 +1 -2 +2 ...]


Package-Level Variables (total 2, neither is exported)

	/* 2 unexporteds ... *//* 2 unexporteds: */
	  var debug debugger
	  var randBool bool
Package-Level Constants (total 4, all are exported)

	const Identity EditType = 0
		Identity indicates that a symbol pair is identical in both list X and Y.

	const Modified EditType = 3
		Modified indicates that a symbol pair is a modification of each other.

	const UniqueX EditType = 1
		UniqueX indicates that a symbol only exists in X and not Y.

	const UniqueY EditType = 2
		UniqueY indicates that a symbol only exists in Y and not X.

The pages are generated with Golds v0.4.9. (GOOS=linux GOARCH=amd64)