}
  }

  @LazyInit private transient @Nullable Collection<V> values;

  @Override
  public Collection<V> values() {
    Collection<V> result = values;
    return (result == null) ? values = createValues() : result;
  }

  Collection<V> createValues() {
    return new Values();
  }

  Iterator<V> valuesIterator() {

func (b *Boolean) Capture(values []string) error {
	*b = Boolean(strings.EqualFold(values[0], "true"))
	return nil
}

// LiteralString is a type for parsed SQL string literals
type LiteralString string

// Capture interface used by participle
func (ls *LiteralString) Capture(values []string) error {
	// Remove enclosing single quote
	n := len(values[0])
	r := values[0][1 : n-1]
	// Translate doubled quotes

        int bytesDecoded = fileStandardInfo.decode(buffer, 0, buffer.length);

        // Verify - non-zero values should be treated as true
        assertEquals(22, bytesDecoded);
        assertEquals(expectedEndOfFile, fileStandardInfo.getSize());
    }

    @Test
    @DisplayName("Test encode with various values")
    void testEncode() throws SMBProtocolDecodingException {
        // First decode to set internal state

These dependencies can `raise` exceptions, the same as normal dependencies:

{* ../../docs_src/dependencies/tutorial006_an_py310.py hl[10,15] *}

### Return values { #return-values }

And they can return values or not, the values won't be used.

So, you can reuse a normal dependency (that returns a value) you already use somewhere else, and even though the value won't be used, the dependency will be executed:

    int dummy = 0;
    for (int i = 0; i < reps; i++) {
      dummy += impl.create(values).size();
    }
    return dummy;
  }

  @Benchmark
  boolean createPopulateAndRemove(int reps) {
    boolean dummy = false;
    for (int i = 1; i < reps; i++) {
      Map<Element, Element> map = impl.create(values);
      for (Element value : values) {
        dummy |= map.remove(value) == null;
      }
    }

    private static String toJsonArray(final String[] values) {
        if (values == null) {
            return "[]";
        }
        final StringBuilder buf = new StringBuilder();
        buf.append('[');
        for (int i = 0; i < values.length; i++) {
            if (i > 0) {
                buf.append(',');
            }
            buf.append(escapeJsonString(values[i]));
        }
        buf.append(']');

     * Creates a {@link StreamOf} instance from the provided values.
     * If the input array is {@code null}, an empty stream is returned.
     *
     * @param <T> The type of elements in the stream.
     * @param values The elements to be included in the stream. Can be {@code null}.
     * @return A {@link StreamOf} instance containing the provided values, or an empty stream if {@code values} is {@code null}.
     */
    @SafeVarargs

    response = client.post("/tuple-form/", data={"values": ("1", "2")})
    assert response.status_code == 200, response.text
    assert response.json() == [1, 2]


def test_tuple_form_invalid():
    response = client.post("/tuple-form/", data={"values": ("1", "2", "3")})
    assert response.status_code == 422, response.text

    response = client.post("/tuple-form/", data={"values": ("1")})

}
absl::Status SetAttrFloatList(AbstractOperation* op_, const char* attr_name,
                              const float* values, int num_values,
                              ForwardOperation* forward_op_) {
  forward_op_->attrs.Set(attr_name,
                         gtl::ArraySlice<const float>(values, num_values));
  return op_->SetAttrFloatList(attr_name, values, num_values);
}

   */
  @VisibleForTesting transient @Nullable Object @Nullable [] keys;

  /**
   * The values of the entries in the map, in the range of [0, size()). The values in [size(),
   * values.length) are all {@code null}.
   */
  @VisibleForTesting transient @Nullable Object @Nullable [] values;

  /**
   * Keeps track of metadata like the number of hash table bits and modifications of this data