go mod tidy
grep 'rsc.io/quote v1.0.0' go.sum
! grep 'rsc.io/quote v1.5.2' go.sum
! grep rsc.io/sampler go.sum

# go.sum with no entries is OK to keep
# (better for version control not to delete and recreate.)
cp x.go.noimports x.go
go mod tidy
exists go.sum
! grep . go.sum

-- go.mod --
module x
-- x.go --
package x
import _ "rsc.io/quote"
-- x.go.noimports --

        n1.toString() == "a"
        n2.toString() == "b"

        n1.is(factory.named(Named, "a"))
        n2.is(factory.named(Named, "b"))
    }

    def "can unpack and recreate Named instance"() {
        expect:
        def n1 = factory.named(Named, "a")
        n1 instanceof Managed
        n1.publicType() == Named
        n1.isImmutable()
        def state = n1.unpackState()

 */
@ThreadSafe
public interface CrossBuildInMemoryCache<K, V> extends Cache<K, V> {
    /**
     * Locates the given entry, using the supplied factory when the entry is not present or has been discarded, to recreate the entry in the cache.
     *
     * <p>Implementations must prevent more than one thread calculating the same key at the same time.
     */
    @Override
    V get(K key, Function<? super K, ? extends V> factory);

     */
    boolean addAllInternal(Collection<? extends Task> task);

    /**
     * Creates an instance of the given task type without invoking its constructors. This is used to recreate a task instance from the configuration cache.
     *
     * TODO:configuration-cache - review this
     */
    <T extends Task> T createWithoutConstructor(String name, Class<T> type, long uniqueId);

import org.gradle.internal.hash.Hashable;

import javax.annotation.Nullable;

/**
 * An immutable snapshot of the state of some Java object or object graph.
 *
 * <p>Implementations are not required to be able to recreate the object, and should retain as little state as possible.
 * In particular, implementations should not hold on to user ClassLoaders.</p>
 */
public interface ValueSnapshot extends Hashable {
    /**

import java.util.function.Function;
import java.util.function.Supplier;

public interface Cache<K, V>  {
    /**
     * Locates the given entry, using the supplied factory when the entry is not present or has been discarded, to recreate the entry in the cache.
     *
     * <p>Implementations may prevent more than one thread calculating the same key at the same time or not.
     */
    V get(K key, Function<? super K, ? extends V> factory);

 */
public interface Managed {
    /**
     * Returns a snapshot of the current state of this object. This can be passed to the {@link ManagedFactory#fromState(Class, Object)} method to recreate this object from the snapshot.
     * Note that the state may not be immutable, so should be made isolated to reuse in another context. The state can also be fingerprinted to generate a fingerprint of this object.
     *

        It does not affect the behaviour of proxy.golang.org or the go command.
        Instead we recommend using the retract directive which will be processed by all 3 of the above.

        If you have deleted your repo, please recreate it and publish a retraction.

        Retracting a module version involves adding a retract directive to your go.mod file and publishing a new version.
        For example: https://github.com/jba/retract-demo/blob/main/go.mod#L5-L8.

    app: ratelimit
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ratelimit
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ratelimit
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: ratelimit
    spec:
      containers:
      - image: envoyproxy/ratelimit:9d8d70a8 # 2022/08/16
        imagePullPolicy: IfNotPresent

	socketDir := initTempDir(t)
	defer os.RemoveAll(socketDir)

	dsw := cache.NewDesiredStateOfWorld()
	newWatcher(t, socketDir, dsw, wait.NeverStop)

	// Create a plugin first, we are then going to remove the plugin, update the plugin with a different name
	// and recreate it.
	socketPath := filepath.Join(socketDir, "plugin-reregistration.sock")
	pluginName := "reregister-plugin"