Genericize lib.OrderedMap (#1948)

Author: johnkerl

pkg/bifs/stats.go

@@ -265,12 +265,12 @@ func bif_mode_or_antimode(
 	// Do not use a Go map[string]int as that makes the output in the case of ties
 	// (e.g. input = [3,3,4,4]) non-determinstic. That's bad for unit tests and also
 	// simply bad UX.
-	counts := lib.NewOrderedMap()
+	counts := lib.NewOrderedMap[int]()
 
 	// We use stringification to detect uniqueness. Yet we want the output to be typed,
 	// e.g. mode of an array of ints should be an int, not a string. Here we store
 	// a reference to one representative for each equivalence class.
-	reps := lib.NewOrderedMap()
+	reps := lib.NewOrderedMap[*mlrval.Mlrval]()
 
 	if collection.IsArray() {
 		a := collection.AcquireArrayValue()
@@ -280,7 +280,7 @@ func bif_mode_or_antimode(
 		for _, e := range a {
 			valueString := e.OriginalString()
 			if counts.Has(valueString) {
-				counts.Put(valueString, counts.Get(valueString).(int)+1)
+				counts.Put(valueString, counts.Get(valueString)+1)
 			} else {
 				counts.Put(valueString, 1)
 				reps.Put(valueString, e)
@@ -294,7 +294,7 @@ func bif_mode_or_antimode(
 		for pe := m.Head; pe != nil; pe = pe.Next {
 			valueString := pe.Value.OriginalString()
 			if counts.Has(valueString) {
-				counts.Put(valueString, counts.Get(valueString).(int)+1)
+				counts.Put(valueString, counts.Get(valueString)+1)
 			} else {
 				counts.Put(valueString, 1)
 				reps.Put(valueString, pe.Value)
@@ -306,16 +306,15 @@ func bif_mode_or_antimode(
 	maxv := -1
 	for pf := counts.Head; pf != nil; pf = pf.Next {
 		k := pf.Key
-		v := pf.Value.(int)
+		v := pf.Value
 		if first || cmp(v, maxv) {
 			maxk = k
 			maxv = v
 			first = false
 		}
 	}
-	// OrderedMap has interface{} values, so dereference as Mlrval. Then, copy the Mlrval
-	// so we're not returning a pointer to input data.
-	return reps.Get(maxk).(*mlrval.Mlrval).Copy()
+	// Copy the Mlrval so we're not returning a pointer to input data.
+	return reps.Get(maxk).Copy()
 }
 
 func BIF_sum(collection *mlrval.Mlrval) *mlrval.Mlrval {

pkg/lib/ordered_map.go

@@ -1,42 +1,42 @@
 // ================================================================
-// ORDERED MAP FROM STRING TO INTERFACE{}
+// ORDERED MAP FROM STRING TO GENERIC VALUE TYPE
 //
-// Quite like types.OrderedMap but only with interface{} keys. See orderedMap.go for
+// Quite like types.OrderedMap but only with string keys. See orderedMap.go for
 // more information.
 // ================================================================
 
 package lib
 
 // ----------------------------------------------------------------
-type OrderedMap struct {
+type OrderedMap[V any] struct {
 	FieldCount    int64
-	Head          *orderedMapEntry
-	Tail          *orderedMapEntry
-	keysToEntries map[string]*orderedMapEntry
+	Head          *orderedMapEntry[V]
+	Tail          *orderedMapEntry[V]
+	keysToEntries map[string]*orderedMapEntry[V]
 }
 
-type orderedMapEntry struct {
+type orderedMapEntry[V any] struct {
 	Key   string
-	Value interface{}
-	Prev  *orderedMapEntry
-	Next  *orderedMapEntry
+	Value V
+	Prev  *orderedMapEntry[V]
+	Next  *orderedMapEntry[V]
 }
 
 // ----------------------------------------------------------------
-func NewOrderedMap() *OrderedMap {
-	return &OrderedMap{
+func NewOrderedMap[V any]() *OrderedMap[V] {
+	return &OrderedMap[V]{
 		FieldCount:    0,
 		Head:          nil,
 		Tail:          nil,
-		keysToEntries: make(map[string]*orderedMapEntry),
+		keysToEntries: make(map[string]*orderedMapEntry[V]),
 	}
 }
 
 // ----------------------------------------------------------------
 // Value-copy is up to the caller -- PutReference and PutCopy
 // are in the public OrderedMap API.
-func newOrderedMapEntry(key *string, value interface{}) *orderedMapEntry {
-	return &orderedMapEntry{
+func newOrderedMapEntry[V any](key *string, value V) *orderedMapEntry[V] {
+	return &orderedMapEntry[V]{
 		*key,
 		value,
 		nil,
@@ -45,15 +45,15 @@ func newOrderedMapEntry(key *string, value interface{}) *orderedMapEntry {
 }
 
 // ----------------------------------------------------------------
-func (omap *OrderedMap) IsEmpty() bool {
+func (omap *OrderedMap[V]) IsEmpty() bool {
 	return omap.FieldCount == 0
 }
 
-func (omap *OrderedMap) Has(key string) bool {
+func (omap *OrderedMap[V]) Has(key string) bool {
 	return omap.findEntry(&key) != nil
 }
 
-func (omap *OrderedMap) findEntry(key *string) *orderedMapEntry {
+func (omap *OrderedMap[V]) findEntry(key *string) *orderedMapEntry[V] {
 	if omap.keysToEntries != nil {
 		return omap.keysToEntries[*key]
 	} else {
@@ -67,7 +67,7 @@ func (omap *OrderedMap) findEntry(key *string) *orderedMapEntry {
 }
 
 // ----------------------------------------------------------------
-func (omap *OrderedMap) Put(key string, value interface{}) {
+func (omap *OrderedMap[V]) Put(key string, value V) {
 	pe := omap.findEntry(&key)
 	if pe == nil {
 		pe = newOrderedMapEntry(&key, value)
@@ -90,30 +90,30 @@ func (omap *OrderedMap) Put(key string, value interface{}) {
 }
 
 // ----------------------------------------------------------------
-func (omap *OrderedMap) Get(key string) interface{} {
+func (omap *OrderedMap[V]) Get(key string) V {
 	pe := omap.findEntry(&key)
 	if pe == nil {
-		return nil
-	} else {
-		return pe.Value
+		var zero V
+		return zero
 	}
+	return pe.Value
 }
 
 // The Get is sufficient for pointer values -- the caller can check if the
 // return value is nil. For int/string values (which are non-nullable) we have
 // this method.
-func (omap *OrderedMap) GetWithCheck(key string) (interface{}, bool) {
+func (omap *OrderedMap[V]) GetWithCheck(key string) (V, bool) {
 	pe := omap.findEntry(&key)
 	if pe == nil {
-		return nil, false
-	} else {
-		return pe.Value, true
+		var zero V
+		return zero, false
 	}
+	return pe.Value, true
 }
 
 // ----------------------------------------------------------------
 // Returns true if it was found and removed
-func (omap *OrderedMap) Remove(key string) bool {
+func (omap *OrderedMap[V]) Remove(key string) bool {
 	pe := omap.findEntry(&key)
 	if pe == nil {
 		return false
@@ -124,7 +124,7 @@ func (omap *OrderedMap) Remove(key string) bool {
 }
 
 // ----------------------------------------------------------------
-func (omap *OrderedMap) unlink(pe *orderedMapEntry) {
+func (omap *OrderedMap[V]) unlink(pe *orderedMapEntry[V]) {
 	if pe == omap.Head {
 		if pe == omap.Tail {
 			omap.Head = nil

pkg/terminals/regtest/regtester.go

@@ -464,7 +464,7 @@ func (regtester *RegTester) executeSingleCmdFile(
 	// Set any case-specific environment variables before running the case.
 	for pe := envKeyValuePairs.Head; pe != nil; pe = pe.Next {
 		key := pe.Key
-		value := pe.Value.(string)
+		value := pe.Value
 		if verbosityLevel >= 3 {
 			fmt.Printf("SETENV %s=%s\n", key, value)
 		}
@@ -825,12 +825,12 @@ func (regtester *RegTester) compareFiles(
 func (regtester *RegTester) loadEnvFile(
 	filename string,
 	caseDir string,
-) (*lib.OrderedMap, error) {
+) (*lib.OrderedMap[string], error) {
 	// If the file doesn't exist that's the normal case -- most cases do not
 	// have a .env file.
 	_, err := os.Stat(filename)
 	if os.IsNotExist(err) {
-		return lib.NewOrderedMap(), nil
+		return lib.NewOrderedMap[string](), nil
 	}
 
 	// If the file does exist and isn't loadable, that's an error.
@@ -839,7 +839,7 @@ func (regtester *RegTester) loadEnvFile(
 		return nil, err
 	}
 
-	keyValuePairs := lib.NewOrderedMap()
+	keyValuePairs := lib.NewOrderedMap[string]()
 	lines := strings.Split(contents, "\n")
 	for _, line := range lines {
 		line = strings.TrimSuffix(line, "\r")

pkg/transformers/count.go

@@ -117,8 +117,8 @@ type TransformerCount struct {
 	// * Map keys are strings "foo,bar" and "baz,quux".
 	// * groupedCounts maps "foo,bar" to 1 and "baz,quux" to 1.
 	// * groupByValues maps "foo,bar" to ["foo", "bar"] and "baz,quux" to ["baz", "quux"].
-	groupedCounts  *lib.OrderedMap
-	groupingValues *lib.OrderedMap
+	groupedCounts  *lib.OrderedMap[int64]
+	groupingValues *lib.OrderedMap[[]*mlrval.Mlrval]
 }
 
 func NewTransformerCount(
@@ -133,8 +133,8 @@ func NewTransformerCount(
 		outputFieldName:   outputFieldName,
 
 		ungroupedCount: 0,
-		groupedCounts:  lib.NewOrderedMap(),
-		groupingValues: lib.NewOrderedMap(),
+		groupedCounts:  lib.NewOrderedMap[int64](),
+		groupingValues: lib.NewOrderedMap[[]*mlrval.Mlrval](),
 	}
 
 	if groupByFieldNames == nil {
@@ -200,7 +200,7 @@ func (tr *TransformerCount) countGrouped(
 		} else {
 			tr.groupedCounts.Put(
 				groupingKey,
-				tr.groupedCounts.Get(groupingKey).(int64)+1,
+				tr.groupedCounts.Get(groupingKey)+1,
 			)
 		}
 
@@ -224,14 +224,14 @@ func (tr *TransformerCount) countGrouped(
 				// * Grouping values for key is ["foo", "bar"]
 				// Here we populate a record with "a=foo,b=bar".
 
-				groupingValuesForKey := tr.groupingValues.Get(groupingKey).([]*mlrval.Mlrval)
+				groupingValuesForKey := tr.groupingValues.Get(groupingKey)
 				i := 0
 				for _, groupingValueForKey := range groupingValuesForKey {
 					newrec.PutCopy(tr.groupByFieldNames[i], groupingValueForKey)
 					i++
 				}
 
-				countForGroup := outer.Value.(int64)
+				countForGroup := outer.Value
 				newrec.PutCopy(tr.outputFieldName, mlrval.FromInt(countForGroup))
 
 				outrecAndContext := types.NewRecordAndContext(newrec, &inrecAndContext.Context)

pkg/transformers/count_similar.go

@@ -105,7 +105,7 @@ type TransformerCountSimilar struct {
 	counterFieldName  string
 
 	// State:
-	recordListsByGroup *lib.OrderedMap // map from string to *list.List
+	recordListsByGroup *lib.OrderedMap[*list.List] // map from string to *list.List
 }
 
 // ----------------------------------------------------------------
@@ -116,7 +116,7 @@ func NewTransformerCountSimilar(
 	tr := &TransformerCountSimilar{
 		groupByFieldNames:  groupByFieldNames,
 		counterFieldName:   counterFieldName,
-		recordListsByGroup: lib.NewOrderedMap(),
+		recordListsByGroup: lib.NewOrderedMap[*list.List](),
 	}
 	return tr, nil
 }
@@ -138,18 +138,17 @@ func (tr *TransformerCountSimilar) Transform(
 			return
 		}
 
-		irecordListForGroup := tr.recordListsByGroup.Get(groupingKey)
-		if irecordListForGroup == nil { // first time
-			irecordListForGroup = list.New()
-			tr.recordListsByGroup.Put(groupingKey, irecordListForGroup)
+		recordListForGroup := tr.recordListsByGroup.Get(groupingKey)
+		if recordListForGroup == nil { // first time
+			recordListForGroup = list.New()
+			tr.recordListsByGroup.Put(groupingKey, recordListForGroup)
 		}
-		recordListForGroup := irecordListForGroup.(*list.List)
 
 		recordListForGroup.PushBack(inrecAndContext)
 	} else {
 
 		for outer := tr.recordListsByGroup.Head; outer != nil; outer = outer.Next {
-			recordListForGroup := outer.Value.(*list.List)
+			recordListForGroup := outer.Value
 			// TODO: make 64-bit friendly
 			groupSize := recordListForGroup.Len()
 			mgroupSize := mlrval.FromInt(int64(groupSize))

pkg/transformers/group_by.go

@@ -93,7 +93,7 @@ type TransformerGroupBy struct {
 
 	// state
 	// map from string to *list.List
-	recordListsByGroup *lib.OrderedMap
+	recordListsByGroup *lib.OrderedMap[*list.List]
 }
 
 func NewTransformerGroupBy(
@@ -103,7 +103,7 @@ func NewTransformerGroupBy(
 	tr := &TransformerGroupBy{
 		groupByFieldNames: groupByFieldNames,
 
-		recordListsByGroup: lib.NewOrderedMap(),
+		recordListsByGroup: lib.NewOrderedMap[*list.List](),
 	}
 
 	return tr, nil
@@ -132,11 +132,11 @@ func (tr *TransformerGroupBy) Transform(
 			tr.recordListsByGroup.Put(groupingKey, recordListForGroup)
 		}
 
-		recordListForGroup.(*list.List).PushBack(inrecAndContext)
+		recordListForGroup.PushBack(inrecAndContext)
 
 	} else {
 		for outer := tr.recordListsByGroup.Head; outer != nil; outer = outer.Next {
-			recordListForGroup := outer.Value.(*list.List)
+			recordListForGroup := outer.Value
 			for inner := recordListForGroup.Front(); inner != nil; inner = inner.Next() {
 				outputRecordsAndContexts.PushBack(inner.Value.(*types.RecordAndContext))
 			}

pkg/transformers/group_like.go

@@ -79,13 +79,13 @@ func transformerGroupLikeParseCLI(
 // ----------------------------------------------------------------
 type TransformerGroupLike struct {
 	// map from string to *list.List
-	recordListsByGroup *lib.OrderedMap
+	recordListsByGroup *lib.OrderedMap[*list.List]
 }
 
 func NewTransformerGroupLike() (*TransformerGroupLike, error) {
 
 	tr := &TransformerGroupLike{
-		recordListsByGroup: lib.NewOrderedMap(),
+		recordListsByGroup: lib.NewOrderedMap[*list.List](),
 	}
 
 	return tr, nil
@@ -111,11 +111,11 @@ func (tr *TransformerGroupLike) Transform(
 			tr.recordListsByGroup.Put(groupingKey, recordListForGroup)
 		}
 
-		recordListForGroup.(*list.List).PushBack(inrecAndContext)
+		recordListForGroup.PushBack(inrecAndContext)
 
 	} else {
 		for outer := tr.recordListsByGroup.Head; outer != nil; outer = outer.Next {
-			recordListForGroup := outer.Value.(*list.List)
+			recordListForGroup := outer.Value
 			for inner := recordListForGroup.Front(); inner != nil; inner = inner.Next() {
 				outputRecordsAndContexts.PushBack(inner.Value.(*types.RecordAndContext))
 			}