diff --git a/cpp/src/arrow/array/builder_primitive.h b/cpp/src/arrow/array/builder_primitive.h
index 6d79d6e9649..8f9773db56f 100644
--- a/cpp/src/arrow/array/builder_primitive.h
+++ b/cpp/src/arrow/array/builder_primitive.h
@@ -88,9 +88,9 @@ class NumericBuilder
   using ArrayType = typename TypeTraits<T>::ArrayType;
 
   template <typename T1 = T>
-  explicit NumericBuilder(
-      enable_if_parameter_free<T1, MemoryPool*> pool = default_memory_pool(),
-      int64_t alignment = kDefaultBufferAlignment)
+    requires arrow_parameter_free<T1>
+  explicit NumericBuilder(MemoryPool* pool = default_memory_pool(),
+                          int64_t alignment = kDefaultBufferAlignment)
       : ArrayBuilder(pool, alignment),
         type_(TypeTraits<T>::type_singleton()),
         data_builder_(pool, alignment) {}
@@ -268,8 +268,9 @@ class NumericBuilder
   ///  or null(0) values.
   /// \return Status
   template <typename ValuesIter, typename ValidIter>
-  enable_if_t<!std::is_pointer<ValidIter>::value, Status> AppendValues(
-      ValuesIter values_begin, ValuesIter values_end, ValidIter valid_begin) {
+    requires(!std::is_pointer_v<ValidIter>)
+  Status AppendValues(ValuesIter values_begin, ValuesIter values_end,
+                      ValidIter valid_begin) {
     static_assert(!internal::is_null_pointer<ValidIter>::value,
                   "Don't pass a NULLPTR directly as valid_begin, use the 2-argument "
                   "version instead");
@@ -285,8 +286,9 @@ class NumericBuilder
 
   // Same as above, with a pointer type ValidIter
   template <typename ValuesIter, typename ValidIter>
-  enable_if_t<std::is_pointer<ValidIter>::value, Status> AppendValues(
-      ValuesIter values_begin, ValuesIter values_end, ValidIter valid_begin) {
+    requires std::is_pointer_v<ValidIter>
+  Status AppendValues(ValuesIter values_begin, ValuesIter values_end,
+                      ValidIter valid_begin) {
     int64_t length = static_cast<int64_t>(std::distance(values_begin, values_end));
     ARROW_RETURN_NOT_OK(Reserve(length));
     data_builder_.UnsafeAppend(values_begin, values_end);
@@ -624,8 +626,9 @@ class ARROW_EXPORT BooleanBuilder
   ///  or null(0) values
   /// \return Status
   template <typename ValuesIter, typename ValidIter>
-  enable_if_t<!std::is_pointer<ValidIter>::value, Status> AppendValues(
-      ValuesIter values_begin, ValuesIter values_end, ValidIter valid_begin) {
+    requires(!std::is_pointer_v<ValidIter>)
+  Status AppendValues(ValuesIter values_begin, ValuesIter values_end,
+                      ValidIter valid_begin) {
     static_assert(!internal::is_null_pointer<ValidIter>::value,
                   "Don't pass a NULLPTR directly as valid_begin, use the 2-argument "
                   "version instead");
@@ -643,8 +646,9 @@ class ARROW_EXPORT BooleanBuilder
 
   // Same as above, for a pointer type ValidIter
   template <typename ValuesIter, typename ValidIter>
-  enable_if_t<std::is_pointer<ValidIter>::value, Status> AppendValues(
-      ValuesIter values_begin, ValuesIter values_end, ValidIter valid_begin) {
+    requires std::is_pointer_v<ValidIter>
+  Status AppendValues(ValuesIter values_begin, ValuesIter values_end,
+                      ValidIter valid_begin) {
     int64_t length = static_cast<int64_t>(std::distance(values_begin, values_end));
     ARROW_RETURN_NOT_OK(Reserve(length));
     data_builder_.UnsafeAppend<false>(
diff --git a/cpp/src/arrow/compute/function_internal.h b/cpp/src/arrow/compute/function_internal.h
index 7bea4043a5f..aafc76f3d04 100644
--- a/cpp/src/arrow/compute/function_internal.h
+++ b/cpp/src/arrow/compute/function_internal.h
@@ -17,6 +17,7 @@
 
 #pragma once
 
+#include <concepts>
 #include <sstream>
 #include <string>
 #include <vector>
@@ -97,16 +98,16 @@ ARROW_EXPORT
 Result<std::unique_ptr<FunctionOptions>> DeserializeFunctionOptions(const Buffer& buffer);
 
 template <typename T>
-static inline enable_if_t<!has_enum_traits<T>::value, std::string> GenericToString(
-    const T& value) {
+  requires(!has_enum_traits<T>::value)
+static inline std::string GenericToString(const T& value) {
   std::stringstream ss;
   ss << value;
   return ss.str();
 }
 
 template <typename T>
-static inline enable_if_t<!has_enum_traits<T>::value, std::string> GenericToString(
-    const std::optional<T>& value) {
+  requires(!has_enum_traits<T>::value)
+static inline std::string GenericToString(const std::optional<T>& value) {
   return value.has_value() ? GenericToString(value.value()) : "nullopt";
 }
 
@@ -119,8 +120,8 @@ static inline std::string GenericToString(const std::string& value) {
 }
 
 template <typename T>
-static inline enable_if_t<has_enum_traits<T>::value, std::string> GenericToString(
-    const T value) {
+  requires has_enum_traits<T>::value
+static inline std::string GenericToString(const T value) {
   return EnumTraits<T>::value_name(value);
 }
 
@@ -256,21 +257,20 @@ GenericTypeSingleton() {
 }
 
 template <typename T>
-static inline enable_if_same<T, std::shared_ptr<const KeyValueMetadata>,
-                             std::shared_ptr<DataType>>
-GenericTypeSingleton() {
+  requires std::same_as<T, std::shared_ptr<const KeyValueMetadata>>
+static inline std::shared_ptr<DataType> GenericTypeSingleton() {
   return map(binary(), binary());
 }
 
 template <typename T>
-static inline enable_if_t<has_enum_traits<T>::value, std::shared_ptr<DataType>>
-GenericTypeSingleton() {
+  requires has_enum_traits<T>::value
+static inline std::shared_ptr<DataType> GenericTypeSingleton() {
   return TypeTraits<typename EnumTraits<T>::Type>::type_singleton();
 }
 
 template <typename T>
-static inline enable_if_same<T, SortKey, std::shared_ptr<DataType>>
-GenericTypeSingleton() {
+  requires std::same_as<T, SortKey>
+static inline std::shared_ptr<DataType> GenericTypeSingleton() {
   std::vector<std::shared_ptr<Field>> fields;
   fields.emplace_back(new Field("target", GenericTypeSingleton<std::string>()));
   fields.emplace_back(new Field("order", GenericTypeSingleton<SortOrder>()));
@@ -294,7 +294,8 @@ static inline Result<std::shared_ptr<Scalar>> GenericToScalar(const FieldRef& re
   return MakeScalar(ref.ToDotPath());
 }
 
-template <typename T, typename Enable = enable_if_t<has_enum_traits<T>::value>>
+template <typename T>
+  requires has_enum_traits<T>::value
 static inline Result<std::shared_ptr<Scalar>> GenericToScalar(const T value) {
   using CType = typename EnumTraits<T>::CType;
   return GenericToScalar(static_cast<CType>(value));
@@ -389,8 +390,9 @@ static inline Result<std::shared_ptr<Scalar>> GenericToScalar(
 }
 
 template <typename T>
-static inline enable_if_primitive_ctype<typename CTypeTraits<T>::ArrowType, Result<T>>
-GenericFromScalar(const std::shared_ptr<Scalar>& value) {
+  requires requires { typename CTypeTraits<T>::ArrowType; } &&
+           is_primitive_ctype<typename CTypeTraits<T>::ArrowType>::value
+static inline Result<T> GenericFromScalar(const std::shared_ptr<Scalar>& value) {
   using ArrowType = typename CTypeTraits<T>::ArrowType;
   using ScalarType = typename TypeTraits<ArrowType>::ScalarType;
   if (value->type->id() != ArrowType::type_id) {
@@ -403,8 +405,8 @@ GenericFromScalar(const std::shared_ptr<Scalar>& value) {
 }
 
 template <typename T>
-static inline enable_if_primitive_ctype<typename EnumTraits<T>::Type, Result<T>>
-GenericFromScalar(const std::shared_ptr<Scalar>& value) {
+  requires is_primitive_ctype<typename EnumTraits<T>::Type>::value
+static inline Result<T> GenericFromScalar(const std::shared_ptr<Scalar>& value) {
   ARROW_ASSIGN_OR_RAISE(auto raw_val,
                         GenericFromScalar<typename EnumTraits<T>::CType>(value));
   return ValidateEnumValue<T>(raw_val);
@@ -414,8 +416,8 @@ template <typename T, typename U>
 using enable_if_same_result = enable_if_same<T, U, Result<T>>;
 
 template <typename T>
-static inline enable_if_same_result<T, std::string> GenericFromScalar(
-    const std::shared_ptr<Scalar>& value) {
+  requires std::same_as<T, std::string>
+static inline Result<T> GenericFromScalar(const std::shared_ptr<Scalar>& value) {
   if (!is_base_binary_like(value->type->id())) {
     return Status::Invalid("Expected binary-like type but got ", value->type->ToString());
   }
@@ -425,15 +427,15 @@ static inline enable_if_same_result<T, std::string> GenericFromScalar(
 }
 
 template <typename T>
-static inline enable_if_same_result<T, FieldRef> GenericFromScalar(
-    const std::shared_ptr<Scalar>& value) {
+  requires std::same_as<T, FieldRef>
+static inline Result<T> GenericFromScalar(const std::shared_ptr<Scalar>& value) {
   ARROW_ASSIGN_OR_RAISE(auto path, GenericFromScalar<std::string>(value));
   return FieldRef::FromDotPath(path);
 }
 
 template <typename T>
-static inline enable_if_same_result<T, SortKey> GenericFromScalar(
-    const std::shared_ptr<Scalar>& value) {
+  requires std::same_as<T, SortKey>
+static inline Result<T> GenericFromScalar(const std::shared_ptr<Scalar>& value) {
   if (value->type->id() != Type::STRUCT) {
     return Status::Invalid("Expected type STRUCT but got ", value->type->id());
   }
@@ -447,26 +449,26 @@ static inline enable_if_same_result<T, SortKey> GenericFromScalar(
 }
 
 template <typename T>
-static inline enable_if_same_result<T, std::shared_ptr<DataType>> GenericFromScalar(
-    const std::shared_ptr<Scalar>& value) {
+  requires std::same_as<T, std::shared_ptr<DataType>>
+static inline Result<T> GenericFromScalar(const std::shared_ptr<Scalar>& value) {
   return value->type;
 }
 
 template <typename T>
-static inline enable_if_same_result<T, TypeHolder> GenericFromScalar(
-    const std::shared_ptr<Scalar>& value) {
+  requires std::same_as<T, TypeHolder>
+static inline Result<T> GenericFromScalar(const std::shared_ptr<Scalar>& value) {
   return value->type;
 }
 
 template <typename T>
-static inline enable_if_same_result<T, std::shared_ptr<Scalar>> GenericFromScalar(
-    const std::shared_ptr<Scalar>& value) {
+  requires std::same_as<T, std::shared_ptr<Scalar>>
+static inline Result<T> GenericFromScalar(const std::shared_ptr<Scalar>& value) {
   return value;
 }
 
 template <typename T>
-static inline enable_if_same_result<T, std::shared_ptr<const KeyValueMetadata>>
-GenericFromScalar(const std::shared_ptr<Scalar>& value) {
+  requires std::same_as<T, std::shared_ptr<const KeyValueMetadata>>
+static inline Result<T> GenericFromScalar(const std::shared_ptr<Scalar>& value) {
   auto ty = GenericTypeSingleton<std::shared_ptr<const KeyValueMetadata>>();
   if (!value->type->Equals(ty)) {
     return Status::Invalid("Expected ", ty->ToString(), " but got ",
@@ -486,8 +488,8 @@ GenericFromScalar(const std::shared_ptr<Scalar>& value) {
 }
 
 template <typename T>
-static inline enable_if_same_result<T, Datum> GenericFromScalar(
-    const std::shared_ptr<Scalar>& value) {
+  requires std::same_as<T, Datum>
+static inline Result<T> GenericFromScalar(const std::shared_ptr<Scalar>& value) {
   if (value->type->id() == Type::LIST) {
     const auto& holder = checked_cast<const BaseListScalar&>(*value);
     return holder.value;
@@ -504,8 +506,8 @@ template <>
 constexpr inline bool is_optional_v<std::nullopt_t> = true;
 
 template <typename T>
-static inline std::enable_if_t<is_optional_v<T>, Result<T>> GenericFromScalar(
-    const std::shared_ptr<Scalar>& value) {
+  requires is_optional_v<T>
+static inline Result<T> GenericFromScalar(const std::shared_ptr<Scalar>& value) {
   using value_type = typename T::value_type;
   if (value->type->id() == Type::NA) {
     return std::nullopt;
@@ -514,8 +516,9 @@ static inline std::enable_if_t<is_optional_v<T>, Result<T>> GenericFromScalar(
 }
 
 template <typename T>
-static enable_if_same<typename CTypeTraits<T>::ArrowType, ListType, Result<T>>
-GenericFromScalar(const std::shared_ptr<Scalar>& value) {
+  requires requires { typename CTypeTraits<T>::ArrowType; } &&
+           std::same_as<typename CTypeTraits<T>::ArrowType, ListType>
+static inline Result<T> GenericFromScalar(const std::shared_ptr<Scalar>& value) {
   using ValueType = typename T::value_type;
   if (value->type->id() != Type::LIST) {
     return Status::Invalid("Expected type LIST but got ", value->type->ToString());
diff --git a/cpp/src/arrow/compute/kernels/aggregate_internal.h b/cpp/src/arrow/compute/kernels/aggregate_internal.h
index 126f2891e21..e03398584db 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_internal.h
+++ b/cpp/src/arrow/compute/kernels/aggregate_internal.h
@@ -33,43 +33,43 @@ namespace arrow::compute::internal {
 template <typename I, typename Enable = void>
 struct FindAccumulatorType {};
 
-template <typename I>
-struct FindAccumulatorType<I, enable_if_boolean<I>> {
+template <arrow_boolean I>
+struct FindAccumulatorType<I> {
   using Type = UInt64Type;
 };
 
-template <typename I>
-struct FindAccumulatorType<I, enable_if_signed_integer<I>> {
+template <arrow_signed_integer I>
+struct FindAccumulatorType<I> {
   using Type = Int64Type;
 };
 
-template <typename I>
-struct FindAccumulatorType<I, enable_if_unsigned_integer<I>> {
+template <arrow_unsigned_integer I>
+struct FindAccumulatorType<I> {
   using Type = UInt64Type;
 };
 
-template <typename I>
-struct FindAccumulatorType<I, enable_if_floating_point<I>> {
+template <arrow_floating_point I>
+struct FindAccumulatorType<I> {
   using Type = DoubleType;
 };
 
-template <typename I>
-struct FindAccumulatorType<I, enable_if_decimal32<I>> {
+template <arrow_decimal32 I>
+struct FindAccumulatorType<I> {
   using Type = Decimal32Type;
 };
 
-template <typename I>
-struct FindAccumulatorType<I, enable_if_decimal64<I>> {
+template <arrow_decimal64 I>
+struct FindAccumulatorType<I> {
   using Type = Decimal64Type;
 };
 
-template <typename I>
-struct FindAccumulatorType<I, enable_if_decimal128<I>> {
+template <arrow_decimal128 I>
+struct FindAccumulatorType<I> {
   using Type = Decimal128Type;
 };
 
-template <typename I>
-struct FindAccumulatorType<I, enable_if_decimal256<I>> {
+template <arrow_decimal256 I>
+struct FindAccumulatorType<I> {
   using Type = Decimal256Type;
 };
 
@@ -86,8 +86,8 @@ struct MultiplyTraits {
   }
 };
 
-template <typename Type>
-struct MultiplyTraits<Type, enable_if_decimal<Type>> {
+template <arrow_decimal Type>
+struct MultiplyTraits<Type> {
   using CType = typename TypeTraits<Type>::CType;
 
   constexpr static CType one(const DataType& ty) {
@@ -132,18 +132,18 @@ using arrow::internal::VisitSetBitRunsVoid;
 template <typename T, typename Enable = void>
 struct GetSumType;
 
-template <typename T>
-struct GetSumType<T, enable_if_floating_point<T>> {
+template <arrow_floating_point T>
+struct GetSumType<T> {
   using SumType = double;
 };
 
-template <typename T>
-struct GetSumType<T, enable_if_integer<T>> {
+template <arrow_integer T>
+struct GetSumType<T> {
   using SumType = arrow::internal::int128_t;
 };
 
-template <typename T>
-struct GetSumType<T, enable_if_decimal<T>> {
+template <arrow_decimal T>
+struct GetSumType<T> {
   using SumType = typename TypeTraits<T>::CType;
 };
 
@@ -156,8 +156,8 @@ struct GetSumType<T, enable_if_decimal<T>> {
 // https://en.wikipedia.org/wiki/Pairwise_summation
 template <typename ValueType, typename SumType, SimdLevel::type SimdLevel,
           typename ValueFunc>
-enable_if_t<std::is_floating_point<SumType>::value, SumType> SumArray(
-    const ArraySpan& data, ValueFunc&& func) {
+  requires std::floating_point<SumType>
+SumType SumArray(const ArraySpan& data, ValueFunc&& func) {
   using arrow::internal::VisitSetBitRunsVoid;
 
   const int64_t data_size = data.length - data.GetNullCount();
@@ -234,8 +234,8 @@ enable_if_t<std::is_floating_point<SumType>::value, SumType> SumArray(
 // naive summation for integers and decimals
 template <typename ValueType, typename SumType, SimdLevel::type SimdLevel,
           typename ValueFunc>
-enable_if_t<!std::is_floating_point<SumType>::value, SumType> SumArray(
-    const ArraySpan& data, ValueFunc&& func) {
+  requires(!std::floating_point<SumType>)
+SumType SumArray(const ArraySpan& data, ValueFunc&& func) {
   using arrow::internal::VisitSetBitRunsVoid;
 
   SumType sum = 0;
diff --git a/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h b/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
index b4840061ae7..e54e0b93c68 100644
--- a/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
+++ b/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
@@ -18,6 +18,7 @@
 #pragma once
 
 #include <bit>
+#include <concepts>
 #include <limits>
 #include "arrow/compute/api_scalar.h"
 #include "arrow/compute/kernels/common_internal.h"
@@ -44,33 +45,34 @@ namespace internal {
 
 struct Add {
   template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                                    Status*) {
+    requires floating_value<T>
+  static constexpr T Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
     return left + right;
   }
 
   template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_unsigned_integer_value<T> Call(KernelContext*, Arg0 left,
-                                                            Arg1 right, Status*) {
+    requires unsigned_integer_value<T>
+  static constexpr T Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
     return left + right;
   }
 
   template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_signed_integer_value<T> Call(KernelContext*, Arg0 left,
-                                                          Arg1 right, Status*) {
+    requires signed_integer_value<T>
+  static constexpr T Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
     return arrow::internal::SafeSignedAdd(left, right);
   }
 
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_decimal_value<T> Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
+    requires decimal_value<T>
+  static T Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
     return left + right;
   }
 };
 
 struct AddChecked {
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_integer_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                         Status* st) {
+    requires integer_value<T>
+  static T Call(KernelContext*, Arg0 left, Arg1 right, Status* st) {
     static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
     T result = 0;
     if (ARROW_PREDICT_FALSE(AddWithOverflow(left, right, &result))) {
@@ -80,14 +82,15 @@ struct AddChecked {
   }
 
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                          Status*) {
+    requires floating_value<T>
+  static T Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
     static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
     return left + right;
   }
 
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_decimal_value<T> Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
+    requires decimal_value<T>
+  static T Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
     return left + right;
   }
 };
@@ -125,34 +128,34 @@ struct AddTimeDurationChecked {
 
 struct AbsoluteValue {
   template <typename T, typename Arg>
-  static constexpr enable_if_floating_value<Arg, T> Call(KernelContext*, Arg arg,
-                                                         Status*) {
+    requires floating_value<Arg>
+  static constexpr T Call(KernelContext*, Arg arg, Status*) {
     return std::fabs(arg);
   }
 
   template <typename T, typename Arg>
-  static constexpr enable_if_unsigned_integer_value<Arg, T> Call(KernelContext*, Arg arg,
-                                                                 Status*) {
+    requires unsigned_integer_value<Arg>
+  static constexpr T Call(KernelContext*, Arg arg, Status*) {
     return arg;
   }
 
   template <typename T, typename Arg>
-  static constexpr enable_if_signed_integer_value<Arg, T> Call(KernelContext*, Arg arg,
-                                                               Status* st) {
+    requires signed_integer_value<Arg>
+  static constexpr T Call(KernelContext*, Arg arg, Status* st) {
     return (arg < 0) ? arrow::internal::SafeSignedNegate(arg) : arg;
   }
 
   template <typename T, typename Arg>
-  static constexpr enable_if_decimal_value<Arg, T> Call(KernelContext*, Arg arg,
-                                                        Status*) {
+    requires decimal_value<Arg>
+  static constexpr T Call(KernelContext*, Arg arg, Status*) {
     return arg.Abs();
   }
 };
 
 struct AbsoluteValueChecked {
   template <typename T, typename Arg>
-  static enable_if_signed_integer_value<Arg, T> Call(KernelContext*, Arg arg,
-                                                     Status* st) {
+    requires signed_integer_value<Arg>
+  static T Call(KernelContext*, Arg arg, Status* st) {
     static_assert(std::is_same<T, Arg>::value, "");
     if (arg == std::numeric_limits<Arg>::min()) {
       *st = Status::Invalid("overflow");
@@ -162,57 +165,58 @@ struct AbsoluteValueChecked {
   }
 
   template <typename T, typename Arg>
-  static enable_if_unsigned_integer_value<Arg, T> Call(KernelContext* ctx, Arg arg,
-                                                       Status* st) {
+    requires unsigned_integer_value<Arg>
+  static T Call(KernelContext* ctx, Arg arg, Status* st) {
     static_assert(std::is_same<T, Arg>::value, "");
     return arg;
   }
 
   template <typename T, typename Arg>
-  static constexpr enable_if_floating_value<Arg, T> Call(KernelContext*, Arg arg,
-                                                         Status* st) {
+    requires floating_value<Arg>
+  static constexpr T Call(KernelContext*, Arg arg, Status* st) {
     static_assert(std::is_same<T, Arg>::value, "");
     return std::fabs(arg);
   }
 
   template <typename T, typename Arg>
-  static constexpr enable_if_decimal_value<Arg, T> Call(KernelContext*, Arg arg,
-                                                        Status*) {
+    requires decimal_value<Arg>
+  static constexpr T Call(KernelContext*, Arg arg, Status*) {
     return arg.Abs();
   }
 };
 
 struct Subtract {
   template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                                    Status*) {
+    requires floating_value<T>
+  static constexpr T Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
     static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
     return left - right;
   }
 
   template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_unsigned_integer_value<T> Call(KernelContext*, Arg0 left,
-                                                            Arg1 right, Status*) {
+    requires unsigned_integer_value<T>
+  static constexpr T Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
     static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
     return left - right;
   }
 
   template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_signed_integer_value<T> Call(KernelContext*, Arg0 left,
-                                                          Arg1 right, Status*) {
+    requires signed_integer_value<T>
+  static constexpr T Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
     return arrow::internal::SafeSignedSubtract(left, right);
   }
 
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_decimal_value<T> Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
+    requires decimal_value<T>
+  static T Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
     return left + (-right);
   }
 };
 
 struct SubtractChecked {
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_integer_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                         Status* st) {
+    requires integer_value<T>
+  static T Call(KernelContext*, Arg0 left, Arg1 right, Status* st) {
     T result = 0;
     if (ARROW_PREDICT_FALSE(SubtractWithOverflow(left, right, &result))) {
       *st = Status::Invalid("overflow");
@@ -221,14 +225,15 @@ struct SubtractChecked {
   }
 
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                          Status*) {
+    requires floating_value<T>
+  static T Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
     static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
     return left - right;
   }
 
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_decimal_value<T> Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
+    requires decimal_value<T>
+  static T Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
     return left + (-right);
   }
 };
@@ -298,22 +303,20 @@ struct Multiply {
   static_assert(std::is_same<decltype(uint64_t() * uint64_t()), uint64_t>::value, "");
 
   template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_floating_value<T> Call(KernelContext*, T left, T right,
-                                                    Status*) {
+    requires floating_value<T>
+  static constexpr T Call(KernelContext*, T left, T right, Status*) {
     return left * right;
   }
 
   template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_t<
-      is_unsigned_integer_value<T>::value && !std::is_same<T, uint16_t>::value, T>
-  Call(KernelContext*, T left, T right, Status*) {
+    requires(unsigned_integer_value<T> && !std::is_same_v<T, uint16_t>)
+  static constexpr T Call(KernelContext*, T left, T right, Status*) {
     return left * right;
   }
 
   template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_t<
-      is_signed_integer_value<T>::value && !std::is_same<T, int16_t>::value, T>
-  Call(KernelContext*, T left, T right, Status*) {
+    requires(signed_integer_value<T> && !std::is_same_v<T, int16_t>)
+  static constexpr T Call(KernelContext*, T left, T right, Status*) {
     return to_unsigned(left) * to_unsigned(right);
   }
 
@@ -322,26 +325,27 @@ struct Multiply {
   // behaviour). Therefore we first cast to 32 bit unsigned integers where overflow is
   // well defined.
   template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_same<T, int16_t, T> Call(KernelContext*, int16_t left,
-                                                      int16_t right, Status*) {
+    requires std::same_as<T, int16_t>
+  static constexpr T Call(KernelContext*, int16_t left, int16_t right, Status*) {
     return static_cast<uint32_t>(left) * static_cast<uint32_t>(right);
   }
   template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_same<T, uint16_t, T> Call(KernelContext*, uint16_t left,
-                                                       uint16_t right, Status*) {
+    requires std::same_as<T, uint16_t>
+  static constexpr T Call(KernelContext*, uint16_t left, uint16_t right, Status*) {
     return static_cast<uint32_t>(left) * static_cast<uint32_t>(right);
   }
 
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_decimal_value<T> Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
+    requires decimal_value<T>
+  static T Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
     return left * right;
   }
 };
 
 struct MultiplyChecked {
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_integer_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                         Status* st) {
+    requires integer_value<T>
+  static T Call(KernelContext*, Arg0 left, Arg1 right, Status* st) {
     static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
     T result = 0;
     if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(left, right, &result))) {
@@ -351,28 +355,29 @@ struct MultiplyChecked {
   }
 
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                          Status*) {
+    requires floating_value<T>
+  static T Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
     static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
     return left * right;
   }
 
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_decimal_value<T> Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
+    requires decimal_value<T>
+  static T Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
     return left * right;
   }
 };
 
 struct Divide {
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                          Status*) {
+    requires floating_value<T>
+  static T Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
     return left / right;
   }
 
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_integer_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                         Status* st) {
+    requires integer_value<T>
+  static T Call(KernelContext*, Arg0 left, Arg1 right, Status* st) {
     T result;
     if (ARROW_PREDICT_FALSE(DivideWithOverflow(left, right, &result))) {
       if (right == 0) {
@@ -385,8 +390,8 @@ struct Divide {
   }
 
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_decimal_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                         Status* st) {
+    requires decimal_value<T>
+  static T Call(KernelContext*, Arg0 left, Arg1 right, Status* st) {
     if (right == Arg1()) {
       *st = Status::Invalid("Divide by zero");
       return T();
@@ -398,8 +403,8 @@ struct Divide {
 
 struct DivideChecked {
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_integer_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                         Status* st) {
+    requires integer_value<T>
+  static T Call(KernelContext*, Arg0 left, Arg1 right, Status* st) {
     static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
     T result;
     if (ARROW_PREDICT_FALSE(DivideWithOverflow(left, right, &result))) {
@@ -413,8 +418,8 @@ struct DivideChecked {
   }
 
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                          Status* st) {
+    requires floating_value<T>
+  static T Call(KernelContext*, Arg0 left, Arg1 right, Status* st) {
     static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
     if (ARROW_PREDICT_FALSE(right == 0)) {
       *st = Status::Invalid("divide by zero");
@@ -424,22 +429,22 @@ struct DivideChecked {
   }
 
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_decimal_value<T> Call(KernelContext* ctx, Arg0 left, Arg1 right,
-                                         Status* st) {
+    requires decimal_value<T>
+  static T Call(KernelContext* ctx, Arg0 left, Arg1 right, Status* st) {
     return Divide::Call<T>(ctx, left, right, st);
   }
 };
 
 struct FloatingDivide {
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_floating_value<Arg0> Call(KernelContext*, Arg0 left, Arg1 right,
-                                             Status*) {
+    requires floating_value<Arg0>
+  static Arg0 Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
     return left / right;
   }
 
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_integer_value<Arg0, double> Call(KernelContext* ctx, Arg0 left,
-                                                    Arg1 right, Status* st) {
+    requires integer_value<Arg0>
+  static double Call(KernelContext* ctx, Arg0 left, Arg1 right, Status* st) {
     static_assert(std::is_same<Arg0, Arg1>::value);
     return Call<double>(ctx, static_cast<double>(left), static_cast<double>(right), st);
   }
@@ -449,8 +454,8 @@ struct FloatingDivide {
 
 struct FloatingDivideChecked {
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_floating_value<Arg0> Call(KernelContext*, Arg0 left, Arg1 right,
-                                             Status* st) {
+    requires floating_value<Arg0>
+  static Arg0 Call(KernelContext*, Arg0 left, Arg1 right, Status* st) {
     static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value);
     if (ARROW_PREDICT_FALSE(right == 0)) {
       *st = Status::Invalid("divide by zero");
@@ -460,8 +465,8 @@ struct FloatingDivideChecked {
   }
 
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_integer_value<Arg0, double> Call(KernelContext* ctx, Arg0 left,
-                                                    Arg1 right, Status* st) {
+    requires integer_value<Arg0>
+  static double Call(KernelContext* ctx, Arg0 left, Arg1 right, Status* st) {
     static_assert(std::is_same<Arg0, Arg1>::value);
     return Call<double>(ctx, static_cast<double>(left), static_cast<double>(right), st);
   }
@@ -470,38 +475,40 @@ struct FloatingDivideChecked {
 
 struct Negate {
   template <typename T, typename Arg>
-  static constexpr enable_if_floating_value<T> Call(KernelContext*, Arg arg, Status*) {
+    requires floating_value<T>
+  static constexpr T Call(KernelContext*, Arg arg, Status*) {
     return -arg;
   }
 
   template <typename T, typename Arg>
-  static constexpr enable_if_half_float_value<T> Call(KernelContext*, Arg arg, Status*) {
+    requires half_float_value<T>
+  static constexpr T Call(KernelContext*, Arg arg, Status*) {
     return -arg;
   }
 
   template <typename T, typename Arg>
-  static constexpr enable_if_unsigned_integer_value<T> Call(KernelContext*, Arg arg,
-                                                            Status*) {
+    requires unsigned_integer_value<T>
+  static constexpr T Call(KernelContext*, Arg arg, Status*) {
     return ~arg + 1;
   }
 
   template <typename T, typename Arg>
-  static constexpr enable_if_signed_integer_value<T> Call(KernelContext*, Arg arg,
-                                                          Status*) {
+    requires signed_integer_value<T>
+  static constexpr T Call(KernelContext*, Arg arg, Status*) {
     return arrow::internal::SafeSignedNegate(arg);
   }
 
   template <typename T, typename Arg>
-  static constexpr enable_if_decimal_value<Arg, T> Call(KernelContext*, Arg arg,
-                                                        Status*) {
+    requires decimal_value<Arg>
+  static constexpr T Call(KernelContext*, Arg arg, Status*) {
     return arg.Negate();
   }
 };
 
 struct NegateChecked {
   template <typename T, typename Arg>
-  static enable_if_signed_integer_value<Arg, T> Call(KernelContext*, Arg arg,
-                                                     Status* st) {
+    requires signed_integer_value<Arg>
+  static T Call(KernelContext*, Arg arg, Status* st) {
     static_assert(std::is_same<T, Arg>::value, "");
     T result = 0;
     if (ARROW_PREDICT_FALSE(NegateWithOverflow(arg, &result))) {
@@ -511,8 +518,8 @@ struct NegateChecked {
   }
 
   template <typename T, typename Arg>
-  static enable_if_unsigned_integer_value<Arg, T> Call(KernelContext* ctx, Arg arg,
-                                                       Status* st) {
+    requires unsigned_integer_value<Arg>
+  static T Call(KernelContext* ctx, Arg arg, Status* st) {
     static_assert(std::is_same<T, Arg>::value, "");
     ARROW_DCHECK(false) << "This is included only for the purposes of instantiability "
                            "from the arithmetic kernel generator";
@@ -520,21 +527,22 @@ struct NegateChecked {
   }
 
   template <typename T, typename Arg>
-  static constexpr enable_if_floating_value<Arg, T> Call(KernelContext*, Arg arg,
-                                                         Status* st) {
+    requires floating_value<Arg>
+  static constexpr T Call(KernelContext*, Arg arg, Status* st) {
     static_assert(std::is_same<T, Arg>::value, "");
     return -arg;
   }
 
   template <typename T, typename Arg>
-  static constexpr enable_if_half_float_value<T> Call(KernelContext*, Arg arg, Status*) {
+    requires half_float_value<T>
+  static constexpr T Call(KernelContext*, Arg arg, Status*) {
     static_assert(std::is_same<T, Arg>::value, "");
     return -arg;
   }
 
   template <typename T, typename Arg>
-  static constexpr enable_if_decimal_value<Arg, T> Call(KernelContext*, Arg arg,
-                                                        Status*) {
+    requires decimal_value<Arg>
+  static constexpr T Call(KernelContext*, Arg arg, Status*) {
     return arg.Negate();
   }
 };
@@ -569,7 +577,8 @@ struct Power {
   }
 
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_integer_value<T> Call(KernelContext*, T base, T exp, Status* st) {
+    requires integer_value<T>
+  static T Call(KernelContext*, T base, T exp, Status* st) {
     if (exp < 0) {
       *st = Status::Invalid("integers to negative integer powers are not allowed");
       return 0;
@@ -578,15 +587,16 @@ struct Power {
   }
 
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_floating_value<T> Call(KernelContext*, T base, T exp, Status*) {
+    requires floating_value<T>
+  static T Call(KernelContext*, T base, T exp, Status*) {
     return std::pow(base, exp);
   }
 };
 
 struct PowerChecked {
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_integer_value<T> Call(KernelContext*, Arg0 base, Arg1 exp,
-                                         Status* st) {
+    requires integer_value<T>
+  static T Call(KernelContext*, Arg0 base, Arg1 exp, Status* st) {
     if (exp < 0) {
       *st = Status::Invalid("integers to negative integer powers are not allowed");
       return 0;
@@ -611,7 +621,8 @@ struct PowerChecked {
   }
 
   template <typename T, typename Arg0, typename Arg1>
-  static enable_if_floating_value<T> Call(KernelContext*, Arg0 base, Arg1 exp, Status*) {
+    requires floating_value<T>
+  static T Call(KernelContext*, Arg0 base, Arg1 exp, Status*) {
     static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
     return std::pow(base, exp);
   }
@@ -619,7 +630,8 @@ struct PowerChecked {
 
 struct SquareRoot {
   template <typename T, typename Arg>
-  static enable_if_floating_value<Arg, T> Call(KernelContext*, Arg arg, Status*) {
+    requires floating_value<Arg>
+  static T Call(KernelContext*, Arg arg, Status*) {
     static_assert(std::is_same<T, Arg>::value, "");
     if (arg < 0.0) {
       return std::numeric_limits<T>::quiet_NaN();
@@ -630,7 +642,8 @@ struct SquareRoot {
 
 struct SquareRootChecked {
   template <typename T, typename Arg>
-  static enable_if_floating_value<Arg, T> Call(KernelContext*, Arg arg, Status* st) {
+    requires floating_value<Arg>
+  static T Call(KernelContext*, Arg arg, Status* st) {
     static_assert(std::is_same<T, Arg>::value, "");
     if (arg < 0.0) {
       *st = Status::Invalid("square root of negative number");
@@ -642,14 +655,14 @@ struct SquareRootChecked {
 
 struct Sign {
   template <typename T, typename Arg>
-  static constexpr enable_if_floating_value<Arg, T> Call(KernelContext*, Arg arg,
-                                                         Status*) {
+    requires floating_value<Arg>
+  static constexpr T Call(KernelContext*, Arg arg, Status*) {
     return std::isnan(arg) ? arg : ((arg == 0) ? 0 : (std::signbit(arg) ? -1 : 1));
   }
 
   template <typename T, typename Arg>
-  static constexpr enable_if_half_float_value<Arg, T> Call(KernelContext*, Arg arg,
-                                                           Status*) {
+    requires half_float_value<Arg>
+  static constexpr T Call(KernelContext*, Arg arg, Status*) {
     return arg.is_nan()
                ? arg
                : (arg.is_zero() ? Float16::zero()
@@ -657,35 +670,35 @@ struct Sign {
   }
 
   template <typename T, typename Arg>
-  static constexpr enable_if_unsigned_integer_value<Arg, T> Call(KernelContext*, Arg arg,
-                                                                 Status*) {
+    requires unsigned_integer_value<Arg>
+  static constexpr T Call(KernelContext*, Arg arg, Status*) {
     return (arg > 0) ? 1 : 0;
   }
 
   template <typename T, typename Arg>
-  static constexpr enable_if_signed_integer_value<Arg, T> Call(KernelContext*, Arg arg,
-                                                               Status*) {
+    requires signed_integer_value<Arg>
+  static constexpr T Call(KernelContext*, Arg arg, Status*) {
     return (arg > 0) ? 1 : ((arg == 0) ? 0 : -1);
   }
 
   template <typename T, typename Arg>
-  static constexpr enable_if_decimal_value<Arg, T> Call(KernelContext*, Arg arg,
-                                                        Status*) {
+    requires decimal_value<Arg>
+  static constexpr T Call(KernelContext*, Arg arg, Status*) {
     return (arg == 0) ? 0 : arg.Sign();
   }
 };
 
 struct Max {
   template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_not_floating_value<T> Call(KernelContext*, Arg0 arg0,
-                                                        Arg1 arg1, Status*) {
+    requires(!std::floating_point<T>)
+  static constexpr T Call(KernelContext*, Arg0 arg0, Arg1 arg1, Status*) {
     static_assert(std::is_same<T, Arg0>::value && std::is_same<Arg0, Arg1>::value);
     return std::max(arg0, arg1);
   }
 
   template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                                    Status*) {
+    requires floating_value<T>
+  static constexpr T Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
     static_assert(std::is_same<T, Arg0>::value && std::is_same<Arg0, Arg1>::value);
     if (std::isnan(left)) {
       return right;
@@ -699,15 +712,15 @@ struct Max {
 
 struct Min {
   template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_not_floating_value<T> Call(KernelContext*, Arg0 arg0,
-                                                        Arg1 arg1, Status*) {
+    requires(!std::floating_point<T>)
+  static constexpr T Call(KernelContext*, Arg0 arg0, Arg1 arg1, Status*) {
     static_assert(std::is_same<T, Arg0>::value && std::is_same<Arg0, Arg1>::value);
     return std::min(arg0, arg1);
   }
 
   template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                                    Status*) {
+    requires floating_value<T>
+  static constexpr T Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
     static_assert(std::is_same<T, Arg0>::value && std::is_same<Arg0, Arg1>::value);
     if (std::isnan(left)) {
       return right;
diff --git a/cpp/src/arrow/compute/kernels/codegen_internal.h b/cpp/src/arrow/compute/kernels/codegen_internal.h
index 15a946fbdbb..ca86997cf05 100644
--- a/cpp/src/arrow/compute/kernels/codegen_internal.h
+++ b/cpp/src/arrow/compute/kernels/codegen_internal.h
@@ -126,8 +126,8 @@ struct KernelStateFromFunctionOptions : public KernelState {
 template <typename Type, typename Enable = void>
 struct GetViewType;
 
-template <typename Type>
-struct GetViewType<Type, enable_if_has_c_type<Type>> {
+template <arrow_has_c_type Type>
+struct GetViewType<Type> {
   using T = typename Type::c_type;
   using PhysicalType = T;
 
@@ -143,9 +143,9 @@ struct GetViewType<HalfFloatType> {
 };
 
 template <typename Type>
-struct GetViewType<Type, enable_if_t<is_base_binary_type<Type>::value ||
-                                     is_fixed_size_binary_type<Type>::value ||
-                                     is_binary_view_like_type<Type>::value>> {
+  requires(arrow_base_binary<Type> || arrow_fixed_size_binary<Type> ||
+           arrow_binary_view_like<Type>)
+struct GetViewType<Type> {
   using T = std::string_view;
   using PhysicalType = T;
 
@@ -203,8 +203,8 @@ struct GetViewType<Decimal256Type> {
 template <typename Type, typename Enable = void>
 struct GetOutputType;
 
-template <typename Type>
-struct GetOutputType<Type, enable_if_has_c_type<Type>> {
+template <arrow_has_c_type Type>
+struct GetOutputType<Type> {
   using T = typename Type::c_type;
 };
 
@@ -213,8 +213,8 @@ struct GetOutputType<HalfFloatType> {
   using T = Float16;
 };
 
-template <typename Type>
-struct GetOutputType<Type, enable_if_t<is_string_like_type<Type>::value>> {
+template <arrow_string_like Type>
+struct GetOutputType<Type> {
   using T = std::string;
 };
 
@@ -283,6 +283,26 @@ using enable_if_decimal_value =
                     std::is_same<Decimal256, T>::value,
                 R>;
 
+// C++20 concept equivalents for C-value types
+template <typename T>
+concept signed_integer_value = is_signed_integer_value<T>::value;
+
+template <typename T>
+concept unsigned_integer_value = is_unsigned_integer_value<T>::value;
+
+template <typename T>
+concept integer_value = signed_integer_value<T> || unsigned_integer_value<T>;
+
+template <typename T>
+concept floating_value = std::floating_point<T>;
+
+template <typename T>
+concept half_float_value = std::same_as<T, Float16>;
+
+template <typename T>
+concept decimal_value = std::same_as<T, Decimal32> || std::same_as<T, Decimal64> ||
+                        std::same_as<T, Decimal128> || std::same_as<T, Decimal256>;
+
 // ----------------------------------------------------------------------
 // Iteration / value access utilities
 
@@ -290,13 +310,18 @@ template <typename T, typename R = void>
 using enable_if_c_number_or_decimal = enable_if_t<
     (has_c_type<T>::value && !is_boolean_type<T>::value) || is_decimal_type<T>::value, R>;
 
+/// \brief Concept for Arrow types stored as a C number or decimal in memory
+template <typename T>
+concept arrow_c_number_or_decimal =
+    (arrow_has_c_type<T> && !arrow_boolean<T>) || arrow_decimal<T>;
+
 // Iterator over various input array types, yielding a GetViewType<Type>
 
 template <typename Type, typename Enable = void>
 struct ArrayIterator;
 
-template <typename Type>
-struct ArrayIterator<Type, enable_if_c_number_or_decimal<Type>> {
+template <arrow_c_number_or_decimal Type>
+struct ArrayIterator<Type> {
   using T = typename TypeTraits<Type>::ScalarType::ValueType;
   const T* values;
 
@@ -313,8 +338,8 @@ struct ArrayIterator<HalfFloatType> {
   T operator()() { return *values++; }
 };
 
-template <typename Type>
-struct ArrayIterator<Type, enable_if_boolean<Type>> {
+template <arrow_boolean Type>
+struct ArrayIterator<Type> {
   BitmapReader reader;
 
   explicit ArrayIterator(const ArraySpan& arr)
@@ -326,8 +351,8 @@ struct ArrayIterator<Type, enable_if_boolean<Type>> {
   }
 };
 
-template <typename Type>
-struct ArrayIterator<Type, enable_if_base_binary<Type>> {
+template <arrow_base_binary Type>
+struct ArrayIterator<Type> {
   using offset_type = typename Type::offset_type;
   const ArraySpan& arr;
   const offset_type* offsets;
@@ -375,8 +400,8 @@ struct ArrayIterator<FixedSizeBinaryType> {
 template <typename Type, typename Enable = void>
 struct OutputArrayWriter;
 
-template <typename Type>
-struct OutputArrayWriter<Type, enable_if_c_number_or_decimal<Type>> {
+template <arrow_c_number_or_decimal Type>
+struct OutputArrayWriter<Type> {
   using T = typename TypeTraits<Type>::ScalarType::ValueType;
   T* values;
 
@@ -398,8 +423,8 @@ struct OutputArrayWriter<Type, enable_if_c_number_or_decimal<Type>> {
 template <typename Type, typename Enable = void>
 struct UnboxScalar;
 
-template <typename Type>
-struct UnboxScalar<Type, enable_if_has_c_type<Type>> {
+template <arrow_has_c_type Type>
+struct UnboxScalar<Type> {
   using T = typename Type::c_type;
   static T Unbox(const Scalar& val) {
     std::string_view view =
@@ -417,8 +442,8 @@ struct UnboxScalar<HalfFloatType> {
   }
 };
 
-template <typename Type>
-struct UnboxScalar<Type, enable_if_has_string_view<Type>> {
+template <arrow_has_string_view Type>
+struct UnboxScalar<Type> {
   using T = std::string_view;
   static T Unbox(const Scalar& val) {
     if (!val.is_valid) return std::string_view();
@@ -585,8 +610,8 @@ static Status SimpleBinary(KernelContext* ctx, const ExecSpan& batch, ExecResult
 template <typename Type, typename Enable = void>
 struct OutputAdapter;
 
-template <typename Type>
-struct OutputAdapter<Type, enable_if_boolean<Type>> {
+template <arrow_boolean Type>
+struct OutputAdapter<Type> {
   template <typename Generator>
   static Status Write(KernelContext*, ArraySpan* out, Generator&& generator) {
     GenerateBitsUnrolled(out->buffers[1].data, out->offset, out->length,
@@ -595,8 +620,8 @@ struct OutputAdapter<Type, enable_if_boolean<Type>> {
   }
 };
 
-template <typename Type>
-struct OutputAdapter<Type, enable_if_c_number_or_decimal<Type>> {
+template <arrow_c_number_or_decimal Type>
+struct OutputAdapter<Type> {
   using T = std::conditional_t<std::is_same_v<Type, HalfFloatType>, Float16,
                                typename TypeTraits<Type>::ScalarType::ValueType>;
 
@@ -611,8 +636,8 @@ struct OutputAdapter<Type, enable_if_c_number_or_decimal<Type>> {
   }
 };
 
-template <typename Type>
-struct OutputAdapter<Type, enable_if_base_binary<Type>> {
+template <arrow_base_binary Type>
+struct OutputAdapter<Type> {
   template <typename Generator>
   static Status Write(KernelContext* ctx, ArraySpan* out, Generator&& generator) {
     return Status::NotImplemented("NYI");
@@ -678,8 +703,8 @@ struct ScalarUnaryNotNullStateful {
     }
   };
 
-  template <typename Type>
-  struct ArrayExec<Type, enable_if_c_number_or_decimal<Type>> {
+  template <arrow_c_number_or_decimal Type>
+  struct ArrayExec<Type> {
     static Status Exec(const ThisType& functor, KernelContext* ctx, const ArraySpan& arg0,
                        ExecResult* out) {
       Status st = Status::OK();
@@ -697,8 +722,8 @@ struct ScalarUnaryNotNullStateful {
     }
   };
 
-  template <typename Type>
-  struct ArrayExec<Type, enable_if_base_binary<Type>> {
+  template <arrow_base_binary Type>
+  struct ArrayExec<Type> {
     static Status Exec(const ThisType& functor, KernelContext* ctx, const ArraySpan& arg0,
                        ExecResult* out) {
       // NOTE: This code is not currently used by any kernels and has
@@ -719,8 +744,8 @@ struct ScalarUnaryNotNullStateful {
     }
   };
 
-  template <typename Type>
-  struct ArrayExec<Type, enable_if_t<is_boolean_type<Type>::value>> {
+  template <arrow_boolean Type>
+  struct ArrayExec<Type> {
     static Status Exec(const ThisType& functor, KernelContext* ctx, const ArraySpan& arg0,
                        ExecResult* out) {
       Status st = Status::OK();
diff --git a/cpp/src/arrow/type_traits.h b/cpp/src/arrow/type_traits.h
index 1b7a02e1085..edab499c9e0 100644
--- a/cpp/src/arrow/type_traits.h
+++ b/cpp/src/arrow/type_traits.h
@@ -17,6 +17,7 @@
 
 #pragma once
 
+#include <concepts>
 #include <memory>
 #include <string>
 #include <type_traits>
@@ -998,6 +999,181 @@ template <typename T, typename R = void>
 using enable_if_physical_floating_point =
     enable_if_t<is_physical_floating_type<T>::value, R>;
 
+//
+// C++20 concepts for Arrow type predicates
+//
+
+/// \addtogroup type-concepts
+/// @{
+
+// -- Primitive type concepts --
+
+template <typename T>
+concept arrow_null = is_null_type<T>::value;
+
+template <typename T>
+concept arrow_boolean = is_boolean_type<T>::value;
+
+template <typename T>
+concept arrow_number = is_number_type<T>::value;
+
+template <typename T>
+concept arrow_integer = is_integer_type<T>::value;
+
+template <typename T>
+concept arrow_signed_integer = is_signed_integer_type<T>::value;
+
+template <typename T>
+concept arrow_unsigned_integer = is_unsigned_integer_type<T>::value;
+
+template <typename T>
+concept arrow_floating_point = is_floating_type<T>::value;
+
+template <typename T>
+concept arrow_half_float = is_half_float_type<T>::value;
+
+template <typename T>
+concept arrow_8bit_int = is_8bit_int<T>::value;
+
+// -- Binary / String type concepts --
+
+template <typename T>
+concept arrow_base_binary = is_base_binary_type<T>::value;
+
+template <typename T>
+concept arrow_binary = is_binary_type<T>::value;
+
+template <typename T>
+concept arrow_string = is_string_type<T>::value;
+
+template <typename T>
+concept arrow_binary_view_like = is_binary_view_like_type<T>::value;
+
+template <typename T>
+concept arrow_binary_view = is_binary_view_type<T>::value;
+
+template <typename T>
+concept arrow_string_view = is_string_view_type<T>::value;
+
+template <typename T>
+concept arrow_string_like = is_string_like_type<T>::value;
+
+template <typename T>
+concept arrow_binary_like = is_binary_like_type<T>::value;
+
+template <typename T>
+concept arrow_fixed_size_binary = is_fixed_size_binary_type<T>::value;
+
+template <typename T>
+concept arrow_fixed_width = is_fixed_width_type<T>::value;
+
+// -- Decimal type concepts --
+
+template <typename T>
+concept arrow_decimal = is_decimal_type<T>::value;
+
+template <typename T>
+concept arrow_decimal32 = is_decimal32_type<T>::value;
+
+template <typename T>
+concept arrow_decimal64 = is_decimal64_type<T>::value;
+
+template <typename T>
+concept arrow_decimal128 = is_decimal128_type<T>::value;
+
+template <typename T>
+concept arrow_decimal256 = is_decimal256_type<T>::value;
+
+// -- Nested type concepts --
+
+template <typename T>
+concept arrow_nested = is_nested_type<T>::value;
+
+template <typename T>
+concept arrow_var_length_list = is_var_length_list_type<T>::value;
+
+template <typename T>
+concept arrow_fixed_size_list = is_fixed_size_list_type<T>::value;
+
+template <typename T>
+concept arrow_list = is_list_type<T>::value;
+
+template <typename T>
+concept arrow_list_view = is_list_view_type<T>::value;
+
+template <typename T>
+concept arrow_list_like = is_list_like_type<T>::value;
+
+template <typename T>
+concept arrow_var_length_list_like = is_var_length_list_like_type<T>::value;
+
+template <typename T>
+concept arrow_struct = is_struct_type<T>::value;
+
+template <typename T>
+concept arrow_union = is_union_type<T>::value;
+
+// -- Temporal type concepts --
+
+template <typename T>
+concept arrow_temporal = is_temporal_type<T>::value;
+
+template <typename T>
+concept arrow_date = is_date_type<T>::value;
+
+template <typename T>
+concept arrow_time = is_time_type<T>::value;
+
+template <typename T>
+concept arrow_timestamp = is_timestamp_type<T>::value;
+
+template <typename T>
+concept arrow_duration = is_duration_type<T>::value;
+
+template <typename T>
+concept arrow_interval = is_interval_type<T>::value;
+
+// -- Special type concepts --
+
+template <typename T>
+concept arrow_run_end_encoded = is_run_end_encoded_type<T>::value;
+
+template <typename T>
+concept arrow_dictionary = is_dictionary_type<T>::value;
+
+template <typename T>
+concept arrow_extension = is_extension_type<T>::value;
+
+// -- Attribute-based concepts --
+
+template <typename T>
+concept arrow_primitive_ctype = is_primitive_ctype<T>::value;
+
+template <typename T>
+concept arrow_has_c_type = has_c_type<T>::value;
+
+template <typename T>
+concept arrow_has_string_view = has_string_view<T>::value;
+
+template <typename T>
+concept arrow_parameter_free = is_parameter_free_type<T>::value;
+
+// -- Physical representation concepts --
+
+template <typename T>
+concept arrow_physical_signed_integer = is_physical_signed_integer_type<T>::value;
+
+template <typename T>
+concept arrow_physical_unsigned_integer = is_physical_unsigned_integer_type<T>::value;
+
+template <typename T>
+concept arrow_physical_integer = is_physical_integer_type<T>::value;
+
+template <typename T>
+concept arrow_physical_floating_point = is_physical_floating_type<T>::value;
+
+/// @}
+
 /// @}
 
 /// \addtogroup runtime-type-predicates
diff --git a/cpp/src/arrow/util/formatting.h b/cpp/src/arrow/util/formatting.h
index 844b6fb91a8..0d5ed37451c 100644
--- a/cpp/src/arrow/util/formatting.h
+++ b/cpp/src/arrow/util/formatting.h
@@ -59,6 +59,9 @@ struct is_formattable {
 template <typename T, typename R = void>
 using enable_if_formattable = enable_if_t<is_formattable<T>::value, R>;
 
+template <typename T>
+concept arrow_formattable = is_formattable<T>::value;
+
 template <typename Appender>
 using Return = decltype(std::declval<Appender>()(std::string_view{}));
 
@@ -546,8 +549,8 @@ class StringFormatter<TimestampType> {
   std::string timezone_;
 };
 
-template <typename T>
-class StringFormatter<T, enable_if_time<T>> {
+template <arrow_time T>
+class StringFormatter<T> {
  public:
   using value_type = typename T::c_type;