((MockSearchRequestParams) p).setQuery("rewritten1");
            return p;
        };
        SearchHelper.SearchRequestParamsRewriter rewriter2 = p -> {
            ((MockSearchRequestParams) p).setQuery("rewritten2");
            return p;
        };

        searchHelper.addRewriter(rewriter1);
        searchHelper.addRewriter(rewriter2);

If the call never returned, then once again the original program
would never access <code>*p</code> or <code>*q</code>, but the rewritten program would.
And if the call contained synchronizing operations, then the original program
could establish happens before edges preceding the accesses
to <code>*p</code> and <code>*q</code>, but the rewritten program would not.
</p>

<p>
Not allowing a single read to observe multiple values means

        return queryBuilder.getName();
    }

    /**
     * Rewrites the query using the provided rewrite context.
     *
     * @param queryShardContext the query rewrite context
     * @return the rewritten query builder
     * @throws IOException if an I/O error occurs during rewriting
     */
    @Override
    public QueryBuilder rewrite(final QueryRewriteContext queryShardContext) throws IOException {

    "//tensorflow/tools/pip_package:wheel" \
    "//tensorflow/tools/pip_package:licenses"
}

# This test ensures that all the targets built into the Python package include
# their dependencies. It's a rewritten version of the "smoke test", an older
# Python script that was very difficult to understand. See
# https://github.com/tensorflow/tensorflow/blob/master/tensorflow/tools/pip_package/pip_smoke_test.py

	})
	// Test compressed index consistency fix
	t.Run("comp-index", func(t *testing.T) {
		// This file has a compressed index, due to https://github.com/minio/minio/pull/20575
		// We ensure it is rewritten without an index.
		// We compare this against the signature of the files stored without a version.

				iamLogIf(ctx, nerr.Err)
			}
		}
	}

	return nil
}

// CreateUser - create new user credentials and policy, if user already exists
// they shall be rewritten with new inputs.
func (sys *IAMSys) CreateUser(ctx context.Context, accessKey string, ureq madmin.AddOrUpdateUserReq) (updatedAt time.Time, err error) {
	if !sys.Initialized() {
		return updatedAt, errServerNotInitialized

	printString("type is bool or string")  // type of i is type of x (interface{})
default:
	printString("don't know the type")     // type of i is type of x (interface{})
}
</pre>

<p>
could be rewritten:
</p>

<pre>
v := x  // x is evaluated exactly once
if v == nil {
	i := v                                 // type of i is type of x (interface{})
	printString("x is nil")

    `tf.spectral.irfft`.
*   Exported model signatures using the 'predict' method will no longer have
    their input and output keys silently ignored and rewritten to 'inputs' and
    'outputs'. If a model was exported with different names before 1.2, and is
    now served with tensorflow/serving, it will accept requests using 'inputs'

has all the typing information as `User`, so your editor will work as expected (autocompletion and everything), and **FastAPI** will be able to understand the dependency defined in `Annotated`. 😎

Roughly **all the docs** have been rewritten to use `Annotated` as the main way to declare **parameters** and **dependencies**. All the **examples** in the docs now include a version with `Annotated` and a version without it, for each of the specific Python versions (when there are small d...