package fmtsort

Import Path
	internal/fmtsort (on go.dev)

Dependency Relation
	imports 2 packages, and imported by one package

Involved Source Files

	   #d sort.go
		Package fmtsort provides a general stable ordering mechanism
		for maps, on behalf of the fmt and text/template packages.
		It is not guaranteed to be efficient and works only for types
		that are valid map keys.
Package-Level Type Names (only one, which is exported)

	/* sort exporteds by: alphabet | popularity */
	 type SortedMap (struct)
		SortedMap represents a map's keys and values. The keys and values are
		aligned in index order: Value[i] is the value in the map corresponding to Key[i].

		Fields (total 2, both are exported)
			Key []reflect.Value
			Value []reflect.Value
		Methods (total 3, all are exported)
			(*T) Len() int
			(*T) Less(i, j int) bool
			(*T) Swap(i, j int)
		Implements (at least one exported)
			*T : sort.Interface
		As Outputs Of (at least one exported)
			func Sort(mapValue reflect.Value) *SortedMap


Package-Level Functions (total 5, in which 1 are exported)

	 func Sort(mapValue reflect.Value) *SortedMap
		Sort accepts a map and returns a SortedMap that has the same keys and
		values but in a stable sorted order according to the keys, modulo issues
		raised by unorderable key values such as NaNs.

		The ordering rules are more general than with Go's < operator:

		 - when applicable, nil compares low
		 - ints, floats, and strings order by <
		 - NaN compares less than non-NaN floats
		 - bool compares false before true
		 - complex compares real, then imag
		 - pointers compare by machine address
		 - channel values compare by machine address
		 - structs compare each field in turn
		 - arrays compare each element in turn.
		   Otherwise identical arrays compare by length.
		 - interface values compare first by reflect.Type describing the concrete type
		   and then by concrete value as described in the previous rules.

	/* 4 unexporteds ... *//* 4 unexporteds: */
	 func compare(aVal, bVal reflect.Value) int
		compare compares two values of the same type. It returns -1, 0, 1
		according to whether a > b (1), a == b (0), or a < b (-1).
		If the types differ, it returns -1.
		See the comment on Sort for the comparison rules.

	 func floatCompare(a, b float64) int
		floatCompare compares two floating-point values. NaNs compare low.

	 func isNaN(a float64) bool
	 func nilCompare(aVal, bVal reflect.Value) (int, bool)
		nilCompare checks whether either value is nil. If not, the boolean is false.
		If either value is nil, the boolean is true and the integer is the comparison
		value. The comparison is defined to be 0 if both are nil, otherwise the one
		nil value compares low. Both arguments must represent a chan, func,
		interface, map, pointer, or slice.

The pages are generated with Golds v0.4.2. (GOOS=darwin GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.