absl::Span<AbstractTensorHandle* const> inputs,
                         int input_index, bool use_function,
                         AbstractTensorHandle** numerical_grad) {
  vector<AbstractTensorHandle*> theta_inputs(inputs.size());
  for (int i{}; i < inputs.size(); ++i) {
    theta_inputs[i] = inputs[i];
  }

  AbstractTensorHandle* theta =

  SmallVector<StringRef> inputs;
  mlir::dyn_cast_or_null<StringAttr>(entry_function_attr.get("inputs"))
      .strref()
      .split(inputs, /*Separator=*/",");

  return inputs;
}

void ConvertMainArgAttrs(func::FuncOp main_func_op, const int arg_idx,
                         const StringRef index_path) {
  const ArrayRef<NamedAttribute> arg_attrs =

  CallableOptions callable_options;
  std::vector<Tensor> feed_tensors;
  *callable_options.mutable_run_options() = run_options;
  for (const auto& input : inputs) {
    const string& name = input.first;
    const Tensor& tensor = input.second;
    callable_options.add_feed(name);
    feed_tensors.push_back(tensor);
  }
  for (const string& output_tensor_name : output_tensor_names) {
    callable_options.add_fetch(output_tensor_name);

                    Assert.returnTypesFor task.inputs, "dir", TaskInputFilePropertyBuilder, TaskInputFilePropertyBuilderInternal
                    Assert.returnTypesFor task.inputs, "file", TaskInputFilePropertyBuilder, TaskInputFilePropertyBuilderInternal
                    Assert.returnTypesFor task.inputs, "files", TaskInputFilePropertyBuilder, TaskInputFilePropertyBuilderInternal
                }

		a.reg = i
		return a.reg
	}

	k := len(i.inputs)
	for _, p := range a.abiInfo.InParams() {
		for _, r := range p.Registers {
			m := archRegForAbiReg(r, c)
			a.reg.inputs = append(a.reg.inputs, inputInfo{idx: k, regs: (1 << m)})
			k++
		}
	}
	a.reg.inputs = append(a.reg.inputs, i.inputs...) // These are less constrained, thus should come last
	k = len(i.outputs)

OpView::OpView(OpSpec op)
    : op_(op),
      input_args_(op_.Inputs().begin(), op_.Inputs().end()),
      output_args_(op_.Outputs().begin(), op_.Outputs().end()),
      argument_attrs_(op_.Attributes().begin(), op_.Attributes().end()) {
  // Initialize function arguments
  all_arguments_.push_back(OpArgumentView("AbstractContext*", "ctx"));
  for (const auto& arg : op_.Inputs()) {
    all_arguments_.push_back(OpArgumentView(arg));
  }

                Option.empty(),
                Option.empty(),
                getExtra()
        );

        Inputs inputs = incremental.inputs(compileOptions, compilers, setup, previousResult);
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug(inputs.toString());
        }
        if (spec.getScalaCompileOptions().isForce()) {
            // TODO This should use Deleter

  for (auto input : inputs) {
    forward_op_->inputs.push_back(input);
  }
  return absl::OkStatus();
}

Status SetAttrString(AbstractOperation* op_, const char* attr_name,
                     const char* data, size_t length,
                     ForwardOperation* forward_op_) {
  forward_op_->attrs.Set(attr_name, StringPiece(data, length));
  return op_->SetAttrString(attr_name, data, length);
}

}

}  // anonymous namespace

std::vector<const Tensor*> InputsFromContext(OpKernelContext* ctx) {
  std::vector<const Tensor*> inputs;
  inputs.reserve(ctx->num_inputs());
  for (int input_idx = 0; input_idx < ctx->num_inputs(); input_idx++) {
    inputs.push_back(&ctx->input(input_idx));
  }
  return inputs;
}

absl::StatusOr<std::vector<int>> GetConstantInputIndicesFromContext(
    OpKernelContext* ctx) {

[[sec:task_inputs_outputs]]
== Task inputs and outputs

In the most common case, a task takes some inputs and generates some outputs.
We can consider the process of Java compilation as an example of a task.
The Java source files act as inputs of the task, while the generated class files, i.e. the result of the compilation, are the outputs of the task.

.Example task inputs and outputs
image::taskInputsOutputs.png[]