You can use the same type declarations with `str`, `float`, `bool` and many other complex data types.

Several of these are explored in the next chapters of the tutorial.

## Order matters { #order-matters }

When creating *path operations*, you can find situations where you have a fixed path.

Like `/users/me`, let's say that it's to get data about the current user.

	nameMatcher := regexp.MustCompile(`^(?:\W?(\w+?)\W?\.)?(?:(\*)|\W?(\w+?)\W?)$`)
	return func(tableColumn string) (table, column string) {
		if matches := nameMatcher.FindStringSubmatch(tableColumn); len(matches) == 4 {
			table = matches[1]
			star := matches[2]
			columnName := matches[3]
			if star != "" {
				return table, star
			}
			return table, columnName
		}
		return "", ""
	}
}()

        }
    }

    boolean matches(final String shr, final String servc) {
        return this.share.equalsIgnoreCase(shr) && (servc == null || servc.startsWith("??") || this.service.equalsIgnoreCase(servc));
    }

    @Override
    public boolean equals(final Object obj) {
        if (obj instanceof final SmbTreeImpl tree) {
            return matches(tree.share, tree.service);
        }

            final String key = e.getKey();
            if (StringUtil.isBlank(key)) {
                return false;
            }
            return pattern.matcher(key).matches();
        }).collect(Collectors.toMap(Entry<String, String>::getKey, Entry<String, String>::getValue));
    }

    /**
     * Gets a map of environment variables.
     *

            key = encrypt ? getEncryptionKey() : getDecryptionKey();
            keyCopy = Arrays.copyOf(key, key.length);

            // Validate key length matches expected cipher requirements
            if (keyCopy.length != keyLength) {
                throw new IllegalArgumentException("Key length mismatch: expected " + keyLength + ", got " + keyCopy.length);
            }

<img src="/img/tutorial/dependencies/image01.png">

## Simple usage { #simple-usage }

If you look at it, *path operation functions* are declared to be used whenever a *path* and *operation* matches, and then **FastAPI** takes care of calling the function with the correct parameters, extracting the data from the request.

Actually, all (or most) of the web frameworks work in this same way.

Using the **SNI extension** discussed above, the TLS Termination Proxy would check which of the TLS (HTTPS) certificates available it should use for this connection, using the one that matches the domain expected by the client.

In this case, it would use the certificate for `someapp.example.com`.

<img src="/img/deployment/https/https03.drawio.svg">

And be compatible with all of them at the same time.

///

Create a utility function to hash a password coming from the user.

And another utility to verify if a received password matches the hash stored.

And another one to authenticate and return a user.

{* ../../docs_src/security/tutorial004_an_py310.py hl[8,49,56:57,60:61,70:76] *}

/// note

   *
   * <p>While resolving a type variable from a {@code var -> type} map, we don't care whether the
   * type variable's bound has been partially resolved. As long as the type variable "identity"
   * matches.
   *
   * <p>On the other hand, if for example we are resolving {@code List<A extends B>} to {@code
   * List<A extends String>}, we need to compare that {@code <A extends B>} is unequal to {@code <A

            final int localPort, final String hostName, final boolean forceSigning, final boolean connectedOnly) {
        for (final SmbTransportImpl conn : this.connections) {
            if (conn.matches(address, port, localAddr, localPort, hostName)
                    && (tc.getConfig().getSessionLimit() == 0 || conn.getNumSessions() < tc.getConfig().getSessionLimit())) {
                try {