tf_executor.yield %add1, %add2 : tensor<*xi32>, tensor<*xi32>
    }
    %island2:3 = tf_executor.island(%island1#2) {
      %sub = "tf.Sub"(%arg0, %arg1) : (tensor<*xi32>, tensor<i32>) -> tensor<*xi32>
      %mul = "tf.Mul"(%sub, %arg1) : (tensor<*xi32>, tensor<i32>) -> tensor<*xi32>
      tf_executor.yield %sub, %mul : tensor<*xi32>, tensor<*xi32>
    }

import (
	"fmt"
	. "iter"
	"runtime"
	"testing"
)

func count(n int) Seq[int] {
	return func(yield func(int) bool) {
		for i := range n {
			if !yield(i) {
				break
			}
		}
	}
}

func squares(n int) Seq2[int, int64] {
	return func(yield func(int, int64) bool) {
		for i := range n {
			if !yield(i, int64(i)*int64(i)) {
				break
			}
		}
	}
}

func TestPull(t *testing.T) {

// When called as seq(yield), seq calls yield(v) for each value v in the sequence,
// stopping early if yield returns false.
type Seq[V any] func(yield func(V) bool)

// Seq2 is an iterator over sequences of pairs of values, most commonly key-value pairs.
// When called as seq(yield), seq calls yield(k, v) for each pair (k, v) in the sequence,
// stopping early if yield returns false.

          func.call @ifregion_then(%id0, %var_handle) : (!tf_res, !tf_res) -> ()
          "tf.Yield"() : () -> ()
        }, {
          func.call @ifregion_else(%id0, %var_handle) : (!tf_res, !tf_res) -> ()
          "tf.Yield"() : () -> ()
        }) {is_stateless = false} : (tensor<i1>) -> ()
      tf_executor.yield
    }
    tf_executor.fetch %island : !tf_executor.control
  }
  func.return
}

// CHECK: tf_executor.graph {
// CHECK:   %[[CONTROL:.*]] = tf_executor.island {
// CHECK:     tf_executor.yield
// CHECK:   }
// CHECK:   tf_executor.fetch %[[CONTROL]] : !tf_executor.control
// CHECK: }
// CHECK: return

func.func @graph_already() {
  tf_executor.graph {
    %control = tf_executor.island {
      tf_executor.yield
    }
    tf_executor.fetch %control : !tf_executor.control
  }
  func.return
}

  // CHECK-SAME: _then_func_name = "testIf1Then"
  // CHECK-SAME: is_stateless = false
  // CHECK: [[Result0:%.*]] = func.call @testIf1Then
  // CHECK: "tf.Yield"([[Result0]])
  // CHECK: [[Result1:%.*]] = func.call @testIf1Else
  // CHECK: "tf.Yield"([[Result1]])
  // CHECK: _attr0 = 10
  // CHECK-SAME: _attr1 = true
  // CHECK-NOT: attr2 =
  // CHECK-NOT: else_branch
  // CHECK-NOT: then_branch
  // CHECK-SAME: }

from fastapi import Depends


async def dependency_a():
    dep_a = generate_dep_a()
    try:
        yield dep_a
    finally:
        dep_a.close()


async def dependency_b(dep_a: Annotated[DepA, Depends(dependency_a)]):
    dep_b = generate_dep_b()
    try:
        yield dep_b
    finally:
        dep_b.close(dep_a)


async def dependency_c(dep_b: Annotated[DepB, Depends(dependency_b)]):

      "tf.Yield"(%0) : (tensor<512x256xf32>) -> ()
    }, {
      "tf.Yield"(%arg2) : (tensor<512x256xf32>) -> ()
    }) { is_stateless = true}: (tensor<i1>) -> tensor<512x256xf32>
    "tf.Yield"(%1) : (tensor<512x256xf32>) -> ()
  }, {
    "tf.Yield"(%arg2) : (tensor<512x256xf32>) -> ()
  }) { is_stateless = true}: (tensor<i1>) -> tensor<512x256xf32>

      tf_executor.yield %launch#0, %launch#1: tensor<f32>, tensor<i32>
    }
    tf_executor.fetch
  }
  func.return
}

// CHECK-NOT: tf_executor.island
// CHECK:      [[A:%.+]]:2, {{.*}} = tf_executor.island wraps "tf.opA"
// CHECK-SAME: device = "CPU:0"
// CHECK-NOT:  tf_device.launch
// CHECK-NOT:      tf_executor.yield [[A]]#1, [[A]]#0

    %output0, %control0 = tf_executor.island {
      %a = "tf.opA"(%arg0) : (tensor<i32>) -> tensor<i32>
      tf_executor.yield %a : tensor<i32>
    }
    %output1, %control1 = tf_executor.island {
      %b = "tf.opB"(%output0) : (tensor<i32>) -> tensor<i32>
      tf_executor.yield %b : tensor<i32>
    }
    tf_executor.fetch %output1 : tensor<i32>
  }
  func.return %graph_result : tensor<i32>
}