*: interface{} -> any (#81)

Since 64d5926e (Drop support for Go < 1.18) and 3bf6c92d (Add PyDict
mode) ogórek started to require go ≥ 1.18 that added generics. That
release also added `any` type alias for interface{} to increase
signal/noise ratio in the programs where interface{} is frequently used.

Any is aliased to interface{} similarly to how rune is aliased to
int32, and so any and interface{} are fully interchangeable, just any
reads more shorter and concise:

    https://pkg.go.dev/builtin#any

-> Replace interface{} with any throughout the whole codebase for the
   sources to be read more well.

The replacement was done via running the following sed script:

    $ sed -i -e 's/interface{}/any/g' *.go

doc.go

@@ -3,7 +3,7 @@
 // Use [Decoder] to decode a pickle from input stream, for example:
 //
 //	d := ogórek.NewDecoder(r)
-//	obj, err := d.Decode() // obj is interface{} representing decoded Python object
+//	obj, err := d.Decode() // obj is any representing decoded Python object
 //
 // Use [Encoder] to encode an object as pickle into output stream, for example:
 //

encode.go

@@ -44,7 +44,7 @@ type EncoderConfig struct {
 	// will be encoded as an object reference.
 	//
 	// See Ref documentation for more details.
-	PersistentRef func(obj interface{}) *Ref
+	PersistentRef func(obj any) *Ref
 
 	// StrictUnicode, when true, requests to always encode Go string
 	// objects as Python unicode independently of used pickle protocol.
@@ -71,7 +71,7 @@ func NewEncoderWithConfig(w io.Writer, config *EncoderConfig) *Encoder {
 }
 
 // Encode writes the pickle encoding of v to w, the encoder's writer
-func (e *Encoder) Encode(v interface{}) error {
+func (e *Encoder) Encode(v any) error {
 	proto := e.config.Protocol
 	if !(0 <= proto && proto <= highestProtocol) {
 		return fmt.Errorf("pickle: encode: invalid protocol %d", proto)
@@ -109,7 +109,7 @@ func (e *Encoder) emit(bv ...byte) error {
 }
 
 // emitf writes formatted string into encoder output.
-func (e *Encoder) emitf(format string, argv ...interface{}) error {
+func (e *Encoder) emitf(format string, argv ...any) error {
 	_, err := fmt.Fprintf(e.w, format, argv...)
 	return err
 }
@@ -659,7 +659,7 @@ func (e *Encoder) encodeStruct(st reflect.Value) error {
 	return e.emit(opDict)
 }
 
-func reflectValueOf(v interface{}) reflect.Value {
+func reflectValueOf(v any) reflect.Value {
 
 	rv, ok := v.(reflect.Value)
 	if !ok {

ogorek.go

@@ -127,7 +127,7 @@ type mark struct{}
 type None struct{}
 
 // Tuple is a representation of Python's tuple.
-type Tuple []interface{}
+type Tuple []any
 
 // Bytes represents Python's bytes.
 type Bytes string
@@ -154,8 +154,8 @@ func (v unicode) GoString() string {
 type Decoder struct {
 	r      *bufio.Reader
 	config *DecoderConfig
-	stack  []interface{}
-	memo   map[string]interface{}
+	stack  []any
+	memo   map[string]any
 
 	// a reusable buffer that can be used by the various decoding functions
 	// functions using this should call buf.Reset to clear the old contents
@@ -182,7 +182,7 @@ type DecoderConfig struct {
 	// equivalent-to-type Go ghost object, e.g. equivalent to zodb.BTree.
 	//
 	// See Ref documentation for more details.
-	PersistentLoad func(ref Ref) (interface{}, error)
+	PersistentLoad func(ref Ref) (any, error)
 
 	// StrictUnicode, when true, requests to decode to Go string only
 	// Python unicode objects. Python2 bytestrings (py2 str type) are
@@ -211,14 +211,14 @@ func NewDecoderWithConfig(r io.Reader, config *DecoderConfig) *Decoder {
 	return &Decoder{
 		r:        reader,
 		config:   config,
-		stack:    make([]interface{}, 0),
-		memo:     make(map[string]interface{}),
+		stack:    make([]any, 0),
+		memo:     make(map[string]any),
 		protocol: 0,
 	}
 }
 
 // Decode decodes the pickle stream and returns the result or an error.
-func (d *Decoder) Decode() (interface{}, error) {
+func (d *Decoder) Decode() (any, error) {
 
 	insn := 0
 loop:
@@ -303,7 +303,7 @@ loop:
 		case opList:
 			err = d.loadList()
 		case opEmptyList:
-			d.push([]interface{}{})
+			d.push([]any{})
 		case opObj:
 			err = d.obj()
 		case opPut:
@@ -411,7 +411,7 @@ func (d *Decoder) readLine() ([]byte, error) {
 // userOK tells whether it is ok to return all objects to user.
 //
 // for example it is not ok to return the mark object.
-func userOK(objv ...interface{}) error {
+func userOK(objv ...any) error {
 	for _, obj := range objv {
 		switch obj.(type) {
 		case mark:
@@ -439,13 +439,13 @@ func (d *Decoder) marker() (int, error) {
 }
 
 // Append a new value
-func (d *Decoder) push(v interface{}) {
+func (d *Decoder) push(v any) {
 	d.stack = append(d.stack, v)
 }
 
 // Pop a value
 // The returned error is errStackUnderflow if decoder stack is empty
-func (d *Decoder) pop() (interface{}, error) {
+func (d *Decoder) pop() (any, error) {
 	ln := len(d.stack) - 1
 	if ln < 0 {
 		return nil, errStackUnderflow
@@ -456,7 +456,7 @@ func (d *Decoder) pop() (interface{}, error) {
 }
 
 // Pop a value (when you know for sure decoder stack is not empty)
-func (d *Decoder) xpop() interface{} {
+func (d *Decoder) xpop() any {
 	v, err := d.pop()
 	if err != nil {
 		panic(err)
@@ -465,7 +465,7 @@ func (d *Decoder) xpop() interface{} {
 }
 
 // popUser pops stack value and checks whether it is ok to return to user.
-func (d *Decoder) popUser() (interface{}, error) {
+func (d *Decoder) popUser() (any, error) {
 	v, err := d.pop()
 	if err != nil {
 		return nil, err
@@ -511,7 +511,7 @@ func (d *Decoder) loadInt() error {
 		return err
 	}
 
-	var val interface{}
+	var val any
 
 	switch string(line) {
 	case opFalse[1:3]:
@@ -641,7 +641,7 @@ type Ref struct {
 	//
 	// used to be string for protocol 0, but "upgraded" to be arbitrary
 	// object for later protocols.
-	Pid interface{}
+	Pid any
 }
 
 // Push a persistent object id
@@ -950,8 +950,8 @@ func (d *Decoder) loadAppend() error {
 		return err
 	}
 	switch l.(type) {
-	case []interface{}:
-		l := l.([]interface{})
+	case []any:
+		l := l.([]any)
 		d.stack[len(d.stack)-1] = append(l, v)
 	default:
 		return fmt.Errorf("pickle: loadAppend: expected a list, got %T", l)
@@ -987,7 +987,7 @@ func (d *Decoder) global() error {
 //
 // It checks whether key is of appropriate type, and if yes - succeeds.
 // If key is not appropriate - the map stays unchanged and false is returned.
-func mapTryAssign(m map[interface{}]interface{}, key, value interface{}) (ok bool) {
+func mapTryAssign(m map[any]any, key, value any) (ok bool) {
 	// use panic/recover to detect inappropriate keys.
 	//
 	// We could try to use reflect.TypeOf(key).Comparable() instead, but that
@@ -1015,7 +1015,7 @@ func mapTryAssign(m map[interface{}]interface{}, key, value interface{}) (ok boo
 }
 
 // dictTryAssign is like mapTryAssign but for Dict.
-func dictTryAssign(d Dict, key, value interface{}) (ok bool) {
+func dictTryAssign(d Dict, key, value any) (ok bool) {
 	defer func() {
 		if r := recover(); r != nil {
 			ok = false
@@ -1038,7 +1038,7 @@ func (d *Decoder) loadDict() error {
 		return fmt.Errorf("pickle: loadDict: odd # of elements")
 	}
 
-	var m interface{}
+	var m any
 	if d.config.PyDict {
 		m, err = d.loadDictDict(items)
 	} else {
@@ -1053,8 +1053,8 @@ func (d *Decoder) loadDict() error {
 	return nil
 }
 
-func (d *Decoder) loadDictMap(items []interface{}) (map[interface{}]interface{}, error) {
-	m := make(map[interface{}]interface{}, len(items)/2)
+func (d *Decoder) loadDictMap(items []any) (map[any]any, error) {
+	m := make(map[any]any, len(items)/2)
 	for i := 0; i < len(items); i += 2 {
 		key := items[i]
 		if !mapTryAssign(m, key, items[i+1]) {
@@ -1064,7 +1064,7 @@ func (d *Decoder) loadDictMap(items []interface{}) (map[interface{}]interface{},
 	return m, nil
 }
 
-func (d *Decoder) loadDictDict(items []interface{}) (Dict, error) {
+func (d *Decoder) loadDictDict(items []any) (Dict, error) {
 	m := NewDictWithSizeHint(len(items)/2)
 	for i := 0; i < len(items); i += 2 {
 		key := items[i]
@@ -1077,11 +1077,11 @@ func (d *Decoder) loadDictDict(items []interface{}) (Dict, error) {
 
 
 func (d *Decoder) loadEmptyDict() error {
-	var m interface{}
+	var m any
 	if d.config.PyDict {
 		m = NewDict()
 	} else {
-		m = make(map[interface{}]interface{}, 0)
+		m = make(map[any]any, 0)
 	}
 	d.push(m)
 	return nil
@@ -1098,8 +1098,8 @@ func (d *Decoder) loadAppends() error {
 
 	l := d.stack[k-1]
 	switch l.(type) {
-	case []interface{}:
-		l := l.([]interface{})
+	case []any:
+		l := l.([]any)
 		for _, v := range d.stack[k+1 : len(d.stack)] {
 			l = append(l, v)
 		}
@@ -1167,7 +1167,7 @@ func (d *Decoder) loadList() error {
 		return err
 	}
 
-	v := append([]interface{}{}, d.stack[k+1:]...)
+	v := append([]any{}, d.stack[k+1:]...)
 	d.stack = append(d.stack[:k], v)
 	return nil
 }
@@ -1267,7 +1267,7 @@ func (d *Decoder) loadSetItem() error {
 	}
 	m := d.stack[len(d.stack)-1]
 	switch m := m.(type) {
-	case map[interface{}]interface{}:
+	case map[any]any:
 		if !mapTryAssign(m, k, v) {
 			return fmt.Errorf("pickle: loadSetItem: map: invalid key type %T", k)
 		}
@@ -1295,7 +1295,7 @@ func (d *Decoder) loadSetItems() error {
 
 	l := d.stack[k-1]
 	switch m := l.(type) {
-	case map[interface{}]interface{}:
+	case map[any]any:
 		for i := k + 1; i < len(d.stack); i += 2 {
 			key := d.stack[i]
 			if !mapTryAssign(m, key, d.stack[i+1]) {
@@ -1478,7 +1478,7 @@ func decodeLong(data string) (*big.Int, error) {
 //
 // Python uses such representation of bytes for protocols <= 2 - where there is
 // no BYTES* opcodes.
-func decodeLatin1Bytes(arg interface{}) ([]byte, error) {
+func decodeLatin1Bytes(arg any) ([]byte, error) {
 	// bytes as latin1-decoded unicode
 	ulatin1, ok := arg.(string)
 	if !ok {

ogorek_test.go

@@ -45,13 +45,13 @@ func hexInput(hexdata string) TestPickle {
 }
 
 var graphitePickle1 = hexInput("80025d71017d710228550676616c75657371035d71042847407d90000000000047407f100000000000474080e0000000000047409764000000000047409c40000000000047409d88000000000047409f74000000000047409c74000000000047409cdc00000000004740a10000000000004740a0d800000000004740938800000000004740a00e00000000004740988800000000004e4e655505737461727471054a00d87a5255047374657071064a805101005503656e6471074a00f08f5255046e616d657108552d5a5a5a5a2e55555555555555552e43434343434343432e4d4d4d4d4d4d4d4d2e5858585858585858582e545454710975612e")
-var graphiteObject1 = []interface{}{map[interface{}]interface{}{"values": []interface{}{float64(473), float64(497), float64(540), float64(1497), float64(1808), float64(1890), float64(2013), float64(1821), float64(1847), float64(2176), float64(2156), float64(1250), float64(2055), float64(1570), None{}, None{}}, "start": int64(1383782400), "step": int64(86400), "end": int64(1385164800), "name": "ZZZZ.UUUUUUUU.CCCCCCCC.MMMMMMMM.XXXXXXXXX.TTT"}}
+var graphiteObject1 = []any{map[any]any{"values": []any{float64(473), float64(497), float64(540), float64(1497), float64(1808), float64(1890), float64(2013), float64(1821), float64(1847), float64(2176), float64(2156), float64(1250), float64(2055), float64(1570), None{}, None{}}, "start": int64(1383782400), "step": int64(86400), "end": int64(1385164800), "name": "ZZZZ.UUUUUUUU.CCCCCCCC.MMMMMMMM.XXXXXXXXX.TTT"}}
 
 var graphitePickle2 = hexInput("286c70300a286470310a53277374617274270a70320a49313338333738323430300a73532773746570270a70330a4938363430300a735327656e64270a70340a49313338353136343830300a73532776616c756573270a70350a286c70360a463437332e300a61463439372e300a61463534302e300a6146313439372e300a6146313830382e300a6146313839302e300a6146323031332e300a6146313832312e300a6146313834372e300a6146323137362e300a6146323135362e300a6146313235302e300a6146323035352e300a6146313537302e300a614e614e617353276e616d65270a70370a5327757365722e6c6f67696e2e617265612e6d616368696e652e6d65747269632e6d696e757465270a70380a73612e")
-var graphiteObject2 = []interface{}{map[interface{}]interface{}{"values": []interface{}{float64(473), float64(497), float64(540), float64(1497), float64(1808), float64(1890), float64(2013), float64(1821), float64(1847), float64(2176), float64(2156), float64(1250), float64(2055), float64(1570), None{}, None{}}, "start": int64(1383782400), "step": int64(86400), "end": int64(1385164800), "name": "user.login.area.machine.metric.minute"}}
+var graphiteObject2 = []any{map[any]any{"values": []any{float64(473), float64(497), float64(540), float64(1497), float64(1808), float64(1890), float64(2013), float64(1821), float64(1847), float64(2176), float64(2156), float64(1250), float64(2055), float64(1570), None{}, None{}}, "start": int64(1383782400), "step": int64(86400), "end": int64(1385164800), "name": "user.login.area.machine.metric.minute"}}
 
 var graphitePickle3 = hexInput("286c70310a286470320a5327696e74657276616c73270a70330a286c70340a7353276d65747269635f70617468270a70350a5327636172626f6e2e6167656e7473270a70360a73532769734c656166270a70370a4930300a7361286470380a67330a286c70390a7367350a5327636172626f6e2e61676772656761746f72270a7031300a7367370a4930300a736128647031310a67330a286c7031320a7367350a5327636172626f6e2e72656c617973270a7031330a7367370a4930300a73612e")
-var graphiteObject3 = []interface{}{map[interface{}]interface{}{"intervals": []interface{}{}, "metric_path": "carbon.agents", "isLeaf": false}, map[interface{}]interface{}{"intervals": []interface{}{}, "metric_path": "carbon.aggregator", "isLeaf": false}, map[interface{}]interface{}{"intervals": []interface{}{}, "metric_path": "carbon.relays", "isLeaf": false}}
+var graphiteObject3 = []any{map[any]any{"intervals": []any{}, "metric_path": "carbon.agents", "isLeaf": false}, map[any]any{"intervals": []any{}, "metric_path": "carbon.aggregator", "isLeaf": false}, map[any]any{"intervals": []any{}, "metric_path": "carbon.relays", "isLeaf": false}}
 
 const longLine = "28,34,30,55,100,130,87,169,194,202,232,252,267,274,286,315,308,221,358,368,401,406,434,452,475,422,497,530,517,559,400,418,571,578,599,600,625,630,635,647,220,715,736,760,705,785,794,495,808,852,861,863,869,875,890,893,896,922,812,980,1074,1087,1145,1153,1163,1171,445,1195,1203,1242,1255,1274,52,1287,1319,636,1160,1339,1345,1353,1369,1391,1396,1405,1221,1410,1431,1451,1460,1470,1472,1492,1517,1528,419,1530,1532,1535,1573,1547,1574,1437,1594,1595,847,1551,983,1637,1647,1666,1672,1691,1726,1515,1731,1739,1741,1723,1776,1685,505,1624,1436,1890,728,1910,1931,1544,2013,2025,2030,2043,2069,1162,2129,2160,2199,2210,1911,2246,804,2276,1673,2299,2315,2322,2328,2355,2376,2405,1159,2425,2430,2452,1804,2442,2567,2577,1167,2611,2534,1879,2623,2682,2699,2652,2742,2754,2774,2782,2795,2431,2821,2751,2850,2090,513,2898,592,2932,2933,1555,2969,3003,3007,3010,2595,3064,3087,3105,3106,3110,151,3129,3132,304,3173,3205,3233,3245,3279,3302,3307,714,316,3331,3347,3360,3375,3380,3442,2620,3482,3493,3504,3516,3517,3518,3533,3511,2681,3530,3601,3606,3615,1210,3633,3651,3688,3690,3781,1907,3839,3840,3847,3867,3816,3899,3924,2345,3912,3966,982,4040,4056,4076,4084,4105,2649,4171,3873,1415,3567,4188,4221,4227,4231,2279,4250,4253,770,894,4343,4356,4289,4404,4438,2572,3124,4334,2114,3953,4522,4537,4561,4571,641,4629,4640,4664,4687,4702,4709,4740,4605,4746,4768,3856,3980,4814,2984,4895,4908,1249,4944,4947,4979,4988,4995,32,4066,5043,4956,5069,5072,5076,5084,5085,5137,4262,5152,479,5156,3114,1277,5183,5186,1825,5106,5216,963,5239,5252,5218,5284,1980,1972,5352,5364,5294,5379,5387,5391,5397,5419,5434,5468,5471,3350,5510,5522,5525,5538,5554,5573,5597,5610,5615,5624,842,2851,5641,5655,5656,5658,5678,5682,5696,5699,5709,5728,5753,851,5805,3528,5822,801,5855,2929,5871,5899,5918,5925,5927,5931,5935,5939,5958,778,5971,5980,5300,6009,6023,6030,6032,6016,6110,5009,6155,6197,1760,6253,6267,4886,5608,6289,6308,6311,6321,6316,6333,6244,6070,6349,6353,6186,6357,6366,6386,6387,6389,6399,6411,6421,6432,6437,6465,6302,6493,5602,6511,6529,6536,6170,6557,6561,6577,6581,6590,5290,5649,6231,6275,6635,6651,6652,5929,6692,6693,6695,6705,6711,6723,6738,6752,6753,3629,2975,6790,5845,338,6814,6826,6478,6860,6872,6882,880,356,6897,4102,6910,6611,1030,6934,6936,6987,6984,6999,827,6902,7027,7049,7051,4628,7084,7083,7071,7102,7137,5867,7152,6048,2410,3896,7168,7177,7224,6606,7233,1793,7261,7284,7290,7292,5212,7315,6964,3238,355,1969,4256,448,7325,908,2824,2981,3193,3363,3613,5325,6388,2247,1348,72,131,5414,7285,7343,7349,7362,7372,7381,7410,7418,7443,5512,7470,7487,7497,7516,7277,2622,2863,945,4344,3774,1024,2272,7523,4476,256,5643,3164,7539,7540,7489,1932,7559,7575,7602,7605,7609,7608,7619,7204,7652,7663,6907,7672,7654,7674,7687,7718,7745,1202,4030,7797,7801,7799,2924,7871,7873,7900,7907,7911,7912,7917,7923,7935,8007,8017,7636,8084,8087,3686,8114,8153,8158,8171,8175,8182,8205,8222,8225,8229,8232,8234,8244,8247,7256,8279,6929,8285,7040,8328,707,6773,7949,8468,5759,6344,8509,1635"
 
@@ -79,9 +79,9 @@ type TestEntry struct {
 	//
 	// In the usual case objectIn == objectOut and they can differ if
 	// e.g. objectIn contains a Go struct.
-	objectIn  interface{}
+	objectIn  any
 	picklev   []TestPickle
-	objectOut interface{}
+	objectOut any
 
 	strictUnicodeN bool // whether to test with StrictUnicode=n while decoding/encoding
 	strictUnicodeY bool // whether to test with StrictUnicode=y while decoding/encoding
@@ -105,35 +105,35 @@ type TestEntry struct {
 // X is syntactic sugar to prepare one TestEntry.
 //
 // the entry is tested under both StrictUnicode=n and StrictUnicode=y modes.
-func X(name string, object interface{}, picklev ...TestPickle) TestEntry {
+func X(name string, object any, picklev ...TestPickle) TestEntry {
 	return TestEntry{name: name, objectIn: object, objectOut: object, picklev: picklev,
 			 strictUnicodeN: true, strictUnicodeY: true,
 			 pyDictN: true, pyDictY: true}
 }
 
 // Xuauto is syntactic sugar to prepare one TestEntry that is tested only under StrictUnicode=n mode.
-func Xuauto(name string, object interface{}, picklev ...TestPickle) TestEntry {
+func Xuauto(name string, object any, picklev ...TestPickle) TestEntry {
 	x := X(name, object, picklev...)
 	x.strictUnicodeY = false
 	return x
 }
 
 // Xustrict is syntactic sugar to prepare one TestEntry that is tested only under StrictUnicode=y mode.
-func Xustrict(name string, object interface{}, picklev ...TestPickle) TestEntry {
+func Xustrict(name string, object any, picklev ...TestPickle) TestEntry {
 	x := X(name, object, picklev...)
 	x.strictUnicodeN = false
 	return x
 }
 
 // Xdgo is syntactic sugar to prepare one TestEntry that is tested only under PyDict=n mode.
-func Xdgo(name string, object interface{}, picklev ...TestPickle) TestEntry {
+func Xdgo(name string, object any, picklev ...TestPickle) TestEntry {
 	x := X(name, object, picklev...)
 	x.pyDictY = false
 	return x
 }
 
 // Xdpy is syntactic sugar to prepare one TestEntry that is tested only under PyDict=y mode.
-func Xdpy(name string, object interface{}, picklev ...TestPickle) TestEntry {
+func Xdpy(name string, object any, picklev ...TestPickle) TestEntry {
 	x := X(name, object, picklev...)
 	x.pyDictN = false
 	return x
@@ -141,7 +141,7 @@ func Xdpy(name string, object interface{}, picklev ...TestPickle) TestEntry {
 
 // Xuauto_dgo is syntactic sugar to prepare one TestEntry that is tested only
 // under StrictUnicode=n ^ pyDict=n mode.
-func Xuauto_dgo(name string, object interface{}, picklev ...TestPickle) TestEntry {
+func Xuauto_dgo(name string, object any, picklev ...TestPickle) TestEntry {
 	x := X(name, object, picklev...)
 	x.strictUnicodeY = false
 	x.pyDictY = false
@@ -150,7 +150,7 @@ func Xuauto_dgo(name string, object interface{}, picklev ...TestPickle) TestEntr
 
 // Xuauto_dpy is syntactic sugar to prepare one TestEntry that is tested only
 // under StrictUnicode=n ^ pyDict=y mode.
-func Xuauto_dpy(name string, object interface{}, picklev ...TestPickle) TestEntry {
+func Xuauto_dpy(name string, object any, picklev ...TestPickle) TestEntry {
 	x := X(name, object, picklev...)
 	x.strictUnicodeY = false
 	x.pyDictN = false
@@ -158,14 +158,14 @@ func Xuauto_dpy(name string, object interface{}, picklev ...TestPickle) TestEntr
 }
 
 // Xloosy is syntactic sugar to prepare one TestEntry with loosy encoding.
-func Xloosy(name string, objectIn, objectOut interface{}, picklev ...TestPickle) TestEntry {
+func Xloosy(name string, objectIn, objectOut any, picklev ...TestPickle) TestEntry {
 	x := X(name, objectIn, picklev...)
 	x.objectOut = objectOut
 	return x
 }
 
 // Xloosy_uauto_dgo is like Xuauto_dgo but for Xloosy.
-func Xloosy_uauto_dgo(name string, objectIn, objectOut interface{}, picklev ...TestPickle) TestEntry {
+func Xloosy_uauto_dgo(name string, objectIn, objectOut any, picklev ...TestPickle) TestEntry {
 	x := Xuauto_dgo(name, objectIn, picklev...)
 	x.objectOut = objectOut
 	return x
@@ -174,8 +174,8 @@ func Xloosy_uauto_dgo(name string, objectIn, objectOut interface{}, picklev ...T
 func I(input string) TestPickle { return TestPickle{protov: nil, data: input, err: nil} }
 
 // PP(protov) creates func PX(pickle) which in turn produces TestPickle{protocol: protov, pickle}.
-func PP(protov ...int) func(xpickle interface{}) TestPickle {
-	return func(xpickle interface{}) TestPickle {
+func PP(protov ...int) func(xpickle any) TestPickle {
+	return func(xpickle any) TestPickle {
 		t := TestPickle{protov: protov}
 		switch x := xpickle.(type) {
 		case string:
@@ -322,12 +322,12 @@ var tests = []TestEntry{
 		P2_("K\x01K\x02\x86K\x03K\x04\x86\x86."), // BININT1 + TUPLE2
 		I("((I1\nI2\ntp0\n(I3\nI4\ntp1\ntp2\n.")),
 
-	X("list([])", []interface{}{},
+	X("list([])", []any{},
 		P0("(l."), // MARK + LIST
 		P1_("]."), // EMPTY_LIST
 		I("(lp0\n.")),
 
-	X("list([1,2,3,True])", []interface{}{int64(1), int64(2), int64(3), true},
+	X("list([1,2,3,True])", []any{int64(1), int64(2), int64(3), true},
 		P0("(I1\nI2\nI3\nI01\nl."),    // MARK + INT + INT(True) + LIST
 		P1("(K\x01K\x02K\x03I01\nl."), // MARK + BININT1 + INT(True) + LIST
 		P2_("(K\x01K\x02K\x03\x88l."), // MARK + BININT1 + NEW_TRUE + LIST
@@ -453,18 +453,18 @@ var tests = []TestEntry{
 
 	// dicts in default PyDict=n mode
 
-	Xdgo("dict({})", make(map[interface{}]interface{}),
+	Xdgo("dict({})", make(map[any]any),
 		P0("(d."), // MARK + DICT
 		P1_("}."), // EMPTY_DICT
 		I("(dp0\n.")),
 
-	Xuauto_dgo("dict({'a': '1'})", map[interface{}]interface{}{"a": "1"},
+	Xuauto_dgo("dict({'a': '1'})", map[any]any{"a": "1"},
 		P0("(S\"a\"\nS\"1\"\nd."),                     // MARK + STRING + DICT
 		P12("(U\x01aU\x011d."),                        // MARK + SHORT_BINSTRING + DICT
 		P3("(X\x01\x00\x00\x00aX\x01\x00\x00\x001d."), // MARK + BINUNICODE + DICT
 		P4_("(\x8c\x01a\x8c\x011d.")),                 // MARK + SHORT_BINUNICODE + DICT
 
-	Xuauto_dgo("dict({'a': '1', 'b': '2'})", map[interface{}]interface{}{"a": "1", "b": "2"},
+	Xuauto_dgo("dict({'a': '1', 'b': '2'})", map[any]any{"a": "1", "b": "2"},
 		// map iteration order is not stable - test only decoding
 		I("(S\"a\"\nS\"1\"\nS\"b\"\nS\"2\"\nd."), // P0: MARK + STRING + DICT
 		I("(U\x01aU\x011U\x01bU\x012d."),         // P12: MARK + SHORT_BINSTRING + DICT
@@ -527,7 +527,7 @@ var tests = []TestEntry{
 		P0123(errP0123GlobalStringLineOnly),
 		P4_("\x8c\x05foo\n2\x8c\x03bar\x93.")), // SHORT_BINUNICODE + STACK_GLOBAL
 
-	Xuauto(`foo.bar("bing")  # global + reduce`, Call{Callable: Class{Module: "foo", Name: "bar"}, Args: []interface{}{"bing"}},
+	Xuauto(`foo.bar("bing")  # global + reduce`, Call{Callable: Class{Module: "foo", Name: "bar"}, Args: []any{"bing"}},
 		P0("cfoo\nbar\n(S\"bing\"\ntR."),                     // GLOBAL + MARK + STRING + TUPLE + REDUCE
 		P1("cfoo\nbar\n(U\x04bingtR."),                       // GLOBAL + MARK + SHORT_BINSTRING + TUPLE + REDUCE
 		P2("cfoo\nbar\nU\x04bing\x85R."),                     // GLOBAL + SHORT_BINSTRING + TUPLE1 + REDUCE
@@ -554,7 +554,7 @@ var tests = []TestEntry{
 
 	// decode only
 	// TODO PUT + GET + BINGET + LONG_BINGET
-	X("LONG_BINPUT", []interface{}{int64(17)},
+	X("LONG_BINPUT", []any{int64(17)},
 		I("(lr0000I17\na.")),
 
 	Xuauto_dgo("graphite message1", graphiteObject1, graphitePickle1),
@@ -570,7 +570,7 @@ var tests = []TestEntry{
 	// loosy encode: decoding back gives another object.
 	// the only case where ogórek encoding is loosy is for Go struct types.
 	Xloosy_uauto_dgo("[]ogórek.foo{\"Qux\", 4}", []foo{{"Qux", 4}},
-		[]interface{}{map[interface{}]interface{}{"Foo": "Qux", "Bar": int64(4)}},
+		[]any{map[any]any{"Foo": "Qux", "Bar": int64(4)}},
 
 		// MARK + STRING + INT + DICT + LIST
 		P0("((S\"Foo\"\nS\"Qux\"\nS\"Bar\"\nI4\ndl."),
@@ -700,7 +700,7 @@ func TestEncode(t *testing.T) {
 //
 // It also verifies decoder robustness - via feeding it various kinds of
 // corrupt data derived from input.
-func testDecode(t *testing.T, decConfig DecoderConfig, object interface{}, input string) {
+func testDecode(t *testing.T, decConfig DecoderConfig, object any, input string) {
 	newDecoder := func(r io.Reader) *Decoder {
 		return NewDecoderWithConfig(r, &decConfig)
 	}
@@ -759,7 +759,7 @@ func testDecode(t *testing.T, decConfig DecoderConfig, object interface{}, input
 // encode-back tests are still performed.
 //
 // If errOk != nil, object encoding must produce that error.
-func testEncode(t *testing.T, proto int, encConfig EncoderConfig, decConfig DecoderConfig, object, objectDecodedBack interface{}, dataOk string, errOk error) {
+func testEncode(t *testing.T, proto int, encConfig EncoderConfig, decConfig DecoderConfig, object, objectDecodedBack any, dataOk string, errOk error) {
 	newEncoder := func(w io.Writer) *Encoder {
 		econf := EncoderConfig{}
 		econf = encConfig
@@ -823,7 +823,7 @@ func testEncode(t *testing.T, proto int, encConfig EncoderConfig, decConfig Deco
 // decoding further on next call
 func TestDecodeMultiple(t *testing.T) {
 	input := "I5\n.I7\n.N."
-	expected := []interface{}{int64(5), int64(7), None{}}
+	expected := []any{int64(5), int64(7), None{}}
 
 	buf := bytes.NewBufferString(input)
 	dec := NewDecoder(buf)
@@ -959,7 +959,7 @@ func TestPersistentRefs(t *testing.T) {
 	errInvalidRef := errors.New("invalid reference")
 
 	// Ref -> ? object
-	loadref := func(ref Ref) (interface{}, error) {
+	loadref := func(ref Ref) (any, error) {
 		// pretend we handle "zodb.BTree" -> ZBTree.
 		t, ok := ref.Pid.(Tuple)
 		if !ok || len(t) != 2 {
@@ -983,7 +983,7 @@ func TestPersistentRefs(t *testing.T) {
 	}
 
 	// object -> ? Ref
-	getref := func(obj interface{}) *Ref {
+	getref := func(obj any) *Ref {
 		// pretend we handle ZBTree.
 		switch obj := obj.(type) {
 		default:
@@ -999,7 +999,7 @@ func TestPersistentRefs(t *testing.T) {
 
 	testv := []struct {
 		input    string
-		expected interface{}
+		expected any
 	}{
 		{"Pabc\n.", errInvalidRef},
 		{"\x80\x01S'abc'\nQ.", errInvalidRef},
@@ -1127,7 +1127,7 @@ func BenchmarkDecode(b *testing.B) {
 
 func BenchmarkEncode(b *testing.B) {
 	// prepare one large slice from all test vector values
-	input := make([]interface{}, 0)
+	input := make([]any, 0)
 	approxOutSize := 0
 	for _, test := range tests {
 		if test.picklev[0].err == nil {
@@ -1196,7 +1196,7 @@ func TestUnquoteCharEOF(t *testing.T) {
 
 func TestStringsFmt(t *testing.T) {
 	tvhash := []struct{
-		in      interface{}
+		in      any
 		vhashok string
 	}{
 		{"мир",             `"мир"`},

pyquote_test.go

@@ -9,14 +9,14 @@ import (
 // Under the given transformation function in must be transformed to outOK.
 type CodecTestCase struct {
 	in    string
-	outOK interface{} // string | error
+	outOK any // string | error
 }
 
 // testCodec tests transform func applied to all test cases from testv.
 func testCodec(t *testing.T, transform func(in string)(string, error), testv []CodecTestCase) {
 	for _, tt := range testv {
 		s, err := transform(tt.in)
-		var out interface{} = s
+		var out any = s
 		if err != nil {
 			out = err
 		}

typeconv.go

@@ -12,7 +12,7 @@ import (
 // Python int is decoded as int64, while Python long is decoded as big.Int.
 // Go code should use AsInt64 to accept normal-range integers independently of
 // their Python representation.
-func AsInt64(x interface{}) (int64, error) {
+func AsInt64(x any) (int64, error) {
 	switch x := x.(type) {
 	case int64:
 		return x, nil
@@ -33,7 +33,7 @@ func AsInt64(x interface{}) (int64, error) {
 //
 // [ByteString] is treated related to [Bytes] because [ByteString] represents str
 // type from py2 which can contain both string and binary data.
-func AsBytes(x interface{}) (Bytes, error) {
+func AsBytes(x any) (Bytes, error) {
 	switch x := x.(type) {
 	case Bytes:
 		return x, nil
@@ -50,7 +50,7 @@ func AsBytes(x interface{}) (Bytes, error) {
 //
 // [ByteString] is treated related to string because [ByteString] represents str
 // type from py2 which can contain both string and binary data.
-func AsString(x interface{}) (string, error) {
+func AsString(x any) (string, error) {
 	switch x := x.(type) {
 	case string:
 		return x, nil
@@ -64,7 +64,7 @@ func AsString(x interface{}) (string, error) {
 // stringEQ compares arbitrary x to string y.
 //
 // It succeeds only if AsString(x) succeeds and string data of x equals to y.
-func stringEQ(x interface{}, y string) bool {
+func stringEQ(x any, y string) bool {
 	s, err := AsString(x)
 	if err != nil {
 		return false

typeconv_test.go

@@ -13,8 +13,8 @@ func TestAsInt64(t *testing.T) {
 	Erange := fmt.Errorf("long outside of int64 range")
 
 	testv := []struct {
-		in    interface{}
-		outOK interface{}
+		in    any
+		outOK any
 	}{
 		{int64(0),                       int64(0)},
 		{int64(1),                       int64(1)},
@@ -36,7 +36,7 @@ func TestAsInt64(t *testing.T) {
 
 	for _, tt := range testv {
 		iout, err := AsInt64(tt.in)
-		var out interface{} = iout
+		var out any = iout
 		if err != nil {
 			out = err
 			if iout != 0 {
@@ -54,10 +54,10 @@ func TestAsInt64(t *testing.T) {
 }
 
 func TestAsBytesString(t *testing.T) {
-	Ebytes := func(x interface{}) error {
+	Ebytes := func(x any) error {
 		return fmt.Errorf("expect bytes|bytestr; got %T", x)
 	}
-	Estring := func(x interface{}) error {
+	Estring := func(x any) error {
 		return fmt.Errorf("expect unicode|bytestr; got %T", x)
 	}
 
@@ -65,7 +65,7 @@ func TestAsBytesString(t *testing.T) {
 	const n = false
 
 	testv := []struct {
-		in  interface{}
+		in  any
 		bok bool // AsBytes  succeeds
 		sok bool // AsString succeeds
 	}{