f()
        finish()
    }
}

public fun <A : Any> List<A>.mergeWith(f: SublistMerger<A>.() -> Unit): List<A> =
    mutableListOf<A>().also { destination -> mergeInto(destination, f) }

public inline fun <A : Any, reified R : A> List<A>.mergeOnly(crossinline create: (List<R>) -> A?): List<A> =

        subject.handle(initialRequests, scriptHandler, target, targetScope)

        // then:
        verify(pluginRequestApplicator).applyPlugins(initialRequests.mergeWith(autoAppliedPlugins), scriptHandler, pluginManager, targetScope)
    }

        val autoAppliedPlugins = autoAppliedPluginHandler.getAutoAppliedPlugins(initialRequests, target)
        pluginRequestApplicator.applyPlugins(
            initialRequests.mergeWith(autoAppliedPlugins),
            scriptHandler,
            target.pluginManager,
            targetScope
        )
    }

}

absl::StatusOr<InferredShape> MergeInferredShapes(const InferredShape& a,
                                                  const InferredShape& b) {
  InferredShape result;
  TF_RETURN_IF_ERROR(a.shape.MergeWith(b.shape, &result.shape));

  if (a.handle_type == DT_INVALID) {
    result.handle_type = b.handle_type;
  } else if (b.handle_type == DT_INVALID) {
    result.handle_type = a.handle_type;

            PluginRequests autoAppliedPlugins = autoAppliedPluginHandler.getAutoAppliedPlugins(initialPluginRequests, target);
            PluginRequests allPlugins = initialPluginRequests.mergeWith(autoAppliedPlugins);
            pluginRequestApplicator.applyPlugins(allPlugins, scriptHandler, pluginManager, targetScope);