/** The crawl delay in seconds for this directive. */
        private int crawlDelay;

        /** The list of allowed paths for this directive. */
        private final List<String> allowedPaths = new ArrayList<>();

        /** The list of disallowed paths for this directive. */
        private final List<String> disallowedPaths = new ArrayList<>();

        /**

In this case, `str` is the type parameter passed to `List` (or `list` in Python 3.9 and above).

///

That means: "the variable `items` is a `list`, and each of the items in this list is a `str`".

/// tip

If you use Python 3.9 or above, you don't have to import `List` from `typing`, you can use the same regular `list` type instead.

///

     * it will return an empty list of changes.
     *
     * @return changes since the last invocation
     * @throws CIFSException if an error occurs retrieving file notifications
     */
    List<FileNotifyInformation> watch() throws CIFSException;

    /**
     * {@inheritDoc}
     *
     * @see java.util.concurrent.Callable#call()
     */
    @Override
    List<FileNotifyInformation> call() throws CIFSException;

		}
		if w.scope[len(w.scope)-1] != name {
			log.Fatalf("attempt to leave scope %q, but scope is currently %#v", name, w.scope)
		}
		w.scope = w.scope[:len(w.scope)-1]
	}
}

func sortedMethodNames(typ *types.Interface) []string {
	n := typ.NumMethods()
	list := make([]string, n)
	for i := range list {
		list[i] = typ.Method(i).Name()
	}

            final List<Integer> list = new ArrayList<>();
            for (final String value : values) {
                try {
                    list.add(Integer.parseInt(value.trim()));
                } catch (final NumberFormatException e) {}
            }
            this.days = new int[list.size()];
            for (int i = 0; i < list.size(); i++) {
                this.days[i] = list.get(i);

        final int[] loadCount = { 0 };
        DataStoreFactory testFactory = new DataStoreFactory() {
            @Override
            protected List<String> loadDataStoreNameList() {
                loadCount[0]++;
                return List.of("Store1", "Store2");
            }
        };

        // First call should load
        String[] names = testFactory.getDataStoreNames();

        FunctionScoreQueryBuilder functionScoreQuery =
                QueryBuilders.functionScoreQuery(queryBuilder, list.toArray(new FilterFunctionBuilder[list.size()]));
        regQ(functionScoreQuery);
        return functionScoreQuery;
    }

    protected BoolQueryBuilder regBoolCQ(List<QueryBuilder> mustList, List<QueryBuilder> shouldList, List<QueryBuilder> mustNotList,

        FunctionScoreQueryBuilder functionScoreQuery =
                QueryBuilders.functionScoreQuery(queryBuilder, list.toArray(new FilterFunctionBuilder[list.size()]));
        regQ(functionScoreQuery);
        return functionScoreQuery;
    }

    protected BoolQueryBuilder regBoolCQ(List<QueryBuilder> mustList, List<QueryBuilder> shouldList, List<QueryBuilder> mustNotList,

      .build()

  /**
   * The protocols the client supports. This method always returns a non-null list that
   * contains minimally [Protocol.HTTP_1_1].
   */
  @get:JvmName("protocols")
  val protocols: List<Protocol> = protocols.toImmutableList()

  @get:JvmName("connectionSpecs")
  val connectionSpecs: List<ConnectionSpec> =
    connectionSpecs.toImmutableList()

  @JvmName("-deprecated_url")
  @Deprecated(

      return (Entry<String, Integer>[]) new Entry<?, ?>[length];
    }

    @Override
    public Iterable<Entry<String, Integer>> order(List<Entry<String, Integer>> insertionOrder) {
      return insertionOrder;
    }

    @Override
    public List<Entry<String, Integer>> create(Object... elements) {
      ImmutableMap.Builder<String, Integer> builder = ImmutableMap.builder();
      for (Object o : elements) {