result.unsortedOrder as List == [0, 1, 2, 3]
    }

    static interface Flavor extends Named {}

    enum MyEnum {
        FOO,
        BAR
    }

    static Flavor flavor(String name) {
        TestUtil.objectInstantiator().named(Flavor, name)
    }

    static abstract class ConcreteNamed implements Named {
    }

// a named type remain the same as long as the same source and AddMethod calls
// are presented to the type checker in the same order (go.dev/issue/61298).
func TestMethodOrdering(t *testing.T) {
	const src = `
package p

type T struct{}

func (T) a() {}
func (T) c() {}
func (T) b() {}
`
	// should get the same method order each time
	var methods []string

query_or_cookie_extractor(["query_or_cookie_extractor"])

read_query["/items/"]

query_extractor --> query_or_cookie_extractor --> read_query
```

## Using the same dependency multiple times

If one of your dependencies is declared multiple times for the same *path operation*, for example, multiple dependencies have a common sub-dependency, **FastAPI** will know to call that sub-dependency only once per request.

====
<1> Gets a reference of type `Task` to the existing task named `check`
<2> Registers a new untyped task named `myTask1`
<3> Gets a reference to the existing task named `compileJava` of type `JavaCompile`
<4> Registers a new task named `myCopy1` of type `Copy`

        if (attributeValue == null) {
            throw new IllegalStateException("No attribute value for " + attribute);
        }

        if (attributeValue instanceof Named) {
            return ((Named) attributeValue).getName();
        } else if (attributeValue instanceof Object[]) {
            // don't bother trying to handle primitive arrays specially

                    c1 { attributes { attribute(flavor, objects.named(Flavor, 'preview')); $debug } }
                    c2 { attributes { attribute(flavor, objects.named(Flavor, 'preview')); $release } }
                    c3 { attributes { attribute(flavor, objects.named(Flavor, 'full')); $debug } }
                    c4 { attributes { attribute(flavor, objects.named(Flavor, 'full')); $release } }
                }

//     using exactly the same version of the toolchain, the same build
//     tags, and the same values of certain flags and environment
//     variables.
//
//   - Similar crashing problems are likely to arise unless all common
//     dependencies of the application and its plugins are built from
//     exactly the same source code.
//
//   - Together, these restrictions mean that, in practice, the

package os

import "internal/testlog"

// Stat returns a [FileInfo] describing the named file.
// If there is an error, it will be of type [*PathError].
func Stat(name string) (FileInfo, error) {
	testlog.Stat(name)
	return statNolog(name)
}

// Lstat returns a [FileInfo] describing the named file.
// If the file is a symbolic link, the returned FileInfo

        context.details.withVariant("runtime") {
            attributes {
                attributes.attribute(OperatingSystemFamily.OPERATING_SYSTEM_ATTRIBUTE, objects.named(OperatingSystemFamily, "none"))
                attributes.attribute(MachineArchitecture.ARCHITECTURE_ATTRIBUTE, objects.named(MachineArchitecture, "none"))
            }
        }
        nativeVariants.each { variantDefinition ->

    }

    def "named(String, Action) fails when named element requested in filtered collection with incompatible type"() {
        when:
        accessedBy { map, action -> map.withType(specialItemClass).named("item", action) }

        then:
        def ex = thrown InvalidModelRuleException