Alternative approach with output_type as optional in cpp.

Author: tadeja

cpp/src/arrow/compute/api_vector.cc

@@ -257,7 +257,7 @@ ListFlattenOptions::ListFlattenOptions(bool recursive)
 constexpr char ListFlattenOptions::kTypeName[];
 
 InversePermutationOptions::InversePermutationOptions(
-    int64_t max_index, std::shared_ptr<DataType> output_type)
+    int64_t max_index, std::optional<std::shared_ptr<DataType>> output_type)
     : FunctionOptions(internal::kInversePermutationOptionsType),
       max_index(max_index),
       output_type(std::move(output_type)) {}

cpp/src/arrow/compute/api_vector.h

@@ -299,7 +299,7 @@ class ARROW_EXPORT ListFlattenOptions : public FunctionOptions {
 class ARROW_EXPORT InversePermutationOptions : public FunctionOptions {
  public:
   explicit InversePermutationOptions(int64_t max_index = -1,
-                                     std::shared_ptr<DataType> output_type = NULLPTR);
+                                     std::optional<std::shared_ptr<DataType>> output_type = std::nullopt);
   static constexpr const char kTypeName[] = "InversePermutationOptions";
   static InversePermutationOptions Defaults() { return InversePermutationOptions(); }
 
@@ -308,11 +308,11 @@ class ARROW_EXPORT InversePermutationOptions : public FunctionOptions {
   /// of the input indices minus 1 and the length of the function's output will be the
   /// length of the input indices.
   int64_t max_index = -1;
-  /// \brief The type of the output inverse permutation. If null, the output will be of
-  /// the same type as the input indices, otherwise must be signed integer type. An
+  /// \brief Optional type of the output inverse permutation. Default of `nullopt` will
+  /// use the same type as the input indices, otherwise must be signed integer type. An
   /// invalid error will be reported if this type is not able to store the length of the
   /// input indices.
-  std::shared_ptr<DataType> output_type = NULLPTR;
+  std::optional<std::shared_ptr<DataType>> output_type;
 };
 
 /// \brief Options for scatter function

cpp/src/arrow/compute/function_internal.h

@@ -347,11 +347,19 @@ static inline Result<std::shared_ptr<Scalar>> GenericToScalar(
 static inline Result<std::shared_ptr<Scalar>> GenericToScalar(
     const std::shared_ptr<DataType>& value) {
   if (!value) {
-    return std::make_shared<NullScalar>();
+     return Status::Invalid("shared_ptr<DataType> is nullptr");
   }
   return MakeNullScalar(value);
 }
 
+static inline Result<std::shared_ptr<Scalar>> GenericToScalar(
+    const std::optional<std::shared_ptr<DataType>>& value) {
+  if (!value.has_value()) {
+    return std::make_shared<NullScalar>();
+  }
+  return GenericToScalar(value.value());
+}
+
 static inline Result<std::shared_ptr<Scalar>> GenericToScalar(const TypeHolder& value) {
   return GenericToScalar(value.GetSharedPtr());
 }
@@ -448,9 +456,6 @@ static inline enable_if_same_result<T, SortKey> GenericFromScalar(
 template <typename T>
 static inline enable_if_same_result<T, std::shared_ptr<DataType>> GenericFromScalar(
     const std::shared_ptr<Scalar>& value) {
-  if (value->type->id() == Type::NA) {
-    return std::shared_ptr<NullType>();
-  }
   return value->type;
 }
 

cpp/src/arrow/compute/kernels/vector_swizzle.cc

@@ -51,10 +51,8 @@ Result<TypeHolder> ResolveInversePermutationOutputType(
   DCHECK_EQ(input_types.size(), 1);
   DCHECK_NE(input_types[0], nullptr);
 
-  std::shared_ptr<DataType> output_type = InversePermutationState::Get(ctx).output_type;
-  if (!output_type) {
-    output_type = input_types[0].owned_type;
-  }
+std::shared_ptr<DataType> output_type =
+    InversePermutationState::Get(ctx).output_type.value_or(input_types[0].owned_type);
   if (!is_signed_integer(output_type->id())) {
     return Status::TypeError(
         "Output type of inverse_permutation must be signed integer, got " +
@@ -78,10 +76,7 @@ struct InversePermutationImpl {
 
     // Apply default options semantics.
     int64_t output_length = options.max_index < 0 ? input_length : options.max_index + 1;
-    std::shared_ptr<DataType> output_type = options.output_type;
-    if (!output_type) {
-      output_type = input_type;
-    }
+    std::shared_ptr<DataType> output_type = options.output_type.value_or(input_type);
 
     ThisType impl(ctx, indices, input_length, output_length);
     RETURN_NOT_OK(VisitTypeInline(*output_type, &impl));

python/pyarrow/_compute.pyx

@@ -1467,7 +1467,7 @@ class InversePermutationOptions(_InversePermutationOptions):
         If negative, this value will be set to the length of the input indices
         minus 1 and the length of the function’s output will be the length
         of the input indices.
-    output_type : DataType, default None
+    output_type : Optional[DataType], default None
         The type of the output inverse permutation.
         If None, the output will be of the same type as the input indices, otherwise
         must be signed integer type. An invalid error will be reported if this type

python/pyarrow/includes/libarrow.pxd

@@ -2593,7 +2593,7 @@ cdef extern from "arrow/compute/api.h" namespace "arrow::compute" nogil:
         CInversePermutationOptions(int64_t max_index)
         CInversePermutationOptions(int64_t max_index, shared_ptr[CDataType] output_type)
         int64_t max_index
-        shared_ptr[CDataType] output_type
+        optional[shared_ptr[CDataType]] output_type
 
     cdef cppclass CScatterOptions \
             "arrow::compute::ScatterOptions"(CFunctionOptions):