*     the returned future.
   * @param executor Executor to run the function in.
   * @return A future that holds result of the transformation.
   * @since 9.0 (in 2.0 as {@code compose})
   */
  public static <I extends @Nullable Object, O extends @Nullable Object>
      ListenableFuture<O> transform(

    rewriter.replaceAllUsesWith(output_uniform_dequantize_call_op.getResult(0),
                                new_output_dequant_op.getResult());

    // Erase unused ops after the transformation.
    rewriter.eraseOp(output_uniform_dequantize_call_pattern->GetCallOp());
    rewriter.eraseOp(output_uniform_quantize_call_pattern->GetCallOp());
    rewriter.eraseOp(multiply_op);

```mlir
  %2 = "tf.TPUExecuteAndUpdateVariables"(%arg0, %arg1, %compile)
    { device_var_reads_indices = [0, 1],
      device_var_updates_indices = [0, -1] }
````

The transformation happens only for on-device variables. The above
transformation requires `%arg0`, `%arg1` to have the same device assignment
as the `TPUExecute` op.
### `-tf-tpu-parallel-execute-sink-resource-write`

    }

    def "replace transformation runs eagerly"() {
        given:
        Transformer<FileCollection, FileCollection> transform = Mock()
        collection.from(containing(new File("a.txt")))

        when:
        collection.replace(transform)

        then:
        1 * transform.transform(_)
    }

    def "replace transformation result is evaluated lazily"() {
        given:

            return interimResult;
        }

        private List<ProjectBuildingResult> build(
                Map<File, MavenProject> projectIndex, List<InterimResult> interimResults) {
            // The transformation may need to access dependencies raw models,
            // which may cause some re-entrance in the build() method and can
            // actually cause deadlocks.  In order to workaround the problem,

        property.set(Providers.notDefined())

        expect:
        property.convention(provider)
        !property.present
        property.getOrNull() == null
    }

    def "can map value using a transformation"() {
        def transformer = Mock(Transformer)
        def property = propertyWithNoValue()

        when:
        def provider = property.map(transformer)

        then:
        0 * _

        when:
        property.replace { null }

        then:
        property.get() == someOtherValue()
    }

    def "replace transformation runs eagerly"() {
        given:
        Transformer<Provider<String>, Provider<String>> transform = Mock()
        property.set(someValue())

        when:
        property.replace(transform)

    if (failed(applyPatternsAndFoldGreedily(module, std::move(patterns)))) {
      signalPassFailure();
    }
  }

  // Constant quantization is a lossy transformation, so they are applied only
  // after all the other patterns have been applied.
  RewritePatternSet patterns_2(ctx);
  populateWithGenerated(patterns_2);

  }

  /**
   * Returns a view of a multimap whose values are derived from the original multimap's entries. In
   * contrast to {@link #transformValues}, this method's entry-transformation logic may depend on
   * the key as well as the value.
   *
   * <p>All other properties of the transformed multimap, such as iteration order, are left intact.
   * For example, the code:
   *

  }

  /**
   * Returns a view of a multimap whose values are derived from the original multimap's entries. In
   * contrast to {@link #transformValues}, this method's entry-transformation logic may depend on
   * the key as well as the value.
   *
   * <p>All other properties of the transformed multimap, such as iteration order, are left intact.
   * For example, the code:
   *