"type": "string"
                    },
                    "type": {
                        "title": "Error Type",
                        "type": "string"
                    }
                }
            },
            "HTTPValidationError": {
                "title": "HTTPValidationError",
                "type": "object",
                "properties": {

 *
 * <p>If you have an instance of one of the primary {@code common.graph} types ({@link Graph},
 * {@link ValueGraph}, and {@link Network}):
 *
 * {@snippet :
 * someGraphAlgorithm(startNode, graph);
 * }
 *
 * This works because those types each implement {@code PredecessorsFunction}. It will also work
 * with any other implementation of this interface.
 *

 *
 * <p>If you have an instance of one of the primary {@code common.graph} types ({@link Graph},
 * {@link ValueGraph}, and {@link Network}):
 *
 * {@snippet :
 * someGraphAlgorithm(startNode, graph);
 * }
 *
 * This works because those types each implement {@code SuccessorsFunction}. It will also work with
 * any other implementation of this interface.
 *

the operation would become deadlocked if the channels are full.

### Typed handlers

Typed handlers are handlers that have a specific type for the request and response payloads.

```go
    // Create a typed handler.
    handler := func(ctx context.Context, p *Payload, in <-chan *Req, out chan<- *Resp) *RemoteErr {

  transient Class<K> keyTypeOrObjectUnderJ2cl;
  transient Class<V> valueTypeOrObjectUnderJ2cl;

  /**
   * Returns a new, empty {@code EnumBiMap} using the specified key and value types.
   *
   * @param keyType the key type
   * @param valueType the value type
   */
  public static <K extends Enum<K>, V extends Enum<V>> EnumBiMap<K, V> create(
      Class<K> keyType, Class<V> valueType) {
    return new EnumBiMap<>(keyType, valueType);
  }

  private static <T> void setImplementation(Class<T> type, Class<? extends T> implementation) {
    checkArgument(type != implementation, "Don't register %s to itself!", type);
    checkArgument(
        !DEFAULTS.containsKey(type), "A default value was already registered for %s", type);
    checkArgument(
        implementations.put(type, implementation) == null,
        "Implementation for %s was already registered",

```JSON
{"item_id":"foo"}
```

## Path parameters with types { #path-parameters-with-types }

You can declare the type of a path parameter in the function, using standard Python type annotations:

{* ../../docs_src/path_params/tutorial002_py39.py hl[7] *}

In this case, `item_id` is declared to be an `int`.

/// check

     *             if there is an error resolving the name
     */
    NetbiosAddress getNbtByName(String host, int type, String scope, InetAddress svr) throws UnknownHostException;

    /**
     * Determines the address of a host given it's host name. NetBIOS
     * names also have a <code>type</code>. Types(aka Hex Codes)
     * are used to distinguish the various services on a host. <a
     * href="../../../nbtcodes.html">Here</a> is

     * @param ctype2
     *            The array of character types.
     * @param val
     *            The character code.
     */
    protected static void wordChar(final byte[] ctype2, final int val) {
        ctype2[val] |= CT_ALPHA;
    }

    /**
     * Sets characters as whitespace.
     *
     * @param ctype2
     *            The array of character types.
     * @param low

### Faite en python moderne

Tout est basé sur la déclaration de type standard de **Python 3.8** (grâce à Pydantic). Pas de nouvelles syntaxes à apprendre. Juste du Python standard et moderne.

Si vous souhaitez un rappel de 2 minutes sur l'utilisation des types en Python (même si vous ne comptez pas utiliser FastAPI), jetez un oeil au tutoriel suivant: [Python Types](python-types.md){.internal-link target=_blank}.