// CHECK-NEXT:       input_arg {
// CHECK-NEXT:         name: "function0"
// CHECK:            input_arg {
// CHECK-NEXT:         name: "function01"
// CHECK:            output_arg {
// CHECK-NEXT:         name: "function02"
// CHECK:          node_def {
// CHECK-NEXT:       name: "[[NAME:[^"]*]]"
// CHECK-NEXT:       op: "Identity"
// CHECK-NEXT:       input: "function0"
// CHECK:          ret {

            )

        val function0 = mock<() -> Unit>()
        val function1 = mock<(String) -> Unit>()
        val function2 = mock<(Int, Double) -> Boolean>()
        val extensions = mock<ExtensionContainerInternal> {
            on { getByName("function0") } doReturn function0
            on { getByName("function1") } doReturn function1
            on { getByName("function2") } doReturn function2
        }

// (that would indicate a slice type). Thus, generic functions cannot
// have empty type parameter lists, either. This is a syntax error.

func h[] /* ERROR "empty type parameter list" */ () {}

func _() {
	h /* ERROR "cannot index" */ [] /* ERROR "operand" */ ()
}

// Generic functions must have a function body.

#include "tensorflow/core/platform/statusor.h"

namespace tf {
namespace libtf {

class Function {
 public:
  tensorflow::Status RegisterTrace(tensorflow::AbstractFunctionPtr,
                                   TaggedValue input_signature,
                                   TaggedValue output_signature);

  // Executes this function under the execution context.
  //
  // Raises an error is no matching signature is found for TaggedValue.

// Check that the `tf._resource_arg_unique_id` argument attributes of
// test_func_name0 are propagated to the function's arg_attr and
// resource_arg_unique_id.

// CHECK:      name: "x"
// CHECK:      op: "VarHandleOp"

// CHECK:      name: "func_call"
// CHECK:      input: "called"

// CHECK:      library
// CHECK:        function
// CHECK:          signature
// CHECK:            input_arg
// CHECK:              type: DT_RESOURCE

    absl::Span<tensorflow::AbstractTensorHandle* const> inputs,
    absl::Span<tensorflow::AbstractTensorHandle*> outputs) {
  // TODO(srbs): Provide a function execution API on ctx so that we do not
  // expose the internals of how functions are to be executed here.
  std::string fname;
  {
    const tensorflow::FunctionDef* fdef = nullptr;
    TF_RETURN_IF_ERROR(trace->GetFunctionDef(&fdef));

  // to proactively transfer the result to host since the consumer op (or
  // function) of the result may still be on TPU.
  // TODO(b/194081364): remove this option once we unify servo TPU serving
  // result transfer behavior.
  bool tpu_transfer_result_to_host = false;
};

// Compile MLIR generated by tf.function in TF dialect into BEF.
Status CompileTFMLIRToBEF(const TfrtFunctionCompileOptions& options,

Lkotlin/jvm/functions/Function1;
Lkotlin/jvm/functions/Function20;
Lkotlin/jvm/functions/Function21;
Lkotlin/jvm/functions/Function22;
Lkotlin/jvm/functions/Function2;
Lkotlin/jvm/functions/Function3;
Lkotlin/jvm/functions/Function4;
Lkotlin/jvm/functions/Function5;
Lkotlin/jvm/functions/Function6;
Lkotlin/jvm/functions/Function7;
Lkotlin/jvm/functions/Function8;
Lkotlin/jvm/functions/Function9;
Lkotlin/jvm/internal/ArrayIterator;

    tf_executor.fetch
  }
  func.return
}

// CHECK:      library {
// CHECK:        function {
// CHECK-NEXT:     signature {
// CHECK-NEXT:       name: "bar"
// CHECK-NEXT:     }
// CHECK:          node_def {
// CHECK-NEXT:       name: "tf.Const"
// CHECK-NEXT:       op: "Const"
// CHECK-NEXT:       attr {

   *
   * @param g the second function to apply
   * @param f the first function to apply
   * @return the composition of {@code f} and {@code g}
   * @see <a href="//en.wikipedia.org/wiki/Function_composition">function composition</a>
   */
  public static <A extends @Nullable Object, B extends @Nullable Object, C extends @Nullable Object>
      Function<A, C> compose(Function<B, C> g, Function<A, ? extends B> f) {