for (Plugin element : tgt) {
                    Object key = getPluginKey().apply(element);
                    master.put(key, element);
                }

                Map<Object, List<Plugin>> predecessors = new LinkedHashMap<>();
                List<Plugin> pending = new ArrayList<>();
                for (Plugin element : src) {
                    Object key = getPluginKey().apply(element);

As part of that, I needed to investigate, test and use many alternatives.

The history of **FastAPI** is in great part the history of its predecessors.

As said in the section [Alternatives](alternatives.md){.internal-link target=_blank}:

<blockquote markdown="1">

**FastAPI** wouldn't exist if not for the previous work of others.

    Map<K, V> result = super.convertToHashFloodingResistantImplementation();
    links = null;
    return result;
  }

  /*
   * For discussion of the safety of the following methods for operating on predecessors and
   * successors, see the comments near the end of CompactHashMap, noting that the methods here call
   * link(), which is defined at the end of this file.
   */

  private int getPredecessor(int entry) {

                                       &arg)
                    .succeeded()) {
              options.insert(arg);
            }
          }
        } else {
          op->emitOpError("Predecessor op doesn't implement BranchOpInterface");
          return failure();
        }
      }
    }
    if (!options.empty()) {
      if (options.size() != 1) {
        op->emitOpError("Incompatible code paths.");

	// come right after it.
	after := map[ID][]*Block{}

	// Check each loop header and decide if we want to move it.
	for _, loop := range loopnest.loops {
		b := loop.header
		var p *Block // b's in-loop predecessor
		for _, e := range b.Preds {
			if e.b.Kind != BlockPlain {
				continue
			}
			if loopnest.b2l[e.b.ID] != loop {
				continue
			}
			p = e.b
		}
		if p == nil {
			continue
		}

  let constructor = "TFDevice::CreateEmbeddingProgramKeyPass()";
    let description = [{
    Passes in the program key to embedding ops. Will move the embedding ops
    after a _TPUCompileMlir op if there is no predecessor _TPUCompileMlir op.
    Both the embedding op and compile op are assumed to be wrapped in separate
    tf_device.launch() ops. This is because the embedding op is head outside

Como parte disso, eu precisava investigar, testar e usar muitas alternativas.

A história do **FastAPI** é, em grande parte, a história de seus predecessores.

Como dito na seção [Alternativas](alternatives.md){.internal-link target=_blank}:

<blockquote markdown="1">

**FastAPI** não existiria se não pelo trabalho anterior de outros.

      return WalkResult::interrupt();
    return WalkResult::advance();
  });
  return result.wasInterrupted();
}

// Make invariant the `ShapeOp`s or a `ReadVariableOp` that's the `ShapeOp`'s
// predecessor.
void MakeShapeOpInvariant(tf_device::ReplicateOp replicate_op, int num_replicas,
                          Block* replicate_block, TF::ShapeOp shape_op) {
  // Ignore ShapeOps that have virtual devices.

	}
	for _, r := range rules {
		if r.op == "!<" {
			disallowed = append(disallowed, r)
			continue
		}
		for _, def := range r.def {
			if def == "NONE" {
				errorf("NONE cannot be a predecessor")
				continue
			}
			if !g.addNode(def) {
				errorf("multiple definitions for %s", def)
			}
			for _, less := range r.less {
				if less == "NONE" {
					continue
				}