description: Changes to the language
labels: ["Proposal", "LanguageChange", "LanguageChangeReview"]
title: "proposal: spec: proposal title"


body:
  - type: markdown
    attributes:
      value: |
       ## Our process for evaluating language changes can be found [here](https://go.googlesource.com/proposal/+/refs/heads/master#language-changes)

  - type: dropdown
    id: author-go-experience
    attributes:
      label: "Go Programming Experience"

platforms/core-configuration/declarative-dsl-core/                  @gradle/bt-declarative-gradle-project
platforms/core-configuration/declarative-dsl-evaluator/             @gradle/bt-declarative-gradle-project
platforms/core-configuration/declarative-dsl-provider/              @gradle/bt-declarative-gradle-project

        features down to compact but powerful abstractions, and controlling feature bloat carefully.


        Guava's main yardstick for evaluating proposed features can be summed up as [utility times
        ubiquity](https://github.com/google/guava/wiki/PhilosophyExplained#utility-times-ubiquity).


        #### Utility: compare with alternatives

* Fixed unmounting of vSphere volumes when kubelet runs in a container. ([#49111](https://github.com/kubernetes/kubernetes/pull/49111), [@jsafrane](https://github.com/jsafrane))
* use informers for quota evaluation of core resources where possible ([#49230](https://github.com/kubernetes/kubernetes/pull/49230), [@deads2k](https://github.com/deads2k))

         * because it can resolve ambiguities when a path could be of many types.
         *
         * @param pathTypeFilter predicate evaluating whether a path type should be included in the result
         * @return {@code this} for method call chaining
         */
        @Nonnull

		return
	}
	objOpts := make([]lifecycle.ObjectOpts, len(objInfos))
	for i, oi := range objInfos {
		objOpts[i] = oi.ToLifecycleOpts()
	}
	evaluator := lifecycle.NewEvaluator(*i.lifeCycle).WithLockRetention(&lr).WithReplicationConfig(i.replication.Config)
	events, err := evaluator.Eval(objOpts)
	if err != nil {
		// This error indicates that the objOpts passed to Eval is invalid.
		bugLogIf(ctx, err, i.bucket, i.objectPath())

   */
  @ForOverride
  protected abstract int doHash(T t);

  /**
   * Returns a new equivalence relation for {@code F} which evaluates equivalence by first applying
   * {@code function} to the argument, then evaluating using {@code this}. That is, for any pair of
   * non-null objects {@code x} and {@code y}, {@code equivalence.onResultOf(function).equivalent(a,

   * this may not preserve the order of entries.
   *
   * @param keyFunction the function used to produce the key for each value
   * @return a map mapping the result of evaluating the function {@code keyFunction} on each value
   *     in this fluent iterable to that value
   * @throws IllegalArgumentException if {@code keyFunction} produces the same key for more than one

   * stream.collect(ImmutableMap.toImmutableMap(keyFunction, v -> v))}.
   *
   * @param keyFunction the function used to produce the key for each value
   * @return a map mapping the result of evaluating the function {@code keyFunction} on each value
   *     in this fluent iterable to that value
   * @throws IllegalArgumentException if {@code keyFunction} produces the same key for more than one

- In the course of admitting a single request, the ValidatingAdmissionPolicy plugin will perform no more than one authorization check per unique authorizer expression. All evaluations of identical authorizer expressions will produce the same decision. ([#116443](https://github.com/kubernetes/kubernetes/pull/116443), [@benluddy](https://github.com/benluddy)) [SIG API Machinery and Testing]