// CHECK-NEXT:         value {
// CHECK-NEXT:           tensor {
// CHECK-NEXT:             dtype: DT_INT32
// CHECK-NEXT:             tensor_shape {
// CHECK-NEXT:             }
// CHECK-NEXT:             int_val: 1
// CHECK-NEXT:           }
// CHECK-NEXT:         }
// CHECK-NEXT:       }
// CHECK:          }
// CHECK:          node_def {
// CHECK-NEXT:       name: "tf.Empty"
// CHECK-NEXT:       op: "Empty"

        tf_executor.yield %1 : tensor<i32>
      }
      // CHECK: control_output: "control_const"
      // CHECK:       control_ret {
      // CHECK-NEXT:    key: "control_const"
      // CHECK-NEXT:    value: "control_const"
      // CHECK-NEXT:  }
      tf_executor.fetch %0#1 : !tf_executor.control
    }
    func.return
  }

        %3 = "tf.A"() : () -> tensor<?xi32>
        tf_device.return %3 : tensor<?xi32>
      }) {device = "/device:test_device:0"} : () -> tensor<?xi32>
    // CHECK: tf_executor.fetch %[[LAUNCH_OUTPUT]]
    tf_executor.fetch %1#0 : tensor<?xi32>
  }
  func.return %0 : tensor<?xi32>
}

// CHECK: func private @[[LAUNCH]]
// CHECK-SAME: () -> tensor<?xi32>
// CHECK: %[[A_OUTPUT:[0-9]*]] = "tf.A"()

```go
ConfigMapCount := krt.NewSingleton[int](func(ctx krt.HandlerContext) *int {
    cms := krt.Fetch(ctx, ConfigMaps)
    return ptr.Of(len(cms))
})
```

The `Fetch` operation enables querying against other collections.
If the result of the `Fetch` operation changes, the collection will automatically be recomputed; the framework handles the state and event detection.

func TestDecoderIssue3577(t *testing.T) {
	next := make(chan nextRead, 10)
	wantErr := errors.New("my error")
	next <- nextRead{5, nil}
	next <- nextRead{10, wantErr}
	next <- nextRead{0, wantErr}
	d := NewDecoder(StdEncoding, &faultInjectReader{
		source: "VHdhcyBicmlsbGlnLCBhbmQgdGhlIHNsaXRoeSB0b3Zlcw==", // twas brillig...
		nextc:  next,
	})
	errc := make(chan error, 1)
	go func() {

      loc, func.getFunctionType().getResults(),
      tf_executor::ControlType::get(&getContext()), ArrayRef<Value>());
  // Create Fetch.
  ValueRange to_fetch = island.getResults();
  if (to_fetch.size() != 1) {
    // Drop control result for fetch.
    to_fetch = to_fetch.drop_back();
  }
  builder.create<tf_executor::FetchOp>(loc, to_fetch);
  // Build Island.
  island.getBody().push_back(new Block);

// kubernetesReleaseVersionDefault is helper function that can fetch
// available version information from release servers based on
// label names, like "stable" or "latest".
//
// If argument is already semantic version string, it
// will return same string.
//
// In case of labels, it tries to fetch from release
// servers and then return actual semantic version.
//

      // CHECK: tf_executor.yield %[[CALL_OUTPUT]]
      tf_executor.yield %3 : tensor<?xf32>
    }
    tf_executor.fetch %1#0 : tensor<?xf32>
  }
  func.return %0 : tensor<?xf32>
}

func.func @_func(%arg0: tensor<?xf32>) -> tensor<?xf32> {
  func.return %arg0 : tensor<?xf32>
}

// -----

	return nil
}

// GetLocks - fetch older locks for a remote node.
func (client *peerRESTClient) GetLocks(ctx context.Context) (lockMap map[string][]lockRequesterInfo, err error) {
	resp, err := getLocksRPC.Call(ctx, client.gridConn(), grid.NewMSS())
	if err != nil || resp == nil {
		return nil, err
	}
	return *resp, nil
}

// LocalStorageInfo - fetch server information for a remote node.

	statLocal     func(rev, remote string) []string                                                   // cmd to stat local rev
	parseStat     func(rev, out string) (*RevInfo, error)                                             // cmd to parse output of statLocal
	fetch         []string                                                                            // cmd to fetch everything from remote