diff --git a/cpp/examples/arrow/CMakeLists.txt b/cpp/examples/arrow/CMakeLists.txt
index e11b3bd0ab2..229373665d5 100644
--- a/cpp/examples/arrow/CMakeLists.txt
+++ b/cpp/examples/arrow/CMakeLists.txt
@@ -133,4 +133,7 @@ if(ARROW_PARQUET AND ARROW_DATASET)
 
   add_arrow_example(join_example EXTRA_LINK_LIBS ${DATASET_EXAMPLES_LINK_LIBS})
   add_dependencies(join-example parquet)
+
+  add_arrow_example(udf_example)
+
 endif()
diff --git a/cpp/examples/arrow/compute_register_example.cc b/cpp/examples/arrow/compute_register_example.cc
index 0f6165a0646..f089b910ec4 100644
--- a/cpp/examples/arrow/compute_register_example.cc
+++ b/cpp/examples/arrow/compute_register_example.cc
@@ -126,7 +126,7 @@ const cp::FunctionDoc func_doc{
 
 int main(int argc, char** argv) {
   const std::string name = "compute_register_example";
-  auto func = std::make_shared<cp::ScalarFunction>(name, cp::Arity::Unary(), &func_doc);
+  auto func = std::make_shared<cp::ScalarFunction>(name, cp::Arity::Unary(), func_doc);
   cp::ScalarKernel kernel({cp::InputType::Array(arrow::int64())}, arrow::int64(),
                           ExampleFunctionImpl);
   kernel.mem_allocation = cp::MemAllocation::NO_PREALLOCATE;
diff --git a/cpp/examples/arrow/udf_example.cc b/cpp/examples/arrow/udf_example.cc
new file mode 100644
index 00000000000..f45e2c644d0
--- /dev/null
+++ b/cpp/examples/arrow/udf_example.cc
@@ -0,0 +1,103 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include <arrow/api.h>
+#include <arrow/compute/api.h>
+
+#include <cstdlib>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+// Demonstrate registering a user-defined Arrow compute function outside of the Arrow
+// source tree
+
+namespace cp = ::arrow::compute;
+
+#define ABORT_ON_FAILURE(expr)                     \
+  do {                                             \
+    arrow::Status status_ = (expr);                \
+    if (!status_.ok()) {                           \
+      std::cerr << status_.message() << std::endl; \
+      abort();                                     \
+    }                                              \
+  } while (0);
+
+template <typename TYPE,
+          typename = typename std::enable_if<arrow::is_number_type<TYPE>::value |
+                                             arrow::is_boolean_type<TYPE>::value |
+                                             arrow::is_temporal_type<TYPE>::value>::type>
+arrow::Result<std::shared_ptr<arrow::Array>> GetArrayDataSample(
+    const std::vector<typename TYPE::c_type>& values) {
+  using ArrowBuilderType = typename arrow::TypeTraits<TYPE>::BuilderType;
+  ArrowBuilderType builder;
+  ARROW_RETURN_NOT_OK(builder.Reserve(values.size()));
+  ARROW_RETURN_NOT_OK(builder.AppendValues(values));
+  return builder.Finish();
+}
+
+const cp::FunctionDoc func_doc{
+    "User-defined-function usage to demonstrate registering an out-of-tree function",
+    "returns x + y + z",
+    {"x", "y", "z"},
+    "UDFOptions"};
+
+arrow::Status SampleFunction(cp::KernelContext* ctx, const cp::ExecBatch& batch,
+                             arrow::Datum* out) {
+  // temp = x + y; return temp + z
+  ARROW_ASSIGN_OR_RAISE(auto temp, cp::CallFunction("add", {batch[0], batch[1]}));
+  return cp::CallFunction("add", {temp, batch[2]}).Value(out);
+}
+
+arrow::Status Execute() {
+  const std::string name = "add_three";
+  auto func = std::make_shared<cp::ScalarFunction>(name, cp::Arity::Ternary(), func_doc);
+  cp::ScalarKernel kernel(
+      {cp::InputType::Array(arrow::int64()), cp::InputType::Array(arrow::int64()),
+       cp::InputType::Array(arrow::int64())},
+      arrow::int64(), SampleFunction);
+
+  kernel.mem_allocation = cp::MemAllocation::NO_PREALLOCATE;
+  kernel.null_handling = cp::NullHandling::COMPUTED_NO_PREALLOCATE;
+
+  ARROW_RETURN_NOT_OK(func->AddKernel(std::move(kernel)));
+
+  auto registry = cp::GetFunctionRegistry();
+  ARROW_RETURN_NOT_OK(registry->AddFunction(std::move(func)));
+
+  ARROW_ASSIGN_OR_RAISE(auto x, GetArrayDataSample<arrow::Int64Type>({1, 2, 3}));
+  ARROW_ASSIGN_OR_RAISE(auto y, GetArrayDataSample<arrow::Int64Type>({4, 5, 6}));
+  ARROW_ASSIGN_OR_RAISE(auto z, GetArrayDataSample<arrow::Int64Type>({7, 8, 9}));
+
+  ARROW_ASSIGN_OR_RAISE(auto res, cp::CallFunction(name, {x, y, z}));
+  auto res_array = res.make_array();
+  std::cout << "Result" << std::endl;
+  std::cout << res_array->ToString() << std::endl;
+  return arrow::Status::OK();
+}
+
+int main(int argc, char** argv) {
+  auto status = Execute();
+  if (!status.ok()) {
+    std::cerr << "Error occurred : " << status.message() << std::endl;
+    return EXIT_FAILURE;
+  }
+  return EXIT_SUCCESS;
+}
diff --git a/cpp/src/arrow/compute/cast.cc b/cpp/src/arrow/compute/cast.cc
index 4de68ba8d90..bd49041b4f3 100644
--- a/cpp/src/arrow/compute/cast.cc
+++ b/cpp/src/arrow/compute/cast.cc
@@ -95,7 +95,7 @@ const FunctionDoc cast_doc{"Cast values to another data type",
 // to the standard SQL CAST(expr AS target_type)
 class CastMetaFunction : public MetaFunction {
  public:
-  CastMetaFunction() : MetaFunction("cast", Arity::Unary(), &cast_doc) {}
+  CastMetaFunction() : MetaFunction("cast", Arity::Unary(), cast_doc) {}
 
   Result<const CastOptions*> ValidateOptions(const FunctionOptions* options) const {
     auto cast_options = static_cast<const CastOptions*>(options);
@@ -153,7 +153,7 @@ CastOptions::CastOptions(bool safe)
 constexpr char CastOptions::kTypeName[];
 
 CastFunction::CastFunction(std::string name, Type::type out_type_id)
-    : ScalarFunction(std::move(name), Arity::Unary(), /*doc=*/nullptr),
+    : ScalarFunction(std::move(name), Arity::Unary(), FunctionDoc::Empty()),
       out_type_id_(out_type_id) {}
 
 Status CastFunction::AddKernel(Type::type in_type_id, ScalarKernel kernel) {
diff --git a/cpp/src/arrow/compute/exec_test.cc b/cpp/src/arrow/compute/exec_test.cc
index 198cb84ff5e..b00bcb319c3 100644
--- a/cpp/src/arrow/compute/exec_test.cc
+++ b/cpp/src/arrow/compute/exec_test.cc
@@ -681,8 +681,8 @@ class TestCallScalarFunction : public TestComputeInternals {
 
     // This function simply copies memory from the input argument into the
     // (preallocated) output
-    auto func =
-        std::make_shared<ScalarFunction>("test_copy", Arity::Unary(), /*doc=*/nullptr);
+    auto func = std::make_shared<ScalarFunction>("test_copy", Arity::Unary(),
+                                                 /*doc=*/FunctionDoc::Empty());
 
     // Add a few kernels. Our implementation only accepts arrays
     ASSERT_OK(func->AddKernel({InputType::Array(uint8())}, uint8(), ExecCopy));
@@ -691,8 +691,8 @@ class TestCallScalarFunction : public TestComputeInternals {
     ASSERT_OK(registry->AddFunction(func));
 
     // A version which doesn't want the executor to call PropagateNulls
-    auto func2 = std::make_shared<ScalarFunction>("test_copy_computed_bitmap",
-                                                  Arity::Unary(), /*doc=*/nullptr);
+    auto func2 = std::make_shared<ScalarFunction>(
+        "test_copy_computed_bitmap", Arity::Unary(), /*doc=*/FunctionDoc::Empty());
     ScalarKernel kernel({InputType::Array(uint8())}, uint8(), ExecComputedBitmap);
     kernel.null_handling = NullHandling::COMPUTED_PREALLOCATE;
     ASSERT_OK(func2->AddKernel(kernel));
@@ -705,9 +705,9 @@ class TestCallScalarFunction : public TestComputeInternals {
     // A function that allocates its own output memory. We have cases for both
     // non-preallocated data and non-preallocated validity bitmap
     auto f1 = std::make_shared<ScalarFunction>("test_nopre_data", Arity::Unary(),
-                                               /*doc=*/nullptr);
-    auto f2 = std::make_shared<ScalarFunction>("test_nopre_validity_or_data",
-                                               Arity::Unary(), /*doc=*/nullptr);
+                                               /*doc=*/FunctionDoc::Empty());
+    auto f2 = std::make_shared<ScalarFunction>(
+        "test_nopre_validity_or_data", Arity::Unary(), /*doc=*/FunctionDoc::Empty());
 
     ScalarKernel kernel({InputType::Array(uint8())}, uint8(), ExecNoPreallocatedData);
     kernel.mem_allocation = MemAllocation::NO_PREALLOCATE;
@@ -727,7 +727,7 @@ class TestCallScalarFunction : public TestComputeInternals {
     // This function's behavior depends on a static parameter that is made
     // available to the kernel's execution function through its Options object
     auto func = std::make_shared<ScalarFunction>("test_stateful", Arity::Unary(),
-                                                 /*doc=*/nullptr);
+                                                 /*doc=*/FunctionDoc::Empty());
 
     ScalarKernel kernel({InputType::Array(int32())}, int32(), ExecStateful, InitStateful);
     ASSERT_OK(func->AddKernel(kernel));
@@ -738,7 +738,7 @@ class TestCallScalarFunction : public TestComputeInternals {
     auto registry = GetFunctionRegistry();
 
     auto func = std::make_shared<ScalarFunction>("test_scalar_add_int32", Arity::Binary(),
-                                                 /*doc=*/nullptr);
+                                                 /*doc=*/FunctionDoc::Empty());
     ASSERT_OK(func->AddKernel({InputType::Scalar(int32()), InputType::Scalar(int32())},
                               int32(), ExecAddInt32));
     ASSERT_OK(registry->AddFunction(func));
diff --git a/cpp/src/arrow/compute/function.cc b/cpp/src/arrow/compute/function.cc
index 1a7f36862dd..f1b3fcbccf4 100644
--- a/cpp/src/arrow/compute/function.cc
+++ b/cpp/src/arrow/compute/function.cc
@@ -290,9 +290,9 @@ Status ValidateFunctionDescription(const std::string& s) {
 }  // namespace
 
 Status Function::Validate() const {
-  if (!doc_->summary.empty()) {
+  if (!doc_.summary.empty()) {
     // Documentation given, check its contents
-    int arg_count = static_cast<int>(doc_->arg_names.size());
+    int arg_count = static_cast<int>(doc_.arg_names.size());
     // Some varargs functions allow 0 vararg, others expect at least 1,
     // hence the two possible values below.
     bool arg_count_match = (arg_count == arity_.num_args) ||
@@ -302,9 +302,9 @@ Status Function::Validate() const {
           "In function '", name_,
           "': ", "number of argument names for function documentation != function arity");
     }
-    Status st = ValidateFunctionSummary(doc_->summary);
+    Status st = ValidateFunctionSummary(doc_.summary);
     if (st.ok()) {
-      st &= ValidateFunctionDescription(doc_->description);
+      st &= ValidateFunctionDescription(doc_.description);
     }
     if (!st.ok()) {
       return st.WithMessage("In function '", name_, "': ", st.message());
diff --git a/cpp/src/arrow/compute/function.h b/cpp/src/arrow/compute/function.h
index 1273ab09c4f..face491690f 100644
--- a/cpp/src/arrow/compute/function.h
+++ b/cpp/src/arrow/compute/function.h
@@ -205,7 +205,7 @@ class ARROW_EXPORT Function {
   const Arity& arity() const { return arity_; }
 
   /// \brief Return the function documentation
-  const FunctionDoc& doc() const { return *doc_; }
+  const FunctionDoc& doc() const { return doc_; }
 
   /// \brief Returns the number of registered kernels for this function.
   virtual int num_kernels() const = 0;
@@ -244,12 +244,12 @@ class ARROW_EXPORT Function {
   virtual Status Validate() const;
 
  protected:
-  Function(std::string name, Function::Kind kind, const Arity& arity,
-           const FunctionDoc* doc, const FunctionOptions* default_options)
+  Function(std::string name, Function::Kind kind, const Arity& arity, FunctionDoc doc,
+           const FunctionOptions* default_options)
       : name_(std::move(name)),
         kind_(kind),
         arity_(arity),
-        doc_(doc ? doc : &FunctionDoc::Empty()),
+        doc_(std::move(doc)),
         default_options_(default_options) {}
 
   Status CheckArity(const std::vector<InputType>&) const;
@@ -258,7 +258,7 @@ class ARROW_EXPORT Function {
   std::string name_;
   Function::Kind kind_;
   Arity arity_;
-  const FunctionDoc* doc_;
+  const FunctionDoc doc_;
   const FunctionOptions* default_options_ = NULLPTR;
 };
 
@@ -279,9 +279,9 @@ class FunctionImpl : public Function {
   int num_kernels() const override { return static_cast<int>(kernels_.size()); }
 
  protected:
-  FunctionImpl(std::string name, Function::Kind kind, const Arity& arity,
-               const FunctionDoc* doc, const FunctionOptions* default_options)
-      : Function(std::move(name), kind, arity, doc, default_options) {}
+  FunctionImpl(std::string name, Function::Kind kind, const Arity& arity, FunctionDoc doc,
+               const FunctionOptions* default_options)
+      : Function(std::move(name), kind, arity, std::move(doc), default_options) {}
 
   std::vector<KernelType> kernels_;
 };
@@ -305,10 +305,10 @@ class ARROW_EXPORT ScalarFunction : public detail::FunctionImpl<ScalarKernel> {
  public:
   using KernelType = ScalarKernel;
 
-  ScalarFunction(std::string name, const Arity& arity, const FunctionDoc* doc,
+  ScalarFunction(std::string name, const Arity& arity, FunctionDoc doc,
                  const FunctionOptions* default_options = NULLPTR)
-      : detail::FunctionImpl<ScalarKernel>(std::move(name), Function::SCALAR, arity, doc,
-                                           default_options) {}
+      : detail::FunctionImpl<ScalarKernel>(std::move(name), Function::SCALAR, arity,
+                                           std::move(doc), default_options) {}
 
   /// \brief Add a kernel with given input/output types, no required state
   /// initialization, preallocation for fixed-width types, and default null
@@ -329,10 +329,10 @@ class ARROW_EXPORT VectorFunction : public detail::FunctionImpl<VectorKernel> {
  public:
   using KernelType = VectorKernel;
 
-  VectorFunction(std::string name, const Arity& arity, const FunctionDoc* doc,
+  VectorFunction(std::string name, const Arity& arity, FunctionDoc doc,
                  const FunctionOptions* default_options = NULLPTR)
-      : detail::FunctionImpl<VectorKernel>(std::move(name), Function::VECTOR, arity, doc,
-                                           default_options) {}
+      : detail::FunctionImpl<VectorKernel>(std::move(name), Function::VECTOR, arity,
+                                           std::move(doc), default_options) {}
 
   /// \brief Add a simple kernel with given input/output types, no required
   /// state initialization, no data preallocation, and no preallocation of the
@@ -350,10 +350,11 @@ class ARROW_EXPORT ScalarAggregateFunction
  public:
   using KernelType = ScalarAggregateKernel;
 
-  ScalarAggregateFunction(std::string name, const Arity& arity, const FunctionDoc* doc,
+  ScalarAggregateFunction(std::string name, const Arity& arity, FunctionDoc doc,
                           const FunctionOptions* default_options = NULLPTR)
-      : detail::FunctionImpl<ScalarAggregateKernel>(
-            std::move(name), Function::SCALAR_AGGREGATE, arity, doc, default_options) {}
+      : detail::FunctionImpl<ScalarAggregateKernel>(std::move(name),
+                                                    Function::SCALAR_AGGREGATE, arity,
+                                                    std::move(doc), default_options) {}
 
   /// \brief Add a kernel (function implementation). Returns error if the
   /// kernel's signature does not match the function's arity.
@@ -365,10 +366,11 @@ class ARROW_EXPORT HashAggregateFunction
  public:
   using KernelType = HashAggregateKernel;
 
-  HashAggregateFunction(std::string name, const Arity& arity, const FunctionDoc* doc,
+  HashAggregateFunction(std::string name, const Arity& arity, FunctionDoc doc,
                         const FunctionOptions* default_options = NULLPTR)
-      : detail::FunctionImpl<HashAggregateKernel>(
-            std::move(name), Function::HASH_AGGREGATE, arity, doc, default_options) {}
+      : detail::FunctionImpl<HashAggregateKernel>(std::move(name),
+                                                  Function::HASH_AGGREGATE, arity,
+                                                  std::move(doc), default_options) {}
 
   /// \brief Add a kernel (function implementation). Returns error if the
   /// kernel's signature does not match the function's arity.
@@ -392,9 +394,10 @@ class ARROW_EXPORT MetaFunction : public Function {
                                     const FunctionOptions* options,
                                     ExecContext* ctx) const = 0;
 
-  MetaFunction(std::string name, const Arity& arity, const FunctionDoc* doc,
+  MetaFunction(std::string name, const Arity& arity, FunctionDoc doc,
                const FunctionOptions* default_options = NULLPTR)
-      : Function(std::move(name), Function::META, arity, doc, default_options) {}
+      : Function(std::move(name), Function::META, arity, std::move(doc),
+                 default_options) {}
 };
 
 /// @}
diff --git a/cpp/src/arrow/compute/function_test.cc b/cpp/src/arrow/compute/function_test.cc
index 13de2a29ab8..94e86c7bd57 100644
--- a/cpp/src/arrow/compute/function_test.cc
+++ b/cpp/src/arrow/compute/function_test.cc
@@ -179,8 +179,9 @@ TEST(Arity, Basics) {
 }
 
 TEST(ScalarFunction, Basics) {
-  ScalarFunction func("scalar_test", Arity::Binary(), /*doc=*/nullptr);
-  ScalarFunction varargs_func("varargs_test", Arity::VarArgs(1), /*doc=*/nullptr);
+  ScalarFunction func("scalar_test", Arity::Binary(), /*doc=*/FunctionDoc::Empty());
+  ScalarFunction varargs_func("varargs_test", Arity::VarArgs(1),
+                              /*doc=*/FunctionDoc::Empty());
 
   ASSERT_EQ("scalar_test", func.name());
   ASSERT_EQ(2, func.arity().num_args);
@@ -194,8 +195,9 @@ TEST(ScalarFunction, Basics) {
 }
 
 TEST(VectorFunction, Basics) {
-  VectorFunction func("vector_test", Arity::Binary(), /*doc=*/nullptr);
-  VectorFunction varargs_func("varargs_test", Arity::VarArgs(1), /*doc=*/nullptr);
+  VectorFunction func("vector_test", Arity::Binary(), /*doc=*/FunctionDoc::Empty());
+  VectorFunction varargs_func("varargs_test", Arity::VarArgs(1),
+                              /*doc=*/FunctionDoc::Empty());
 
   ASSERT_EQ("vector_test", func.name());
   ASSERT_EQ(2, func.arity().num_args);
@@ -260,15 +262,15 @@ void CheckAddDispatch(FunctionType* func) {
 }
 
 TEST(ScalarVectorFunction, DispatchExact) {
-  ScalarFunction func1("scalar_test", Arity::Binary(), /*doc=*/nullptr);
-  VectorFunction func2("vector_test", Arity::Binary(), /*doc=*/nullptr);
+  ScalarFunction func1("scalar_test", Arity::Binary(), /*doc=*/FunctionDoc::Empty());
+  VectorFunction func2("vector_test", Arity::Binary(), /*doc=*/FunctionDoc::Empty());
 
   CheckAddDispatch(&func1);
   CheckAddDispatch(&func2);
 }
 
 TEST(ArrayFunction, VarArgs) {
-  ScalarFunction va_func("va_test", Arity::VarArgs(1), /*doc=*/nullptr);
+  ScalarFunction va_func("va_test", Arity::VarArgs(1), /*doc=*/FunctionDoc::Empty());
 
   std::vector<InputType> va_args = {int8()};
 
@@ -294,7 +296,7 @@ TEST(ArrayFunction, VarArgs) {
 }
 
 TEST(ScalarAggregateFunction, Basics) {
-  ScalarAggregateFunction func("agg_test", Arity::Unary(), /*doc=*/nullptr);
+  ScalarAggregateFunction func("agg_test", Arity::Unary(), /*doc=*/FunctionDoc::Empty());
 
   ASSERT_EQ("agg_test", func.name());
   ASSERT_EQ(1, func.arity().num_args);
@@ -313,7 +315,7 @@ Status NoopMerge(KernelContext*, const KernelState&, KernelState*) {
 Status NoopFinalize(KernelContext*, Datum*) { return Status::OK(); }
 
 TEST(ScalarAggregateFunction, DispatchExact) {
-  ScalarAggregateFunction func("agg_test", Arity::Unary(), /*doc=*/nullptr);
+  ScalarAggregateFunction func("agg_test", Arity::Unary(), FunctionDoc::Empty());
 
   std::vector<InputType> in_args = {ValueDescr::Array(int8())};
   ScalarAggregateKernel kernel(std::move(in_args), int64(), NoopInit, NoopConsume,
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic.cc b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
index c9e2d85a26b..16495bc8030 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
@@ -918,7 +918,7 @@ void RegisterScalarAggregateBasic(FunctionRegistry* registry) {
   static auto default_count_options = CountOptions::Defaults();
 
   auto func = std::make_shared<ScalarAggregateFunction>(
-      "count", Arity::Unary(), &count_doc, &default_count_options);
+      "count", Arity::Unary(), count_doc, &default_count_options);
 
   // Takes any input, outputs int64 scalar
   InputType any_input;
@@ -927,12 +927,12 @@ void RegisterScalarAggregateBasic(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunction(std::move(func)));
 
   func = std::make_shared<ScalarAggregateFunction>(
-      "count_distinct", Arity::Unary(), &count_distinct_doc, &default_count_options);
+      "count_distinct", Arity::Unary(), count_distinct_doc, &default_count_options);
   // Takes any input, outputs int64 scalar
   AddCountDistinctKernels(func.get());
   DCHECK_OK(registry->AddFunction(std::move(func)));
 
-  func = std::make_shared<ScalarAggregateFunction>("sum", Arity::Unary(), &sum_doc,
+  func = std::make_shared<ScalarAggregateFunction>("sum", Arity::Unary(), sum_doc,
                                                    &default_scalar_aggregate_options);
   AddArrayScalarAggKernels(SumInit, {boolean()}, uint64(), func.get());
   AddAggKernel(
@@ -961,7 +961,7 @@ void RegisterScalarAggregateBasic(FunctionRegistry* registry) {
 #endif
   DCHECK_OK(registry->AddFunction(std::move(func)));
 
-  func = std::make_shared<ScalarAggregateFunction>("mean", Arity::Unary(), &mean_doc,
+  func = std::make_shared<ScalarAggregateFunction>("mean", Arity::Unary(), mean_doc,
                                                    &default_scalar_aggregate_options);
   AddArrayScalarAggKernels(MeanInit, {boolean()}, float64(), func.get());
   AddArrayScalarAggKernels(MeanInit, NumericTypes(), float64(), func.get());
@@ -985,8 +985,8 @@ void RegisterScalarAggregateBasic(FunctionRegistry* registry) {
 #endif
   DCHECK_OK(registry->AddFunction(std::move(func)));
 
-  func = std::make_shared<ScalarAggregateFunction>(
-      "min_max", Arity::Unary(), &min_max_doc, &default_scalar_aggregate_options);
+  func = std::make_shared<ScalarAggregateFunction>("min_max", Arity::Unary(), min_max_doc,
+                                                   &default_scalar_aggregate_options);
   AddMinMaxKernels(MinMaxInit, {null(), boolean()}, func.get());
   AddMinMaxKernels(MinMaxInit, NumericTypes(), func.get());
   AddMinMaxKernels(MinMaxInit, TemporalTypes(), func.get());
@@ -1011,18 +1011,18 @@ void RegisterScalarAggregateBasic(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunction(std::move(func)));
 
   // Add min/max as convenience functions
-  func = std::make_shared<ScalarAggregateFunction>("min", Arity::Unary(), &min_or_max_doc,
+  func = std::make_shared<ScalarAggregateFunction>("min", Arity::Unary(), min_or_max_doc,
                                                    &default_scalar_aggregate_options);
   AddMinOrMaxAggKernel<MinOrMax::Min>(func.get(), min_max_func);
   DCHECK_OK(registry->AddFunction(std::move(func)));
 
-  func = std::make_shared<ScalarAggregateFunction>("max", Arity::Unary(), &min_or_max_doc,
+  func = std::make_shared<ScalarAggregateFunction>("max", Arity::Unary(), min_or_max_doc,
                                                    &default_scalar_aggregate_options);
   AddMinOrMaxAggKernel<MinOrMax::Max>(func.get(), min_max_func);
   DCHECK_OK(registry->AddFunction(std::move(func)));
 
-  func = std::make_shared<ScalarAggregateFunction>(
-      "product", Arity::Unary(), &product_doc, &default_scalar_aggregate_options);
+  func = std::make_shared<ScalarAggregateFunction>("product", Arity::Unary(), product_doc,
+                                                   &default_scalar_aggregate_options);
   AddArrayScalarAggKernels(ProductInit::Init, {boolean()}, uint64(), func.get());
   AddArrayScalarAggKernels(ProductInit::Init, SignedIntTypes(), int64(), func.get());
   AddArrayScalarAggKernels(ProductInit::Init, UnsignedIntTypes(), uint64(), func.get());
@@ -1038,19 +1038,19 @@ void RegisterScalarAggregateBasic(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunction(std::move(func)));
 
   // any
-  func = std::make_shared<ScalarAggregateFunction>("any", Arity::Unary(), &any_doc,
+  func = std::make_shared<ScalarAggregateFunction>("any", Arity::Unary(), any_doc,
                                                    &default_scalar_aggregate_options);
   AddArrayScalarAggKernels(AnyInit, {boolean()}, boolean(), func.get());
   DCHECK_OK(registry->AddFunction(std::move(func)));
 
   // all
-  func = std::make_shared<ScalarAggregateFunction>("all", Arity::Unary(), &all_doc,
+  func = std::make_shared<ScalarAggregateFunction>("all", Arity::Unary(), all_doc,
                                                    &default_scalar_aggregate_options);
   AddArrayScalarAggKernels(AllInit, {boolean()}, boolean(), func.get());
   DCHECK_OK(registry->AddFunction(std::move(func)));
 
   // index
-  func = std::make_shared<ScalarAggregateFunction>("index", Arity::Unary(), &index_doc);
+  func = std::make_shared<ScalarAggregateFunction>("index", Arity::Unary(), index_doc);
   AddBasicAggKernels(IndexInit::Init, BaseBinaryTypes(), int64(), func.get());
   AddBasicAggKernels(IndexInit::Init, PrimitiveTypes(), int64(), func.get());
   AddBasicAggKernels(IndexInit::Init, TemporalTypes(), int64(), func.get());
diff --git a/cpp/src/arrow/compute/kernels/aggregate_mode.cc b/cpp/src/arrow/compute/kernels/aggregate_mode.cc
index 287c2c5d368..7d3440cbef3 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_mode.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_mode.cc
@@ -428,7 +428,7 @@ const FunctionDoc mode_doc{
 
 void RegisterScalarAggregateMode(FunctionRegistry* registry) {
   static auto default_options = ModeOptions::Defaults();
-  auto func = std::make_shared<VectorFunction>("mode", Arity::Unary(), &mode_doc,
+  auto func = std::make_shared<VectorFunction>("mode", Arity::Unary(), mode_doc,
                                                &default_options);
   DCHECK_OK(func->AddKernel(
       NewModeKernel(boolean(), ModeExecutor<StructType, BooleanType>::Exec)));
diff --git a/cpp/src/arrow/compute/kernels/aggregate_quantile.cc b/cpp/src/arrow/compute/kernels/aggregate_quantile.cc
index 1ca030130b0..810fb539913 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_quantile.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_quantile.cc
@@ -531,7 +531,7 @@ const FunctionDoc quantile_doc{
 
 void RegisterScalarAggregateQuantile(FunctionRegistry* registry) {
   static QuantileOptions default_options;
-  auto func = std::make_shared<VectorFunction>("quantile", Arity::Unary(), &quantile_doc,
+  auto func = std::make_shared<VectorFunction>("quantile", Arity::Unary(), quantile_doc,
                                                &default_options);
   AddQuantileKernels(func.get());
   DCHECK_OK(registry->AddFunction(std::move(func)));
diff --git a/cpp/src/arrow/compute/kernels/aggregate_tdigest.cc b/cpp/src/arrow/compute/kernels/aggregate_tdigest.cc
index 7c86267d940..037bba42f16 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_tdigest.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_tdigest.cc
@@ -196,7 +196,7 @@ const FunctionDoc approximate_median_doc{
 std::shared_ptr<ScalarAggregateFunction> AddTDigestAggKernels() {
   static auto default_tdigest_options = TDigestOptions::Defaults();
   auto func = std::make_shared<ScalarAggregateFunction>(
-      "tdigest", Arity::Unary(), &tdigest_doc, &default_tdigest_options);
+      "tdigest", Arity::Unary(), tdigest_doc, &default_tdigest_options);
   AddTDigestKernels(TDigestInit, NumericTypes(), func.get());
   AddTDigestKernels(TDigestInit, {decimal128(1, 1), decimal256(1, 1)}, func.get());
   return func;
@@ -207,7 +207,7 @@ std::shared_ptr<ScalarAggregateFunction> AddApproximateMedianAggKernels(
   static ScalarAggregateOptions default_scalar_aggregate_options;
 
   auto median = std::make_shared<ScalarAggregateFunction>(
-      "approximate_median", Arity::Unary(), &approximate_median_doc,
+      "approximate_median", Arity::Unary(), approximate_median_doc,
       &default_scalar_aggregate_options);
 
   auto sig =
diff --git a/cpp/src/arrow/compute/kernels/aggregate_var_std.cc b/cpp/src/arrow/compute/kernels/aggregate_var_std.cc
index feb98718aee..1f9a26960b8 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_var_std.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_var_std.cc
@@ -289,8 +289,8 @@ const FunctionDoc variance_doc{
 
 std::shared_ptr<ScalarAggregateFunction> AddStddevAggKernels() {
   static auto default_std_options = VarianceOptions::Defaults();
-  auto func = std::make_shared<ScalarAggregateFunction>(
-      "stddev", Arity::Unary(), &stddev_doc, &default_std_options);
+  auto func = std::make_shared<ScalarAggregateFunction>("stddev", Arity::Unary(),
+                                                        stddev_doc, &default_std_options);
   AddVarStdKernels(StddevInit, NumericTypes(), func.get());
   AddVarStdKernels(StddevInit, {decimal128(1, 1), decimal256(1, 1)}, func.get());
   return func;
@@ -299,7 +299,7 @@ std::shared_ptr<ScalarAggregateFunction> AddStddevAggKernels() {
 std::shared_ptr<ScalarAggregateFunction> AddVarianceAggKernels() {
   static auto default_var_options = VarianceOptions::Defaults();
   auto func = std::make_shared<ScalarAggregateFunction>(
-      "variance", Arity::Unary(), &variance_doc, &default_var_options);
+      "variance", Arity::Unary(), variance_doc, &default_var_options);
   AddVarStdKernels(VarianceInit, NumericTypes(), func.get());
   AddVarStdKernels(VarianceInit, {decimal128(1, 1), decimal256(1, 1)}, func.get());
   return func;
diff --git a/cpp/src/arrow/compute/kernels/hash_aggregate.cc b/cpp/src/arrow/compute/kernels/hash_aggregate.cc
index db34ee6c596..d9ffcda5962 100644
--- a/cpp/src/arrow/compute/kernels/hash_aggregate.cc
+++ b/cpp/src/arrow/compute/kernels/hash_aggregate.cc
@@ -3554,7 +3554,7 @@ void RegisterHashAggregateBasic(FunctionRegistry* registry) {
 
   {
     auto func = std::make_shared<HashAggregateFunction>(
-        "hash_count", Arity::Binary(), &hash_count_doc, &default_count_options);
+        "hash_count", Arity::Binary(), hash_count_doc, &default_count_options);
 
     DCHECK_OK(func->AddKernel(
         MakeKernel(ValueDescr::ARRAY, HashAggregateInit<GroupedCountImpl>)));
@@ -3563,7 +3563,7 @@ void RegisterHashAggregateBasic(FunctionRegistry* registry) {
 
   {
     auto func = std::make_shared<HashAggregateFunction>(
-        "hash_sum", Arity::Binary(), &hash_sum_doc, &default_scalar_aggregate_options);
+        "hash_sum", Arity::Binary(), hash_sum_doc, &default_scalar_aggregate_options);
     DCHECK_OK(AddHashAggKernels({boolean()}, GroupedSumFactory::Make, func.get()));
     DCHECK_OK(AddHashAggKernels(SignedIntTypes(), GroupedSumFactory::Make, func.get()));
     DCHECK_OK(AddHashAggKernels(UnsignedIntTypes(), GroupedSumFactory::Make, func.get()));
@@ -3578,7 +3578,7 @@ void RegisterHashAggregateBasic(FunctionRegistry* registry) {
 
   {
     auto func = std::make_shared<HashAggregateFunction>(
-        "hash_product", Arity::Binary(), &hash_product_doc,
+        "hash_product", Arity::Binary(), hash_product_doc,
         &default_scalar_aggregate_options);
     DCHECK_OK(AddHashAggKernels({boolean()}, GroupedProductFactory::Make, func.get()));
     DCHECK_OK(
@@ -3596,7 +3596,7 @@ void RegisterHashAggregateBasic(FunctionRegistry* registry) {
 
   {
     auto func = std::make_shared<HashAggregateFunction>(
-        "hash_mean", Arity::Binary(), &hash_mean_doc, &default_scalar_aggregate_options);
+        "hash_mean", Arity::Binary(), hash_mean_doc, &default_scalar_aggregate_options);
     DCHECK_OK(AddHashAggKernels({boolean()}, GroupedMeanFactory::Make, func.get()));
     DCHECK_OK(AddHashAggKernels(SignedIntTypes(), GroupedMeanFactory::Make, func.get()));
     DCHECK_OK(
@@ -3612,7 +3612,7 @@ void RegisterHashAggregateBasic(FunctionRegistry* registry) {
 
   {
     auto func = std::make_shared<HashAggregateFunction>(
-        "hash_stddev", Arity::Binary(), &hash_stddev_doc, &default_variance_options);
+        "hash_stddev", Arity::Binary(), hash_stddev_doc, &default_variance_options);
     DCHECK_OK(AddHashAggKernels(SignedIntTypes(),
                                 GroupedVarStdFactory<VarOrStd::Std>::Make, func.get()));
     DCHECK_OK(AddHashAggKernels(UnsignedIntTypes(),
@@ -3626,7 +3626,7 @@ void RegisterHashAggregateBasic(FunctionRegistry* registry) {
 
   {
     auto func = std::make_shared<HashAggregateFunction>(
-        "hash_variance", Arity::Binary(), &hash_variance_doc, &default_variance_options);
+        "hash_variance", Arity::Binary(), hash_variance_doc, &default_variance_options);
     DCHECK_OK(AddHashAggKernels(SignedIntTypes(),
                                 GroupedVarStdFactory<VarOrStd::Var>::Make, func.get()));
     DCHECK_OK(AddHashAggKernels(UnsignedIntTypes(),
@@ -3641,7 +3641,7 @@ void RegisterHashAggregateBasic(FunctionRegistry* registry) {
   HashAggregateFunction* tdigest_func = nullptr;
   {
     auto func = std::make_shared<HashAggregateFunction>(
-        "hash_tdigest", Arity::Binary(), &hash_tdigest_doc, &default_tdigest_options);
+        "hash_tdigest", Arity::Binary(), hash_tdigest_doc, &default_tdigest_options);
     DCHECK_OK(
         AddHashAggKernels(SignedIntTypes(), GroupedTDigestFactory::Make, func.get()));
     DCHECK_OK(
@@ -3657,7 +3657,7 @@ void RegisterHashAggregateBasic(FunctionRegistry* registry) {
 
   {
     auto func = std::make_shared<HashAggregateFunction>(
-        "hash_approximate_median", Arity::Binary(), &hash_approximate_median_doc,
+        "hash_approximate_median", Arity::Binary(), hash_approximate_median_doc,
         &default_scalar_aggregate_options);
     DCHECK_OK(func->AddKernel(MakeApproximateMedianKernel(tdigest_func)));
     DCHECK_OK(registry->AddFunction(std::move(func)));
@@ -3666,7 +3666,7 @@ void RegisterHashAggregateBasic(FunctionRegistry* registry) {
   HashAggregateFunction* min_max_func = nullptr;
   {
     auto func = std::make_shared<HashAggregateFunction>(
-        "hash_min_max", Arity::Binary(), &hash_min_max_doc,
+        "hash_min_max", Arity::Binary(), hash_min_max_doc,
         &default_scalar_aggregate_options);
     DCHECK_OK(AddHashAggKernels(NumericTypes(), GroupedMinMaxFactory::Make, func.get()));
     DCHECK_OK(AddHashAggKernels(TemporalTypes(), GroupedMinMaxFactory::Make, func.get()));
@@ -3682,7 +3682,7 @@ void RegisterHashAggregateBasic(FunctionRegistry* registry) {
 
   {
     auto func = std::make_shared<HashAggregateFunction>(
-        "hash_min", Arity::Binary(), &hash_min_or_max_doc,
+        "hash_min", Arity::Binary(), hash_min_or_max_doc,
         &default_scalar_aggregate_options);
     DCHECK_OK(func->AddKernel(MakeMinOrMaxKernel<MinOrMax::Min>(min_max_func)));
     DCHECK_OK(registry->AddFunction(std::move(func)));
@@ -3690,7 +3690,7 @@ void RegisterHashAggregateBasic(FunctionRegistry* registry) {
 
   {
     auto func = std::make_shared<HashAggregateFunction>(
-        "hash_max", Arity::Binary(), &hash_min_or_max_doc,
+        "hash_max", Arity::Binary(), hash_min_or_max_doc,
         &default_scalar_aggregate_options);
     DCHECK_OK(func->AddKernel(MakeMinOrMaxKernel<MinOrMax::Max>(min_max_func)));
     DCHECK_OK(registry->AddFunction(std::move(func)));
@@ -3698,21 +3698,21 @@ void RegisterHashAggregateBasic(FunctionRegistry* registry) {
 
   {
     auto func = std::make_shared<HashAggregateFunction>(
-        "hash_any", Arity::Binary(), &hash_any_doc, &default_scalar_aggregate_options);
+        "hash_any", Arity::Binary(), hash_any_doc, &default_scalar_aggregate_options);
     DCHECK_OK(func->AddKernel(MakeKernel(boolean(), HashAggregateInit<GroupedAnyImpl>)));
     DCHECK_OK(registry->AddFunction(std::move(func)));
   }
 
   {
     auto func = std::make_shared<HashAggregateFunction>(
-        "hash_all", Arity::Binary(), &hash_all_doc, &default_scalar_aggregate_options);
+        "hash_all", Arity::Binary(), hash_all_doc, &default_scalar_aggregate_options);
     DCHECK_OK(func->AddKernel(MakeKernel(boolean(), HashAggregateInit<GroupedAllImpl>)));
     DCHECK_OK(registry->AddFunction(std::move(func)));
   }
 
   {
     auto func = std::make_shared<HashAggregateFunction>(
-        "hash_count_distinct", Arity::Binary(), &hash_count_distinct_doc,
+        "hash_count_distinct", Arity::Binary(), hash_count_distinct_doc,
         &default_count_options);
     DCHECK_OK(func->AddKernel(
         MakeKernel(ValueDescr::ARRAY, GroupedDistinctInit<GroupedCountDistinctImpl>)));
@@ -3721,7 +3721,7 @@ void RegisterHashAggregateBasic(FunctionRegistry* registry) {
 
   {
     auto func = std::make_shared<HashAggregateFunction>(
-        "hash_distinct", Arity::Binary(), &hash_distinct_doc, &default_count_options);
+        "hash_distinct", Arity::Binary(), hash_distinct_doc, &default_count_options);
     DCHECK_OK(func->AddKernel(
         MakeKernel(ValueDescr::ARRAY, GroupedDistinctInit<GroupedDistinctImpl>)));
     DCHECK_OK(registry->AddFunction(std::move(func)));
@@ -3729,7 +3729,7 @@ void RegisterHashAggregateBasic(FunctionRegistry* registry) {
 
   {
     auto func = std::make_shared<HashAggregateFunction>("hash_one", Arity::Binary(),
-                                                        &hash_one_doc);
+                                                        hash_one_doc);
     DCHECK_OK(AddHashAggKernels(NumericTypes(), GroupedOneFactory::Make, func.get()));
     DCHECK_OK(AddHashAggKernels(TemporalTypes(), GroupedOneFactory::Make, func.get()));
     DCHECK_OK(AddHashAggKernels(BaseBinaryTypes(), GroupedOneFactory::Make, func.get()));
@@ -3741,7 +3741,7 @@ void RegisterHashAggregateBasic(FunctionRegistry* registry) {
 
   {
     auto func = std::make_shared<HashAggregateFunction>("hash_list", Arity::Binary(),
-                                                        &hash_list_doc);
+                                                        hash_list_doc);
     DCHECK_OK(AddHashAggKernels(NumericTypes(), GroupedListFactory::Make, func.get()));
     DCHECK_OK(AddHashAggKernels(TemporalTypes(), GroupedListFactory::Make, func.get()));
     DCHECK_OK(AddHashAggKernels(BaseBinaryTypes(), GroupedListFactory::Make, func.get()));
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index f53d9f0c7f0..4365ad4e768 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -1935,8 +1935,8 @@ void AddNullExec(ScalarFunction* func) {
 
 template <typename Op, typename FunctionImpl = ArithmeticFunction>
 std::shared_ptr<ScalarFunction> MakeArithmeticFunction(std::string name,
-                                                       const FunctionDoc* doc) {
-  auto func = std::make_shared<FunctionImpl>(name, Arity::Binary(), doc);
+                                                       FunctionDoc doc) {
+  auto func = std::make_shared<FunctionImpl>(name, Arity::Binary(), std::move(doc));
   for (const auto& ty : NumericTypes()) {
     auto exec = ArithmeticExecFromOp<ScalarBinaryEqualTypes, Op>(ty);
     DCHECK_OK(func->AddKernel({ty, ty}, ty, exec));
@@ -1949,8 +1949,8 @@ std::shared_ptr<ScalarFunction> MakeArithmeticFunction(std::string name,
 // only on non-null output.
 template <typename Op, typename FunctionImpl = ArithmeticFunction>
 std::shared_ptr<ScalarFunction> MakeArithmeticFunctionNotNull(std::string name,
-                                                              const FunctionDoc* doc) {
-  auto func = std::make_shared<FunctionImpl>(name, Arity::Binary(), doc);
+                                                              FunctionDoc doc) {
+  auto func = std::make_shared<FunctionImpl>(name, Arity::Binary(), std::move(doc));
   for (const auto& ty : NumericTypes()) {
     auto exec = ArithmeticExecFromOp<ScalarBinaryNotNullEqualTypes, Op>(ty);
     DCHECK_OK(func->AddKernel({ty, ty}, ty, exec));
@@ -1961,8 +1961,8 @@ std::shared_ptr<ScalarFunction> MakeArithmeticFunctionNotNull(std::string name,
 
 template <typename Op>
 std::shared_ptr<ScalarFunction> MakeUnaryArithmeticFunction(std::string name,
-                                                            const FunctionDoc* doc) {
-  auto func = std::make_shared<ArithmeticFunction>(name, Arity::Unary(), doc);
+                                                            FunctionDoc doc) {
+  auto func = std::make_shared<ArithmeticFunction>(name, Arity::Unary(), std::move(doc));
   for (const auto& ty : NumericTypes()) {
     auto exec = ArithmeticExecFromOp<ScalarUnary, Op>(ty);
     DCHECK_OK(func->AddKernel({ty}, ty, exec));
@@ -1975,9 +1975,9 @@ std::shared_ptr<ScalarFunction> MakeUnaryArithmeticFunction(std::string name,
 // output type for integral inputs.
 template <typename Op, typename IntOutType>
 std::shared_ptr<ScalarFunction> MakeUnaryArithmeticFunctionWithFixedIntOutType(
-    std::string name, const FunctionDoc* doc) {
+    std::string name, FunctionDoc doc) {
   auto int_out_ty = TypeTraits<IntOutType>::type_singleton();
-  auto func = std::make_shared<ArithmeticFunction>(name, Arity::Unary(), doc);
+  auto func = std::make_shared<ArithmeticFunction>(name, Arity::Unary(), std::move(doc));
   for (const auto& ty : NumericTypes()) {
     auto out_ty = arrow::is_floating(ty->id()) ? ty : int_out_ty;
     auto exec = GenerateArithmeticWithFixedIntOutType<ScalarUnary, IntOutType, Op>(ty);
@@ -1996,9 +1996,9 @@ std::shared_ptr<ScalarFunction> MakeUnaryArithmeticFunctionWithFixedIntOutType(
 // Like MakeUnaryArithmeticFunction, but for arithmetic ops that need to run
 // only on non-null output.
 template <typename Op>
-std::shared_ptr<ScalarFunction> MakeUnaryArithmeticFunctionNotNull(
-    std::string name, const FunctionDoc* doc) {
-  auto func = std::make_shared<ArithmeticFunction>(name, Arity::Unary(), doc);
+std::shared_ptr<ScalarFunction> MakeUnaryArithmeticFunctionNotNull(std::string name,
+                                                                   FunctionDoc doc) {
+  auto func = std::make_shared<ArithmeticFunction>(name, Arity::Unary(), std::move(doc));
   for (const auto& ty : NumericTypes()) {
     auto exec = ArithmeticExecFromOp<ScalarUnaryNotNull, Op>(ty);
     DCHECK_OK(func->AddKernel({ty}, ty, exec));
@@ -2075,11 +2075,11 @@ Status ExecRound(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
 // kernel dispatch based on RoundMode, only on non-null output.
 template <template <typename, RoundMode, typename...> class Op, typename OptionsType>
 std::shared_ptr<ScalarFunction> MakeUnaryRoundFunction(std::string name,
-                                                       const FunctionDoc* doc) {
+                                                       FunctionDoc doc) {
   using State = RoundOptionsWrapper<OptionsType>;
   static const OptionsType kDefaultOptions = OptionsType::Defaults();
   auto func = std::make_shared<ArithmeticIntegerToFloatingPointFunction>(
-      name, Arity::Unary(), doc, &kDefaultOptions);
+      name, Arity::Unary(), std::move(doc), &kDefaultOptions);
   for (const auto& ty : {float32(), float64(), decimal128(1, 0), decimal256(1, 0)}) {
     auto type_id = ty->id();
     auto exec = [type_id](KernelContext* ctx, const ExecBatch& batch, Datum* out) {
@@ -2110,8 +2110,8 @@ std::shared_ptr<ScalarFunction> MakeUnaryRoundFunction(std::string name,
 // only on non-null output.
 template <typename Op>
 std::shared_ptr<ScalarFunction> MakeUnarySignedArithmeticFunctionNotNull(
-    std::string name, const FunctionDoc* doc) {
-  auto func = std::make_shared<ArithmeticFunction>(name, Arity::Unary(), doc);
+    std::string name, FunctionDoc doc) {
+  auto func = std::make_shared<ArithmeticFunction>(name, Arity::Unary(), std::move(doc));
   for (const auto& ty : NumericTypes()) {
     if (!arrow::is_unsigned_integer(ty->id())) {
       auto exec = ArithmeticExecFromOp<ScalarUnaryNotNull, Op>(ty);
@@ -2124,8 +2124,8 @@ std::shared_ptr<ScalarFunction> MakeUnarySignedArithmeticFunctionNotNull(
 
 template <typename Op>
 std::shared_ptr<ScalarFunction> MakeBitWiseFunctionNotNull(std::string name,
-                                                           const FunctionDoc* doc) {
-  auto func = std::make_shared<ArithmeticFunction>(name, Arity::Binary(), doc);
+                                                           FunctionDoc doc) {
+  auto func = std::make_shared<ArithmeticFunction>(name, Arity::Binary(), std::move(doc));
   for (const auto& ty : IntTypes()) {
     auto exec = TypeAgnosticBitWiseExecFromOp<ScalarBinaryNotNullEqualTypes, Op>(ty);
     DCHECK_OK(func->AddKernel({ty, ty}, ty, exec));
@@ -2136,8 +2136,8 @@ std::shared_ptr<ScalarFunction> MakeBitWiseFunctionNotNull(std::string name,
 
 template <typename Op>
 std::shared_ptr<ScalarFunction> MakeShiftFunctionNotNull(std::string name,
-                                                         const FunctionDoc* doc) {
-  auto func = std::make_shared<ArithmeticFunction>(name, Arity::Binary(), doc);
+                                                         FunctionDoc doc) {
+  auto func = std::make_shared<ArithmeticFunction>(name, Arity::Binary(), std::move(doc));
   for (const auto& ty : IntTypes()) {
     auto exec = ShiftExecFromOp<ScalarBinaryNotNullEqualTypes, Op>(ty);
     DCHECK_OK(func->AddKernel({ty, ty}, ty, exec));
@@ -2148,8 +2148,8 @@ std::shared_ptr<ScalarFunction> MakeShiftFunctionNotNull(std::string name,
 
 template <typename Op, typename FunctionImpl = ArithmeticFloatingPointFunction>
 std::shared_ptr<ScalarFunction> MakeUnaryArithmeticFunctionFloatingPoint(
-    std::string name, const FunctionDoc* doc) {
-  auto func = std::make_shared<FunctionImpl>(name, Arity::Unary(), doc);
+    std::string name, FunctionDoc doc) {
+  auto func = std::make_shared<FunctionImpl>(name, Arity::Unary(), std::move(doc));
   for (const auto& ty : FloatingPointTypes()) {
     auto exec = GenerateArithmeticFloatingPoint<ScalarUnary, Op>(ty);
     DCHECK_OK(func->AddKernel({ty}, ty, exec));
@@ -2160,9 +2160,9 @@ std::shared_ptr<ScalarFunction> MakeUnaryArithmeticFunctionFloatingPoint(
 
 template <typename Op>
 std::shared_ptr<ScalarFunction> MakeUnaryArithmeticFunctionFloatingPointNotNull(
-    std::string name, const FunctionDoc* doc) {
-  auto func =
-      std::make_shared<ArithmeticFloatingPointFunction>(name, Arity::Unary(), doc);
+    std::string name, FunctionDoc doc) {
+  auto func = std::make_shared<ArithmeticFloatingPointFunction>(name, Arity::Unary(),
+                                                                std::move(doc));
   for (const auto& ty : FloatingPointTypes()) {
     auto exec = GenerateArithmeticFloatingPoint<ScalarUnaryNotNull, Op>(ty);
     DCHECK_OK(func->AddKernel({ty}, ty, exec));
@@ -2172,10 +2172,10 @@ std::shared_ptr<ScalarFunction> MakeUnaryArithmeticFunctionFloatingPointNotNull(
 }
 
 template <typename Op>
-std::shared_ptr<ScalarFunction> MakeArithmeticFunctionFloatingPoint(
-    std::string name, const FunctionDoc* doc) {
-  auto func =
-      std::make_shared<ArithmeticFloatingPointFunction>(name, Arity::Binary(), doc);
+std::shared_ptr<ScalarFunction> MakeArithmeticFunctionFloatingPoint(std::string name,
+                                                                    FunctionDoc doc) {
+  auto func = std::make_shared<ArithmeticFloatingPointFunction>(name, Arity::Binary(),
+                                                                std::move(doc));
   for (const auto& ty : FloatingPointTypes()) {
     auto exec = GenerateArithmeticFloatingPoint<ScalarBinaryEqualTypes, Op>(ty);
     DCHECK_OK(func->AddKernel({ty, ty}, ty, exec));
@@ -2186,9 +2186,9 @@ std::shared_ptr<ScalarFunction> MakeArithmeticFunctionFloatingPoint(
 
 template <typename Op>
 std::shared_ptr<ScalarFunction> MakeArithmeticFunctionFloatingPointNotNull(
-    std::string name, const FunctionDoc* doc) {
-  auto func =
-      std::make_shared<ArithmeticFloatingPointFunction>(name, Arity::Binary(), doc);
+    std::string name, FunctionDoc doc) {
+  auto func = std::make_shared<ArithmeticFloatingPointFunction>(name, Arity::Binary(),
+                                                                std::move(doc));
   for (const auto& ty : FloatingPointTypes()) {
     auto output = is_integer(ty->id()) ? float64() : ty;
     auto exec = GenerateArithmeticFloatingPoint<ScalarBinaryNotNullEqualTypes, Op>(ty);
@@ -2573,18 +2573,18 @@ void RegisterScalarArithmetic(FunctionRegistry* registry) {
 
   // ----------------------------------------------------------------------
   auto absolute_value =
-      MakeUnaryArithmeticFunction<AbsoluteValue>("abs", &absolute_value_doc);
+      MakeUnaryArithmeticFunction<AbsoluteValue>("abs", absolute_value_doc);
   AddDecimalUnaryKernels<AbsoluteValue>(absolute_value.get());
   DCHECK_OK(registry->AddFunction(std::move(absolute_value)));
 
   // ----------------------------------------------------------------------
   auto absolute_value_checked = MakeUnaryArithmeticFunctionNotNull<AbsoluteValueChecked>(
-      "abs_checked", &absolute_value_checked_doc);
+      "abs_checked", absolute_value_checked_doc);
   AddDecimalUnaryKernels<AbsoluteValueChecked>(absolute_value_checked.get());
   DCHECK_OK(registry->AddFunction(std::move(absolute_value_checked)));
 
   // ----------------------------------------------------------------------
-  auto add = MakeArithmeticFunction<Add>("add", &add_doc);
+  auto add = MakeArithmeticFunction<Add>("add", add_doc);
   AddDecimalBinaryKernels<Add>("add", add.get());
 
   // Add add(timestamp, duration) -> timestamp
@@ -2609,7 +2609,7 @@ void RegisterScalarArithmetic(FunctionRegistry* registry) {
 
   // ----------------------------------------------------------------------
   auto add_checked =
-      MakeArithmeticFunctionNotNull<AddChecked>("add_checked", &add_checked_doc);
+      MakeArithmeticFunctionNotNull<AddChecked>("add_checked", add_checked_doc);
   AddDecimalBinaryKernels<AddChecked>("add_checked", add_checked.get());
 
   // Add add_checked(timestamp, duration) -> timestamp
@@ -2636,7 +2636,7 @@ void RegisterScalarArithmetic(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunction(std::move(add_checked)));
 
   // ----------------------------------------------------------------------
-  auto subtract = MakeArithmeticFunction<Subtract>("subtract", &sub_doc);
+  auto subtract = MakeArithmeticFunction<Subtract>("subtract", sub_doc);
   AddDecimalBinaryKernels<Subtract>("subtract", subtract.get());
 
   // Add subtract(timestamp, timestamp) -> duration
@@ -2694,8 +2694,8 @@ void RegisterScalarArithmetic(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunction(std::move(subtract)));
 
   // ----------------------------------------------------------------------
-  auto subtract_checked = MakeArithmeticFunctionNotNull<SubtractChecked>(
-      "subtract_checked", &sub_checked_doc);
+  auto subtract_checked =
+      MakeArithmeticFunctionNotNull<SubtractChecked>("subtract_checked", sub_checked_doc);
   AddDecimalBinaryKernels<SubtractChecked>("subtract_checked", subtract_checked.get());
 
   // Add subtract_checked(timestamp, timestamp) -> duration
@@ -2760,7 +2760,7 @@ void RegisterScalarArithmetic(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunction(std::move(subtract_checked)));
 
   // ----------------------------------------------------------------------
-  auto multiply = MakeArithmeticFunction<Multiply>("multiply", &mul_doc);
+  auto multiply = MakeArithmeticFunction<Multiply>("multiply", mul_doc);
   AddDecimalBinaryKernels<Multiply>("multiply", multiply.get());
 
   // Add multiply(duration, int64) -> duration
@@ -2773,8 +2773,8 @@ void RegisterScalarArithmetic(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunction(std::move(multiply)));
 
   // ----------------------------------------------------------------------
-  auto multiply_checked = MakeArithmeticFunctionNotNull<MultiplyChecked>(
-      "multiply_checked", &mul_checked_doc);
+  auto multiply_checked =
+      MakeArithmeticFunctionNotNull<MultiplyChecked>("multiply_checked", mul_checked_doc);
   AddDecimalBinaryKernels<MultiplyChecked>("multiply_checked", multiply_checked.get());
 
   // Add multiply_checked(duration, int64) -> duration
@@ -2790,7 +2790,7 @@ void RegisterScalarArithmetic(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunction(std::move(multiply_checked)));
 
   // ----------------------------------------------------------------------
-  auto divide = MakeArithmeticFunctionNotNull<Divide>("divide", &div_doc);
+  auto divide = MakeArithmeticFunctionNotNull<Divide>("divide", div_doc);
   AddDecimalBinaryKernels<Divide>("divide", divide.get());
 
   // Add divide(duration, int64) -> duration
@@ -2803,7 +2803,7 @@ void RegisterScalarArithmetic(FunctionRegistry* registry) {
 
   // ----------------------------------------------------------------------
   auto divide_checked =
-      MakeArithmeticFunctionNotNull<DivideChecked>("divide_checked", &div_checked_doc);
+      MakeArithmeticFunctionNotNull<DivideChecked>("divide_checked", div_checked_doc);
   AddDecimalBinaryKernels<DivideChecked>("divide_checked", divide_checked.get());
 
   // Add divide_checked(duration, int64) -> duration
@@ -2816,47 +2816,47 @@ void RegisterScalarArithmetic(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunction(std::move(divide_checked)));
 
   // ----------------------------------------------------------------------
-  auto negate = MakeUnaryArithmeticFunction<Negate>("negate", &negate_doc);
+  auto negate = MakeUnaryArithmeticFunction<Negate>("negate", negate_doc);
   AddDecimalUnaryKernels<Negate>(negate.get());
   DCHECK_OK(registry->AddFunction(std::move(negate)));
 
   // ----------------------------------------------------------------------
   auto negate_checked = MakeUnarySignedArithmeticFunctionNotNull<NegateChecked>(
-      "negate_checked", &negate_checked_doc);
+      "negate_checked", negate_checked_doc);
   AddDecimalUnaryKernels<NegateChecked>(negate_checked.get());
   DCHECK_OK(registry->AddFunction(std::move(negate_checked)));
 
   // ----------------------------------------------------------------------
   auto power = MakeArithmeticFunction<Power, ArithmeticDecimalToFloatingPointFunction>(
-      "power", &pow_doc);
+      "power", pow_doc);
   DCHECK_OK(registry->AddFunction(std::move(power)));
 
   // ----------------------------------------------------------------------
   auto power_checked =
       MakeArithmeticFunctionNotNull<PowerChecked,
                                     ArithmeticDecimalToFloatingPointFunction>(
-          "power_checked", &pow_checked_doc);
+          "power_checked", pow_checked_doc);
   DCHECK_OK(registry->AddFunction(std::move(power_checked)));
 
   // ----------------------------------------------------------------------
-  auto sqrt = MakeUnaryArithmeticFunctionFloatingPoint<SquareRoot>("sqrt", &sqrt_doc);
+  auto sqrt = MakeUnaryArithmeticFunctionFloatingPoint<SquareRoot>("sqrt", sqrt_doc);
   DCHECK_OK(registry->AddFunction(std::move(sqrt)));
 
   // ----------------------------------------------------------------------
   auto sqrt_checked = MakeUnaryArithmeticFunctionFloatingPointNotNull<SquareRootChecked>(
-      "sqrt_checked", &sqrt_checked_doc);
+      "sqrt_checked", sqrt_checked_doc);
   DCHECK_OK(registry->AddFunction(std::move(sqrt_checked)));
 
   // ----------------------------------------------------------------------
   auto sign =
-      MakeUnaryArithmeticFunctionWithFixedIntOutType<Sign, Int8Type>("sign", &sign_doc);
+      MakeUnaryArithmeticFunctionWithFixedIntOutType<Sign, Int8Type>("sign", sign_doc);
   DCHECK_OK(registry->AddFunction(std::move(sign)));
 
   // ----------------------------------------------------------------------
   // Bitwise functions
   {
     auto bit_wise_not = std::make_shared<ArithmeticFunction>(
-        "bit_wise_not", Arity::Unary(), &bit_wise_not_doc);
+        "bit_wise_not", Arity::Unary(), bit_wise_not_doc);
     for (const auto& ty : IntTypes()) {
       auto exec = TypeAgnosticBitWiseExecFromOp<ScalarUnaryNotNull, BitWiseNot>(ty);
       DCHECK_OK(bit_wise_not->AddKernel({ty}, ty, exec));
@@ -2866,110 +2866,109 @@ void RegisterScalarArithmetic(FunctionRegistry* registry) {
   }
 
   auto bit_wise_and =
-      MakeBitWiseFunctionNotNull<BitWiseAnd>("bit_wise_and", &bit_wise_and_doc);
+      MakeBitWiseFunctionNotNull<BitWiseAnd>("bit_wise_and", bit_wise_and_doc);
   DCHECK_OK(registry->AddFunction(std::move(bit_wise_and)));
 
   auto bit_wise_or =
-      MakeBitWiseFunctionNotNull<BitWiseOr>("bit_wise_or", &bit_wise_or_doc);
+      MakeBitWiseFunctionNotNull<BitWiseOr>("bit_wise_or", bit_wise_or_doc);
   DCHECK_OK(registry->AddFunction(std::move(bit_wise_or)));
 
   auto bit_wise_xor =
-      MakeBitWiseFunctionNotNull<BitWiseXor>("bit_wise_xor", &bit_wise_xor_doc);
+      MakeBitWiseFunctionNotNull<BitWiseXor>("bit_wise_xor", bit_wise_xor_doc);
   DCHECK_OK(registry->AddFunction(std::move(bit_wise_xor)));
 
-  auto shift_left = MakeShiftFunctionNotNull<ShiftLeft>("shift_left", &shift_left_doc);
+  auto shift_left = MakeShiftFunctionNotNull<ShiftLeft>("shift_left", shift_left_doc);
   DCHECK_OK(registry->AddFunction(std::move(shift_left)));
 
   auto shift_left_checked = MakeShiftFunctionNotNull<ShiftLeftChecked>(
-      "shift_left_checked", &shift_left_checked_doc);
+      "shift_left_checked", shift_left_checked_doc);
   DCHECK_OK(registry->AddFunction(std::move(shift_left_checked)));
 
-  auto shift_right =
-      MakeShiftFunctionNotNull<ShiftRight>("shift_right", &shift_right_doc);
+  auto shift_right = MakeShiftFunctionNotNull<ShiftRight>("shift_right", shift_right_doc);
   DCHECK_OK(registry->AddFunction(std::move(shift_right)));
 
   auto shift_right_checked = MakeShiftFunctionNotNull<ShiftRightChecked>(
-      "shift_right_checked", &shift_right_checked_doc);
+      "shift_right_checked", shift_right_checked_doc);
   DCHECK_OK(registry->AddFunction(std::move(shift_right_checked)));
 
   // ----------------------------------------------------------------------
   // Trig functions
-  auto sin = MakeUnaryArithmeticFunctionFloatingPoint<Sin>("sin", &sin_doc);
+  auto sin = MakeUnaryArithmeticFunctionFloatingPoint<Sin>("sin", sin_doc);
   DCHECK_OK(registry->AddFunction(std::move(sin)));
 
   auto sin_checked = MakeUnaryArithmeticFunctionFloatingPointNotNull<SinChecked>(
-      "sin_checked", &sin_checked_doc);
+      "sin_checked", sin_checked_doc);
   DCHECK_OK(registry->AddFunction(std::move(sin_checked)));
 
-  auto cos = MakeUnaryArithmeticFunctionFloatingPoint<Cos>("cos", &cos_doc);
+  auto cos = MakeUnaryArithmeticFunctionFloatingPoint<Cos>("cos", cos_doc);
   DCHECK_OK(registry->AddFunction(std::move(cos)));
 
   auto cos_checked = MakeUnaryArithmeticFunctionFloatingPointNotNull<CosChecked>(
-      "cos_checked", &cos_checked_doc);
+      "cos_checked", cos_checked_doc);
   DCHECK_OK(registry->AddFunction(std::move(cos_checked)));
 
-  auto tan = MakeUnaryArithmeticFunctionFloatingPoint<Tan>("tan", &tan_doc);
+  auto tan = MakeUnaryArithmeticFunctionFloatingPoint<Tan>("tan", tan_doc);
   DCHECK_OK(registry->AddFunction(std::move(tan)));
 
   auto tan_checked = MakeUnaryArithmeticFunctionFloatingPointNotNull<TanChecked>(
-      "tan_checked", &tan_checked_doc);
+      "tan_checked", tan_checked_doc);
   DCHECK_OK(registry->AddFunction(std::move(tan_checked)));
 
-  auto asin = MakeUnaryArithmeticFunctionFloatingPoint<Asin>("asin", &asin_doc);
+  auto asin = MakeUnaryArithmeticFunctionFloatingPoint<Asin>("asin", asin_doc);
   DCHECK_OK(registry->AddFunction(std::move(asin)));
 
   auto asin_checked = MakeUnaryArithmeticFunctionFloatingPointNotNull<AsinChecked>(
-      "asin_checked", &asin_checked_doc);
+      "asin_checked", asin_checked_doc);
   DCHECK_OK(registry->AddFunction(std::move(asin_checked)));
 
-  auto acos = MakeUnaryArithmeticFunctionFloatingPoint<Acos>("acos", &acos_doc);
+  auto acos = MakeUnaryArithmeticFunctionFloatingPoint<Acos>("acos", acos_doc);
   DCHECK_OK(registry->AddFunction(std::move(acos)));
 
   auto acos_checked = MakeUnaryArithmeticFunctionFloatingPointNotNull<AcosChecked>(
-      "acos_checked", &acos_checked_doc);
+      "acos_checked", acos_checked_doc);
   DCHECK_OK(registry->AddFunction(std::move(acos_checked)));
 
-  auto atan = MakeUnaryArithmeticFunctionFloatingPoint<Atan>("atan", &atan_doc);
+  auto atan = MakeUnaryArithmeticFunctionFloatingPoint<Atan>("atan", atan_doc);
   DCHECK_OK(registry->AddFunction(std::move(atan)));
 
-  auto atan2 = MakeArithmeticFunctionFloatingPoint<Atan2>("atan2", &atan2_doc);
+  auto atan2 = MakeArithmeticFunctionFloatingPoint<Atan2>("atan2", atan2_doc);
   DCHECK_OK(registry->AddFunction(std::move(atan2)));
 
   // ----------------------------------------------------------------------
   // Logarithms
-  auto ln = MakeUnaryArithmeticFunctionFloatingPoint<LogNatural>("ln", &ln_doc);
+  auto ln = MakeUnaryArithmeticFunctionFloatingPoint<LogNatural>("ln", ln_doc);
   DCHECK_OK(registry->AddFunction(std::move(ln)));
 
   auto ln_checked = MakeUnaryArithmeticFunctionFloatingPointNotNull<LogNaturalChecked>(
-      "ln_checked", &ln_checked_doc);
+      "ln_checked", ln_checked_doc);
   DCHECK_OK(registry->AddFunction(std::move(ln_checked)));
 
-  auto log10 = MakeUnaryArithmeticFunctionFloatingPoint<Log10>("log10", &log10_doc);
+  auto log10 = MakeUnaryArithmeticFunctionFloatingPoint<Log10>("log10", log10_doc);
   DCHECK_OK(registry->AddFunction(std::move(log10)));
 
   auto log10_checked = MakeUnaryArithmeticFunctionFloatingPointNotNull<Log10Checked>(
-      "log10_checked", &log10_checked_doc);
+      "log10_checked", log10_checked_doc);
   DCHECK_OK(registry->AddFunction(std::move(log10_checked)));
 
-  auto log2 = MakeUnaryArithmeticFunctionFloatingPoint<Log2>("log2", &log2_doc);
+  auto log2 = MakeUnaryArithmeticFunctionFloatingPoint<Log2>("log2", log2_doc);
   DCHECK_OK(registry->AddFunction(std::move(log2)));
 
   auto log2_checked = MakeUnaryArithmeticFunctionFloatingPointNotNull<Log2Checked>(
-      "log2_checked", &log2_checked_doc);
+      "log2_checked", log2_checked_doc);
   DCHECK_OK(registry->AddFunction(std::move(log2_checked)));
 
-  auto log1p = MakeUnaryArithmeticFunctionFloatingPoint<Log1p>("log1p", &log1p_doc);
+  auto log1p = MakeUnaryArithmeticFunctionFloatingPoint<Log1p>("log1p", log1p_doc);
   DCHECK_OK(registry->AddFunction(std::move(log1p)));
 
   auto log1p_checked = MakeUnaryArithmeticFunctionFloatingPointNotNull<Log1pChecked>(
-      "log1p_checked", &log1p_checked_doc);
+      "log1p_checked", log1p_checked_doc);
   DCHECK_OK(registry->AddFunction(std::move(log1p_checked)));
 
-  auto logb = MakeArithmeticFunctionFloatingPoint<Logb>("logb", &logb_doc);
+  auto logb = MakeArithmeticFunctionFloatingPoint<Logb>("logb", logb_doc);
   DCHECK_OK(registry->AddFunction(std::move(logb)));
 
   auto logb_checked = MakeArithmeticFunctionFloatingPointNotNull<LogbChecked>(
-      "logb_checked", &logb_checked_doc);
+      "logb_checked", logb_checked_doc);
   DCHECK_OK(registry->AddFunction(std::move(logb_checked)));
 
   // ----------------------------------------------------------------------
@@ -2977,7 +2976,7 @@ void RegisterScalarArithmetic(FunctionRegistry* registry) {
   auto floor =
       MakeUnaryArithmeticFunctionFloatingPoint<Floor,
                                                ArithmeticIntegerToFloatingPointFunction>(
-          "floor", &floor_doc);
+          "floor", floor_doc);
   DCHECK_OK(floor->AddKernel(
       {InputType(Type::DECIMAL128)}, OutputType(FirstType),
       FixedRoundDecimalExec<Decimal128Type, RoundMode::DOWN, /*ndigits=*/0>));
@@ -2989,7 +2988,7 @@ void RegisterScalarArithmetic(FunctionRegistry* registry) {
   auto ceil =
       MakeUnaryArithmeticFunctionFloatingPoint<Ceil,
                                                ArithmeticIntegerToFloatingPointFunction>(
-          "ceil", &ceil_doc);
+          "ceil", ceil_doc);
   DCHECK_OK(ceil->AddKernel(
       {InputType(Type::DECIMAL128)}, OutputType(FirstType),
       FixedRoundDecimalExec<Decimal128Type, RoundMode::UP, /*ndigits=*/0>));
@@ -3001,7 +3000,7 @@ void RegisterScalarArithmetic(FunctionRegistry* registry) {
   auto trunc =
       MakeUnaryArithmeticFunctionFloatingPoint<Trunc,
                                                ArithmeticIntegerToFloatingPointFunction>(
-          "trunc", &trunc_doc);
+          "trunc", trunc_doc);
   DCHECK_OK(trunc->AddKernel(
       {InputType(Type::DECIMAL128)}, OutputType(FirstType),
       FixedRoundDecimalExec<Decimal128Type, RoundMode::TOWARDS_ZERO, /*ndigits=*/0>));
@@ -3010,12 +3009,12 @@ void RegisterScalarArithmetic(FunctionRegistry* registry) {
       FixedRoundDecimalExec<Decimal256Type, RoundMode::TOWARDS_ZERO, /*ndigits=*/0>));
   DCHECK_OK(registry->AddFunction(std::move(trunc)));
 
-  auto round = MakeUnaryRoundFunction<Round, RoundOptions>("round", &round_doc);
+  auto round = MakeUnaryRoundFunction<Round, RoundOptions>("round", round_doc);
   DCHECK_OK(registry->AddFunction(std::move(round)));
 
   auto round_to_multiple =
       MakeUnaryRoundFunction<RoundToMultiple, RoundToMultipleOptions>(
-          "round_to_multiple", &round_to_multiple_doc);
+          "round_to_multiple", round_to_multiple_doc);
   DCHECK_OK(registry->AddFunction(std::move(round_to_multiple)));
 }
 
diff --git a/cpp/src/arrow/compute/kernels/scalar_boolean.cc b/cpp/src/arrow/compute/kernels/scalar_boolean.cc
index 9c625b55998..1aea247ddf6 100644
--- a/cpp/src/arrow/compute/kernels/scalar_boolean.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_boolean.cc
@@ -455,9 +455,9 @@ struct KleeneAndNotOp {
 };
 
 void MakeFunction(const std::string& name, int arity, ArrayKernelExec exec,
-                  const FunctionDoc* doc, FunctionRegistry* registry,
+                  FunctionDoc doc, FunctionRegistry* registry,
                   NullHandling::type null_handling = NullHandling::INTERSECTION) {
-  auto func = std::make_shared<ScalarFunction>(name, Arity(arity), doc);
+  auto func = std::make_shared<ScalarFunction>(name, Arity(arity), std::move(doc));
 
   std::vector<InputType> in_types(arity, InputType(boolean()));
   ScalarKernel kernel(std::move(in_types), boolean(), exec);
@@ -541,19 +541,19 @@ namespace internal {
 
 void RegisterScalarBoolean(FunctionRegistry* registry) {
   // These functions can write into sliced output bitmaps
-  MakeFunction("invert", 1, applicator::SimpleUnary<InvertOp>, &invert_doc, registry);
-  MakeFunction("and", 2, applicator::SimpleBinary<AndOp>, &and_doc, registry);
-  MakeFunction("and_not", 2, applicator::SimpleBinary<AndNotOp>, &and_not_doc, registry);
-  MakeFunction("or", 2, applicator::SimpleBinary<OrOp>, &or_doc, registry);
-  MakeFunction("xor", 2, applicator::SimpleBinary<XorOp>, &xor_doc, registry);
+  MakeFunction("invert", 1, applicator::SimpleUnary<InvertOp>, invert_doc, registry);
+  MakeFunction("and", 2, applicator::SimpleBinary<AndOp>, and_doc, registry);
+  MakeFunction("and_not", 2, applicator::SimpleBinary<AndNotOp>, and_not_doc, registry);
+  MakeFunction("or", 2, applicator::SimpleBinary<OrOp>, or_doc, registry);
+  MakeFunction("xor", 2, applicator::SimpleBinary<XorOp>, xor_doc, registry);
 
   // The null bitmap is not preallocated for Kleene kernels, as sometimes
   // all outputs are valid even though some inputs may be null.
-  MakeFunction("and_kleene", 2, applicator::SimpleBinary<KleeneAndOp>, &and_kleene_doc,
+  MakeFunction("and_kleene", 2, applicator::SimpleBinary<KleeneAndOp>, and_kleene_doc,
                registry, NullHandling::COMPUTED_NO_PREALLOCATE);
   MakeFunction("and_not_kleene", 2, applicator::SimpleBinary<KleeneAndNotOp>,
-               &and_not_kleene_doc, registry, NullHandling::COMPUTED_NO_PREALLOCATE);
-  MakeFunction("or_kleene", 2, applicator::SimpleBinary<KleeneOrOp>, &or_kleene_doc,
+               and_not_kleene_doc, registry, NullHandling::COMPUTED_NO_PREALLOCATE);
+  MakeFunction("or_kleene", 2, applicator::SimpleBinary<KleeneOrOp>, or_kleene_doc,
                registry, NullHandling::COMPUTED_NO_PREALLOCATE);
 }
 
diff --git a/cpp/src/arrow/compute/kernels/scalar_compare.cc b/cpp/src/arrow/compute/kernels/scalar_compare.cc
index fc852781029..f5ccb991d9b 100644
--- a/cpp/src/arrow/compute/kernels/scalar_compare.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_compare.cc
@@ -240,9 +240,8 @@ struct VarArgsCompareFunction : ScalarFunction {
 };
 
 template <typename Op>
-std::shared_ptr<ScalarFunction> MakeCompareFunction(std::string name,
-                                                    const FunctionDoc* doc) {
-  auto func = std::make_shared<CompareFunction>(name, Arity::Binary(), doc);
+std::shared_ptr<ScalarFunction> MakeCompareFunction(std::string name, FunctionDoc doc) {
+  auto func = std::make_shared<CompareFunction>(name, Arity::Binary(), std::move(doc));
 
   DCHECK_OK(func->AddKernel(
       {boolean(), boolean()}, boolean(),
@@ -313,8 +312,9 @@ std::shared_ptr<ScalarFunction> MakeCompareFunction(std::string name,
 
 std::shared_ptr<ScalarFunction> MakeFlippedFunction(std::string name,
                                                     const ScalarFunction& func,
-                                                    const FunctionDoc* doc) {
-  auto flipped_func = std::make_shared<CompareFunction>(name, Arity::Binary(), doc);
+                                                    FunctionDoc doc) {
+  auto flipped_func =
+      std::make_shared<CompareFunction>(name, Arity::Binary(), std::move(doc));
   for (const ScalarKernel* kernel : func.kernels()) {
     ScalarKernel flipped_kernel = *kernel;
     flipped_kernel.exec = MakeFlippedBinaryExec(kernel->exec);
@@ -691,13 +691,12 @@ Result<ValueDescr> ResolveMinOrMaxOutputType(KernelContext*,
 }
 
 template <typename Op>
-std::shared_ptr<ScalarFunction> MakeScalarMinMax(std::string name,
-                                                 const FunctionDoc* doc) {
+std::shared_ptr<ScalarFunction> MakeScalarMinMax(std::string name, FunctionDoc doc) {
   static auto default_element_wise_aggregate_options =
       ElementWiseAggregateOptions::Defaults();
 
   auto func = std::make_shared<VarArgsCompareFunction>(
-      name, Arity::VarArgs(), doc, &default_element_wise_aggregate_options);
+      name, Arity::VarArgs(), std::move(doc), &default_element_wise_aggregate_options);
   for (const auto& ty : NumericTypes()) {
     auto exec = GeneratePhysicalNumeric<ScalarMinMax, Op>(ty);
     ScalarKernel kernel{KernelSignature::Make({ty}, ty, /*is_varargs=*/true), exec,
@@ -789,16 +788,16 @@ const FunctionDoc max_element_wise_doc{
 }  // namespace
 
 void RegisterScalarComparison(FunctionRegistry* registry) {
-  DCHECK_OK(registry->AddFunction(MakeCompareFunction<Equal>("equal", &equal_doc)));
+  DCHECK_OK(registry->AddFunction(MakeCompareFunction<Equal>("equal", equal_doc)));
   DCHECK_OK(
-      registry->AddFunction(MakeCompareFunction<NotEqual>("not_equal", &not_equal_doc)));
+      registry->AddFunction(MakeCompareFunction<NotEqual>("not_equal", not_equal_doc)));
 
-  auto greater = MakeCompareFunction<Greater>("greater", &greater_doc);
+  auto greater = MakeCompareFunction<Greater>("greater", greater_doc);
   auto greater_equal =
-      MakeCompareFunction<GreaterEqual>("greater_equal", &greater_equal_doc);
+      MakeCompareFunction<GreaterEqual>("greater_equal", greater_equal_doc);
 
-  auto less = MakeFlippedFunction("less", *greater, &less_doc);
-  auto less_equal = MakeFlippedFunction("less_equal", *greater_equal, &less_equal_doc);
+  auto less = MakeFlippedFunction("less", *greater, less_doc);
+  auto less_equal = MakeFlippedFunction("less_equal", *greater_equal, less_equal_doc);
   DCHECK_OK(registry->AddFunction(std::move(less)));
   DCHECK_OK(registry->AddFunction(std::move(less_equal)));
   DCHECK_OK(registry->AddFunction(std::move(greater)));
@@ -808,11 +807,11 @@ void RegisterScalarComparison(FunctionRegistry* registry) {
   // Variadic element-wise functions
 
   auto min_element_wise =
-      MakeScalarMinMax<Minimum>("min_element_wise", &min_element_wise_doc);
+      MakeScalarMinMax<Minimum>("min_element_wise", min_element_wise_doc);
   DCHECK_OK(registry->AddFunction(std::move(min_element_wise)));
 
   auto max_element_wise =
-      MakeScalarMinMax<Maximum>("max_element_wise", &max_element_wise_doc);
+      MakeScalarMinMax<Maximum>("max_element_wise", max_element_wise_doc);
   DCHECK_OK(registry->AddFunction(std::move(max_element_wise)));
 }
 
diff --git a/cpp/src/arrow/compute/kernels/scalar_if_else.cc b/cpp/src/arrow/compute/kernels/scalar_if_else.cc
index 5e1edbe4abe..00dcc55a8ac 100644
--- a/cpp/src/arrow/compute/kernels/scalar_if_else.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_if_else.cc
@@ -2773,7 +2773,7 @@ const FunctionDoc choose_doc{
 void RegisterScalarIfElse(FunctionRegistry* registry) {
   {
     auto func =
-        std::make_shared<IfElseFunction>("if_else", Arity::Ternary(), &if_else_doc);
+        std::make_shared<IfElseFunction>("if_else", Arity::Ternary(), if_else_doc);
 
     AddPrimitiveIfElseKernels(func, NumericTypes());
     AddPrimitiveIfElseKernels(func, TemporalTypes());
@@ -2789,7 +2789,7 @@ void RegisterScalarIfElse(FunctionRegistry* registry) {
   }
   {
     auto func = std::make_shared<CaseWhenFunction>(
-        "case_when", Arity::VarArgs(/*min_args=*/2), &case_when_doc);
+        "case_when", Arity::VarArgs(/*min_args=*/2), case_when_doc);
     AddPrimitiveCaseWhenKernels(func, NumericTypes());
     AddPrimitiveCaseWhenKernels(func, TemporalTypes());
     AddPrimitiveCaseWhenKernels(func, IntervalTypes());
@@ -2812,7 +2812,7 @@ void RegisterScalarIfElse(FunctionRegistry* registry) {
   }
   {
     auto func = std::make_shared<CoalesceFunction>(
-        "coalesce", Arity::VarArgs(/*min_args=*/1), &coalesce_doc);
+        "coalesce", Arity::VarArgs(/*min_args=*/1), coalesce_doc);
     AddPrimitiveCoalesceKernels(func, NumericTypes());
     AddPrimitiveCoalesceKernels(func, TemporalTypes());
     AddPrimitiveCoalesceKernels(func, IntervalTypes());
@@ -2837,7 +2837,7 @@ void RegisterScalarIfElse(FunctionRegistry* registry) {
   }
   {
     auto func = std::make_shared<ChooseFunction>("choose", Arity::VarArgs(/*min_args=*/2),
-                                                 &choose_doc);
+                                                 choose_doc);
     AddPrimitiveChooseKernels(func, NumericTypes());
     AddPrimitiveChooseKernels(func, TemporalTypes());
     AddPrimitiveChooseKernels(func, IntervalTypes());
diff --git a/cpp/src/arrow/compute/kernels/scalar_nested.cc b/cpp/src/arrow/compute/kernels/scalar_nested.cc
index cf8a7e08b03..1e40d7aabab 100644
--- a/cpp/src/arrow/compute/kernels/scalar_nested.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_nested.cc
@@ -689,7 +689,7 @@ const FunctionDoc map_lookup_doc{
 
 void RegisterScalarNested(FunctionRegistry* registry) {
   auto list_value_length = std::make_shared<ScalarFunction>(
-      "list_value_length", Arity::Unary(), &list_value_length_doc);
+      "list_value_length", Arity::Unary(), list_value_length_doc);
   DCHECK_OK(list_value_length->AddKernel({InputType(Type::LIST)}, int32(),
                                          ListValueLength<ListType>));
   DCHECK_OK(list_value_length->AddKernel({InputType(Type::FIXED_SIZE_LIST)}, int32(),
@@ -698,25 +698,25 @@ void RegisterScalarNested(FunctionRegistry* registry) {
                                          ListValueLength<LargeListType>));
   DCHECK_OK(registry->AddFunction(std::move(list_value_length)));
 
-  auto list_element = std::make_shared<ScalarFunction>("list_element", Arity::Binary(),
-                                                       &list_element_doc);
+  auto list_element =
+      std::make_shared<ScalarFunction>("list_element", Arity::Binary(), list_element_doc);
   AddListElementArrayKernels(list_element.get());
   AddListElementScalarKernels(list_element.get());
   DCHECK_OK(registry->AddFunction(std::move(list_element)));
 
   auto struct_field =
-      std::make_shared<ScalarFunction>("struct_field", Arity::Unary(), &struct_field_doc);
+      std::make_shared<ScalarFunction>("struct_field", Arity::Unary(), struct_field_doc);
   AddStructFieldKernels(struct_field.get());
   DCHECK_OK(registry->AddFunction(std::move(struct_field)));
 
   auto map_lookup =
-      std::make_shared<ScalarFunction>("map_lookup", Arity::Unary(), &map_lookup_doc);
+      std::make_shared<ScalarFunction>("map_lookup", Arity::Unary(), map_lookup_doc);
   AddMapLookupKernels(map_lookup.get());
   DCHECK_OK(registry->AddFunction(std::move(map_lookup)));
 
   static MakeStructOptions kDefaultMakeStructOptions;
   auto make_struct_function = std::make_shared<ScalarFunction>(
-      "make_struct", Arity::VarArgs(), &make_struct_doc, &kDefaultMakeStructOptions);
+      "make_struct", Arity::VarArgs(), make_struct_doc, &kDefaultMakeStructOptions);
 
   ScalarKernel kernel{KernelSignature::Make({InputType{}}, OutputType{MakeStructResolve},
                                             /*is_varargs=*/true),
diff --git a/cpp/src/arrow/compute/kernels/scalar_random.cc b/cpp/src/arrow/compute/kernels/scalar_random.cc
index 3d0e71eb1c9..2204dbf0202 100644
--- a/cpp/src/arrow/compute/kernels/scalar_random.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_random.cc
@@ -99,7 +99,7 @@ void RegisterScalarRandom(FunctionRegistry* registry) {
   static auto random_options = RandomOptions::Defaults();
 
   auto random_func = std::make_shared<ScalarFunction>("random", Arity::Nullary(),
-                                                      &random_doc, &random_options);
+                                                      random_doc, &random_options);
   ScalarKernel kernel{
       {}, ValueDescr(float64(), ValueDescr::Shape::ARRAY), ExecRandom, RandomState::Init};
   kernel.null_handling = NullHandling::OUTPUT_NOT_NULL;
diff --git a/cpp/src/arrow/compute/kernels/scalar_set_lookup.cc b/cpp/src/arrow/compute/kernels/scalar_set_lookup.cc
index 97eedd53eec..7d8d2edc4b3 100644
--- a/cpp/src/arrow/compute/kernels/scalar_set_lookup.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_set_lookup.cc
@@ -481,8 +481,7 @@ const FunctionDoc index_in_meta_doc{
 // Enables calling is_in with CallFunction as though it were binary.
 class IsInMetaBinary : public MetaFunction {
  public:
-  IsInMetaBinary()
-      : MetaFunction("is_in_meta_binary", Arity::Binary(), &is_in_meta_doc) {}
+  IsInMetaBinary() : MetaFunction("is_in_meta_binary", Arity::Binary(), is_in_meta_doc) {}
 
   Result<Datum> ExecuteImpl(const std::vector<Datum>& args,
                             const FunctionOptions* options,
@@ -498,7 +497,7 @@ class IsInMetaBinary : public MetaFunction {
 class IndexInMetaBinary : public MetaFunction {
  public:
   IndexInMetaBinary()
-      : MetaFunction("index_in_meta_binary", Arity::Binary(), &index_in_meta_doc) {}
+      : MetaFunction("index_in_meta_binary", Arity::Binary(), index_in_meta_doc) {}
 
   Result<Datum> ExecuteImpl(const std::vector<Datum>& args,
                             const FunctionOptions* options,
@@ -529,7 +528,7 @@ void RegisterScalarSetLookup(FunctionRegistry* registry) {
     isin_base.exec =
         TrivialScalarUnaryAsArraysExec(ExecIsIn, NullHandling::OUTPUT_NOT_NULL);
     isin_base.null_handling = NullHandling::OUTPUT_NOT_NULL;
-    auto is_in = std::make_shared<SetLookupFunction>("is_in", Arity::Unary(), &is_in_doc);
+    auto is_in = std::make_shared<SetLookupFunction>("is_in", Arity::Unary(), is_in_doc);
 
     AddBasicSetLookupKernels(isin_base, /*output_type=*/boolean(), is_in.get());
 
@@ -549,7 +548,7 @@ void RegisterScalarSetLookup(FunctionRegistry* registry) {
     index_in_base.null_handling = NullHandling::COMPUTED_NO_PREALLOCATE;
     index_in_base.mem_allocation = MemAllocation::NO_PREALLOCATE;
     auto index_in =
-        std::make_shared<SetLookupFunction>("index_in", Arity::Unary(), &index_in_doc);
+        std::make_shared<SetLookupFunction>("index_in", Arity::Unary(), index_in_doc);
 
     AddBasicSetLookupKernels(index_in_base, /*output_type=*/int32(), index_in.get());
 
diff --git a/cpp/src/arrow/compute/kernels/scalar_string_ascii.cc b/cpp/src/arrow/compute/kernels/scalar_string_ascii.cc
index a332364bd82..611601cab87 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_ascii.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_ascii.cc
@@ -776,21 +776,21 @@ const auto ascii_is_title_doc = StringPredicateDoc(
      "an uppercase character."));
 
 void AddAsciiStringPredicates(FunctionRegistry* registry) {
-  AddUnaryStringPredicate<IsAscii>("string_is_ascii", registry, &string_is_ascii_doc);
+  AddUnaryStringPredicate<IsAscii>("string_is_ascii", registry, string_is_ascii_doc);
 
   AddUnaryStringPredicate<IsAlphaNumericAscii>("ascii_is_alnum", registry,
-                                               &ascii_is_alnum_doc);
-  AddUnaryStringPredicate<IsAlphaAscii>("ascii_is_alpha", registry, &ascii_is_alpha_doc);
+                                               ascii_is_alnum_doc);
+  AddUnaryStringPredicate<IsAlphaAscii>("ascii_is_alpha", registry, ascii_is_alpha_doc);
   AddUnaryStringPredicate<IsDecimalAscii>("ascii_is_decimal", registry,
-                                          &ascii_is_decimal_doc);
+                                          ascii_is_decimal_doc);
   // no is_digit for ascii, since it is the same as is_decimal
-  AddUnaryStringPredicate<IsLowerAscii>("ascii_is_lower", registry, &ascii_is_lower_doc);
+  AddUnaryStringPredicate<IsLowerAscii>("ascii_is_lower", registry, ascii_is_lower_doc);
   // no is_numeric for ascii, since it is the same as is_decimal
   AddUnaryStringPredicate<IsPrintableAscii>("ascii_is_printable", registry,
-                                            &ascii_is_printable_doc);
-  AddUnaryStringPredicate<IsSpaceAscii>("ascii_is_space", registry, &ascii_is_space_doc);
-  AddUnaryStringPredicate<IsUpperAscii>("ascii_is_upper", registry, &ascii_is_upper_doc);
-  AddUnaryStringPredicate<IsTitleAscii>("ascii_is_title", registry, &ascii_is_title_doc);
+                                            ascii_is_printable_doc);
+  AddUnaryStringPredicate<IsSpaceAscii>("ascii_is_space", registry, ascii_is_space_doc);
+  AddUnaryStringPredicate<IsUpperAscii>("ascii_is_upper", registry, ascii_is_upper_doc);
+  AddUnaryStringPredicate<IsTitleAscii>("ascii_is_title", registry, ascii_is_title_doc);
 }
 
 // ----------------------------------------------------------------------
@@ -929,15 +929,15 @@ void AddAsciiStringCaseConversion(FunctionRegistry* registry) {
   // Some kernels are able to reuse the original offsets buffer, so don't
   // preallocate them in the output. Only kernels that invoke
   // "StringDataTransform" support no preallocation.
-  MakeUnaryStringBatchKernel<AsciiUpper>("ascii_upper", registry, &ascii_upper_doc,
+  MakeUnaryStringBatchKernel<AsciiUpper>("ascii_upper", registry, ascii_upper_doc,
                                          MemAllocation::NO_PREALLOCATE);
-  MakeUnaryStringBatchKernel<AsciiLower>("ascii_lower", registry, &ascii_lower_doc,
+  MakeUnaryStringBatchKernel<AsciiLower>("ascii_lower", registry, ascii_lower_doc,
                                          MemAllocation::NO_PREALLOCATE);
   MakeUnaryStringBatchKernel<AsciiSwapCase>(
-      "ascii_swapcase", registry, &ascii_swapcase_doc, MemAllocation::NO_PREALLOCATE);
+      "ascii_swapcase", registry, ascii_swapcase_doc, MemAllocation::NO_PREALLOCATE);
   MakeUnaryStringBatchKernel<AsciiCapitalize>("ascii_capitalize", registry,
-                                              &ascii_capitalize_doc);
-  MakeUnaryStringBatchKernel<AsciiTitle>("ascii_title", registry, &ascii_title_doc);
+                                              ascii_capitalize_doc);
+  MakeUnaryStringBatchKernel<AsciiTitle>("ascii_title", registry, ascii_title_doc);
 }
 
 // ----------------------------------------------------------------------
@@ -971,7 +971,7 @@ const FunctionDoc binary_length_doc(
 
 void AddAsciiStringLength(FunctionRegistry* registry) {
   auto func = std::make_shared<ScalarFunction>("binary_length", Arity::Unary(),
-                                               &binary_length_doc);
+                                               binary_length_doc);
   for (const auto& ty : {binary(), utf8()}) {
     auto exec =
         GenerateVarBinaryBase<applicator::ScalarUnaryNotNull, Int32Type, BinaryLength>(
@@ -1041,14 +1041,14 @@ const FunctionDoc ascii_reverse_doc(
 void AddAsciiStringReverse(FunctionRegistry* registry) {
   {
     auto func = std::make_shared<ScalarFunction>("binary_reverse", Arity::Unary(),
-                                                 &binary_reverse_doc);
+                                                 binary_reverse_doc);
     for (const auto& ty : BinaryTypes()) {
       DCHECK_OK(
           func->AddKernel({ty}, ty, GenerateVarBinaryToVarBinary<BinaryReverse>(ty)));
     }
     DCHECK_OK(registry->AddFunction(std::move(func)));
   }
-  MakeUnaryStringBatchKernel<AsciiReverse>("ascii_reverse", registry, &ascii_reverse_doc);
+  MakeUnaryStringBatchKernel<AsciiReverse>("ascii_reverse", registry, ascii_reverse_doc);
 }
 
 // ----------------------------------------------------------------------
@@ -1189,17 +1189,17 @@ const FunctionDoc ascii_rtrim_whitespace_doc(
     {"strings"});
 
 void AddAsciiStringTrim(FunctionRegistry* registry) {
-  MakeUnaryStringBatchKernelWithState<AsciiTrim>("ascii_trim", registry, &ascii_trim_doc);
+  MakeUnaryStringBatchKernelWithState<AsciiTrim>("ascii_trim", registry, ascii_trim_doc);
   MakeUnaryStringBatchKernelWithState<AsciiLTrim>("ascii_ltrim", registry,
-                                                  &ascii_ltrim_doc);
+                                                  ascii_ltrim_doc);
   MakeUnaryStringBatchKernelWithState<AsciiRTrim>("ascii_rtrim", registry,
-                                                  &ascii_rtrim_doc);
+                                                  ascii_rtrim_doc);
   MakeUnaryStringBatchKernel<AsciiTrimWhitespace>("ascii_trim_whitespace", registry,
-                                                  &ascii_trim_whitespace_doc);
+                                                  ascii_trim_whitespace_doc);
   MakeUnaryStringBatchKernel<AsciiLTrimWhitespace>("ascii_ltrim_whitespace", registry,
-                                                   &ascii_ltrim_whitespace_doc);
+                                                   ascii_ltrim_whitespace_doc);
   MakeUnaryStringBatchKernel<AsciiRTrimWhitespace>("ascii_rtrim_whitespace", registry,
-                                                   &ascii_rtrim_whitespace_doc);
+                                                   ascii_rtrim_whitespace_doc);
 }
 
 // ----------------------------------------------------------------------
@@ -1284,10 +1284,10 @@ const FunctionDoc ascii_center_doc(
     {"strings"}, "PadOptions", /*options_required=*/true);
 
 void AddAsciiStringPad(FunctionRegistry* registry) {
-  MakeUnaryStringBatchKernelWithState<AsciiLPad>("ascii_lpad", registry, &ascii_lpad_doc);
-  MakeUnaryStringBatchKernelWithState<AsciiRPad>("ascii_rpad", registry, &ascii_rpad_doc);
+  MakeUnaryStringBatchKernelWithState<AsciiLPad>("ascii_lpad", registry, ascii_lpad_doc);
+  MakeUnaryStringBatchKernelWithState<AsciiRPad>("ascii_rpad", registry, ascii_rpad_doc);
   MakeUnaryStringBatchKernelWithState<AsciiCenter>("ascii_center", registry,
-                                                   &ascii_center_doc);
+                                                   ascii_center_doc);
 }
 
 // ----------------------------------------------------------------------
@@ -1717,7 +1717,7 @@ const FunctionDoc match_like_doc(
 void AddAsciiStringMatchSubstring(FunctionRegistry* registry) {
   {
     auto func = std::make_shared<ScalarFunction>("match_substring", Arity::Unary(),
-                                                 &match_substring_doc);
+                                                 match_substring_doc);
     for (const auto& ty : BaseBinaryTypes()) {
       auto exec = GenerateVarBinaryToVarBinary<MatchSubstring, PlainSubstringMatcher>(ty);
       DCHECK_OK(
@@ -1727,7 +1727,7 @@ void AddAsciiStringMatchSubstring(FunctionRegistry* registry) {
   }
   {
     auto func =
-        std::make_shared<ScalarFunction>("starts_with", Arity::Unary(), &starts_with_doc);
+        std::make_shared<ScalarFunction>("starts_with", Arity::Unary(), starts_with_doc);
     for (const auto& ty : BaseBinaryTypes()) {
       auto exec =
           GenerateVarBinaryToVarBinary<MatchSubstring, PlainStartsWithMatcher>(ty);
@@ -1738,7 +1738,7 @@ void AddAsciiStringMatchSubstring(FunctionRegistry* registry) {
   }
   {
     auto func =
-        std::make_shared<ScalarFunction>("ends_with", Arity::Unary(), &ends_with_doc);
+        std::make_shared<ScalarFunction>("ends_with", Arity::Unary(), ends_with_doc);
     for (const auto& ty : BaseBinaryTypes()) {
       auto exec = GenerateVarBinaryToVarBinary<MatchSubstring, PlainEndsWithMatcher>(ty);
       DCHECK_OK(
@@ -1749,7 +1749,7 @@ void AddAsciiStringMatchSubstring(FunctionRegistry* registry) {
 #ifdef ARROW_WITH_RE2
   {
     auto func = std::make_shared<ScalarFunction>("match_substring_regex", Arity::Unary(),
-                                                 &match_substring_regex_doc);
+                                                 match_substring_regex_doc);
     for (const auto& ty : BaseBinaryTypes()) {
       auto exec = GenerateVarBinaryToVarBinary<MatchSubstring, RegexSubstringMatcher>(ty);
       DCHECK_OK(
@@ -1759,7 +1759,7 @@ void AddAsciiStringMatchSubstring(FunctionRegistry* registry) {
   }
   {
     auto func =
-        std::make_shared<ScalarFunction>("match_like", Arity::Unary(), &match_like_doc);
+        std::make_shared<ScalarFunction>("match_like", Arity::Unary(), match_like_doc);
     for (const auto& ty : BaseBinaryTypes()) {
       auto exec = GenerateVarBinaryToVarBinary<MatchLike>(ty);
       DCHECK_OK(
@@ -1861,7 +1861,7 @@ const FunctionDoc find_substring_regex_doc(
 void AddAsciiStringFindSubstring(FunctionRegistry* registry) {
   {
     auto func = std::make_shared<ScalarFunction>("find_substring", Arity::Unary(),
-                                                 &find_substring_doc);
+                                                 find_substring_doc);
     for (const auto& ty : BaseBinaryTypes()) {
       auto offset_type = offset_bit_width(ty->id()) == 64 ? int64() : int32();
       DCHECK_OK(func->AddKernel({ty}, offset_type,
@@ -1876,7 +1876,7 @@ void AddAsciiStringFindSubstring(FunctionRegistry* registry) {
 #ifdef ARROW_WITH_RE2
   {
     auto func = std::make_shared<ScalarFunction>("find_substring_regex", Arity::Unary(),
-                                                 &find_substring_regex_doc);
+                                                 find_substring_regex_doc);
     for (const auto& ty : BaseBinaryTypes()) {
       auto offset_type = offset_bit_width(ty->id()) == 64 ? int64() : int32();
       DCHECK_OK(func->AddKernel({ty}, offset_type,
@@ -2010,7 +2010,7 @@ const FunctionDoc count_substring_regex_doc(
 void AddAsciiStringCountSubstring(FunctionRegistry* registry) {
   {
     auto func = std::make_shared<ScalarFunction>("count_substring", Arity::Unary(),
-                                                 &count_substring_doc);
+                                                 count_substring_doc);
     for (const auto& ty : BaseBinaryTypes()) {
       auto offset_type = offset_bit_width(ty->id()) == 64 ? int64() : int32();
       DCHECK_OK(func->AddKernel({ty}, offset_type,
@@ -2025,7 +2025,7 @@ void AddAsciiStringCountSubstring(FunctionRegistry* registry) {
 #ifdef ARROW_WITH_RE2
   {
     auto func = std::make_shared<ScalarFunction>("count_substring_regex", Arity::Unary(),
-                                                 &count_substring_regex_doc);
+                                                 count_substring_regex_doc);
     for (const auto& ty : BaseBinaryTypes()) {
       auto offset_type = offset_bit_width(ty->id()) == 64 ? int64() : int32();
       DCHECK_OK(func->AddKernel({ty}, offset_type,
@@ -2251,7 +2251,7 @@ const FunctionDoc replace_substring_regex_doc(
 void AddAsciiStringReplaceSubstring(FunctionRegistry* registry) {
   {
     auto func = std::make_shared<ScalarFunction>("replace_substring", Arity::Unary(),
-                                                 &replace_substring_doc);
+                                                 replace_substring_doc);
     for (const auto& ty : BaseBinaryTypes()) {
       auto exec = GenerateVarBinaryToVarBinary<ReplaceSubstringPlain>(ty);
       ScalarKernel kernel{{ty}, ty, std::move(exec), ReplaceState::Init};
@@ -2263,7 +2263,7 @@ void AddAsciiStringReplaceSubstring(FunctionRegistry* registry) {
 #ifdef ARROW_WITH_RE2
   {
     auto func = std::make_shared<ScalarFunction>(
-        "replace_substring_regex", Arity::Unary(), &replace_substring_regex_doc);
+        "replace_substring_regex", Arity::Unary(), replace_substring_regex_doc);
     for (const auto& ty : BaseBinaryTypes()) {
       auto exec = GenerateVarBinaryToVarBinary<ReplaceSubstringRegex>(ty);
       ScalarKernel kernel{{ty}, ty, std::move(exec), ReplaceState::Init};
@@ -2446,7 +2446,7 @@ const FunctionDoc extract_regex_doc(
 
 void AddAsciiStringExtractRegex(FunctionRegistry* registry) {
   auto func = std::make_shared<ScalarFunction>("extract_regex", Arity::Unary(),
-                                               &extract_regex_doc);
+                                               extract_regex_doc);
   OutputType out_ty(ResolveExtractRegexOutput);
   for (const auto& ty : BaseBinaryTypes()) {
     ScalarKernel kernel{{ty},
@@ -2534,7 +2534,7 @@ const FunctionDoc binary_replace_slice_doc(
 
 void AddAsciiStringReplaceSlice(FunctionRegistry* registry) {
   auto func = std::make_shared<ScalarFunction>("binary_replace_slice", Arity::Unary(),
-                                               &binary_replace_slice_doc);
+                                               binary_replace_slice_doc);
   for (const auto& ty : BaseBinaryTypes()) {
     DCHECK_OK(func->AddKernel({ty}, ty,
                               GenerateTypeAgnosticVarBinaryBase<BinaryReplaceSlice>(ty),
@@ -2620,7 +2620,7 @@ const FunctionDoc split_pattern_doc(
 
 void AddAsciiStringSplitPattern(FunctionRegistry* registry) {
   auto func = std::make_shared<ScalarFunction>("split_pattern", Arity::Unary(),
-                                               &split_pattern_doc);
+                                               split_pattern_doc);
   for (const auto& ty : BaseBinaryTypes()) {
     auto exec = GenerateVarBinaryToVarBinary<SplitPatternExec, ListType>(ty);
     DCHECK_OK(
@@ -2690,7 +2690,7 @@ void AddAsciiStringSplitWhitespace(FunctionRegistry* registry) {
   static const SplitOptions default_options{};
   auto func =
       std::make_shared<ScalarFunction>("ascii_split_whitespace", Arity::Unary(),
-                                       &ascii_split_whitespace_doc, &default_options);
+                                       ascii_split_whitespace_doc, &default_options);
 
   for (const auto& ty : StringTypes()) {
     auto exec = GenerateVarBinaryToVarBinary<SplitWhitespaceAsciiExec, ListType>(ty);
@@ -2760,7 +2760,7 @@ const FunctionDoc split_pattern_regex_doc(
 
 void AddAsciiStringSplitRegex(FunctionRegistry* registry) {
   auto func = std::make_shared<ScalarFunction>("split_pattern_regex", Arity::Unary(),
-                                               &split_pattern_regex_doc);
+                                               split_pattern_regex_doc);
   for (const auto& ty : BaseBinaryTypes()) {
     auto exec = GenerateVarBinaryToVarBinary<SplitRegexExec, ListType>(ty);
     DCHECK_OK(
@@ -3265,8 +3265,8 @@ void AddBinaryJoinForListType(ScalarFunction* func) {
 
 void AddAsciiStringJoin(FunctionRegistry* registry) {
   {
-    auto func = std::make_shared<ScalarFunction>("binary_join", Arity::Binary(),
-                                                 &binary_join_doc);
+    auto func =
+        std::make_shared<ScalarFunction>("binary_join", Arity::Binary(), binary_join_doc);
     AddBinaryJoinForListType<ListType>(func.get());
     AddBinaryJoinForListType<LargeListType>(func.get());
     DCHECK_OK(registry->AddFunction(std::move(func)));
@@ -3274,7 +3274,7 @@ void AddAsciiStringJoin(FunctionRegistry* registry) {
   {
     auto func = std::make_shared<ScalarFunction>(
         "binary_join_element_wise", Arity::VarArgs(/*min_args=*/1),
-        &binary_join_element_wise_doc, GetDefaultJoinOptions());
+        binary_join_element_wise_doc, GetDefaultJoinOptions());
     for (const auto& ty : BaseBinaryTypes()) {
       ScalarKernel kernel{KernelSignature::Make({InputType(ty)}, ty, /*is_varargs=*/true),
                           GenerateTypeAgnosticVarBinaryBase<BinaryJoinElementWise>(ty),
@@ -3412,7 +3412,7 @@ const FunctionDoc binary_repeat_doc(
 
 void AddAsciiStringRepeat(FunctionRegistry* registry) {
   auto func = std::make_shared<ScalarCTypeToInt64Function>(
-      "binary_repeat", Arity::Binary(), &binary_repeat_doc);
+      "binary_repeat", Arity::Binary(), binary_repeat_doc);
   for (const auto& ty : BaseBinaryTypes()) {
     auto exec = GenerateVarBinaryToVarBinary<BinaryRepeat, Int64Type>(ty);
     ScalarKernel kernel{{ty, int64()}, ty, exec};
diff --git a/cpp/src/arrow/compute/kernels/scalar_string_internal.h b/cpp/src/arrow/compute/kernels/scalar_string_internal.h
index a60c3d1ae2e..3d3f030f3ba 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_internal.h
+++ b/cpp/src/arrow/compute/kernels/scalar_string_internal.h
@@ -171,9 +171,9 @@ struct StringTransformExecWithState
 
 template <template <typename> class ExecFunctor>
 void MakeUnaryStringBatchKernel(
-    std::string name, FunctionRegistry* registry, const FunctionDoc* doc,
+    std::string name, FunctionRegistry* registry, FunctionDoc doc,
     MemAllocation::type mem_allocation = MemAllocation::PREALLOCATE) {
-  auto func = std::make_shared<ScalarFunction>(name, Arity::Unary(), doc);
+  auto func = std::make_shared<ScalarFunction>(name, Arity::Unary(), std::move(doc));
   for (const auto& ty : StringTypes()) {
     auto exec = GenerateVarBinaryToVarBinary<ExecFunctor>(ty);
     ScalarKernel kernel{{ty}, ty, std::move(exec)};
@@ -185,9 +185,9 @@ void MakeUnaryStringBatchKernel(
 
 template <template <typename> class ExecFunctor>
 void MakeUnaryStringBatchKernelWithState(
-    std::string name, FunctionRegistry* registry, const FunctionDoc* doc,
+    std::string name, FunctionRegistry* registry, FunctionDoc doc,
     MemAllocation::type mem_allocation = MemAllocation::PREALLOCATE) {
-  auto func = std::make_shared<ScalarFunction>(name, Arity::Unary(), doc);
+  auto func = std::make_shared<ScalarFunction>(name, Arity::Unary(), std::move(doc));
   {
     using t32 = ExecFunctor<StringType>;
     ScalarKernel kernel{{utf8()}, utf8(), t32::Exec, t32::State::Init};
@@ -271,8 +271,8 @@ struct StringPredicateFunctor {
 
 template <typename Predicate>
 void AddUnaryStringPredicate(std::string name, FunctionRegistry* registry,
-                             const FunctionDoc* doc) {
-  auto func = std::make_shared<ScalarFunction>(name, Arity::Unary(), doc);
+                             FunctionDoc doc) {
+  auto func = std::make_shared<ScalarFunction>(name, Arity::Unary(), std::move(doc));
   for (const auto& ty : StringTypes()) {
     auto exec = GenerateVarBinaryToVarBinary<StringPredicateFunctor, Predicate>(ty);
     DCHECK_OK(func->AddKernel({ty}, boolean(), std::move(exec)));
diff --git a/cpp/src/arrow/compute/kernels/scalar_string_utf8.cc b/cpp/src/arrow/compute/kernels/scalar_string_utf8.cc
index 5f1178bbb1b..9e060127280 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_utf8.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_utf8.cc
@@ -39,8 +39,8 @@ namespace {
 
 template <template <typename> class Transformer>
 void MakeUnaryStringUTF8TransformKernel(std::string name, FunctionRegistry* registry,
-                                        const FunctionDoc* doc) {
-  auto func = std::make_shared<ScalarFunction>(name, Arity::Unary(), doc);
+                                        FunctionDoc doc) {
+  auto func = std::make_shared<ScalarFunction>(name, Arity::Unary(), std::move(doc));
   for (const auto& ty : StringTypes()) {
     auto exec = GenerateVarBinaryToVarBinary<Transformer>(ty);
     DCHECK_OK(func->AddKernel({ty}, ty, std::move(exec)));
@@ -319,19 +319,19 @@ const auto utf8_is_title_doc = StringPredicateDoc(
 
 void AddUtf8StringPredicates(FunctionRegistry* registry) {
   AddUnaryStringPredicate<IsAlphaNumericUnicode>("utf8_is_alnum", registry,
-                                                 &utf8_is_alnum_doc);
-  AddUnaryStringPredicate<IsAlphaUnicode>("utf8_is_alpha", registry, &utf8_is_alpha_doc);
+                                                 utf8_is_alnum_doc);
+  AddUnaryStringPredicate<IsAlphaUnicode>("utf8_is_alpha", registry, utf8_is_alpha_doc);
   AddUnaryStringPredicate<IsDecimalUnicode>("utf8_is_decimal", registry,
-                                            &utf8_is_decimal_doc);
-  AddUnaryStringPredicate<IsDigitUnicode>("utf8_is_digit", registry, &utf8_is_digit_doc);
+                                            utf8_is_decimal_doc);
+  AddUnaryStringPredicate<IsDigitUnicode>("utf8_is_digit", registry, utf8_is_digit_doc);
   AddUnaryStringPredicate<IsNumericUnicode>("utf8_is_numeric", registry,
-                                            &utf8_is_numeric_doc);
-  AddUnaryStringPredicate<IsLowerUnicode>("utf8_is_lower", registry, &utf8_is_lower_doc);
+                                            utf8_is_numeric_doc);
+  AddUnaryStringPredicate<IsLowerUnicode>("utf8_is_lower", registry, utf8_is_lower_doc);
   AddUnaryStringPredicate<IsPrintableUnicode>("utf8_is_printable", registry,
-                                              &utf8_is_printable_doc);
-  AddUnaryStringPredicate<IsSpaceUnicode>("utf8_is_space", registry, &utf8_is_space_doc);
-  AddUnaryStringPredicate<IsTitleUnicode>("utf8_is_title", registry, &utf8_is_title_doc);
-  AddUnaryStringPredicate<IsUpperUnicode>("utf8_is_upper", registry, &utf8_is_upper_doc);
+                                              utf8_is_printable_doc);
+  AddUnaryStringPredicate<IsSpaceUnicode>("utf8_is_space", registry, utf8_is_space_doc);
+  AddUnaryStringPredicate<IsTitleUnicode>("utf8_is_title", registry, utf8_is_title_doc);
+  AddUnaryStringPredicate<IsUpperUnicode>("utf8_is_upper", registry, utf8_is_upper_doc);
 }
 
 #endif  // ARROW_WITH_UTF8PROC
@@ -501,13 +501,13 @@ const FunctionDoc utf8_title_doc(
     {"strings"});
 
 void AddUtf8StringCaseConversion(FunctionRegistry* registry) {
-  MakeUnaryStringUTF8TransformKernel<UTF8Upper>("utf8_upper", registry, &utf8_upper_doc);
-  MakeUnaryStringUTF8TransformKernel<UTF8Lower>("utf8_lower", registry, &utf8_lower_doc);
+  MakeUnaryStringUTF8TransformKernel<UTF8Upper>("utf8_upper", registry, utf8_upper_doc);
+  MakeUnaryStringUTF8TransformKernel<UTF8Lower>("utf8_lower", registry, utf8_lower_doc);
   MakeUnaryStringUTF8TransformKernel<UTF8SwapCase>("utf8_swapcase", registry,
-                                                   &utf8_swapcase_doc);
+                                                   utf8_swapcase_doc);
   MakeUnaryStringBatchKernel<Utf8Capitalize>("utf8_capitalize", registry,
-                                             &utf8_capitalize_doc);
-  MakeUnaryStringBatchKernel<Utf8Title>("utf8_title", registry, &utf8_title_doc);
+                                             utf8_capitalize_doc);
+  MakeUnaryStringBatchKernel<Utf8Title>("utf8_title", registry, utf8_title_doc);
 }
 
 #endif  // ARROW_WITH_UTF8PROC
@@ -667,7 +667,7 @@ const FunctionDoc utf8_normalize_doc(
 
 void AddUtf8StringNormalize(FunctionRegistry* registry) {
   MakeUnaryStringBatchKernelWithState<Utf8NormalizeExec>("utf8_normalize", registry,
-                                                         &utf8_normalize_doc);
+                                                         utf8_normalize_doc);
 }
 
 #endif  // ARROW_WITH_UTF8PROC
@@ -692,7 +692,7 @@ const FunctionDoc utf8_length_doc(
 
 void AddUtf8StringLength(FunctionRegistry* registry) {
   auto func =
-      std::make_shared<ScalarFunction>("utf8_length", Arity::Unary(), &utf8_length_doc);
+      std::make_shared<ScalarFunction>("utf8_length", Arity::Unary(), utf8_length_doc);
   {
     auto exec = applicator::ScalarUnaryNotNull<Int32Type, StringType, Utf8Length>::Exec;
     DCHECK_OK(func->AddKernel({utf8()}, int32(), std::move(exec)));
@@ -734,7 +734,7 @@ const FunctionDoc utf8_reverse_doc(
     {"strings"});
 
 void AddUtf8StringReverse(FunctionRegistry* registry) {
-  MakeUnaryStringBatchKernel<Utf8Reverse>("utf8_reverse", registry, &utf8_reverse_doc);
+  MakeUnaryStringBatchKernel<Utf8Reverse>("utf8_reverse", registry, utf8_reverse_doc);
 }
 
 // ----------------------------------------------------------------------
@@ -896,16 +896,16 @@ const FunctionDoc utf8_rtrim_whitespace_doc(
 #endif  // ARROW_WITH_UTF8PROC
 
 void AddUtf8StringTrim(FunctionRegistry* registry) {
-  MakeUnaryStringBatchKernelWithState<UTF8Trim>("utf8_trim", registry, &utf8_trim_doc);
-  MakeUnaryStringBatchKernelWithState<UTF8LTrim>("utf8_ltrim", registry, &utf8_ltrim_doc);
-  MakeUnaryStringBatchKernelWithState<UTF8RTrim>("utf8_rtrim", registry, &utf8_rtrim_doc);
+  MakeUnaryStringBatchKernelWithState<UTF8Trim>("utf8_trim", registry, utf8_trim_doc);
+  MakeUnaryStringBatchKernelWithState<UTF8LTrim>("utf8_ltrim", registry, utf8_ltrim_doc);
+  MakeUnaryStringBatchKernelWithState<UTF8RTrim>("utf8_rtrim", registry, utf8_rtrim_doc);
 #ifdef ARROW_WITH_UTF8PROC
   MakeUnaryStringBatchKernel<UTF8TrimWhitespace>("utf8_trim_whitespace", registry,
-                                                 &utf8_trim_whitespace_doc);
+                                                 utf8_trim_whitespace_doc);
   MakeUnaryStringBatchKernel<UTF8LTrimWhitespace>("utf8_ltrim_whitespace", registry,
-                                                  &utf8_ltrim_whitespace_doc);
+                                                  utf8_ltrim_whitespace_doc);
   MakeUnaryStringBatchKernel<UTF8RTrimWhitespace>("utf8_rtrim_whitespace", registry,
-                                                  &utf8_rtrim_whitespace_doc);
+                                                  utf8_rtrim_whitespace_doc);
 #endif  // ARROW_WITH_UTF8PROC
 }
 
@@ -1002,10 +1002,10 @@ const FunctionDoc utf8_rpad_doc(
     {"strings"}, "PadOptions", /*options_required=*/true);
 
 void AddUtf8StringPad(FunctionRegistry* registry) {
-  MakeUnaryStringBatchKernelWithState<Utf8LPad>("utf8_lpad", registry, &utf8_lpad_doc);
-  MakeUnaryStringBatchKernelWithState<Utf8RPad>("utf8_rpad", registry, &utf8_rpad_doc);
+  MakeUnaryStringBatchKernelWithState<Utf8LPad>("utf8_lpad", registry, utf8_lpad_doc);
+  MakeUnaryStringBatchKernelWithState<Utf8RPad>("utf8_rpad", registry, utf8_rpad_doc);
   MakeUnaryStringBatchKernelWithState<Utf8Center>("utf8_center", registry,
-                                                  &utf8_center_doc);
+                                                  utf8_center_doc);
 }
 
 // ----------------------------------------------------------------------
@@ -1089,7 +1089,7 @@ const FunctionDoc utf8_replace_slice_doc(
 
 void AddUtf8StringReplaceSlice(FunctionRegistry* registry) {
   auto func = std::make_shared<ScalarFunction>("utf8_replace_slice", Arity::Unary(),
-                                               &utf8_replace_slice_doc);
+                                               utf8_replace_slice_doc);
 
   for (const auto& ty : StringTypes()) {
     auto exec = GenerateVarBinaryToVarBinary<Utf8ReplaceSlice>(ty);
@@ -1278,7 +1278,7 @@ const FunctionDoc utf8_slice_codeunits_doc(
 
 void AddUtf8StringSlice(FunctionRegistry* registry) {
   auto func = std::make_shared<ScalarFunction>("utf8_slice_codeunits", Arity::Unary(),
-                                               &utf8_slice_codeunits_doc);
+                                               utf8_slice_codeunits_doc);
   for (const auto& ty : StringTypes()) {
     auto exec = GenerateVarBinaryToVarBinary<SliceCodeunits>(ty);
     DCHECK_OK(
@@ -1364,7 +1364,7 @@ void AddUtf8StringSplitWhitespace(FunctionRegistry* registry) {
   static const SplitOptions default_options;
   auto func =
       std::make_shared<ScalarFunction>("utf8_split_whitespace", Arity::Unary(),
-                                       &utf8_split_whitespace_doc, &default_options);
+                                       utf8_split_whitespace_doc, &default_options);
   for (const auto& ty : StringTypes()) {
     auto exec = GenerateVarBinaryToVarBinary<SplitWhitespaceUtf8Exec, ListType>(ty);
     DCHECK_OK(func->AddKernel({ty}, {list(ty)}, std::move(exec), StringSplitState::Init));
diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal_binary.cc b/cpp/src/arrow/compute/kernels/scalar_temporal_binary.cc
index e73c89857b5..90d21273e78 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal_binary.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal_binary.cc
@@ -326,12 +326,13 @@ struct BinaryTemporalFactory {
 
   template <typename... WithTypes>
   static std::shared_ptr<ScalarFunction> Make(
-      std::string name, OutputType out_type, const FunctionDoc* doc,
+      std::string name, OutputType out_type, FunctionDoc doc,
       const FunctionOptions* default_options = NULLPTR, KernelInit init = NULLPTR) {
     DCHECK_NE(sizeof...(WithTypes), 0);
     BinaryTemporalFactory self{
         out_type, init,
-        std::make_shared<ScalarFunction>(name, Arity::Binary(), doc, default_options)};
+        std::make_shared<ScalarFunction>(name, Arity::Binary(), std::move(doc),
+                                         default_options)};
     AddTemporalKernels(&self, WithTypes{}...);
     return self.func;
   }
@@ -458,18 +459,18 @@ void RegisterScalarTemporalBinary(FunctionRegistry* registry) {
   // Temporal difference functions
   auto years_between =
       BinaryTemporalFactory<YearsBetween, TemporalBinary, Int64Type>::Make<
-          WithDates, WithTimestamps>("years_between", int64(), &years_between_doc);
+          WithDates, WithTimestamps>("years_between", int64(), years_between_doc);
   DCHECK_OK(registry->AddFunction(std::move(years_between)));
 
   auto quarters_between =
       BinaryTemporalFactory<QuartersBetween, TemporalBinary, Int64Type>::Make<
-          WithDates, WithTimestamps>("quarters_between", int64(), &quarters_between_doc);
+          WithDates, WithTimestamps>("quarters_between", int64(), quarters_between_doc);
   DCHECK_OK(registry->AddFunction(std::move(quarters_between)));
 
   auto month_interval_between =
       BinaryTemporalFactory<MonthsBetween, TemporalBinary, MonthIntervalType>::Make<
           WithDates, WithTimestamps>("month_interval_between", month_interval(),
-                                     &months_between_doc);
+                                     months_between_doc);
   DCHECK_OK(registry->AddFunction(std::move(month_interval_between)));
 
   auto month_day_nano_interval_between =
@@ -477,13 +478,13 @@ void RegisterScalarTemporalBinary(FunctionRegistry* registry) {
                             MonthDayNanoIntervalType>::Make<WithDates, WithTimes,
                                                             WithTimestamps>(
           "month_day_nano_interval_between", month_day_nano_interval(),
-          &month_day_nano_interval_between_doc);
+          month_day_nano_interval_between_doc);
   DCHECK_OK(registry->AddFunction(std::move(month_day_nano_interval_between)));
 
   static const auto default_day_of_week_options = DayOfWeekOptions::Defaults();
   auto weeks_between =
       BinaryTemporalFactory<WeeksBetween, TemporalDayOfWeekBinary, Int64Type>::Make<
-          WithDates, WithTimestamps>("weeks_between", int64(), &weeks_between_doc,
+          WithDates, WithTimestamps>("weeks_between", int64(), weeks_between_doc,
                                      &default_day_of_week_options, DayOfWeekState::Init);
   DCHECK_OK(registry->AddFunction(std::move(weeks_between)));
 
@@ -491,49 +492,49 @@ void RegisterScalarTemporalBinary(FunctionRegistry* registry) {
       BinaryTemporalFactory<DayTimeBetween, TemporalBinary, DayTimeIntervalType>::Make<
           WithDates, WithTimes, WithTimestamps>("day_time_interval_between",
                                                 day_time_interval(),
-                                                &day_time_interval_between_doc);
+                                                day_time_interval_between_doc);
   DCHECK_OK(registry->AddFunction(std::move(day_time_interval_between)));
 
   auto days_between =
       BinaryTemporalFactory<DaysBetween, TemporalBinary, Int64Type>::Make<WithDates,
                                                                           WithTimestamps>(
-          "days_between", int64(), &days_between_doc);
+          "days_between", int64(), days_between_doc);
   DCHECK_OK(registry->AddFunction(std::move(days_between)));
 
   auto hours_between =
       BinaryTemporalFactory<HoursBetween, TemporalBinary, Int64Type>::Make<
           WithDates, WithTimes, WithTimestamps>("hours_between", int64(),
-                                                &hours_between_doc);
+                                                hours_between_doc);
   DCHECK_OK(registry->AddFunction(std::move(hours_between)));
 
   auto minutes_between =
       BinaryTemporalFactory<MinutesBetween, TemporalBinary, Int64Type>::Make<
           WithDates, WithTimes, WithTimestamps>("minutes_between", int64(),
-                                                &minutes_between_doc);
+                                                minutes_between_doc);
   DCHECK_OK(registry->AddFunction(std::move(minutes_between)));
 
   auto seconds_between =
       BinaryTemporalFactory<SecondsBetween, TemporalBinary, Int64Type>::Make<
           WithDates, WithTimes, WithTimestamps>("seconds_between", int64(),
-                                                &seconds_between_doc);
+                                                seconds_between_doc);
   DCHECK_OK(registry->AddFunction(std::move(seconds_between)));
 
   auto milliseconds_between =
       BinaryTemporalFactory<MillisecondsBetween, TemporalBinary, Int64Type>::Make<
           WithDates, WithTimes, WithTimestamps>("milliseconds_between", int64(),
-                                                &milliseconds_between_doc);
+                                                milliseconds_between_doc);
   DCHECK_OK(registry->AddFunction(std::move(milliseconds_between)));
 
   auto microseconds_between =
       BinaryTemporalFactory<MicrosecondsBetween, TemporalBinary, Int64Type>::Make<
           WithDates, WithTimes, WithTimestamps>("microseconds_between", int64(),
-                                                &microseconds_between_doc);
+                                                microseconds_between_doc);
   DCHECK_OK(registry->AddFunction(std::move(microseconds_between)));
 
   auto nanoseconds_between =
       BinaryTemporalFactory<NanosecondsBetween, TemporalBinary, Int64Type>::Make<
           WithDates, WithTimes, WithTimestamps>("nanoseconds_between", int64(),
-                                                &nanoseconds_between_doc);
+                                                nanoseconds_between_doc);
   DCHECK_OK(registry->AddFunction(std::move(nanoseconds_between)));
 }
 
diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal_unary.cc b/cpp/src/arrow/compute/kernels/scalar_temporal_unary.cc
index 8df24f733f0..7484de2a005 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal_unary.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal_unary.cc
@@ -1474,12 +1474,12 @@ struct UnaryTemporalFactory {
 
   template <typename... WithTypes>
   static std::shared_ptr<ScalarFunction> Make(
-      std::string name, OutputType out_type, const FunctionDoc* doc,
+      std::string name, OutputType out_type, FunctionDoc doc,
       const FunctionOptions* default_options = NULLPTR, KernelInit init = NULLPTR) {
     DCHECK_NE(sizeof...(WithTypes), 0);
-    UnaryTemporalFactory self{
-        out_type, init,
-        std::make_shared<ScalarFunction>(name, Arity::Unary(), doc, default_options)};
+    UnaryTemporalFactory self{out_type, init,
+                              std::make_shared<ScalarFunction>(
+                                  name, Arity::Unary(), std::move(doc), default_options)};
     AddTemporalKernels(&self, WithTypes{}...);
     return self.func;
   }
@@ -1499,12 +1499,13 @@ struct SimpleUnaryTemporalFactory {
 
   template <typename... WithTypes>
   static std::shared_ptr<ScalarFunction> Make(
-      std::string name, OutputType out_type, const FunctionDoc* doc,
+      std::string name, OutputType out_type, FunctionDoc doc,
       const FunctionOptions* default_options = NULLPTR, KernelInit init = NULLPTR) {
     DCHECK_NE(sizeof...(WithTypes), 0);
     SimpleUnaryTemporalFactory self{
         out_type, init,
-        std::make_shared<ScalarFunction>(name, Arity::Unary(), doc, default_options)};
+        std::make_shared<ScalarFunction>(name, Arity::Unary(), std::move(doc),
+                                         default_options)};
     AddTemporalKernels(&self, WithTypes{}...);
     return self.func;
   }
@@ -1763,35 +1764,35 @@ void RegisterScalarTemporalUnary(FunctionRegistry* registry) {
   auto year =
       UnaryTemporalFactory<Year, TemporalComponentExtract,
                            Int64Type>::Make<WithDates, WithTimestamps>("year", int64(),
-                                                                       &year_doc);
+                                                                       year_doc);
   DCHECK_OK(registry->AddFunction(std::move(year)));
 
   auto is_leap_year =
       UnaryTemporalFactory<IsLeapYear, TemporalComponentExtract, BooleanType>::Make<
-          WithDates, WithTimestamps>("is_leap_year", boolean(), &is_leap_year_doc);
+          WithDates, WithTimestamps>("is_leap_year", boolean(), is_leap_year_doc);
   DCHECK_OK(registry->AddFunction(std::move(is_leap_year)));
 
   auto month =
       UnaryTemporalFactory<Month, TemporalComponentExtract,
                            Int64Type>::Make<WithDates, WithTimestamps>("month", int64(),
-                                                                       &month_doc);
+                                                                       month_doc);
   DCHECK_OK(registry->AddFunction(std::move(month)));
 
   auto day =
       UnaryTemporalFactory<Day, TemporalComponentExtract,
                            Int64Type>::Make<WithDates, WithTimestamps>("day", int64(),
-                                                                       &day_doc);
+                                                                       day_doc);
   DCHECK_OK(registry->AddFunction(std::move(day)));
 
   auto year_month_day =
       SimpleUnaryTemporalFactory<YearMonthDay>::Make<WithDates, WithTimestamps>(
-          "year_month_day", YearMonthDayType(), &year_month_day_doc);
+          "year_month_day", YearMonthDayType(), year_month_day_doc);
   DCHECK_OK(registry->AddFunction(std::move(year_month_day)));
 
   static const auto default_day_of_week_options = DayOfWeekOptions::Defaults();
   auto day_of_week =
       UnaryTemporalFactory<DayOfWeek, TemporalComponentExtractDayOfWeek, Int64Type>::Make<
-          WithDates, WithTimestamps>("day_of_week", int64(), &day_of_week_doc,
+          WithDates, WithTimestamps>("day_of_week", int64(), day_of_week_doc,
                                      &default_day_of_week_options, DayOfWeekState::Init);
   DCHECK_OK(registry->AddFunction(std::move(day_of_week)));
 
@@ -1799,110 +1800,110 @@ void RegisterScalarTemporalUnary(FunctionRegistry* registry) {
       UnaryTemporalFactory<DayOfYear, TemporalComponentExtract,
                            Int64Type>::Make<WithDates, WithTimestamps>("day_of_year",
                                                                        int64(),
-                                                                       &day_of_year_doc);
+                                                                       day_of_year_doc);
   DCHECK_OK(registry->AddFunction(std::move(day_of_year)));
 
   auto iso_year =
       UnaryTemporalFactory<ISOYear, TemporalComponentExtract,
                            Int64Type>::Make<WithDates, WithTimestamps>("iso_year",
                                                                        int64(),
-                                                                       &iso_year_doc);
+                                                                       iso_year_doc);
   DCHECK_OK(registry->AddFunction(std::move(iso_year)));
 
   auto us_year =
       UnaryTemporalFactory<USYear, TemporalComponentExtract,
                            Int64Type>::Make<WithDates, WithTimestamps>("us_year", int64(),
-                                                                       &us_year_doc);
+                                                                       us_year_doc);
   DCHECK_OK(registry->AddFunction(std::move(us_year)));
 
   static const auto default_iso_week_options = WeekOptions::ISODefaults();
   auto iso_week =
       UnaryTemporalFactory<Week, TemporalComponentExtractWeek, Int64Type>::Make<
-          WithDates, WithTimestamps>("iso_week", int64(), &iso_week_doc,
+          WithDates, WithTimestamps>("iso_week", int64(), iso_week_doc,
                                      &default_iso_week_options, WeekState::Init);
   DCHECK_OK(registry->AddFunction(std::move(iso_week)));
 
   static const auto default_us_week_options = WeekOptions::USDefaults();
   auto us_week =
       UnaryTemporalFactory<Week, TemporalComponentExtractWeek, Int64Type>::Make<
-          WithDates, WithTimestamps>("us_week", int64(), &us_week_doc,
+          WithDates, WithTimestamps>("us_week", int64(), us_week_doc,
                                      &default_us_week_options, WeekState::Init);
   DCHECK_OK(registry->AddFunction(std::move(us_week)));
 
   static const auto default_week_options = WeekOptions();
   auto week = UnaryTemporalFactory<Week, TemporalComponentExtractWeek, Int64Type>::Make<
-      WithDates, WithTimestamps>("week", int64(), &week_doc, &default_week_options,
+      WithDates, WithTimestamps>("week", int64(), week_doc, &default_week_options,
                                  WeekState::Init);
   DCHECK_OK(registry->AddFunction(std::move(week)));
 
   auto iso_calendar =
       SimpleUnaryTemporalFactory<ISOCalendar>::Make<WithDates, WithTimestamps>(
-          "iso_calendar", IsoCalendarType(), &iso_calendar_doc);
+          "iso_calendar", IsoCalendarType(), iso_calendar_doc);
   DCHECK_OK(registry->AddFunction(std::move(iso_calendar)));
 
   auto quarter =
       UnaryTemporalFactory<Quarter, TemporalComponentExtract,
                            Int64Type>::Make<WithDates, WithTimestamps>("quarter", int64(),
-                                                                       &quarter_doc);
+                                                                       quarter_doc);
   DCHECK_OK(registry->AddFunction(std::move(quarter)));
 
   // Date / time extractors
   auto hour =
       UnaryTemporalFactory<Hour, TemporalComponentExtract,
                            Int64Type>::Make<WithTimes, WithTimestamps>("hour", int64(),
-                                                                       &hour_doc);
+                                                                       hour_doc);
   DCHECK_OK(registry->AddFunction(std::move(hour)));
 
   auto minute =
       UnaryTemporalFactory<Minute, TemporalComponentExtract,
                            Int64Type>::Make<WithTimes, WithTimestamps>("minute", int64(),
-                                                                       &minute_doc);
+                                                                       minute_doc);
   DCHECK_OK(registry->AddFunction(std::move(minute)));
 
   auto second =
       UnaryTemporalFactory<Second, TemporalComponentExtract,
                            Int64Type>::Make<WithTimes, WithTimestamps>("second", int64(),
-                                                                       &second_doc);
+                                                                       second_doc);
   DCHECK_OK(registry->AddFunction(std::move(second)));
 
   auto millisecond =
       UnaryTemporalFactory<Millisecond, TemporalComponentExtract,
                            Int64Type>::Make<WithTimes, WithTimestamps>("millisecond",
                                                                        int64(),
-                                                                       &millisecond_doc);
+                                                                       millisecond_doc);
   DCHECK_OK(registry->AddFunction(std::move(millisecond)));
 
   auto microsecond =
       UnaryTemporalFactory<Microsecond, TemporalComponentExtract,
                            Int64Type>::Make<WithTimes, WithTimestamps>("microsecond",
                                                                        int64(),
-                                                                       &microsecond_doc);
+                                                                       microsecond_doc);
   DCHECK_OK(registry->AddFunction(std::move(microsecond)));
 
   auto nanosecond =
       UnaryTemporalFactory<Nanosecond, TemporalComponentExtract,
                            Int64Type>::Make<WithTimes, WithTimestamps>("nanosecond",
                                                                        int64(),
-                                                                       &nanosecond_doc);
+                                                                       nanosecond_doc);
   DCHECK_OK(registry->AddFunction(std::move(nanosecond)));
 
   auto subsecond =
       UnaryTemporalFactory<Subsecond, TemporalComponentExtract,
                            DoubleType>::Make<WithTimes, WithTimestamps>("subsecond",
                                                                         float64(),
-                                                                        &subsecond_doc);
+                                                                        subsecond_doc);
   DCHECK_OK(registry->AddFunction(std::move(subsecond)));
 
   // Timezone-related functions
   static const auto default_strftime_options = StrftimeOptions();
   auto strftime =
       SimpleUnaryTemporalFactory<Strftime>::Make<WithTimes, WithDates, WithTimestamps>(
-          "strftime", utf8(), &strftime_doc, &default_strftime_options,
+          "strftime", utf8(), strftime_doc, &default_strftime_options,
           StrftimeState::Init);
   DCHECK_OK(registry->AddFunction(std::move(strftime)));
 
   auto strptime = SimpleUnaryTemporalFactory<Strptime>::Make<WithStringTypes>(
-      "strptime", OutputType::Resolver(ResolveStrptimeOutput), &strptime_doc, nullptr,
+      "strptime", OutputType::Resolver(ResolveStrptimeOutput), strptime_doc, nullptr,
       StrptimeState::Init);
   DCHECK_OK(registry->AddFunction(std::move(strptime)));
 
@@ -1910,13 +1911,13 @@ void RegisterScalarTemporalUnary(FunctionRegistry* registry) {
       UnaryTemporalFactory<AssumeTimezone, AssumeTimezoneExtractor, TimestampType>::Make<
           WithTimestamps>("assume_timezone",
                           OutputType::Resolver(ResolveAssumeTimezoneOutput),
-                          &assume_timezone_doc, nullptr, AssumeTimezoneState::Init);
+                          assume_timezone_doc, nullptr, AssumeTimezoneState::Init);
   DCHECK_OK(registry->AddFunction(std::move(assume_timezone)));
 
   auto is_dst =
       UnaryTemporalFactory<IsDaylightSavings, DaylightSavingsExtractor,
                            BooleanType>::Make<WithTimestamps>("is_dst", boolean(),
-                                                              &is_dst_doc);
+                                                              is_dst_doc);
   DCHECK_OK(registry->AddFunction(std::move(is_dst)));
 
   // Temporal rounding functions
@@ -1924,19 +1925,19 @@ void RegisterScalarTemporalUnary(FunctionRegistry* registry) {
   auto floor_temporal = UnaryTemporalFactory<FloorTemporal, TemporalComponentExtractRound,
                                              TimestampType>::Make<WithDates, WithTimes,
                                                                   WithTimestamps>(
-      "floor_temporal", OutputType(FirstType), &floor_temporal_doc,
+      "floor_temporal", OutputType(FirstType), floor_temporal_doc,
       &default_round_temporal_options, RoundTemporalState::Init);
   DCHECK_OK(registry->AddFunction(std::move(floor_temporal)));
   auto ceil_temporal = UnaryTemporalFactory<CeilTemporal, TemporalComponentExtractRound,
                                             TimestampType>::Make<WithDates, WithTimes,
                                                                  WithTimestamps>(
-      "ceil_temporal", OutputType(FirstType), &ceil_temporal_doc,
+      "ceil_temporal", OutputType(FirstType), ceil_temporal_doc,
       &default_round_temporal_options, RoundTemporalState::Init);
   DCHECK_OK(registry->AddFunction(std::move(ceil_temporal)));
   auto round_temporal = UnaryTemporalFactory<RoundTemporal, TemporalComponentExtractRound,
                                              TimestampType>::Make<WithDates, WithTimes,
                                                                   WithTimestamps>(
-      "round_temporal", OutputType(FirstType), &round_temporal_doc,
+      "round_temporal", OutputType(FirstType), round_temporal_doc,
       &default_round_temporal_options, RoundTemporalState::Init);
   DCHECK_OK(registry->AddFunction(std::move(round_temporal)));
 }
diff --git a/cpp/src/arrow/compute/kernels/scalar_validity.cc b/cpp/src/arrow/compute/kernels/scalar_validity.cc
index ff16e9d9355..1b6eb3d6483 100644
--- a/cpp/src/arrow/compute/kernels/scalar_validity.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_validity.cc
@@ -185,15 +185,15 @@ struct IsNanOperator {
   }
 };
 
-void MakeFunction(std::string name, const FunctionDoc* doc,
-                  std::vector<InputType> in_types, OutputType out_type,
-                  ArrayKernelExec exec, FunctionRegistry* registry,
+void MakeFunction(std::string name, FunctionDoc doc, std::vector<InputType> in_types,
+                  OutputType out_type, ArrayKernelExec exec, FunctionRegistry* registry,
                   MemAllocation::type mem_allocation, NullHandling::type null_handling,
                   bool can_write_into_slices,
                   const FunctionOptions* default_options = NULLPTR,
                   KernelInit init = NULLPTR) {
   Arity arity{static_cast<int>(in_types.size())};
-  auto func = std::make_shared<ScalarFunction>(name, arity, doc, default_options);
+  auto func =
+      std::make_shared<ScalarFunction>(name, arity, std::move(doc), default_options);
 
   ScalarKernel kernel(std::move(in_types), out_type, exec, init);
   kernel.null_handling = null_handling;
@@ -222,9 +222,8 @@ Status ConstBoolExec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
   return Status::OK();
 }
 
-std::shared_ptr<ScalarFunction> MakeIsFiniteFunction(std::string name,
-                                                     const FunctionDoc* doc) {
-  auto func = std::make_shared<ScalarFunction>(name, Arity::Unary(), doc);
+std::shared_ptr<ScalarFunction> MakeIsFiniteFunction(std::string name, FunctionDoc doc) {
+  auto func = std::make_shared<ScalarFunction>(name, Arity::Unary(), std::move(doc));
 
   AddFloatValidityKernel<FloatType, IsFiniteOperator>(float32(), func.get());
   AddFloatValidityKernel<DoubleType, IsFiniteOperator>(float64(), func.get());
@@ -241,9 +240,8 @@ std::shared_ptr<ScalarFunction> MakeIsFiniteFunction(std::string name,
   return func;
 }
 
-std::shared_ptr<ScalarFunction> MakeIsInfFunction(std::string name,
-                                                  const FunctionDoc* doc) {
-  auto func = std::make_shared<ScalarFunction>(name, Arity::Unary(), doc);
+std::shared_ptr<ScalarFunction> MakeIsInfFunction(std::string name, FunctionDoc doc) {
+  auto func = std::make_shared<ScalarFunction>(name, Arity::Unary(), std::move(doc));
 
   AddFloatValidityKernel<FloatType, IsInfOperator>(float32(), func.get());
   AddFloatValidityKernel<DoubleType, IsInfOperator>(float64(), func.get());
@@ -260,9 +258,8 @@ std::shared_ptr<ScalarFunction> MakeIsInfFunction(std::string name,
   return func;
 }
 
-std::shared_ptr<ScalarFunction> MakeIsNanFunction(std::string name,
-                                                  const FunctionDoc* doc) {
-  auto func = std::make_shared<ScalarFunction>(name, Arity::Unary(), doc);
+std::shared_ptr<ScalarFunction> MakeIsNanFunction(std::string name, FunctionDoc doc) {
+  auto func = std::make_shared<ScalarFunction>(name, Arity::Unary(), std::move(doc));
 
   AddFloatValidityKernel<FloatType, IsNanOperator>(float32(), func.get());
   AddFloatValidityKernel<DoubleType, IsNanOperator>(float64(), func.get());
@@ -339,22 +336,22 @@ const FunctionDoc is_nan_doc("Return true if NaN",
 
 void RegisterScalarValidity(FunctionRegistry* registry) {
   static auto kNullOptions = NullOptions::Defaults();
-  MakeFunction("is_valid", &is_valid_doc, {ValueDescr::ANY}, boolean(), IsValidExec,
+  MakeFunction("is_valid", is_valid_doc, {ValueDescr::ANY}, boolean(), IsValidExec,
                registry, MemAllocation::NO_PREALLOCATE, NullHandling::OUTPUT_NOT_NULL,
                /*can_write_into_slices=*/false);
 
-  MakeFunction("is_null", &is_null_doc, {ValueDescr::ANY}, boolean(), IsNullExec,
-               registry, MemAllocation::PREALLOCATE, NullHandling::OUTPUT_NOT_NULL,
+  MakeFunction("is_null", is_null_doc, {ValueDescr::ANY}, boolean(), IsNullExec, registry,
+               MemAllocation::PREALLOCATE, NullHandling::OUTPUT_NOT_NULL,
                /*can_write_into_slices=*/true, &kNullOptions, NanOptionsState::Init);
 
-  MakeFunction("true_unless_null", &true_unless_null_doc, {ValueDescr::ANY}, boolean(),
+  MakeFunction("true_unless_null", true_unless_null_doc, {ValueDescr::ANY}, boolean(),
                TrueUnlessNullExec, registry, MemAllocation::NO_PREALLOCATE,
                NullHandling::INTERSECTION,
                /*can_write_into_slices=*/false);
 
-  DCHECK_OK(registry->AddFunction(MakeIsFiniteFunction("is_finite", &is_finite_doc)));
-  DCHECK_OK(registry->AddFunction(MakeIsInfFunction("is_inf", &is_inf_doc)));
-  DCHECK_OK(registry->AddFunction(MakeIsNanFunction("is_nan", &is_nan_doc)));
+  DCHECK_OK(registry->AddFunction(MakeIsFiniteFunction("is_finite", is_finite_doc)));
+  DCHECK_OK(registry->AddFunction(MakeIsInfFunction("is_inf", is_inf_doc)));
+  DCHECK_OK(registry->AddFunction(MakeIsNanFunction("is_nan", is_nan_doc)));
 }
 
 }  // namespace internal
diff --git a/cpp/src/arrow/compute/kernels/vector_array_sort.cc b/cpp/src/arrow/compute/kernels/vector_array_sort.cc
index 1335882a252..ac4fe443d3e 100644
--- a/cpp/src/arrow/compute/kernels/vector_array_sort.cc
+++ b/cpp/src/arrow/compute/kernels/vector_array_sort.cc
@@ -555,7 +555,7 @@ void RegisterVectorArraySort(FunctionRegistry* registry) {
   base.can_execute_chunkwise = false;
 
   auto array_sort_indices = std::make_shared<VectorFunction>(
-      "array_sort_indices", Arity::Unary(), &array_sort_indices_doc,
+      "array_sort_indices", Arity::Unary(), array_sort_indices_doc,
       GetDefaultArraySortOptions());
   base.init = ArraySortIndicesState::Init;
   AddArraySortingKernels<ArraySortIndices>(base, array_sort_indices.get());
@@ -563,7 +563,7 @@ void RegisterVectorArraySort(FunctionRegistry* registry) {
 
   // partition_nth_indices has a parameter so needs its init function
   auto part_indices = std::make_shared<VectorFunction>(
-      "partition_nth_indices", Arity::Unary(), &partition_nth_indices_doc);
+      "partition_nth_indices", Arity::Unary(), partition_nth_indices_doc);
   base.init = PartitionNthToIndicesState::Init;
   AddArraySortingKernels<PartitionNthToIndices>(base, part_indices.get());
   DCHECK_OK(registry->AddFunction(std::move(part_indices)));
diff --git a/cpp/src/arrow/compute/kernels/vector_hash.cc b/cpp/src/arrow/compute/kernels/vector_hash.cc
index 80fc29c94ad..fccd73e3990 100644
--- a/cpp/src/arrow/compute/kernels/vector_hash.cc
+++ b/cpp/src/arrow/compute/kernels/vector_hash.cc
@@ -758,7 +758,7 @@ void RegisterVectorHash(FunctionRegistry* registry) {
 
   base.finalize = UniqueFinalize;
   base.output_chunked = false;
-  auto unique = std::make_shared<VectorFunction>("unique", Arity::Unary(), &unique_doc);
+  auto unique = std::make_shared<VectorFunction>("unique", Arity::Unary(), unique_doc);
   AddHashKernels<UniqueAction>(unique.get(), base, OutputType(FirstType));
 
   // Dictionary unique
@@ -775,7 +775,7 @@ void RegisterVectorHash(FunctionRegistry* registry) {
 
   base.finalize = ValueCountsFinalize;
   auto value_counts =
-      std::make_shared<VectorFunction>("value_counts", Arity::Unary(), &value_counts_doc);
+      std::make_shared<VectorFunction>("value_counts", Arity::Unary(), value_counts_doc);
   AddHashKernels<ValueCountsAction>(value_counts.get(), base,
                                     OutputType(ValueCountsOutput));
 
@@ -796,7 +796,7 @@ void RegisterVectorHash(FunctionRegistry* registry) {
   base.output_chunked = true;
 
   auto dict_encode = std::make_shared<VectorFunction>(
-      "dictionary_encode", Arity::Unary(), &dictionary_encode_doc,
+      "dictionary_encode", Arity::Unary(), dictionary_encode_doc,
       GetDefaultDictionaryEncodeOptions());
   AddHashKernels<DictEncodeAction>(dict_encode.get(), base, OutputType(DictEncodeOutput));
 
diff --git a/cpp/src/arrow/compute/kernels/vector_nested.cc b/cpp/src/arrow/compute/kernels/vector_nested.cc
index b5bba71793e..9cc1e72bdbc 100644
--- a/cpp/src/arrow/compute/kernels/vector_nested.cc
+++ b/cpp/src/arrow/compute/kernels/vector_nested.cc
@@ -122,7 +122,7 @@ const FunctionDoc list_parent_indices_doc(
 class ListParentIndicesFunction : public MetaFunction {
  public:
   ListParentIndicesFunction()
-      : MetaFunction("list_parent_indices", Arity::Unary(), &list_parent_indices_doc) {}
+      : MetaFunction("list_parent_indices", Arity::Unary(), list_parent_indices_doc) {}
 
   Result<Datum> ExecuteImpl(const std::vector<Datum>& args,
                             const FunctionOptions* options,
@@ -157,7 +157,7 @@ class ListParentIndicesFunction : public MetaFunction {
 
 void RegisterVectorNested(FunctionRegistry* registry) {
   auto flatten =
-      std::make_shared<VectorFunction>("list_flatten", Arity::Unary(), &list_flatten_doc);
+      std::make_shared<VectorFunction>("list_flatten", Arity::Unary(), list_flatten_doc);
   DCHECK_OK(flatten->AddKernel({InputType::Array(Type::LIST)}, OutputType(ListValuesType),
                                ListFlatten<ListType>));
   DCHECK_OK(flatten->AddKernel({InputType::Array(Type::FIXED_SIZE_LIST)},
diff --git a/cpp/src/arrow/compute/kernels/vector_replace.cc b/cpp/src/arrow/compute/kernels/vector_replace.cc
index 612e9e79747..294f6fe0408 100644
--- a/cpp/src/arrow/compute/kernels/vector_replace.cc
+++ b/cpp/src/arrow/compute/kernels/vector_replace.cc
@@ -899,17 +899,17 @@ const FunctionDoc fill_null_backward_doc(
 void RegisterVectorReplace(FunctionRegistry* registry) {
   {
     auto func = std::make_shared<VectorFunction>("replace_with_mask", Arity::Ternary(),
-                                                 &replace_with_mask_doc);
+                                                 replace_with_mask_doc);
     RegisterVectorFunction<ReplaceWithMaskFunctor>(registry, func);
   }
   {
     auto func = std::make_shared<VectorFunction>("fill_null_forward", Arity::Unary(),
-                                                 &fill_null_forward_doc);
+                                                 fill_null_forward_doc);
     RegisterVectorFunction<FillNullForwardFunctor>(registry, func);
   }
   {
     auto func = std::make_shared<VectorFunction>("fill_null_backward", Arity::Unary(),
-                                                 &fill_null_backward_doc);
+                                                 fill_null_backward_doc);
     RegisterVectorFunction<FillNullBackwardFunctor>(registry, func);
   }
 }
diff --git a/cpp/src/arrow/compute/kernels/vector_selection.cc b/cpp/src/arrow/compute/kernels/vector_selection.cc
index 32d639ec8f0..00c702f223e 100644
--- a/cpp/src/arrow/compute/kernels/vector_selection.cc
+++ b/cpp/src/arrow/compute/kernels/vector_selection.cc
@@ -1958,7 +1958,7 @@ const FunctionDoc filter_doc(
 class FilterMetaFunction : public MetaFunction {
  public:
   FilterMetaFunction()
-      : MetaFunction("filter", Arity::Binary(), &filter_doc, GetDefaultFilterOptions()) {}
+      : MetaFunction("filter", Arity::Binary(), filter_doc, GetDefaultFilterOptions()) {}
 
   Result<Datum> ExecuteImpl(const std::vector<Datum>& args,
                             const FunctionOptions* options,
@@ -2115,7 +2115,7 @@ const FunctionDoc take_doc(
 class TakeMetaFunction : public MetaFunction {
  public:
   TakeMetaFunction()
-      : MetaFunction("take", Arity::Binary(), &take_doc, GetDefaultTakeOptions()) {}
+      : MetaFunction("take", Arity::Binary(), take_doc, GetDefaultTakeOptions()) {}
 
   Result<Datum> ExecuteImpl(const std::vector<Datum>& args,
                             const FunctionOptions* options,
@@ -2276,7 +2276,7 @@ const FunctionDoc drop_null_doc(
 
 class DropNullMetaFunction : public MetaFunction {
  public:
-  DropNullMetaFunction() : MetaFunction("drop_null", Arity::Unary(), &drop_null_doc) {}
+  DropNullMetaFunction() : MetaFunction("drop_null", Arity::Unary(), drop_null_doc) {}
 
   Result<Datum> ExecuteImpl(const std::vector<Datum>& args,
                             const FunctionOptions* options,
@@ -2329,13 +2329,13 @@ struct SelectionKernelDescr {
   ArrayKernelExec exec;
 };
 
-void RegisterSelectionFunction(const std::string& name, const FunctionDoc* doc,
+void RegisterSelectionFunction(const std::string& name, FunctionDoc doc,
                                VectorKernel base_kernel, InputType selection_type,
                                const std::vector<SelectionKernelDescr>& descrs,
                                const FunctionOptions* default_options,
                                FunctionRegistry* registry) {
-  auto func =
-      std::make_shared<VectorFunction>(name, Arity::Binary(), doc, default_options);
+  auto func = std::make_shared<VectorFunction>(name, Arity::Binary(), std::move(doc),
+                                               default_options);
   for (auto& descr : descrs) {
     base_kernel.signature = KernelSignature::Make(
         {std::move(descr.input), selection_type}, OutputType(FirstType));
@@ -2428,8 +2428,8 @@ Status IndicesNonZeroExec(KernelContext* ctx, const ExecBatch& batch, Datum* out
 }
 
 std::shared_ptr<VectorFunction> MakeIndicesNonZeroFunction(std::string name,
-                                                           const FunctionDoc* doc) {
-  auto func = std::make_shared<VectorFunction>(name, Arity::Unary(), doc);
+                                                           FunctionDoc doc) {
+  auto func = std::make_shared<VectorFunction>(name, Arity::Unary(), std::move(doc));
 
   VectorKernel kernel;
   kernel.null_handling = NullHandling::OUTPUT_NOT_NULL;
@@ -2481,7 +2481,7 @@ void RegisterVectorSelection(FunctionRegistry* registry) {
 
   VectorKernel filter_base;
   filter_base.init = FilterState::Init;
-  RegisterSelectionFunction("array_filter", &array_filter_doc, filter_base,
+  RegisterSelectionFunction("array_filter", array_filter_doc, filter_base,
                             /*selection_type=*/InputType::Array(boolean()),
                             filter_kernel_descrs, GetDefaultFilterOptions(), registry);
 
@@ -2513,7 +2513,7 @@ void RegisterVectorSelection(FunctionRegistry* registry) {
   take_base.init = TakeState::Init;
   take_base.can_execute_chunkwise = false;
   RegisterSelectionFunction(
-      "array_take", &array_take_doc, take_base,
+      "array_take", array_take_doc, take_base,
       /*selection_type=*/InputType(match::Integer(), ValueDescr::ARRAY),
       take_kernel_descrs, GetDefaultTakeOptions(), registry);
 
@@ -2523,7 +2523,7 @@ void RegisterVectorSelection(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunction(std::make_shared<DropNullMetaFunction>()));
 
   DCHECK_OK(registry->AddFunction(
-      MakeIndicesNonZeroFunction("indices_nonzero", &indices_nonzero_doc)));
+      MakeIndicesNonZeroFunction("indices_nonzero", indices_nonzero_doc)));
 }
 
 }  // namespace internal
diff --git a/cpp/src/arrow/compute/kernels/vector_sort.cc b/cpp/src/arrow/compute/kernels/vector_sort.cc
index ad3323199ad..88c8a193fdf 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort.cc
+++ b/cpp/src/arrow/compute/kernels/vector_sort.cc
@@ -1168,7 +1168,7 @@ const FunctionDoc sort_indices_doc(
 class SortIndicesMetaFunction : public MetaFunction {
  public:
   SortIndicesMetaFunction()
-      : MetaFunction("sort_indices", Arity::Unary(), &sort_indices_doc,
+      : MetaFunction("sort_indices", Arity::Unary(), sort_indices_doc,
                      GetDefaultSortOptions()) {}
 
   Result<Datum> ExecuteImpl(const std::vector<Datum>& args,
@@ -1840,7 +1840,7 @@ static Status CheckConsistency(const Schema& schema,
 class SelectKUnstableMetaFunction : public MetaFunction {
  public:
   SelectKUnstableMetaFunction()
-      : MetaFunction("select_k_unstable", Arity::Unary(), &select_k_unstable_doc,
+      : MetaFunction("select_k_unstable", Arity::Unary(), select_k_unstable_doc,
                      GetDefaultSelectKOptions()) {}
 
   Result<Datum> ExecuteImpl(const std::vector<Datum>& args,
diff --git a/cpp/src/arrow/compute/registry_test.cc b/cpp/src/arrow/compute/registry_test.cc
index e1e0d523187..faf47a46f68 100644
--- a/cpp/src/arrow/compute/registry_test.cc
+++ b/cpp/src/arrow/compute/registry_test.cc
@@ -49,12 +49,13 @@ TEST_F(TestRegistry, CreateBuiltInRegistry) {
 TEST_F(TestRegistry, Basics) {
   ASSERT_EQ(0, registry_->num_functions());
 
-  std::shared_ptr<Function> func =
-      std::make_shared<ScalarFunction>("f1", Arity::Unary(), /*doc=*/nullptr);
+  std::shared_ptr<Function> func = std::make_shared<ScalarFunction>(
+      "f1", Arity::Unary(), /*doc=*/FunctionDoc::Empty());
   ASSERT_OK(registry_->AddFunction(func));
   ASSERT_EQ(1, registry_->num_functions());
 
-  func = std::make_shared<VectorFunction>("f0", Arity::Binary(), /*doc=*/nullptr);
+  func = std::make_shared<VectorFunction>("f0", Arity::Binary(),
+                                          /*doc=*/FunctionDoc::Empty());
   ASSERT_OK(registry_->AddFunction(func));
   ASSERT_EQ(2, registry_->num_functions());
 
@@ -65,7 +66,8 @@ TEST_F(TestRegistry, Basics) {
   ASSERT_RAISES(KeyError, registry_->GetFunction("f2"));
 
   // Try adding a function with name collision
-  func = std::make_shared<ScalarAggregateFunction>("f1", Arity::Unary(), /*doc=*/nullptr);
+  func = std::make_shared<ScalarAggregateFunction>("f1", Arity::Unary(),
+                                                   /*doc=*/FunctionDoc::Empty());
   ASSERT_RAISES(KeyError, registry_->AddFunction(func));
 
   // Allow overwriting by flag
diff --git a/cpp/src/arrow/datum.cc b/cpp/src/arrow/datum.cc
index e51c64d8e7a..ac2e9a7e692 100644
--- a/cpp/src/arrow/datum.cc
+++ b/cpp/src/arrow/datum.cc
@@ -279,4 +279,24 @@ void PrintTo(const Datum& datum, std::ostream* os) {
   }
 }
 
+std::string ToString(Datum::Kind kind) {
+  switch (kind) {
+    case Datum::NONE:
+      return "None";
+    case Datum::SCALAR:
+      return "Scalar";
+    case Datum::ARRAY:
+      return "Array";
+    case Datum::CHUNKED_ARRAY:
+      return "ChunkedArray";
+    case Datum::RECORD_BATCH:
+      return "RecordBatch";
+    case Datum::TABLE:
+      return "Table";
+    default:
+      DCHECK(false);
+      return "";
+  }
+}
+
 }  // namespace arrow
diff --git a/cpp/src/arrow/datum.h b/cpp/src/arrow/datum.h
index bce53decd4a..a732dc429db 100644
--- a/cpp/src/arrow/datum.h
+++ b/cpp/src/arrow/datum.h
@@ -285,4 +285,6 @@ struct ARROW_EXPORT Datum {
   ARROW_EXPORT friend void PrintTo(const Datum&, std::ostream*);
 };
 
+ARROW_EXPORT std::string ToString(Datum::Kind kind);
+
 }  // namespace arrow
diff --git a/cpp/src/arrow/python/CMakeLists.txt b/cpp/src/arrow/python/CMakeLists.txt
index 23c97cc3209..7235e2d0fe3 100644
--- a/cpp/src/arrow/python/CMakeLists.txt
+++ b/cpp/src/arrow/python/CMakeLists.txt
@@ -44,7 +44,8 @@ set(ARROW_PYTHON_SRCS
     numpy_to_arrow.cc
     python_to_arrow.cc
     pyarrow.cc
-    serialize.cc)
+    serialize.cc
+    udf.cc)
 
 set_source_files_properties(init.cc PROPERTIES SKIP_PRECOMPILE_HEADERS ON
                                                SKIP_UNITY_BUILD_INCLUSION ON)
diff --git a/cpp/src/arrow/python/common.h b/cpp/src/arrow/python/common.h
index 24dcb130a26..5c16106730b 100644
--- a/cpp/src/arrow/python/common.h
+++ b/cpp/src/arrow/python/common.h
@@ -180,6 +180,11 @@ class ARROW_PYTHON_EXPORT OwnedRefNoGIL : public OwnedRef {
   explicit OwnedRefNoGIL(PyObject* obj) : OwnedRef(obj) {}
 
   ~OwnedRefNoGIL() {
+    // This destructor may be called after the Python interpreter is finalized.
+    // At least avoid spurious attempts to take the GIL when not necessary.
+    if (obj() == NULLPTR) {
+      return;
+    }
     PyAcquireGIL lock;
     reset();
   }
diff --git a/cpp/src/arrow/python/udf.cc b/cpp/src/arrow/python/udf.cc
new file mode 100644
index 00000000000..41309d27bb7
--- /dev/null
+++ b/cpp/src/arrow/python/udf.cc
@@ -0,0 +1,133 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "arrow/python/udf.h"
+#include "arrow/compute/function.h"
+#include "arrow/python/common.h"
+
+namespace arrow {
+
+namespace py {
+
+namespace {
+Status CheckOutputType(const DataType& expected, const DataType& actual) {
+  if (!expected.Equals(actual)) {
+    return Status::TypeError("Expected output datatype ", expected.ToString(),
+                             ", but function returned datatype ", actual.ToString());
+  }
+  return Status::OK();
+}
+
+struct PythonUdf {
+  ScalarUdfWrapperCallback cb;
+  std::shared_ptr<OwnedRefNoGIL> function;
+  compute::OutputType output_type;
+
+  // function needs to be destroyed at process exit
+  // and Python may no longer be initialized.
+  ~PythonUdf() {
+    if (_Py_IsFinalizing()) {
+      function->detach();
+    }
+  }
+
+  Status operator()(compute::KernelContext* ctx, const compute::ExecBatch& batch,
+                    Datum* out) {
+    return SafeCallIntoPython([&]() -> Status { return Execute(ctx, batch, out); });
+  }
+
+  Status Execute(compute::KernelContext* ctx, const compute::ExecBatch& batch,
+                 Datum* out) {
+    const auto num_args = batch.values.size();
+    ScalarUdfContext udf_context{ctx->memory_pool(), static_cast<int64_t>(batch.length)};
+
+    OwnedRef arg_tuple(PyTuple_New(num_args));
+    RETURN_NOT_OK(CheckPyError());
+    for (size_t arg_id = 0; arg_id < num_args; arg_id++) {
+      switch (batch[arg_id].kind()) {
+        case Datum::SCALAR: {
+          auto c_data = batch[arg_id].scalar();
+          PyObject* data = wrap_scalar(c_data);
+          PyTuple_SetItem(arg_tuple.obj(), arg_id, data);
+          break;
+        }
+        case Datum::ARRAY: {
+          auto c_data = batch[arg_id].make_array();
+          PyObject* data = wrap_array(c_data);
+          PyTuple_SetItem(arg_tuple.obj(), arg_id, data);
+          break;
+        }
+        default:
+          auto datum = batch[arg_id];
+          return Status::NotImplemented(
+              "User-defined-functions are not supported for the datum kind ",
+              ToString(batch[arg_id].kind()));
+      }
+    }
+
+    OwnedRef result(cb(function->obj(), udf_context, arg_tuple.obj()));
+    RETURN_NOT_OK(CheckPyError());
+    // unwrapping the output for expected output type
+    if (is_scalar(result.obj())) {
+      ARROW_ASSIGN_OR_RAISE(auto val, unwrap_scalar(result.obj()));
+      RETURN_NOT_OK(CheckOutputType(*output_type.type(), *val->type));
+      *out = Datum(val);
+      return Status::OK();
+    } else if (is_array(result.obj())) {
+      ARROW_ASSIGN_OR_RAISE(auto val, unwrap_array(result.obj()));
+      RETURN_NOT_OK(CheckOutputType(*output_type.type(), *val->type()));
+      *out = Datum(val);
+      return Status::OK();
+    } else {
+      return Status::TypeError("Unexpected output type: ", Py_TYPE(result.obj())->tp_name,
+                               " (expected Scalar or Array)");
+    }
+    return Status::OK();
+  }
+};
+
+}  // namespace
+
+Status RegisterScalarFunction(PyObject* user_function, ScalarUdfWrapperCallback wrapper,
+                              const ScalarUdfOptions& options) {
+  if (!PyCallable_Check(user_function)) {
+    return Status::TypeError("Expected a callable Python object.");
+  }
+  auto scalar_func = std::make_shared<compute::ScalarFunction>(
+      options.func_name, options.arity, options.func_doc);
+  Py_INCREF(user_function);
+  std::vector<compute::InputType> input_types;
+  for (const auto& in_dtype : options.input_types) {
+    input_types.emplace_back(in_dtype);
+  }
+  compute::OutputType output_type(options.output_type);
+  PythonUdf exec{wrapper, std::make_shared<OwnedRefNoGIL>(user_function), output_type};
+  compute::ScalarKernel kernel(
+      compute::KernelSignature::Make(std::move(input_types), std::move(output_type),
+                                     options.arity.is_varargs),
+      std::move(exec));
+  kernel.mem_allocation = compute::MemAllocation::NO_PREALLOCATE;
+  kernel.null_handling = compute::NullHandling::COMPUTED_NO_PREALLOCATE;
+  RETURN_NOT_OK(scalar_func->AddKernel(std::move(kernel)));
+  auto registry = compute::GetFunctionRegistry();
+  RETURN_NOT_OK(registry->AddFunction(std::move(scalar_func)));
+  return Status::OK();
+}
+
+}  // namespace py
+
+}  // namespace arrow
diff --git a/cpp/src/arrow/python/udf.h b/cpp/src/arrow/python/udf.h
new file mode 100644
index 00000000000..4ab3e7cc72b
--- /dev/null
+++ b/cpp/src/arrow/python/udf.h
@@ -0,0 +1,59 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include "arrow/compute/exec.h"
+#include "arrow/compute/function.h"
+#include "arrow/compute/registry.h"
+#include "arrow/python/platform.h"
+
+#include "arrow/python/common.h"
+#include "arrow/python/pyarrow.h"
+#include "arrow/python/visibility.h"
+
+namespace arrow {
+
+namespace py {
+
+// TODO: TODO(ARROW-16041): UDF Options are not exposed to the Python
+// users. This feature will be included when extending to provide advanced
+// options for the users.
+struct ARROW_PYTHON_EXPORT ScalarUdfOptions {
+  std::string func_name;
+  compute::Arity arity;
+  compute::FunctionDoc func_doc;
+  std::vector<std::shared_ptr<DataType>> input_types;
+  std::shared_ptr<DataType> output_type;
+};
+
+struct ARROW_PYTHON_EXPORT ScalarUdfContext {
+  MemoryPool* pool;
+  int64_t batch_length;
+};
+
+using ScalarUdfWrapperCallback = std::function<PyObject*(
+    PyObject* user_function, const ScalarUdfContext& context, PyObject* inputs)>;
+
+/// \brief register a Scalar user-defined-function from Python
+Status ARROW_PYTHON_EXPORT RegisterScalarFunction(PyObject* user_function,
+                                                  ScalarUdfWrapperCallback wrapper,
+                                                  const ScalarUdfOptions& options);
+
+}  // namespace py
+
+}  // namespace arrow
diff --git a/python/pyarrow/_compute.pxd b/python/pyarrow/_compute.pxd
index ebf2066d046..8b09cbd445e 100644
--- a/python/pyarrow/_compute.pxd
+++ b/python/pyarrow/_compute.pxd
@@ -21,6 +21,11 @@ from pyarrow.lib cimport *
 from pyarrow.includes.common cimport *
 from pyarrow.includes.libarrow cimport *
 
+cdef class ScalarUdfContext(_Weakrefable):
+    cdef:
+        CScalarUdfContext c_context
+
+    cdef void init(self, const CScalarUdfContext& c_context)
 
 cdef class FunctionOptions(_Weakrefable):
     cdef:
diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index 2ba6ae2462c..d17bce47cb8 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -26,9 +26,13 @@ from collections import namedtuple
 
 from pyarrow.lib import frombytes, tobytes, ordered_dict
 from pyarrow.lib cimport *
+from pyarrow.includes.common cimport *
 from pyarrow.includes.libarrow cimport *
 import pyarrow.lib as lib
 
+from libcpp cimport bool as c_bool
+
+import inspect
 import numpy as np
 
 
@@ -2275,3 +2279,211 @@ cdef CExpression _bind(Expression filter, Schema schema) except *:
 
     return GetResultValue(filter.unwrap().Bind(
         deref(pyarrow_unwrap_schema(schema).get())))
+
+
+cdef class ScalarUdfContext:
+    """
+    Per-invocation function context/state.
+
+    This object will always be the first argument to a user-defined
+    function. It should not be used outside of a call to the function.
+    """
+
+    def __init__(self):
+        raise TypeError("Do not call {}'s constructor directly"
+                        .format(self.__class__.__name__))
+
+    cdef void init(self, const CScalarUdfContext &c_context):
+        self.c_context = c_context
+
+    @property
+    def batch_length(self):
+        """
+        The common length of all input arguments (int).
+
+        In the case that all arguments are scalars, this value
+        is used to pass the "actual length" of the arguments,
+        e.g. because the scalar values are encoding a column
+        with a constant value.
+        """
+        return self.c_context.batch_length
+
+    @property
+    def memory_pool(self):
+        """
+        A memory pool for allocations (:class:`MemoryPool`).
+
+        This is the memory pool supplied by the user when they invoked
+        the function and it should be used in any calls to arrow that the
+        UDF makes if that call accepts a memory_pool.
+        """
+        return box_memory_pool(self.c_context.pool)
+
+
+cdef inline CFunctionDoc _make_function_doc(dict func_doc) except *:
+    """
+    Helper function to generate the FunctionDoc
+    This function accepts a dictionary and expects the 
+    summary(str), description(str) and arg_names(List[str]) keys. 
+    """
+    cdef:
+        CFunctionDoc f_doc
+        vector[c_string] c_arg_names
+
+    f_doc.summary = tobytes(func_doc["summary"])
+    f_doc.description = tobytes(func_doc["description"])
+    for arg_name in func_doc["arg_names"]:
+        c_arg_names.push_back(tobytes(arg_name))
+    f_doc.arg_names = c_arg_names
+    # UDFOptions integration:
+    # TODO: https://issues.apache.org/jira/browse/ARROW-16041
+    f_doc.options_class = b""
+    f_doc.options_required = False
+    return f_doc
+
+
+cdef object box_scalar_udf_context(const CScalarUdfContext& c_context):
+    cdef ScalarUdfContext context = ScalarUdfContext.__new__(ScalarUdfContext)
+    context.init(c_context)
+    return context
+
+
+cdef _scalar_udf_callback(user_function, const CScalarUdfContext& c_context, inputs):
+    """
+    Helper callback function used to wrap the ScalarUdfContext from Python to C++
+    execution.
+    """
+    context = box_scalar_udf_context(c_context)
+    return user_function(context, *inputs)
+
+
+def _get_scalar_udf_context(memory_pool, batch_length):
+    cdef CScalarUdfContext c_context
+    c_context.pool = maybe_unbox_memory_pool(memory_pool)
+    c_context.batch_length = batch_length
+    context = box_scalar_udf_context(c_context)
+    return context
+
+
+def register_scalar_function(func, function_name, function_doc, in_types,
+                             out_type):
+    """
+    Register a user-defined scalar function. 
+
+    A scalar function is a function that executes elementwise
+    operations on arrays or scalars, i.e. a scalar function must
+    be computed row-by-row with no state where each output row 
+    is computed only from its corresponding input row.
+    In other words, all argument arrays have the same length,
+    and the output array is of the same length as the arguments.
+    Scalar functions are the only functions allowed in query engine
+    expressions.
+
+    Parameters
+    ----------
+    func : callable
+        A callable implementing the user-defined function.
+        The first argument is the context argument of type
+        ScalarUdfContext.
+        Then, it must take arguments equal to the number of
+        in_types defined. It must return an Array or Scalar
+        matching the out_type. It must return a Scalar if
+        all arguments are scalar, else it must return an Array.
+
+        To define a varargs function, pass a callable that takes
+        varargs. The last in_type will be the type of all varargs
+        arguments.
+    function_name : str
+        Name of the function. This name must be globally unique. 
+    function_doc : dict
+        A dictionary object with keys "summary" (str),
+        and "description" (str).
+    in_types : Dict[str, DataType]
+        A dictionary mapping function argument names to
+        their respective DataType.
+        The argument names will be used to generate
+        documentation for the function. The number of
+        arguments specified here determines the function
+        arity.
+    out_type : DataType
+        Output type of the function.
+
+    Examples
+    --------
+
+    >>> import pyarrow.compute as pc
+    >>> 
+    >>> func_doc = {}
+    >>> func_doc["summary"] = "simple udf"
+    >>> func_doc["description"] = "add a constant to a scalar"
+    >>> 
+    >>> def add_constant(ctx, array):
+    ...     return pc.add(array, 1, memory_pool=ctx.memory_pool)
+    >>> 
+    >>> func_name = "py_add_func"
+    >>> in_types = {"array": pa.int64()}
+    >>> out_type = pa.int64()
+    >>> pc.register_scalar_function(add_constant, func_name, func_doc,
+    ...                   in_types, out_type)
+    >>> 
+    >>> func = pc.get_function(func_name)
+    >>> func.name
+    'py_add_func'
+    >>> answer = pc.call_function(func_name, [pa.array([20])])
+    >>> answer
+    <pyarrow.lib.Int64Array object at 0x10c22e700>
+    [
+    21
+    ]
+    """
+    cdef:
+        c_string c_func_name
+        CArity c_arity
+        CFunctionDoc c_func_doc
+        vector[shared_ptr[CDataType]] c_in_types
+        PyObject* c_function
+        shared_ptr[CDataType] c_out_type
+        CScalarUdfOptions c_options
+
+    if callable(func):
+        c_function = <PyObject*>func
+    else:
+        raise TypeError("func must be a callable")
+
+    c_func_name = tobytes(function_name)
+
+    func_spec = inspect.getfullargspec(func)
+    num_args = -1
+    if isinstance(in_types, dict):
+        for in_type in in_types.values():
+            c_in_types.push_back(
+                pyarrow_unwrap_data_type(ensure_type(in_type)))
+        function_doc["arg_names"] = in_types.keys()
+        num_args = len(in_types)
+    else:
+        raise TypeError(
+            "in_types must be a dictionary of DataType")
+
+    c_arity = CArity(num_args, func_spec.varargs)
+
+    if "summary" not in function_doc:
+        raise ValueError("Function doc must contain a summary")
+
+    if "description" not in function_doc:
+        raise ValueError("Function doc must contain a description")
+
+    if "arg_names" not in function_doc:
+        raise ValueError("Function doc must contain arg_names")
+
+    c_func_doc = _make_function_doc(function_doc)
+
+    c_out_type = pyarrow_unwrap_data_type(ensure_type(out_type))
+
+    c_options.func_name = c_func_name
+    c_options.arity = c_arity
+    c_options.func_doc = c_func_doc
+    c_options.input_types = c_in_types
+    c_options.output_type = c_out_type
+
+    check_status(RegisterScalarFunction(c_function,
+                                        <function[CallbackUdf]> &_scalar_udf_callback, c_options))
diff --git a/python/pyarrow/compute.py b/python/pyarrow/compute.py
index 40751eab26a..99e0da677af 100644
--- a/python/pyarrow/compute.py
+++ b/python/pyarrow/compute.py
@@ -76,6 +76,9 @@
     get_function,
     list_functions,
     _group_by,
+    # Udf
+    register_scalar_function,
+    ScalarUdfContext,
     # Expressions
     Expression,
 )
diff --git a/python/pyarrow/includes/libarrow.pxd b/python/pyarrow/includes/libarrow.pxd
index 4485f744cd7..8b5f9cc1c49 100644
--- a/python/pyarrow/includes/libarrow.pxd
+++ b/python/pyarrow/includes/libarrow.pxd
@@ -1833,6 +1833,10 @@ cdef extern from "arrow/compute/api.h" namespace "arrow::compute" nogil:
         int num_args
         c_bool is_varargs
 
+        CArity()
+
+        CArity(int num_args, c_bool is_varargs)
+
     cdef enum FunctionKind" arrow::compute::Function::Kind":
         FunctionKind_SCALAR" arrow::compute::Function::SCALAR"
         FunctionKind_VECTOR" arrow::compute::Function::VECTOR"
@@ -2341,6 +2345,7 @@ cdef extern from "arrow/compute/api.h" namespace "arrow::compute" nogil:
         const shared_ptr[CTable]& table() const
         const shared_ptr[CScalar]& scalar() const
 
+    cdef c_string ToString(DatumType kind)
 
 cdef extern from * namespace "arrow::compute":
     # inlined from compute/function_internal.h to avoid exposing
@@ -2665,3 +2670,20 @@ cdef extern from "arrow/util/byte_size.h" namespace "arrow::util" nogil:
     int64_t TotalBufferSize(const CChunkedArray& array)
     int64_t TotalBufferSize(const CRecordBatch& record_batch)
     int64_t TotalBufferSize(const CTable& table)
+
+ctypedef PyObject* CallbackUdf(object user_function, const CScalarUdfContext& context, object inputs)
+
+cdef extern from "arrow/python/udf.h" namespace "arrow::py":
+    cdef cppclass CScalarUdfContext" arrow::py::ScalarUdfContext":
+        CMemoryPool *pool
+        int64_t batch_length
+
+    cdef cppclass CScalarUdfOptions" arrow::py::ScalarUdfOptions":
+        c_string func_name
+        CArity arity
+        CFunctionDoc func_doc
+        vector[shared_ptr[CDataType]] input_types
+        shared_ptr[CDataType] output_type
+
+    CStatus RegisterScalarFunction(PyObject* function,
+                                   function[CallbackUdf] wrapper, const CScalarUdfOptions& options)
diff --git a/python/pyarrow/lib.pxd b/python/pyarrow/lib.pxd
index 28889badebe..953b0e7b518 100644
--- a/python/pyarrow/lib.pxd
+++ b/python/pyarrow/lib.pxd
@@ -61,6 +61,9 @@ cdef class MemoryPool(_Weakrefable):
 cdef CMemoryPool* maybe_unbox_memory_pool(MemoryPool memory_pool)
 
 
+cdef object box_memory_pool(CMemoryPool* pool)
+
+
 cdef class DataType(_Weakrefable):
     cdef:
         shared_ptr[CDataType] sp_type
diff --git a/python/pyarrow/memory.pxi b/python/pyarrow/memory.pxi
index 4847141f367..2258be78d54 100644
--- a/python/pyarrow/memory.pxi
+++ b/python/pyarrow/memory.pxi
@@ -84,6 +84,12 @@ cdef CMemoryPool* maybe_unbox_memory_pool(MemoryPool memory_pool):
         return memory_pool.pool
 
 
+cdef api object box_memory_pool(CMemoryPool *c_pool):
+    cdef MemoryPool pool = MemoryPool.__new__(MemoryPool)
+    pool.init(c_pool)
+    return pool
+
+
 cdef class LoggingMemoryPool(MemoryPool):
     cdef:
         unique_ptr[CLoggingMemoryPool] logging_pool
diff --git a/python/pyarrow/tests/test_udf.py b/python/pyarrow/tests/test_udf.py
new file mode 100644
index 00000000000..33315fc12d4
--- /dev/null
+++ b/python/pyarrow/tests/test_udf.py
@@ -0,0 +1,503 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+
+import pytest
+
+import pyarrow as pa
+from pyarrow import compute as pc
+
+# UDFs are all tested with a dataset scan
+pytestmark = pytest.mark.dataset
+
+
+try:
+    import pyarrow.dataset as ds
+except ImportError:
+    ds = None
+
+
+def mock_udf_context(batch_length=10):
+    from pyarrow._compute import _get_scalar_udf_context
+    return _get_scalar_udf_context(pa.default_memory_pool(), batch_length)
+
+
+class MyError(RuntimeError):
+    pass
+
+
+@pytest.fixture(scope="session")
+def unary_func_fixture():
+    """
+    Register a unary scalar function.
+    """
+    def unary_function(ctx, x):
+        return pc.call_function("add", [x, 1],
+                                memory_pool=ctx.memory_pool)
+    func_name = "y=x+1"
+    unary_doc = {"summary": "add function",
+                 "description": "test add function"}
+    pc.register_scalar_function(unary_function,
+                                func_name,
+                                unary_doc,
+                                {"array": pa.int64()},
+                                pa.int64())
+    return unary_function, func_name
+
+
+@pytest.fixture(scope="session")
+def binary_func_fixture():
+    """
+    Register a binary scalar function.
+    """
+    def binary_function(ctx, m, x):
+        return pc.call_function("multiply", [m, x],
+                                memory_pool=ctx.memory_pool)
+    func_name = "y=mx"
+    binary_doc = {"summary": "y=mx",
+                  "description": "find y from y = mx"}
+    pc.register_scalar_function(binary_function,
+                                func_name,
+                                binary_doc,
+                                {"m": pa.int64(),
+                                 "x": pa.int64(),
+                                 },
+                                pa.int64())
+    return binary_function, func_name
+
+
+@pytest.fixture(scope="session")
+def ternary_func_fixture():
+    """
+    Register a ternary scalar function.
+    """
+    def ternary_function(ctx, m, x, c):
+        mx = pc.call_function("multiply", [m, x],
+                              memory_pool=ctx.memory_pool)
+        return pc.call_function("add", [mx, c],
+                                memory_pool=ctx.memory_pool)
+    ternary_doc = {"summary": "y=mx+c",
+                   "description": "find y from y = mx + c"}
+    func_name = "y=mx+c"
+    pc.register_scalar_function(ternary_function,
+                                func_name,
+                                ternary_doc,
+                                {
+                                    "array1": pa.int64(),
+                                    "array2": pa.int64(),
+                                    "array3": pa.int64(),
+                                },
+                                pa.int64())
+    return ternary_function, func_name
+
+
+@pytest.fixture(scope="session")
+def varargs_func_fixture():
+    """
+    Register a varargs scalar function with at least two arguments.
+    """
+    def varargs_function(ctx, first, *values):
+        acc = first
+        for val in values:
+            acc = pc.call_function("add", [acc, val],
+                                   memory_pool=ctx.memory_pool)
+        return acc
+    func_name = "z=ax+by+c"
+    varargs_doc = {"summary": "z=ax+by+c",
+                   "description": "find z from z = ax + by + c"
+                   }
+    pc.register_scalar_function(varargs_function,
+                                func_name,
+                                varargs_doc,
+                                {
+                                    "array1": pa.int64(),
+                                    "array2": pa.int64(),
+                                },
+                                pa.int64())
+    return varargs_function, func_name
+
+
+@pytest.fixture(scope="session")
+def nullary_func_fixture():
+    """
+    Register a nullary scalar function.
+    """
+    def nullary_func(context):
+        return pa.array([42] * context.batch_length, type=pa.int64(),
+                        memory_pool=context.memory_pool)
+
+    func_doc = {
+        "summary": "random function",
+        "description": "generates a random value"
+    }
+    func_name = "test_nullary_func"
+    pc.register_scalar_function(nullary_func,
+                                func_name,
+                                func_doc,
+                                {},
+                                pa.int64())
+
+    return nullary_func, func_name
+
+
+@pytest.fixture(scope="session")
+def wrong_output_type_func_fixture():
+    """
+    Register a scalar function which returns something that is neither
+    a Arrow scalar or array.
+    """
+    def wrong_output_type(ctx):
+        return 42
+
+    func_name = "test_wrong_output_type"
+    in_types = {}
+    out_type = pa.int64()
+    doc = {
+        "summary": "return wrong output type",
+        "description": ""
+    }
+    pc.register_scalar_function(wrong_output_type, func_name, doc,
+                                in_types, out_type)
+    return wrong_output_type, func_name
+
+
+@pytest.fixture(scope="session")
+def wrong_output_datatype_func_fixture():
+    """
+    Register a scalar function whose actual output DataType doesn't
+    match the declared output DataType.
+    """
+    def wrong_output_datatype(ctx, array):
+        return pc.call_function("add", [array, 1])
+    func_name = "test_wrong_output_datatype"
+    in_types = {"array": pa.int64()}
+    # The actual output DataType will be int64.
+    out_type = pa.int16()
+    doc = {
+        "summary": "return wrong output datatype",
+        "description": ""
+    }
+    pc.register_scalar_function(wrong_output_datatype, func_name, doc,
+                                in_types, out_type)
+    return wrong_output_datatype, func_name
+
+
+@pytest.fixture(scope="session")
+def wrong_signature_func_fixture():
+    """
+    Register a scalar function with the wrong signature.
+    """
+    # Missing the context argument
+    def wrong_signature():
+        return pa.scalar(1, type=pa.int64())
+
+    func_name = "test_wrong_signature"
+    in_types = {}
+    out_type = pa.int64()
+    doc = {
+        "summary": "UDF with wrong signature",
+        "description": ""
+    }
+    pc.register_scalar_function(wrong_signature, func_name, doc,
+                                in_types, out_type)
+    return wrong_signature, func_name
+
+
+@pytest.fixture(scope="session")
+def raising_func_fixture():
+    """
+    Register a scalar function which raises a custom exception.
+    """
+    def raising_func(ctx):
+        raise MyError("error raised by scalar UDF")
+    func_name = "test_raise"
+    doc = {
+        "summary": "raising function",
+        "description": ""
+    }
+    pc.register_scalar_function(raising_func, func_name, doc,
+                                {}, pa.int64())
+    return raising_func, func_name
+
+
+def check_scalar_function(func_fixture,
+                          inputs, *,
+                          run_in_dataset=True,
+                          batch_length=None):
+    function, name = func_fixture
+    if batch_length is None:
+        for input in inputs:
+            try:
+                batch_length = len(inputs)
+            except TypeError:
+                pass
+    expected_output = function(mock_udf_context(batch_length), *inputs)
+    func = pc.get_function(name)
+    assert func.name == name
+
+    result = pc.call_function(name, inputs)
+    assert result == expected_output
+    # At the moment there is an issue when handling nullary functions.
+    # See: ARROW-15286 and ARROW-16290.
+    if run_in_dataset:
+        field_names = [f'field{index}' for index, in_arr in inputs]
+        table = pa.Table.from_arrays(inputs, field_names)
+        dataset = ds.dataset(table)
+        func_args = [ds.field(field_name) for field_name in field_names]
+        result_table = dataset.to_table(
+            columns={'result': ds.field('')._call(name, func_args)})
+        assert result_table.column(0).chunks[0] == expected_output
+
+
+def test_scalar_udf_array_unary(unary_func_fixture):
+    check_scalar_function(unary_func_fixture,
+                          [
+                              pa.array([10, 20], pa.int64())
+                          ]
+                          )
+
+
+def test_scalar_udf_array_binary(binary_func_fixture):
+    check_scalar_function(binary_func_fixture,
+                          [
+                              pa.array([10, 20], pa.int64()),
+                              pa.array([2, 4], pa.int64())
+                          ]
+                          )
+
+
+def test_scalar_udf_array_ternary(ternary_func_fixture):
+    check_scalar_function(ternary_func_fixture,
+                          [
+                              pa.array([10, 20], pa.int64()),
+                              pa.array([2, 4], pa.int64()),
+                              pa.array([5, 10], pa.int64())
+                          ]
+                          )
+
+
+def test_scalar_udf_array_varargs(varargs_func_fixture):
+    check_scalar_function(varargs_func_fixture,
+                          [
+                              pa.array([2, 3], pa.int64()),
+                              pa.array([10, 20], pa.int64()),
+                              pa.array([3, 7], pa.int64()),
+                              pa.array([20, 30], pa.int64()),
+                              pa.array([5, 10], pa.int64())
+                          ]
+                          )
+
+
+def test_registration_errors():
+    # validate function name
+    doc = {
+        "summary": "test udf input",
+        "description": "parameters are validated"
+    }
+    in_types = {"scalar": pa.int64()}
+    out_type = pa.int64()
+
+    def test_reg_function(context):
+        return pa.array([10])
+
+    with pytest.raises(TypeError):
+        pc.register_scalar_function(test_reg_function,
+                                    None, doc, in_types,
+                                    out_type)
+
+    # validate function
+    with pytest.raises(TypeError, match="func must be a callable"):
+        pc.register_scalar_function(None, "test_none_function", doc, in_types,
+                                    out_type)
+
+    # validate output type
+    expected_expr = "DataType expected, got <class 'NoneType'>"
+    with pytest.raises(TypeError, match=expected_expr):
+        pc.register_scalar_function(test_reg_function,
+                                    "test_output_function", doc, in_types,
+                                    None)
+
+    # validate input type
+    expected_expr = "in_types must be a dictionary of DataType"
+    with pytest.raises(TypeError, match=expected_expr):
+        pc.register_scalar_function(test_reg_function,
+                                    "test_input_function", doc, None,
+                                    out_type)
+
+    # register an already registered function
+    # first registration
+    pc.register_scalar_function(test_reg_function,
+                                "test_reg_function", doc, {},
+                                out_type)
+    # second registration
+    expected_expr = "Already have a function registered with name:" \
+        + " test_reg_function"
+    with pytest.raises(KeyError, match=expected_expr):
+        pc.register_scalar_function(test_reg_function,
+                                    "test_reg_function", doc, {},
+                                    out_type)
+
+
+def test_varargs_function_validation(varargs_func_fixture):
+    _, func_name = varargs_func_fixture
+
+    error_msg = r"VarArgs function 'z=ax\+by\+c' needs at least 2 arguments"
+
+    with pytest.raises(ValueError, match=error_msg):
+        pc.call_function(func_name, [42])
+
+
+def test_function_doc_validation():
+    # validate arity
+    in_types = {"scalar": pa.int64()}
+    out_type = pa.int64()
+
+    # doc with no summary
+    func_doc = {
+        "description": "desc"
+    }
+
+    def add_const(ctx, scalar):
+        return pc.call_function("add", [scalar, 1])
+
+    with pytest.raises(ValueError,
+                       match="Function doc must contain a summary"):
+        pc.register_scalar_function(add_const, "test_no_summary",
+                                    func_doc, in_types,
+                                    out_type)
+
+    # doc with no decription
+    func_doc = {
+        "summary": "test summary"
+    }
+
+    with pytest.raises(ValueError,
+                       match="Function doc must contain a description"):
+        pc.register_scalar_function(add_const, "test_no_desc",
+                                    func_doc, in_types,
+                                    out_type)
+
+
+def test_nullary_function(nullary_func_fixture):
+    # XXX the Python compute layer API doesn't let us override batch_length,
+    # so only test with the default value of 1.
+    check_scalar_function(nullary_func_fixture, [], run_in_dataset=False,
+                          batch_length=1)
+
+
+def test_wrong_output_type(wrong_output_type_func_fixture):
+    _, func_name = wrong_output_type_func_fixture
+
+    with pytest.raises(TypeError,
+                       match="Unexpected output type: int"):
+        pc.call_function(func_name, [])
+
+
+def test_wrong_output_datatype(wrong_output_datatype_func_fixture):
+    _, func_name = wrong_output_datatype_func_fixture
+
+    expected_expr = ("Expected output datatype int16, "
+                     "but function returned datatype int64")
+
+    with pytest.raises(TypeError, match=expected_expr):
+        pc.call_function(func_name, [pa.array([20, 30])])
+
+
+def test_wrong_signature(wrong_signature_func_fixture):
+    _, func_name = wrong_signature_func_fixture
+
+    expected_expr = (r"wrong_signature\(\) takes 0 positional arguments "
+                     "but 1 was given")
+
+    with pytest.raises(TypeError, match=expected_expr):
+        pc.call_function(func_name, [])
+
+
+def test_wrong_datatype_declaration():
+    def identity(ctx, val):
+        return val
+
+    func_name = "test_wrong_datatype_declaration"
+    in_types = {"array": pa.int64()}
+    out_type = {}
+    doc = {
+        "summary": "test output value",
+        "description": "test output"
+    }
+    with pytest.raises(TypeError,
+                       match="DataType expected, got <class 'dict'>"):
+        pc.register_scalar_function(identity, func_name,
+                                    doc, in_types, out_type)
+
+
+def test_wrong_input_type_declaration():
+    def identity(ctx, val):
+        return val
+
+    func_name = "test_wrong_input_type_declaration"
+    in_types = {"array": None}
+    out_type = pa.int64()
+    doc = {
+        "summary": "test invalid input type",
+        "description": "invalid input function"
+    }
+    with pytest.raises(TypeError,
+                       match="DataType expected, got <class 'NoneType'>"):
+        pc.register_scalar_function(identity, func_name, doc,
+                                    in_types, out_type)
+
+
+def test_udf_context(unary_func_fixture):
+    # Check the memory_pool argument is properly propagated
+    proxy_pool = pa.proxy_memory_pool(pa.default_memory_pool())
+    _, func_name = unary_func_fixture
+
+    res = pc.call_function(func_name,
+                           [pa.array([1] * 1000, type=pa.int64())],
+                           memory_pool=proxy_pool)
+    assert res == pa.array([2] * 1000, type=pa.int64())
+    assert proxy_pool.bytes_allocated() == 1000 * 8
+    # Destroying Python array should destroy underlying C++ memory
+    res = None
+    assert proxy_pool.bytes_allocated() == 0
+
+
+def test_raising_func(raising_func_fixture):
+    _, func_name = raising_func_fixture
+    with pytest.raises(MyError, match="error raised by scalar UDF"):
+        pc.call_function(func_name, [])
+
+
+def test_scalar_input(unary_func_fixture):
+    function, func_name = unary_func_fixture
+    res = pc.call_function(func_name, [pa.scalar(10)])
+    assert res == pa.scalar(11)
+
+
+def test_input_lifetime(unary_func_fixture):
+    function, func_name = unary_func_fixture
+
+    proxy_pool = pa.proxy_memory_pool(pa.default_memory_pool())
+    assert proxy_pool.bytes_allocated() == 0
+
+    v = pa.array([1] * 1000, type=pa.int64(), memory_pool=proxy_pool)
+    assert proxy_pool.bytes_allocated() == 1000 * 8
+    pc.call_function(func_name, [v])
+    assert proxy_pool.bytes_allocated() == 1000 * 8
+    # Calling a UDF should not have kept `v` alive longer than required
+    v = None
+    assert proxy_pool.bytes_allocated() == 0