%0 = "tf.IfRegion"(%arg0) ({
      %1 = "tf.ReadVariableOp"(%handle) : (tensor<!tf_type.resource<tensor<0xf32>>>) -> (tensor<0xf32>)
      "tf.Yield"(%1) : (tensor<0xf32>) -> ()
     },  {
      %2 = "tf.Const"() {value = dense<1.0> : tensor<0xf32>} : () -> tensor<0xf32>
      "tf.Yield"(%2) : (tensor<0xf32>) -> ()
    }) {is_stateless = true} : (tensor<i1>) -> (tensor<0xf32>)
    func.return %0 : tensor<0xf32>
  }
}

  ^bb0(%arg0: tensor<!tf_type.variant<tensor<f32>>>, %arg1: tensor<i32>):
    // CHECK:   %[[PRED:.*]] = "tf._SomeOp"()
    // CHECK:   "tf.Yield"(%[[PRED]])
    %pred = "tf._SomeOp"() : () -> tensor<i1>
    "tf.Yield"(%pred) : (tensor<i1>) -> ()
  },  {
  // CHECK: ^bb0(%[[CARG0:.*]]: tensor<10xf32>, %[[CARG1:.*]]: tensor<i32>, %[[CARG2:.*]]: tensor<1xi32>):

    // match the "func.return" within the function.
    //
    // So this would transform
    // func.func @f(...) -> ... {
    //     yield %x : foo
    // }
    // ...
    // func.call @f(...) -> bar
    //
    // to
    //
    // func.func @f(...) -> ... {
    //     yield %x : foo
    // }
    // ...
    // func.call f(...) -> foo
    auto symbol_uses = f.getSymbolUses(f->getParentOp());

    我们将`SessionLocal()`请求的创建和处理放在一个`try`块中。

    然后我们在finally块中关闭它。

    通过这种方式，我们确保数据库会话在请求后始终关闭。即使在处理请求时出现异常。

    但是您不能从退出代码中引发另一个异常（在yield之后）。可以查阅 [Dependencies with yield and HTTPException](https://fastapi.tiangolo.com/zh/tutorial/dependencies/dependencies-with-yield/#dependencies-with-yield-and-httpexception)

*然后，当在路径操作函数*中使用依赖项时，我们使用`Session`，直接从 SQLAlchemy 导入的类型声明它。

*这将为我们在路径操作函数*中提供更好的编辑器支持，因为编辑器将知道`db`参数的类型`Session`：

        np.random.uniform(low=-1.0, high=1.0, size=(1, 4)).astype('f4')
        for _ in range(num_samples)
    ]

    def data_gen() -> repr_dataset.RepresentativeDataset:
      for sample in samples:
        yield {'input_tensor': ops.convert_to_tensor(sample)}

    with self.session() as sess:
      new_repr_ds = repr_dataset.replace_tensors_by_numpy_ndarrays(
          data_gen(), sess
      )

    "tfl.yield"(%test) : (tensor<i1>) -> ()
  },  {
  ^bb0(%arg2: tensor<i32>, %arg3: tensor<f32>):
    %cst = arith.constant dense<22.0> : tensor<f32>
    %stride = arith.constant dense<1> : tensor<i32>
    %inc = tfl.add %arg2, %stride {fused_activation_function = "NONE"} : tensor<i32>
    "tfl.yield"(%inc, %cst) : (tensor<i32>, tensor<f32>) -> ()

  for (Value value : extern_values) {
    auto arg = block.addArgument(value.getType(), loc);
    replaceAllUsesInRegionWith(value, arg, func_region);
    new_args.push_back(arg);
  }

  // Replace yield op with return.
  Operation* yield_op = outlined_func.getBody().front().getTerminator();
  OpBuilder b(yield_op);
  llvm::SmallVector<Value, 4> args;
  auto loop_carried_yield_operands =

	// at this moment, and if not, yield. This is to catch other CNIs which might have mutated the file between
	// the (theoretical) window after we initially install/write, but before we actually start the filewatch.
	if err := checkValidCNIConfig(in.cfg, in.cniConfigFilepath); err != nil {
		return nil
	}

	// If a file we are watching has a change event, yield and let caller check validity
	select {

  // CHECK-NEXT:   "tf.Yield"(%arg1) : (tensor<1xi8>) -> ()
  // CHECK-NEXT:   }, {
  // CHECK-NEXT:   "tf.Yield"(%arg2) : (tensor<1xi8>) -> ()
  // CHECK-NEXT:  }) : (tensor<i1>) -> tensor<1xi8>
  // CHECK-NEXT: return %0 : tensor<1xi8>
  %0 = "tf.IfRegion"(%arg0) <{is_stateless = false}> ({
    "tf.Yield"(%arg1) : (tensor<1x!tf_type.qint8>) -> ()
    }, {
    "tf.Yield"(%arg2) : (tensor<1x!tf_type.qint8>) -> ()

    get() = sequence {

        yield(this@ancestorClassesIncludingSelf)

        var superclass: Class<*>? = superclass
        while (superclass != null) {
            val thisSuperclass: Class<*> = superclass
            val nextSuperclass = thisSuperclass.superclass
            if (nextSuperclass != null) { // skip java.lang.Object
                yield(thisSuperclass)
            }