}

/*
// RegisterStateless will register a stateless handler that serves
// []byte -> stream of ([]byte, error) requests.
func (m *Manager) RegisterStateless(id HandlerID, h StatelessHandler) error {
	if !id.valid() {
		return ErrUnknownHandler
	}
	if m.handlers.hasAny(id) && !id.isTestHandler() {
		return ErrHandlerAlreadyExists
	}

	m.handlers.stateless[id] = &h
	return nil
}
*/

        "tf.OpB"() : () -> ()
        tf_executor.yield
      }
      tf_executor.fetch
    }
    func.return
  }
}

// -----

// Check that we report an unexpected dependency path between two stateless ops.
func.func @two_stateless_ops() -> () {
  tf_executor.graph {
    // expected-warning@+1 {{unexpected control dependency path: path 0, node 0 (source)}}
    %island1 = tf_executor.island {

 * limitations under the License.
 */
package org.gradle.api.internal;

/**
 * A marker interface for rules which can be safely reused because they are either
 * stateless, or effectively immutable. Ideally this should be inferred, which is
 * why the interface is internal.
 */
public interface ReusableAction {

package org.gradle.internal.component.external.model;

import com.google.common.collect.ImmutableList;
import org.gradle.internal.component.model.ModuleConfigurationMetadata;

/**
 * Variant derivation strategies should be stateless. If they aren't singletons,
 * implementors must make sure that equals/hashcode returns true for all instances.
 */
public interface VariantDerivationStrategy {
    boolean derivesVariants();

write it to a target file.

The `CppFileRenderer` is the main renderer used by the generator; it renders an
entire file. The `CppConfig` defines if it is operating in header or source
mode.

"Views" are stateless and intended to be low-level building blocks: a direct
language-specific representation of the model classes. For example, an `ArgView`
is initialized from an `ArgSpec` (which was created initially from an `ArgDef`

type StatelessPreBindExample struct{}

var _ framework.PreBindPlugin = StatelessPreBindExample{}

// Name is the name of the plugin used in Registry and configurations.
const Name = "stateless-prebind-plugin-example"

// Name returns name of the plugin. It is used in logs, etc.
func (sr StatelessPreBindExample) Name() string {
	return Name
}

module {
  func.func private @f() {
    func.call @g() : () -> ()
    func.return
  }
  func.func private @g() {
    func.call @f() : () -> ()
    func.return
  }
}

// -----
// Test stateful and stateless partitioned calls.
// CHECK-LABEL: func @f
func.func @f() {
  // CHECK: "tf.PartitionedCall"() <{config = "",  config_proto = "", executor_type = "", f = @g}> : () -> ()

 */
public interface LegacySupport {

    /**
     * Sets the currently active session. Some legacy components are basically stateful and their API is missing
     * parameters that would be required to delegate to a stateless component. Saving the session (in a thread-local
     * variable) is our best effort to record any state that is required to enable proper delegation.
     *
     * @param session The currently active session, may be {@code null}.

 * These instances replace original CallSites where the calls are to be intercepted.
 * <p>
 * Descendants of this class should be thread-safe, making a stateless implementation is perfect.
 */
public interface CallInterceptor {

    /**
     * Called when the method/constructor/property read is intercepted.

  // either TensorFlow StatelessX or X op depending on the additional attribute.
  if (llvm::isa<mlir::TF::CaseOp, mlir::TF::IfOp, mlir::TF::WhileOp>(inst)) {
    auto stateless = inst->getAttrOfType<mlir::BoolAttr>("is_stateless");
    if (stateless && stateless.getValue())
      *node_def->mutable_op() = "Stateless" + node_def->op();
  }