fmt, internal/fmtsort: refactor SortedMap to use slice of structs for map sorting

author aimuz <mr.imuz@gmail.com>

Fri, 10 May 2024 09:23:24 +0000 (09:23 +0000)

committer Gopher Robot <gobot@golang.org>

Mon, 13 May 2024 21:22:43 +0000 (21:22 +0000)
author aimuz <mr.imuz@gmail.com>
Fri, 10 May 2024 09:23:24 +0000 (09:23 +0000)
committer Gopher Robot <gobot@golang.org>
Mon, 13 May 2024 21:22:43 +0000 (21:22 +0000)
diff --git a/src/fmt/print.go b/src/fmt/print.go

index 8d6d9612287ad5417fa4917fed76ee7301bbe9fc..f9f200499dc3383fe36aa81e5a8541fcbea9127a 100644 (file)
--- a/src/fmt/print.go
+++ b/src/fmt/print.go
@@ -814,7 +814,7 @@ func (p *pp) printValue(value reflect.Value, verb rune, depth int) {
                         p.buf.writeString(mapString)
                 }
                 sorted := fmtsort.Sort(f)
-               for i, key := range sorted.Key {
+               for i, m := range sorted {
                         if i > 0 {
                                 if p.fmt.sharpV {
                                         p.buf.writeString(commaSpaceString)
@@ -822,9 +822,9 @@ func (p *pp) printValue(value reflect.Value, verb rune, depth int) {
                                         p.buf.writeByte(' ')
                                 }
                         }
-                       p.printValue(key, verb, depth+1)
+                       p.printValue(m.Key, verb, depth+1)
                         p.buf.writeByte(':')
-                       p.printValue(sorted.Value[i], verb, depth+1)
+                       p.printValue(m.Value, verb, depth+1)
                 }
                 if p.fmt.sharpV {
                         p.buf.writeByte('}')
diff --git a/src/internal/fmtsort/sort.go b/src/internal/fmtsort/sort.go

index 278a89bd75d4230e14e935aa9949df0a91bd6d3d..ea042e1811d693b877e6aa2be5964289a8c75b66 100644 (file)
--- a/src/internal/fmtsort/sort.go
+++ b/src/internal/fmtsort/sort.go
@@ -10,24 +10,21 @@ package fmtsort
  
  import (
         "reflect"
-       "sort"
+       "slices"
  )
  
  // Note: Throughout this package we avoid calling reflect.Value.Interface as
  // it is not always legal to do so and it's easier to avoid the issue than to face it.
  
-// 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].
-type SortedMap struct {
-       Key   []reflect.Value
-       Value []reflect.Value
-}
+// SortedMap is a slice of KeyValue pairs that simplifies sorting
+// and iterating over map entries.
+//
+// Each KeyValue pair contains a map key and its corresponding value.
+type SortedMap []KeyValue
  
-func (o *SortedMap) Len() int           { return len(o.Key) }
-func (o *SortedMap) Less(i, j int) bool { return compare(o.Key[i], o.Key[j]) < 0 }
-func (o *SortedMap) Swap(i, j int) {
-       o.Key[i], o.Key[j] = o.Key[j], o.Key[i]
-       o.Value[i], o.Value[j] = o.Value[j], o.Value[i]
+// KeyValue holds a single key and value pair found in a map.
+type KeyValue struct {
+       Key, Value reflect.Value
  }
  
  // Sort accepts a map and returns a SortedMap that has the same keys and
@@ -48,7 +45,7 @@ func (o *SortedMap) Swap(i, j int) {
  //     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.
-func Sort(mapValue reflect.Value) *SortedMap {
+func Sort(mapValue reflect.Value) SortedMap {
         if mapValue.Type().Kind() != reflect.Map {
                 return nil
         }
@@ -56,18 +53,14 @@ func Sort(mapValue reflect.Value) *SortedMap {
         // of a concurrent map update. The runtime is responsible for
         // yelling loudly if that happens. See issue 33275.
         n := mapValue.Len()
-       key := make([]reflect.Value, 0, n)
-       value := make([]reflect.Value, 0, n)
+       sorted := make(SortedMap, 0, n)
         iter := mapValue.MapRange()
         for iter.Next() {
-               key = append(key, iter.Key())
-               value = append(value, iter.Value())
-       }
-       sorted := &SortedMap{
-               Key:   key,
-               Value: value,
+               sorted = append(sorted, KeyValue{iter.Key(), iter.Value()})
         }
-       sort.Stable(sorted)
+       slices.SortStableFunc(sorted, func(a, b KeyValue) int {
+               return compare(a.Key, b.Key)
+       })
         return sorted
  }
  
diff --git a/src/internal/fmtsort/sort_test.go b/src/internal/fmtsort/sort_test.go

index 7d5de9f56b9363382ea9b4e72fe7812a2736b437..29a9c2c43f5cf3fc1ea68f0bb783ad9199b24db8 100644 (file)
--- a/src/internal/fmtsort/sort_test.go
+++ b/src/internal/fmtsort/sort_test.go
@@ -142,13 +142,13 @@ func sprint(data any) string {
                 return "nil"
         }
         b := new(strings.Builder)
-       for i, key := range om.Key {
+       for i, m := range om {
                 if i > 0 {
                         b.WriteRune(' ')
                 }
-               b.WriteString(sprintKey(key))
+               b.WriteString(sprintKey(m.Key))
                 b.WriteRune(':')
-               fmt.Fprint(b, om.Value[i])
+               fmt.Fprint(b, m.Value)
         }
         return b.String()
  }
diff --git a/src/text/template/exec.go b/src/text/template/exec.go

index 4c899b1c79d045ea3fe0876ce1e88431538fe781..1a8f2fa0df8994737ae1353e088203aacb709d88 100644 (file)
--- a/src/text/template/exec.go
+++ b/src/text/template/exec.go
@@ -408,8 +408,8 @@ func (s *state) walkRange(dot reflect.Value, r *parse.RangeNode) {
                         break
                 }
                 om := fmtsort.Sort(val)
-               for i, key := range om.Key {
-                       oneIteration(key, om.Value[i])
+               for _, m := range om {
+                       oneIteration(m.Key, m.Value)
                 }
                 return
         case reflect.Chan:
author	aimuz <mr.imuz@gmail.com>
	Fri, 10 May 2024 09:23:24 +0000 (09:23 +0000)
committer	Gopher Robot <gobot@golang.org>
	Mon, 13 May 2024 21:22:43 +0000 (21:22 +0000)
src/fmt/print.go		patch \| blob \| history
src/internal/fmtsort/sort.go		patch \| blob \| history
src/internal/fmtsort/sort_test.go		patch \| blob \| history
src/text/template/exec.go		patch \| blob \| history