*
 * <li>Optionally, configure the builder.</li>
 *
 * <li>Call {@link #build()} to create the {@code Project} instance.</li>
 *
 * </ol>
 *
 * <p>You can reuse a builder to create multiple {@code Project} instances.</p>
 *
 * <p>The {@code ProjectBuilder} implementation bundled with Gradle 3.0 and 3.1 suffers from a

import (
	"crypto/hmac"
	"errors"
	"hash"
	"io"
)

// Extract generates a pseudorandom key for use with Expand from an input secret
// and an optional independent salt.
//
// Only use this function if you need to reuse the extracted key with multiple
// Expand invocations and different context values. Most common scenarios,
// including the generation of multiple keys, should use New instead.

	}
	// See sockaddr_in6 and sockaddr_in
	dport = ntohs(addr.Addr.Port)

	log.Infof("Local addr %s", conn.LocalAddr())
	log.Infof("Original addr %s: %d", ip, dport)
	return
}

// Setup reuse address to run the validation server more robustly
func reuseAddr(network, address string, conn syscall.RawConn) error {
	return conn.Control(func(descriptor uintptr) {

      assertEquals(200, response.code)
    }

    client.connectionPool.evictAll()
    assertEquals(0, client.connectionPool.connectionCount())

    // Force reuse. This appears flaky (30% of the time) even though sessions are reused.
    // javax.net.ssl.SSLHandshakeException: No new session is allowed and no existing
    // session can be resumed
    //

            assert param.settings.is(ivySettings)
            assert IvyContext.context.ivy.is(ivy)
        }

        and:
        IvyContext.currentStack.empty()
    }

    def "resets Ivy settings on reuse"() {
        given:
        def action1 = Mock(Action)
        def action2 = Mock(Action)
        def ivy
        def ivySettings

        when:
        manager.withIvy(action1)

        then:

<div class="termy">

```console
$ pip install jinja2

---> 100%
```

</div>

## Using `Jinja2Templates`

* Import `Jinja2Templates`.
* Create a `templates` object that you can reuse later.
* Declare a `Request` parameter in the *path operation* that will return a template.

        // cloned value if any.
        auto map_entry = sunk_constant.try_emplace(constant, nullptr);
        if (!map_entry.second) {
          // This constant has already been cloned into the region, reuse it.
          use->set(map_entry.first->getSecond().getResult());
          LLVM_DEBUG(llvm::dbgs() << "Re-use sunk constant " << use->get()
                                  << "\n     in " << use->get() << "\n");

    ```Python hl_lines="8  13"
    {!> ../../../docs_src/dependencies/tutorial006.py!}
    ```

### 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:

=== "Python 3.9+"

    ```Python hl_lines="11  16"

to accumulate values x in a sum.

(By always passing in a result value via the receiver, memory use can be
much better controlled. Instead of having to allocate new memory for each
result, an operation can reuse the space allocated for the result value,
and overwrite that value with the new result in the process.)

Notational convention: Incoming method parameters (including the receiver)

 *    negotiate HTTP/2.
 *
 * Unfortunately, older HTTPS servers refuse to connect when such options are presented. Rather than
 * avoiding these options entirely, this class allows a connection to be attempted with modern
 * options and then retried without them should the attempt fail.
 *
 * ## Connection Reuse
 *
 * Each connection can carry a varying number of streams, depending on the underlying protocol being