// CHECK-NEXT:   [[HANDLE2:%.*]] = "tf.VarHandleOp"
// CHECK-NEXT:   [[KEY:%.*]], [[FUTURE:%.*]] = "tf.IfrtLoadVariable"([[HANDLE2]])
// CHECK-SAME:       used_by_host = false 
// CHECK-NEXT:   [[RES:%.*]] = "tf.IfrtCall"([[KEY]], %arg0) <{program_id = 6515870160938153680 : i64, variable_arg_indices = [0 : i32]}>
// CHECK-SAME:    : (tensor<!tf_type.string>, tensor<1x3xf32>) -> tensor<1x1xf32>
// CHECK-NEXT:    return [[RES]] : tensor<1x1xf32>
//
module {

    }
}
```

!!! note
    Notice that even though the `item` was declared the same way as before, it is now expected to be inside of the body with a key `item`.


**FastAPI** will do the automatic conversion from the request, so that the parameter `item` receives its specific content and the same for `user`.

import spock.lang.Specification

class PersistentListTest extends Specification {

    def "empty lists are the same"() {
        expect:
        PersistentList.of() == PersistentList.of()
    }

    def "lists with elements #elements are the same"() {
        expect:
        listOf(elements) == listOf(elements)

        where:
        elements << [["a"], ["a", "b"]]
    }

 */

package org.jetbrains.kotlin.analysis.api.platform

/**
 * A marker interface for a provider that can be composed, i.e. multiple instances of the same provider can be composed into a single
 * provider.
 *
 * Composable providers share certain traits: There is a notion of a sequentially composed [KotlinCompositeProvider] of that kind, and there

     * in the dependencies of a given configuration.
     * For example, some other dependency, which does not have any exclude rules,
     * might pull in exactly the same transitive dependency.
     * To guarantee that the transitive dependency is excluded from the entire configuration
     * please use per-configuration exclude rules: {@link Configuration#getExcludeRules()}.

			// at the same time added as a unique entry in the processedDestRules.
			if bothWithoutSelector || (rule.GetWorkloadSelector() != nil && selectorsMatch) {
				addRuleToProcessedDestRules = false
			}

			// Deep copy destination rule, to prevent mutate it later when merge with a new one.
			// This can happen when there are more than one destination rule of same host in one namespace.
			copied := mdr.rule.DeepCopy()

def IsNhwcLayoutOp: Constraint<Neg<IsNchwLayoutOp.predicate>>;

// TODO(b/343278954): Move the creation of transposes to a separate prepare pass
// to avoid creating multiple pattern-rewrite rules for the same composite op.
def LegalizeTorchUpsampleBlinear2dComposite: Pat<
    (MHLO_CompositeOp:$old_val
    (variadic $input),
    ConstantStrAttr<StrAttr, "odml.upsample_bilinear2d">, $attrs, $_, $_),
    (TFL_TransposeOp

 * @see ServiceScope
 */
public interface Scope {

    /**
     * These services are reused across builds in the same process.
     *
     * <p>Global services are visible to all other services.</p>
     */
    interface Global extends Scope {}

    /**
     * These services are reused across builds in the same process while the Gradle user home directory remains unchanged.

			1,
		},
		{
			"two servers on the same port",
			[]config.Config{gwHTTPFoo, gwHTTPbar},
			1,
			2,
			map[string]int{"http.7": 2},
			2,
		},
		{
			"two servers on the same port with different bind",
			[]config.Config{gwHTTPbar, gwHTTPlocalbar},
			2,
			2,
			map[string]int{"http.7": 1, "http.7.127.0.0.1": 1},
			2,
		},
		{
			"same-server-config",

     * the same module A.
     *
     * An out-of-block modification event for the [KaResolveExtension]'s associated module does not need to be published in response to an
     * out-of-block modification event for the same module, because the original event suffices for invalidation.
     *
     * @see KaResolveExtensionFile