*
     * <p>This method can also be used to discard the value of the property, by passing {@code null} as the value.
     * The convention for this property, if any, will be used to provide the value instead.
     *
     * @param elements The elements, can be null.
     */

		if k.obj != nil {
			path, err := encoder.For(k.obj)
			if err != nil {
				if debug {
					log.Printf("discarding fact %s about %s\n", fact, k.obj)
				}
				continue // object not accessible from package API; discard fact
			}
			object = path
		}
		gobFacts = append(gobFacts, gobFact{
			PkgPath: k.pkg.Path(),
			Object:  object,
			Fact:    fact,
		})
	}
	s.mu.Unlock()

func Benchmark(f func(b *B)) BenchmarkResult {
	b := &B{
		common: common{
			signal: make(chan bool),
			w:      discard{},
		},
		benchFunc: f,
		benchTime: benchTime,
	}
	if b.run1() {
		b.run()
	}
	return b.result
}

type discard struct{}

        protected void queue(T message) {
            if (failure.get() == null) {
                events.add(message);
            }
            // else, the handler thread is no longer handling messages so discard it
        }

        @Override
        public void close() {
            events.add(END);
            executor.stop(60, TimeUnit.SECONDS);
            Exception failure = this.failure.get();

					if other.isDir() {
						if serverDebugLog {
							console.Debugln("mergeEntryChannels: discarding directory", other.name, "for object", best.name)
						}
						// Discard the directory.
						if err := selectFrom(otherIdx); err != nil {
							return err
						}
						continue
					}
					// Replace directory with object.
					if serverDebugLog {

    waitForDataFrames(Http2Connection.OKHTTP_CLIENT_WINDOW_SIZE)

    // Cancel the call and discard what we've buffered for the response body. This should free up
    // the connection flow-control window so new requests can proceed.
    call1.cancel()
    assertThat(
      response1.body.source().discard(1, TimeUnit.SECONDS),
      "Call should not have completed successfully.",
    ).isFalse()

            try {
                if (done) {
                    // Already calculated
                    return;
                }
                done = true;

                // Attach result and discard calculation state
                owner.result = Try.ofFailable(() -> {
                    NodeExecutionContext effectiveContext = context;
                    if (effectiveContext == null) {

-->

<!-- Items that don't need to be mentioned in Go 1.23 release notes but are picked up by relnote todo.

CL 458895 - an x/playground fix that mentioned an accepted cmd/go proposal go.dev/issue/40728 in Go 1.16 milestone...
CL 582097 - an x/build CL working on relnote itself; it doesn't need a release note

    }

    @Override
    public void maybeDiscardStateRequiredForGraphResolution() {
        if (!keepStateRequiredForGraphResolution) {
            dependencySubstitutions.discard();
        }
    }

    @Override
    public void setMutationValidator(MutationValidator validator) {
        mutationValidator = validator;
        cachePolicy.setMutationValidator(validator);

        return isSameOrNewer("3.2") && !(isSameOrNewer("4.0") && isSameOrOlder("4.0.2"));
    }

    @Override
    boolean isToolingApiHasCauseOnForcedCancel() {
        // Versions before 5.1 would discard context on forced cancel
        return isSameOrNewer("5.1-rc-1");
    }

    @Override
    boolean isToolingApiLogsFailureOnCancel() {