import com.google.common.collect.Lists;
import net.rubygrapefruit.platform.MissingRegistryEntryException;
import net.rubygrapefruit.platform.WindowsRegistry;
import org.gradle.internal.nativeintegration.NativeIntegrationUnavailableException;
import org.gradle.internal.os.OperatingSystem;

import java.io.File;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

        // need to take copy to prevent ConcurrentModificationException
        List<String> keysToRemove = Lists.newArrayList(Sets.difference(System.getenv().keySet(), source.keySet()));
        for (String key : keysToRemove) {
            removeEnvironmentVariable(key);
        }
        for (Map.Entry<String, String> entry : source.entrySet()) {

 */
package org.gradle.internal.component.model;

import com.google.common.collect.Lists;
import org.gradle.internal.Cast;

import javax.annotation.Nullable;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.function.Consumer;

public class MutableModuleSources implements ModuleSources {
    private List<ModuleSource> moduleSources;

	"k8s.io/client-go/tools/cache"
)

// ExampleLister helps list Examples.
// All objects returned here must be treated as read-only.
type ExampleLister interface {
	// List lists all Examples in the indexer.
	// Objects returned here must be treated as read-only.
	List(selector labels.Selector) (ret []*v1.Example, err error)
	// Examples returns an object that can list and get Examples.
	Examples(namespace string) ExampleNamespaceLister

// represent type lists.  In particular, TypesN<T1, T2, ..., TN>
// represents a type list with N types (T1, T2, ..., and TN) in it.
// Except for Types0, every struct in the family has two member types:
// Head for the first type in the list, and Tail for the rest of the
// list.

// The empty type list.
struct Types0 {};

// Type lists of length 1, 2, 3, and so on.

template <typename T1>

import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import org.gradle.model.internal.manage.schema.ModelSchema;
import org.gradle.model.internal.manage.schema.cache.ModelSchemaCache;
import org.gradle.model.internal.type.ModelType;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Queue;

    ```

This will make `tags` be a list, although it doesn't declare the type of the elements of the list.

## List fields with type parameter

But Python has a specific way to declare lists with internal types, or "type parameters":

### Import typing's `List`

In Python 3.9 and above you can use the standard `list` to declare these type annotations as we'll see below. 💡

        }
        formatter.endChildren();
        throw new GeneratedClassCompilationException(formatter.toString());
    }

    private static List<File> outputSourceFilesToSourceDir(File srcDir, List<ClassSource> classes) throws IOException {
        List<File> filesToCompile = Lists.newArrayListWithCapacity(classes.size());
        for (ClassSource classSource : classes) {
            String packageName = classSource.getPackageName();

        public Object apply(WeakReference<Class<?>> input) {
            return input.get();
        }
    };

    private final List<WeakReference<Class<?>>> references;
    private final int hash;

    MultiWeakClassSet(List<Class<?>> classes) {
        this.references = Lists.newArrayList(Iterables.transform(classes, TO_WEAK_REF));
        this.hash = classes.hashCode();
    }

    @Override
    public int hashCode() {

import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

public class VirtualPlatformState {
    private final Comparator<String> vC;
    private final ModuleResolveState platformModule;
    private final ResolveOptimizations resolveOptimizations;

    private final Set<ModuleResolveState> participatingModules = new LinkedHashSet<>();
    private final List<EdgeState> orphanEdges = Lists.newArrayListWithExpectedSize(2);