* See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.util.internal;

import com.google.common.collect.Lists;

import java.util.LinkedList;
import java.util.List;

/**
 * Discards old entries when current count is over the limit.
 *
 * @deprecated Used only by a deprecated public class GFileUtils. Prefer Guava's EvictionQueue in the new code.
 */

 */

package org.gradle.internal.logging.events;

import com.google.common.collect.Lists;
import org.apache.commons.lang.BooleanUtils;
import org.apache.commons.lang.StringUtils;

import java.util.List;

public class YesNoQuestionPromptEvent extends PromptOutputEvent {
    public static final List<String> YES_NO_CHOICES = Lists.newArrayList("yes", "no");
    private final String question;

## Campos do tipo Lista

Você pode definir um atributo como um subtipo. Por exemplo, uma `list` do Python:

```Python hl_lines="14"
{!../../../docs_src/body_nested_models/tutorial001.py!}
```

Isso fará com que tags seja uma lista de itens mesmo sem declarar o tipo dos elementos desta lista.

## Campos do tipo Lista com um parâmetro de tipo

      extends CollectionFuture<V, List<@Nullable V>> {
    ListFuture(
        ImmutableCollection<? extends ListenableFuture<? extends V>> futures,
        boolean allMustSucceed) {
      super(futures, allMustSucceed);
      init();
    }

    @Override
    public List<@Nullable V> combine(List<@Nullable Present<V>> values) {
      List<@Nullable V> result = newArrayListWithCapacity(values.size());

// For objects, the expected type is map[string]any
// For lists, the expected type is []any
// For maps, the expected type is map[string]any
// For anything else, it is converted via value.Value()
//
// It will return an error if the request type is a map but the key
// is not a string.
func convertField(value ref.Val) (any, error) {
	// special handling for lists, where the elements are converted with Value() instead of ConvertToNative

 * limitations under the License.
 */
package org.gradle.internal.serialize;

import com.google.common.collect.Lists;

import java.util.Collections;
import java.util.List;

public class ListSerializer<T> extends AbstractCollectionSerializer<T, List<T>> implements Serializer<List<T>> {

    public ListSerializer(Serializer<T> entrySerializer) {
        super(entrySerializer);
    }

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;

	"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>

    ```

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. 💡