*
     * @return the source id
     */
    int getCodecId();

    /**
     * A codec will be used by the metadata serializer to encode
     * and decode this module source. Codecs must be stateless as
     * they are shared between several metadata instances.
     *
     * Codecs must implement equals/hashcode.
     */
    interface Codec<T extends PersistentModuleSource> {

  func.return %0, %1 : tensor<i32>, tensor<i32>
}

// -----

// Set stateless if the body contains only read-only side-effecting ops.

func.func private @cond(%arg: tensor<i32>, %handle: tensor<!tf_type.resource>) -> tensor<i1> {
  %0 = "tf.Const"() {value = dense<16> : tensor<i32> } : () -> tensor<i32>

See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/

// This transformation pass converts stateful and stateless partitioned calls
// with _xla_compile_device_type attribute to XLA launch ops.

#include <stack>

#include "mlir/Support/LLVM.h"  // from @llvm-project
#include "tensorflow/compiler/mlir/tensorflow/ir/tf_device.h"

  if (op->hasTrait<OpTrait::TF::CannotDuplicate>()) return false;

  // If the op has no memory side effects, it can be duplicated.
  if (isMemoryEffectFree(op)) return true;

  // If the op is marked stateless using the `is_stateless` attribute, that
  // attribute determines if the op can be duplicated.
  if (auto is_stateless = op->getAttrOfType<BoolAttr>("is_stateless"))
    return is_stateless.getValue();

 * resulting XML document is parsed, the parser API will return this text as the original literal
 * string {@code "Foo<Bar>"}.
 *
 * <p>An {@code Escaper} instance is required to be stateless, and safe when used concurrently by
 * multiple threads.
 *
 * <p>Because, in general, escaping operates on the code points of a string and not on its

                parser.describe(visitor);
            }
        };
    }

    @Nonnull
    @Override
    public CapabilityNotationParser create() {
        // Currently the converter is stateless, doesn't need any external context, so for performance we return a singleton
        return versionIsRequired ? STRICT_CONVERTER : LENIENT_CONVERTER;
    }

                httpExchange.sendResponseHeaders(200, 0);
                ProcessBuilder builder = new ProcessBuilder();
                final Process process = builder.command("git", "upload-pack", "--stateless-rpc", backingRepo.getWorkTree().getAbsolutePath()).redirectErrorStream(true).start();

                InputStream instream = new GZIPInputStream(httpExchange.getRequestBody());

package org.gradle.model;

import org.gradle.api.Incubating;

/**
 * A marker type for a class that is a collection of rules.
 * <p>
 * A rule source is not used like a regular Java object.
 * It is a stateless container of methods and possibly constants.
 * <p>
 * Please consult the “Rule based model configuration” chapter of the Gradle User Manual for general information about “rules”.
 *
 * <h3>Rule methods</h3>
 * <p>

func Title(t language.Tag, opts ...Option) Caser {
	return Caser{makeTitle(t, getOpts(opts...))}
}

// Fold returns a Caser that implements Unicode case folding. The returned Caser
// is stateless and safe to use concurrently by multiple goroutines.
//
// Case folding does not normalize the input and may not preserve a normal form.
// Use the collate or search package for more convenient and linguistically

	// StatelessHandlerFn must handle incoming stateless request.
	// A non-nil error value will be returned as RemoteErr(msg) to client.
	StatelessHandlerFn func(ctx context.Context, payload []byte, resp chan<- []byte) *RemoteErr

	// StatelessHandler is handlers for one to many requests,
	// where responses may be dropped.
	// Stateless requests provide no incoming stream and there is no flow control