// 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
		}

     * the target state, not the input state. Implicitly, a rule accepts as input the subject in the state that is the predecessor of the target state.
     */
    public BindingPredicate getPredicate() {
        return predicate;
    }

    public boolean isBound() {
        return boundTo != null;
    }

  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

    while (op && op != func) {
      op->removeAttr("_is_compilation");
      op->removeAttr("_wraps_compilation");
      op = op->getParentOp();
    }
  });
}

int OutsideCompilationOrdering(Operation* predecessor, Operation* op) {
  // Actual compilations go first.
  if (op->hasAttr("_is_compilation")) return 2;
  // Followed by nested ops that contain compilations.
  if (op->hasAttr("_wraps_compilation")) return 1;

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
				}

		// Note: this is trickier than it looks. Replacing
		// a Phi with a Copy can in general cause problems because
		// Phi and Copy don't have exactly the same semantics.
		// Phi arguments always come from a predecessor block,
		// whereas copies don't. This matters in loops like:
		// 1: x = (Phi y)
		//    y = (Add x 1)
		//    goto 1
		// If we replace Phi->Copy, we get
		// 1: x = (Copy y)
		//    y = (Add x 1)