id   collectionUID
}

func NewStaticCollection[T any](vals []T) Collection[T] {
	res := map[Key[T]]T{}
	for _, v := range vals {
		res[GetKey(v)] = v
	}
	return &staticList[T]{
		vals: res,
		id:   nextUID(),
	}
}

func (s *staticList[T]) GetKey(k Key[T]) *T {
	if o, f := s.vals[k]; f {
		return &o
	}
	return nil
}

// nolint: unused // (not true, its to implement an interface)

	}()
	// TODO: in the future, we could have a custom merge function. For now, since we just take the first, we optimize around that case
	return &join[T]{
		collectionName: o.name,
		id:             nextUID(),
		synced:         synced,
		collections:    c,
	}

	Singleton[T]
	Set(*T)
}

func NewStatic[T any](initial *T) StaticSingleton[T] {
	val := new(atomic.Pointer[T])
	val.Store(initial)
	x := &static[T]{
		val:           val,
		id:            nextUID(),
		eventHandlers: &handlers[T]{},
	}
	return collectionAdapter[T]{x}
}

// static represents a Collection of a single static value. This can be explicitly Set() to override it
type static[T any] struct {

	}
	return reflect.DeepEqual(a, b)
}

type collectionUID uint64

var globalUIDCounter = atomic.NewUint64(1)

func nextUID() collectionUID {
	return collectionUID(globalUIDCounter.Inc())

		o.name = fmt.Sprintf("NewInformer[%v]", ptr.TypeName[I]())
	}
	h := &informer[I]{
		inf:            c,
		log:            log.WithLabels("owner", o.name),
		collectionName: o.name,
		id:             nextUID(),
		eventHandlers:  &handlers[I]{},
		augmentation:   o.augmentation,
		synced:         make(chan struct{}),
	}

	go func() {
		// First, wait for the informer to populate

	c := cc.(internalCollection[I])
	h := &manyCollection[I, O]{
		transformation:         hf,
		collectionName:         opts.name,
		id:                     nextUID(),
		log:                    log.WithLabels("owner", opts.name),
		parent:                 c,
		collectionDependencies: sets.New[collectionUID](),
		objectDependencies:     map[Key[I]][]*dependency{},