field := types.NewField(src.NoXPos, s, t)
	n := ir.NewNameAt(src.NoXPos, s, t)
	n.Class = which
	field.Nname = n
	return field
}

// mkstruct is a helper routine to create a struct type with fields
// of the types specified in 'fieldtypes'.
func mkstruct(fieldtypes ...*types.Type) *types.Type {
	fields := make([]*types.Field, len(fieldtypes))
	for k, t := range fieldtypes {
		if t == nil {

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package example1

type MyStruct struct {
	MyStructs []MyStruct
	MyStruct  *MyStruct

// slices.SortFunc.
type myStruct struct {
	a, b, c, d string
	n          int
}

type myStructs []*myStruct

func (s myStructs) Len() int           { return len(s) }
func (s myStructs) Less(i, j int) bool { return s[i].n < s[j].n }
func (s myStructs) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }

func makeRandomStructs(n int) myStructs {
	r := rand.New(rand.NewPCG(42, 0))

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package example2

type MyStruct struct {
	MyStructs []MyStruct
	MyStruct  *MyStruct

		}
		return getFromStructPath(val.Index(idx).Interface(), path[1:])
	case reflect.Ptr:
		structElems = reflect.ValueOf(node).Elem()
		if !util.IsStruct(structElems) {
			return nil, false, fmt.Errorf("getFromStructPath path %s, expected struct ptr, got %T", path, node)
		}
	default:
		return nil, false, fmt.Errorf("getFromStructPath path %s, unsupported type %T", path, node)
	}

			}
		})
	}
}

type myStruct struct {
	a, b, c, d string
	n          int
}

func BenchmarkBinarySearchFuncStruct(b *testing.B) {
	for _, size := range []int{16, 32, 64, 128, 512, 1024} {
		b.Run(fmt.Sprintf("Size%d", size), func(b *testing.B) {
			structs := make([]*myStruct, size)
			for i := range structs {
				structs[i] = &myStruct{n: i}
			}
			midpoint := len(structs) / 2

package main

import (
	"fmt"
	"sync"
)

type MyStruct[T any] struct {
	val T
}

type Lockable[T any] struct {
	MyStruct[T]
	mu sync.Mutex
}

// Get returns the value stored in a Lockable.
func (l *Lockable[T]) Get() T {
	l.mu.Lock()
	defer l.mu.Unlock()
	return l.MyStruct.val
}

// Set sets the value in a Lockable.
func (l *Lockable[T]) Set(v T) {
	l.mu.Lock()

// via a type constraint.  (In this test, I -> IConstraint -> MyStruct -> I.)
type JsonRaw []byte

type MyStruct struct {
	x *I[JsonRaw]
}

type IConstraint interface {
	JsonRaw | MyStruct
}

type I[T IConstraint] struct {

	return NewAny[T]()
}

type MyStruct struct {
	Name string
}

func main() {
	// Create a generic cache.
	// All items are cached as interface{} so they need to be cast back to their
	// original type when retrieved.
	// Failure in issue doesn't happen with 'any' replaced by 'interface{}'
	c := NewAnyCacher[any]()

	myStruct := &MyStruct{"MySuperStruct"}

	c.Set("MySuperStruct", myStruct)

)

// ----------------------------------------------------------------------------
// API

// A Struct represents a struct type.
type Struct struct {
	fields []*Var   // fields != nil indicates the struct is set up (possibly with len(fields) == 0)
	tags   []string // field tags; nil if there are no tags
}

// NewStruct returns a new struct with the given fields and corresponding field tags.