diff --git a/cpp/benchmarks/type_dispatcher/type_dispatcher_benchmark.cu b/cpp/benchmarks/type_dispatcher/type_dispatcher_benchmark.cu
index df3a373c576..18ef5a1168e 100644
--- a/cpp/benchmarks/type_dispatcher/type_dispatcher_benchmark.cu
+++ b/cpp/benchmarks/type_dispatcher/type_dispatcher_benchmark.cu
@@ -27,6 +27,7 @@
 
 #include <cudf/detail/utilities/cuda.cuh>
 
+#include <cudf/utilities/traits.hpp>
 #include <random>
 #include <type_traits>
 #include "../fixture/benchmark_fixture.hpp"
@@ -87,7 +88,7 @@ __global__ void host_dispatching_kernel(mutable_column_device_view source_column
 
 template <FunctorType functor_type>
 struct ColumnHandle {
-  template <typename ColumnType>
+  template <typename ColumnType, CUDF_ENABLE_IF(cudf::is_rep_layout_compatible<ColumnType>())>
   void operator()(mutable_column_device_view source_column, int work_per_thread)
   {
     cudf::detail::grid_1d grid_config{source_column.size(), block_size};
@@ -95,6 +96,12 @@ struct ColumnHandle {
     // Launch the kernel.
     host_dispatching_kernel<functor_type, ColumnType><<<grid_size, block_size>>>(source_column);
   }
+
+  template <typename ColumnType, CUDF_ENABLE_IF(not cudf::is_rep_layout_compatible<ColumnType>())>
+  void operator()(mutable_column_device_view source_column, int work_per_thread)
+  {
+    CUDF_FAIL("Invalid type to benchmark.");
+  }
 };
 
 // The following is for DEVICE_DISPATCHING:
@@ -104,12 +111,18 @@ struct ColumnHandle {
 // n_rows * n_cols.
 template <FunctorType functor_type>
 struct RowHandle {
-  template <typename T>
+  template <typename T, CUDF_ENABLE_IF(cudf::is_rep_layout_compatible<T>())>
   __device__ void operator()(mutable_column_device_view source, cudf::size_type index)
   {
     using F                 = Functor<T, functor_type>;
     source.data<T>()[index] = F::f(source.data<T>()[index]);
   }
+
+  template <typename T, CUDF_ENABLE_IF(not cudf::is_rep_layout_compatible<T>())>
+  __device__ void operator()(mutable_column_device_view source, cudf::size_type index)
+  {
+    cudf_assert(false && "Unsupported type.");
+  }
 };
 
 // This is for DEVICE_DISPATCHING
diff --git a/cpp/include/cudf/ast/detail/transform.cuh b/cpp/include/cudf/ast/detail/transform.cuh
index 2719a8b5077..da15ac07c63 100644
--- a/cpp/include/cudf/ast/detail/transform.cuh
+++ b/cpp/include/cudf/ast/detail/transform.cuh
@@ -20,10 +20,12 @@
 #include <cudf/ast/operators.hpp>
 #include <cudf/column/column_device_view.cuh>
 #include <cudf/column/column_factories.hpp>
+#include <cudf/detail/utilities/assert.cuh>
 #include <cudf/scalar/scalar_device_view.cuh>
 #include <cudf/table/table_device_view.cuh>
 #include <cudf/table/table_view.hpp>
 #include <cudf/types.hpp>
+#include <cudf/utilities/traits.hpp>
 
 #include <rmm/cuda_stream_view.hpp>
 
@@ -55,10 +57,19 @@ struct row_output {
    * @param row_index Row index of data column.
    * @param result Value to assign to output.
    */
-  template <typename Element>
+  template <typename Element, CUDF_ENABLE_IF(is_rep_layout_compatible<Element>())>
   __device__ void resolve_output(detail::device_data_reference device_data_reference,
                                  cudf::size_type row_index,
                                  Element result) const;
+  // Definition below after row_evaluator is a complete type
+
+  template <typename Element, CUDF_ENABLE_IF(not is_rep_layout_compatible<Element>())>
+  __device__ void resolve_output(detail::device_data_reference device_data_reference,
+                                 cudf::size_type row_index,
+                                 Element result) const
+  {
+    cudf_assert(false && "Invalid type in resolve_output.");
+  }
 
  private:
   row_evaluator const& evaluator;
@@ -167,7 +178,7 @@ struct row_evaluator {
    * @param row_index Row index of data column.
    * @return Element
    */
-  template <typename Element>
+  template <typename Element, CUDF_ENABLE_IF(column_device_view::has_element_accessor<Element>())>
   __device__ Element resolve_input(detail::device_data_reference device_data_reference,
                                    cudf::size_type row_index) const
   {
@@ -187,6 +198,15 @@ struct row_evaluator {
     }
   }
 
+  template <typename Element,
+            CUDF_ENABLE_IF(not column_device_view::has_element_accessor<Element>())>
+  __device__ Element resolve_input(detail::device_data_reference device_data_reference,
+                                   cudf::size_type row_index) const
+  {
+    cudf_assert(false && "Unsupported type in resolve_input.");
+    return {};
+  }
+
   /**
    * @brief Callable to perform a unary operation.
    *
@@ -249,7 +269,7 @@ struct row_evaluator {
   mutable_column_device_view* output_column;
 };
 
-template <typename Element>
+template <typename Element, std::enable_if_t<is_rep_layout_compatible<Element>()>*>
 __device__ void row_output::resolve_output(detail::device_data_reference device_data_reference,
                                            cudf::size_type row_index,
                                            Element result) const
diff --git a/cpp/include/cudf/column/column_device_view.cuh b/cpp/include/cudf/column/column_device_view.cuh
index 14d44b77fad..a842e51c94a 100644
--- a/cpp/include/cudf/column/column_device_view.cuh
+++ b/cpp/include/cudf/column/column_device_view.cuh
@@ -71,10 +71,14 @@ class alignas(16) column_device_view_base {
    * a column, and instead, accessing the elements should be done via
    *`data<T>()`.
    *
+   * This function will only participate in overload resolution if `is_rep_layout_compatible<T>()`
+   * or `std::is_same<T,void>::value` are true.
+   *
    * @tparam The type to cast to
    * @return T const* Typed pointer to underlying data
    */
-  template <typename T = void>
+  template <typename T = void,
+            CUDF_ENABLE_IF(std::is_same<T, void>::value or is_rep_layout_compatible<T>())>
   __host__ __device__ T const* head() const noexcept
   {
     return static_cast<T const*>(_data);
@@ -89,10 +93,13 @@ class alignas(16) column_device_view_base {
    * For columns with children, the pointer returned is undefined
    * and should not be used.
    *
+   * This function does not participate in overload resolution if `is_rep_layout_compatible<T>` is
+   * false.
+   *
    * @tparam T The type to cast to
    * @return T const* Typed pointer to underlying data, including the offset
    */
-  template <typename T>
+  template <typename T, CUDF_ENABLE_IF(is_rep_layout_compatible<T>())>
   __host__ __device__ T const* data() const noexcept
   {
     return head<T>() + _offset;
@@ -235,6 +242,18 @@ class alignas(16) column_device_view_base {
     : _type{type}, _size{size}, _data{data}, _null_mask{null_mask}, _offset{offset}
   {
   }
+
+  template <typename C, typename T, typename = void>
+  struct has_element_accessor_impl : std::false_type {
+  };
+
+  template <typename C, typename T>
+  struct has_element_accessor_impl<
+    C,
+    T,
+    void_t<decltype(std::declval<C>().template element<T>(std::declval<size_type>()))>>
+    : std::true_type {
+  };
 };
 
 // Forward declaration
@@ -283,15 +302,145 @@ class alignas(16) column_device_view : public detail::column_device_view_base {
    *
    * This function accounts for the offset.
    *
+   * This function does not participate in overload resolution if `is_rep_layout_compatible<T>` is
+   * false. Specializations of this function may exist for types `T` where
+   *`is_rep_layout_compatible<T>` is false.
+   *
    * @tparam T The element type
    * @param element_index Position of the desired element
    */
-  template <typename T>
-  __device__ T const element(size_type element_index) const noexcept
+  template <typename T, CUDF_ENABLE_IF(is_rep_layout_compatible<T>())>
+  __device__ T element(size_type element_index) const noexcept
   {
     return data<T>()[element_index];
   }
 
+  /**
+   * @brief Returns `string_view` to the string element at the specified index.
+   *
+   * If the element at the specified index is NULL, i.e., `is_null(element_index)
+   * == true`, then any attempt to use the result will lead to undefined behavior.
+   *
+   * This function accounts for the offset.
+   *
+   * @param element_index Position of the desired string element
+   * @return string_view instance representing this element at this index
+   */
+  template <typename T, CUDF_ENABLE_IF(std::is_same<T, string_view>::value)>
+  __device__ T element(size_type element_index) const noexcept
+  {
+    size_type index = element_index + offset();  // account for this view's _offset
+    const int32_t* d_offsets =
+      d_children[strings_column_view::offsets_column_index].data<int32_t>();
+    const char* d_strings = d_children[strings_column_view::chars_column_index].data<char>();
+    size_type offset      = d_offsets[index];
+    return string_view{d_strings + offset, d_offsets[index + 1] - offset};
+  }
+
+ private:
+  /**
+   * @brief Dispatch functor for resolving the index value for a dictionary element.
+   *
+   * The basic dictionary elements are the indices which can be any index type.
+   */
+  struct index_element_fn {
+    template <typename IndexType,
+              CUDF_ENABLE_IF(is_index_type<IndexType>() and std::is_unsigned<IndexType>::value)>
+    __device__ size_type operator()(column_device_view const& indices, size_type index)
+    {
+      return static_cast<size_type>(indices.element<IndexType>(index));
+    }
+
+    template <typename IndexType,
+              typename... Args,
+              CUDF_ENABLE_IF(not(is_index_type<IndexType>() and
+                                 std::is_unsigned<IndexType>::value))>
+    __device__ size_type operator()(Args&&... args)
+    {
+      cudf_assert(false and "dictionary indices must be an unsigned integral type");
+      return 0;
+    }
+  };
+
+ public:
+  /**
+   * @brief Returns `dictionary32` element at the specified index for a
+   * dictionary column.
+   *
+   * `dictionary32` is a strongly typed wrapper around an `int32_t` value that holds the
+   * offset into the dictionary keys for the specified element.
+   *
+   * For example, given a dictionary column `d` with:
+   * ```c++
+   * keys: {"foo", "bar", "baz"}
+   * indices: {2, 0, 2, 1, 0}
+   *
+   * d.element<dictionary32>(0) == dictionary32{2};
+   * d.element<dictionary32>(1) == dictionary32{0};
+   * ```
+   *
+   * If the element at the specified index is NULL, i.e., `is_null(element_index) == true`,
+   * then any attempt to use the result will lead to undefined behavior.
+   *
+   * This function accounts for the offset.
+   *
+   * @param element_index Position of the desired element
+   * @return dictionary32 instance representing this element at this index
+   */
+  template <typename T, CUDF_ENABLE_IF(std::is_same<T, dictionary32>::value)>
+  __device__ T element(size_type element_index) const noexcept
+  {
+    size_type index    = element_index + offset();  // account for this view's _offset
+    auto const indices = d_children[0];
+    return dictionary32{type_dispatcher(indices.type(), index_element_fn{}, indices, index)};
+  }
+
+  /**
+   * @brief Returns a `numeric::decimal32` element at the specified index for a `fixed_point`
+   * column.
+   *
+   * If the element at the specified index is NULL, i.e., `is_null(element_index) == true`,
+   * then any attempt to use the result will lead to undefined behavior.
+   *
+   * @param element_index Position of the desired element
+   * @return numeric::decimal32 representing the element at this index
+   */
+  template <typename T, CUDF_ENABLE_IF(std::is_same<T, numeric::decimal32>::value)>
+  __device__ T element(size_type element_index) const noexcept
+  {
+    using namespace numeric;
+    auto const scale = scale_type{_type.scale()};
+    return decimal32{scaled_integer<int32_t>{data<int32_t>()[element_index], scale}};
+  }
+
+  /**
+   * @brief Returns a `numeric::decimal64` element at the specified index for a `fixed_point`
+   * column.
+   *
+   * If the element at the specified index is NULL, i.e., `is_null(element_index) == true`,
+   * then any attempt to use the result will lead to undefined behavior.
+   *
+   * @param element_index Position of the desired element
+   * @return numeric::decimal64 representing the element at this index
+   */
+  template <typename T, CUDF_ENABLE_IF(std::is_same<T, numeric::decimal64>::value)>
+  __device__ T element(size_type element_index) const noexcept
+  {
+    using namespace numeric;
+    auto const scale = scale_type{_type.scale()};
+    return decimal64{scaled_integer<int64_t>{data<int64_t>()[element_index], scale}};
+  }
+
+  /**
+   * @brief For a given `T`, indicates if `column_device_view::element<T>()` has a valid overload.
+   *
+   */
+  template <typename T>
+  static constexpr bool has_element_accessor()
+  {
+    return has_element_accessor_impl<column_device_view, T>::value;
+  }
+
   /**
    * @brief Iterator for navigating this column
    */
@@ -306,9 +455,12 @@ class alignas(16) column_device_view : public detail::column_device_view_base {
    * with columns where `has_nulls() == true` will result in undefined behavior
    * when accessing null elements.
    *
+   * This function does not participate in overload resolution if
+   * `column_device_view::has_element_accessor<T>()` is false.
+   *
    * For columns with null elements, use `make_null_replacement_iterator`.
    */
-  template <typename T>
+  template <typename T, CUDF_ENABLE_IF(column_device_view::has_element_accessor<T>())>
   const_iterator<T> begin() const
   {
     return const_iterator<T>{count_it{0}, detail::value_accessor<T>{*this}};
@@ -321,9 +473,12 @@ class alignas(16) column_device_view : public detail::column_device_view_base {
    * with columns where `has_nulls() == true` will result in undefined behavior
    * when accessing null elements.
    *
+   * This function does not participate in overload resolution if
+   * `column_device_view::has_element_accessor<T>()` is false.
+   *
    * For columns with null elements, use `make_null_replacement_iterator`.
    */
-  template <typename T>
+  template <typename T, CUDF_ENABLE_IF(column_device_view::has_element_accessor<T>())>
   const_iterator<T> end() const
   {
     return const_iterator<T>{count_it{size()}, detail::value_accessor<T>{*this}};
@@ -357,11 +512,16 @@ class alignas(16) column_device_view : public detail::column_device_view_base {
    * Else, if the element at `i` is null, then the value of `p.first` is
    * undefined and `p.second == false`.
    *
+   * This function does not participate in overload resolution if
+   * `column_device_view::has_element_accessor<T>()` is false.
+   *
    * @throws cudf::logic_error if tparam `has_nulls == true` and
    * `nullable() == false`
    * @throws cudf::logic_error if column datatype and Element type mismatch.
    */
-  template <typename T, bool has_nulls>
+  template <typename T,
+            bool has_nulls,
+            CUDF_ENABLE_IF(column_device_view::has_element_accessor<T>())>
   const_pair_iterator<T, has_nulls> pair_begin() const
   {
     return const_pair_iterator<T, has_nulls>{count_it{0},
@@ -382,11 +542,16 @@ class alignas(16) column_device_view : public detail::column_device_view_base {
    * Else, if the element at `i` is null, then the value of `p.first` is
    * undefined and `p.second == false`.
    *
+   * This function does not participate in overload resolution if
+   * `column_device_view::has_element_accessor<T>()` is false.
+   *
    * @throws cudf::logic_error if tparam `has_nulls == true` and
    * `nullable() == false`
    * @throws cudf::logic_error if column datatype and Element type mismatch.
    */
-  template <typename T, bool has_nulls>
+  template <typename T,
+            bool has_nulls,
+            CUDF_ENABLE_IF(column_device_view::has_element_accessor<T>())>
   const_pair_rep_iterator<T, has_nulls> pair_rep_begin() const
   {
     return const_pair_rep_iterator<T, has_nulls>{count_it{0},
@@ -397,11 +562,16 @@ class alignas(16) column_device_view : public detail::column_device_view_base {
    * @brief Return a pair iterator to the element following the last element of
    * the column.
    *
+   * This function does not participate in overload resolution if
+   * `column_device_view::has_element_accessor<T>()` is false.
+   *
    * @throws cudf::logic_error if tparam `has_nulls == true` and
    * `nullable() == false`
    * @throws cudf::logic_error if column datatype and Element type mismatch.
    */
-  template <typename T, bool has_nulls>
+  template <typename T,
+            bool has_nulls,
+            CUDF_ENABLE_IF(column_device_view::has_element_accessor<T>())>
   const_pair_iterator<T, has_nulls> pair_end() const
   {
     return const_pair_iterator<T, has_nulls>{count_it{size()},
@@ -412,11 +582,16 @@ class alignas(16) column_device_view : public detail::column_device_view_base {
    * @brief Return a pair iterator to the element following the last element of
    * the column.
    *
+   * This function does not participate in overload resolution if
+   * `column_device_view::has_element_accessor<T>()` is false.
+   *
    * @throws cudf::logic_error if tparam `has_nulls == true` and
    * `nullable() == false`
    * @throws cudf::logic_error if column datatype and Element type mismatch.
    */
-  template <typename T, bool has_nulls>
+  template <typename T,
+            bool has_nulls,
+            CUDF_ENABLE_IF(column_device_view::has_element_accessor<T>())>
   const_pair_rep_iterator<T, has_nulls> pair_rep_end() const
   {
     return const_pair_rep_iterator<T, has_nulls>{count_it{size()},
@@ -549,6 +724,9 @@ class alignas(16) mutable_column_device_view : public detail::column_device_view
    * @brief Returns pointer to the base device memory allocation casted to
    * the specified type.
    *
+   * This function will only participate in overload resolution if `is_rep_layout_compatible<T>()`
+   * or `std::is_same<T,void>::value` are true.
+   *
    * @note If `offset() == 0`, then `head<T>() == data<T>()`
    *
    * @note It should be rare to need to access the `head<T>()` allocation of
@@ -558,7 +736,8 @@ class alignas(16) mutable_column_device_view : public detail::column_device_view
    * @tparam The type to cast to
    * @return T* Typed pointer to underlying data
    */
-  template <typename T = void>
+  template <typename T = void,
+            CUDF_ENABLE_IF(std::is_same<T, void>::value or is_rep_layout_compatible<T>())>
   __host__ __device__ T* head() const noexcept
   {
     return const_cast<T*>(detail::column_device_view_base::head<T>());
@@ -568,14 +747,15 @@ class alignas(16) mutable_column_device_view : public detail::column_device_view
    * @brief Returns the underlying data casted to the specified type, plus the
    * offset.
    *
-   * @note If `offset() == 0`, then `head<T>() == data<T>()`
+   * This function does not participate in overload resolution if `is_rep_layout_compatible<T>` is
+   * false.
    *
-   * This pointer is undefined for columns with children.
+   * @note If `offset() == 0`, then `head<T>() == data<T>()`
    *
    * @tparam T The type to cast to
    * @return T* Typed pointer to underlying data, including the offset
    */
-  template <typename T>
+  template <typename T, CUDF_ENABLE_IF(is_rep_layout_compatible<T>())>
   __host__ __device__ T* data() const noexcept
   {
     return const_cast<T*>(detail::column_device_view_base::data<T>());
@@ -586,15 +766,31 @@ class alignas(16) mutable_column_device_view : public detail::column_device_view
    *
    * This function accounts for the offset.
    *
+   * This function does not participate in overload resolution if `is_rep_layout_compatible<T>` is
+   * false. Specializations of this function may exist for types `T` where
+   *`is_rep_layout_compatible<T>` is false.
+   *
+   *
    * @tparam T The element type
    * @param element_index Position of the desired element
    */
-  template <typename T>
-  __device__ T& element(size_type element_index) noexcept
+  template <typename T, CUDF_ENABLE_IF(is_rep_layout_compatible<T>())>
+  __device__ T& element(size_type element_index) const noexcept
   {
     return data<T>()[element_index];
   }
 
+  /**
+   * @brief For a given `T`, indicates if `mutable_column_device_view::element<T>()` has a valid
+   * overload.
+   *
+   */
+  template <typename T>
+  static constexpr bool has_element_accessor()
+  {
+    return has_element_accessor_impl<mutable_column_device_view, T>::value;
+  }
+
   /**
    * @brief Returns raw pointer to the underlying bitmask allocation.
    *
@@ -618,11 +814,14 @@ class alignas(16) mutable_column_device_view : public detail::column_device_view
    * @brief Return first element (accounting for offset) after underlying data
    * is casted to the specified type.
    *
+   * This function does not participate in overload resolution if
+   * `mutable_column_device_view::has_element_accessor<T>()` is false.
+   *
    * @tparam T The desired type
    * @return T* Pointer to the first element after casting
    */
-  template <typename T>
-  std::enable_if_t<is_fixed_width<T>(), iterator<T>> begin()
+  template <typename T, CUDF_ENABLE_IF(mutable_column_device_view::has_element_accessor<T>())>
+  iterator<T> begin()
   {
     return iterator<T>{count_it{0}, detail::mutable_value_accessor<T>{*this}};
   }
@@ -631,11 +830,14 @@ class alignas(16) mutable_column_device_view : public detail::column_device_view
    * @brief Return one past the last element after underlying data is casted to
    * the specified type.
    *
+   * This function does not participate in overload resolution if
+   * `mutable_column_device_view::has_element_accessor<T>()` is false.
+   *
    * @tparam T The desired type
    * @return T const* Pointer to one past the last element after casting
    */
-  template <typename T>
-  std::enable_if_t<is_fixed_width<T>(), iterator<T>> end()
+  template <typename T, CUDF_ENABLE_IF(mutable_column_device_view::has_element_accessor<T>())>
+  iterator<T> end()
   {
     return iterator<T>{count_it{size()}, detail::mutable_value_accessor<T>{*this}};
   }
@@ -740,121 +942,6 @@ class alignas(16) mutable_column_device_view : public detail::column_device_view
   mutable_column_device_view(mutable_column_view source);
 };
 
-/**
- * @brief Returns `string_view` to the string element at the specified index.
- *
- * If the element at the specified index is NULL, i.e., `is_null(element_index)
- * == true`, then any attempt to use the result will lead to undefined behavior.
- *
- * This function accounts for the offset.
- *
- * @param element_index Position of the desired string element
- * @return string_view instance representing this element at this index
- */
-template <>
-__device__ inline string_view const column_device_view::element<string_view>(
-  size_type element_index) const noexcept
-{
-  size_type index          = element_index + offset();  // account for this view's _offset
-  const int32_t* d_offsets = d_children[strings_column_view::offsets_column_index].data<int32_t>();
-  const char* d_strings    = d_children[strings_column_view::chars_column_index].data<char>();
-  size_type offset         = d_offsets[index];
-  return string_view{d_strings + offset, d_offsets[index + 1] - offset};
-}
-
-/**
- * @brief Dispatch functor for resolving the index value for a dictionary element.
- *
- * The basic dictionary elements are the indices which can be any index type.
- */
-struct index_element_fn {
-  template <
-    typename IndexType,
-    std::enable_if_t<is_index_type<IndexType>() and std::is_unsigned<IndexType>::value>* = nullptr>
-  __device__ size_type operator()(column_device_view const& input, size_type index)
-  {
-    return static_cast<size_type>(input.element<IndexType>(index));
-  }
-  template <typename IndexType,
-            typename... Args,
-            std::enable_if_t<not(is_index_type<IndexType>() and
-                                 std::is_unsigned<IndexType>::value)>* = nullptr>
-  __device__ size_type operator()(Args&&... args)
-  {
-    cudf_assert(false and "dictionary indices must be an unsigned integral type");
-    return 0;
-  }
-};
-
-/**
- * @brief Returns `dictionary32` element at the specified index for a
- * dictionary column.
- *
- * `dictionary32` is a strongly typed wrapper around an `int32_t` value that holds the
- * offset into the dictionary keys for the specified element.
- *
- * For example, given a dictionary column `d` with:
- * ```c++
- * keys: {"foo", "bar", "baz"}
- * indices: {2, 0, 2, 1, 0}
- *
- * d.element<dictionary32>(0) == dictionary32{2};
- * d.element<dictionary32>(1) == dictionary32{0};
- * ```
- *
- * If the element at the specified index is NULL, i.e., `is_null(element_index) == true`,
- * then any attempt to use the result will lead to undefined behavior.
- *
- * This function accounts for the offset.
- *
- * @param element_index Position of the desired element
- * @return dictionary32 instance representing this element at this index
- */
-template <>
-__device__ inline dictionary32 const column_device_view::element<dictionary32>(
-  size_type element_index) const noexcept
-{
-  size_type index    = element_index + offset();  // account for this view's _offset
-  auto const indices = d_children[0];
-  return dictionary32{type_dispatcher(indices.type(), index_element_fn{}, indices, index)};
-}
-
-/**
- * @brief Returns a `numeric::decimal32` element at the specified index for a `fixed_point` column.
- *
- * If the element at the specified index is NULL, i.e., `is_null(element_index) == true`,
- * then any attempt to use the result will lead to undefined behavior.
- *
- * @param element_index Position of the desired element
- * @return numeric::decimal32 representing the element at this index
- */
-template <>
-__device__ inline numeric::decimal32 const column_device_view::element<numeric::decimal32>(
-  size_type element_index) const noexcept
-{
-  using namespace numeric;
-  auto const scale = scale_type{_type.scale()};
-  return decimal32{scaled_integer<int32_t>{data<int32_t>()[element_index], scale}};
-}
-
-/**
- * @brief Returns a `numeric::decimal64` element at the specified index for a `fixed_point` column.
- *
- * If the element at the specified index is NULL, i.e., `is_null(element_index) == true`,
- * then any attempt to use the result will lead to undefined behavior.
- *
- * @param element_index Position of the desired element
- * @return numeric::decimal64 representing the element at this index
- */
-template <>
-__device__ inline numeric::decimal64 const column_device_view::element<numeric::decimal64>(
-  size_type element_index) const noexcept
-{
-  using namespace numeric;
-  auto const scale = scale_type{_type.scale()};
-  return decimal64{scaled_integer<int64_t>{data<int64_t>()[element_index], scale}};
-}
-
 namespace detail {
 
 #ifdef __CUDACC__  // because set_bit in bit.hpp is wrapped with __CUDACC__
@@ -896,7 +983,6 @@ __device__ inline bitmask_type get_mask_offset_word(bitmask_type const* __restri
  *
  * @tparam T The type of elements in the column
  */
-
 template <typename T>
 struct value_accessor {
   column_device_view const col;  ///< column view of column in device
@@ -1023,8 +1109,8 @@ struct mutable_value_accessor {
 };
 
 /**
- * @brief Helper function for use by column_device_view and mutable_column_device_view constructors
- * to build device_views from views.
+ * @brief Helper function for use by column_device_view and mutable_column_device_view
+ * constructors to build device_views from views.
  *
  * It is used to build the array of child columns in device memory. Since child columns can
  * also have child columns, this uses recursion to build up the flat device buffer to contain
diff --git a/cpp/include/cudf/column/column_view.hpp b/cpp/include/cudf/column/column_view.hpp
index 168db61f672..82326a21d7d 100644
--- a/cpp/include/cudf/column/column_view.hpp
+++ b/cpp/include/cudf/column/column_view.hpp
@@ -16,6 +16,8 @@
 #pragma once
 
 #include <cudf/types.hpp>
+#include <cudf/utilities/traits.hpp>
+
 #include <vector>
 
 /**
@@ -55,10 +57,14 @@ class column_view_base {
    *a column, and instead, accessing the elements should be done via
    *`data<T>()`.
    *
+   * This function will only participate in overload resolution if `is_rep_layout_compatible<T>()`
+   * or `std::is_same<T,void>::value` are true.
+   *
    * @tparam The type to cast to
    * @return T const* Typed pointer to underlying data
    */
-  template <typename T = void>
+  template <typename T = void,
+            CUDF_ENABLE_IF(std::is_same<T, void>::value or is_rep_layout_compatible<T>())>
   T const* head() const noexcept
   {
     return static_cast<T const*>(_data);
@@ -70,12 +76,13 @@ class column_view_base {
    *
    * @note If `offset() == 0`, then `head<T>() == data<T>()`
    *
-   * @TODO Clarify behavior for variable-width types.
+   * This function does not participate in overload resolution if `is_rep_layout_compatible<T>` is
+   * false.
    *
    * @tparam T The type to cast to
    * @return T const* Typed pointer to underlying data, including the offset
    */
-  template <typename T>
+  template <typename T, CUDF_ENABLE_IF(is_rep_layout_compatible<T>())>
   T const* data() const noexcept
   {
     return head<T>() + _offset;
@@ -85,10 +92,13 @@ class column_view_base {
    * @brief Return first element (accounting for offset) after underlying data
    * is casted to the specified type.
    *
+   * This function does not participate in overload resolution if `is_rep_layout_compatible<T>` is
+   * false.
+   *
    * @tparam T The desired type
    * @return T const* Pointer to the first element after casting
    */
-  template <typename T>
+  template <typename T, CUDF_ENABLE_IF(is_rep_layout_compatible<T>())>
   T const* begin() const noexcept
   {
     return data<T>();
@@ -98,10 +108,13 @@ class column_view_base {
    * @brief Return one past the last element after underlying data is casted to
    * the specified type.
    *
+   * This function does not participate in overload resolution if `is_rep_layout_compatible<T>` is
+   * false.
+   *
    * @tparam T The desired type
    * @return T const* Pointer to one past the last element after casting
    */
-  template <typename T>
+  template <typename T, CUDF_ENABLE_IF(is_rep_layout_compatible<T>())>
   T const* end() const noexcept
   {
     return begin<T>() + size();
@@ -438,6 +451,9 @@ class mutable_column_view : public detail::column_view_base {
    * @brief Returns pointer to the base device memory allocation casted to
    * the specified type.
    *
+   * This function will only participate in overload resolution if `is_rep_layout_compatible<T>()`
+   * or `std::is_same<T,void>::value` are true.
+   *
    * @note If `offset() == 0`, then `head<T>() == data<T>()`
    *
    * @note It should be rare to need to access the `head<T>()` allocation of a
@@ -446,7 +462,8 @@ class mutable_column_view : public detail::column_view_base {
    * @tparam The type to cast to
    * @return T* Typed pointer to underlying data
    */
-  template <typename T = void>
+  template <typename T = void,
+            CUDF_ENABLE_IF(std::is_same<T, void>::value or is_rep_layout_compatible<T>())>
   T* head() const noexcept
   {
     return const_cast<T*>(detail::column_view_base::head<T>());
@@ -456,14 +473,15 @@ class mutable_column_view : public detail::column_view_base {
    * @brief Returns the underlying data casted to the specified type, plus the
    * offset.
    *
-   * @note If `offset() == 0`, then `head<T>() == data<T>()`
+   * This function does not participate in overload resolution if `is_rep_layout_compatible<T>` is
+   * false.
    *
-   * @TODO Clarify behavior for variable-width types.
+   * @note If `offset() == 0`, then `head<T>() == data<T>()`
    *
    * @tparam T The type to cast to
    * @return T* Typed pointer to underlying data, including the offset
    */
-  template <typename T>
+  template <typename T, CUDF_ENABLE_IF(is_rep_layout_compatible<T>())>
   T* data() const noexcept
   {
     return const_cast<T*>(detail::column_view_base::data<T>());
@@ -473,10 +491,13 @@ class mutable_column_view : public detail::column_view_base {
    * @brief Return first element (accounting for offset) when underlying data is
    * casted to the specified type.
    *
+   * This function does not participate in overload resolution if `is_rep_layout_compatible<T>` is
+   * false.
+   *
    * @tparam T The desired type
    * @return T* Pointer to the first element after casting
    */
-  template <typename T>
+  template <typename T, CUDF_ENABLE_IF(is_rep_layout_compatible<T>())>
   T* begin() const noexcept
   {
     return const_cast<T*>(detail::column_view_base::begin<T>());
@@ -486,10 +507,13 @@ class mutable_column_view : public detail::column_view_base {
    * @brief Return one past the last element after underlying data is casted to
    * the specified type.
    *
+   * This function does not participate in overload resolution if `is_rep_layout_compatible<T>` is
+   * false.
+   *
    * @tparam T The desired type
    * @return T* Pointer to one past the last element after casting
    */
-  template <typename T>
+  template <typename T, CUDF_ENABLE_IF(is_rep_layout_compatible<T>())>
   T* end() const noexcept
   {
     return const_cast<T*>(detail::column_view_base::end<T>());
diff --git a/cpp/include/cudf/detail/gather.cuh b/cpp/include/cudf/detail/gather.cuh
index 73647ac2292..bf488621d52 100644
--- a/cpp/include/cudf/detail/gather.cuh
+++ b/cpp/include/cudf/detail/gather.cuh
@@ -139,6 +139,46 @@ void gather_helper(InputItr source_itr,
   }
 }
 
+// Error case when no other overload or specialization is available
+template <typename Element, typename Enable = void>
+struct column_gatherer_impl {
+  std::unique_ptr<column> operator()(...) { CUDF_FAIL("Unsupported type in gather."); }
+};
+
+/**
+ * @brief Function object for gathering a type-erased
+ * column. To be used with the cudf::type_dispatcher.
+ */
+struct column_gatherer {
+  /**
+   * @brief Type-dispatched function to gather from one column to another based
+   * on a `gather_map`.
+   *
+   * @tparam Element Dispatched type for the column being gathered
+   * @tparam MapIterator Iterator type for the gather map
+   * @param source_column View into the column to gather from
+   * @param gather_map_begin Beginning of iterator range of integral values representing the gather
+   * map
+   * @param gather_map_end End of iterator range of integral values representing the gather map
+   * @param nullify_out_of_bounds Nullify values in `gather_map` that are out of bounds
+   * @param stream CUDA stream used for device memory operations and kernel launches.
+   * @param mr Device memory resource used to allocate the returned column's device memory
+   */
+  template <typename Element, typename MapIterator>
+  std::unique_ptr<column> operator()(column_view const& source_column,
+                                     MapIterator gather_map_begin,
+                                     MapIterator gather_map_end,
+                                     bool nullify_out_of_bounds,
+                                     rmm::cuda_stream_view stream,
+                                     rmm::mr::device_memory_resource* mr)
+  {
+    column_gatherer_impl<Element> gatherer{};
+
+    return gatherer(
+      source_column, gather_map_begin, gather_map_end, nullify_out_of_bounds, stream, mr);
+  }
+};
+
 /**
  * @brief Function object for gathering a type-erased column.
  *
@@ -148,8 +188,8 @@ void gather_helper(InputItr source_itr,
  * @tparam Element Dispatched type for the column being gathered
  * @tparam MapIterator Iterator type for the gather map
  */
-template <typename Element, typename MapIterator>
-struct column_gatherer_impl {
+template <typename Element>
+struct column_gatherer_impl<Element, std::enable_if_t<is_rep_layout_compatible<Element>()>> {
   /**
    * @brief Type-dispatched function to gather from one column to another based
    * on a `gather_map`.
@@ -164,6 +204,7 @@ struct column_gatherer_impl {
    * @param stream CUDA stream used for device memory operations and kernel launches.
    * @param mr Device memory resource used to allocate the returned column's device memory
    */
+  template <typename MapIterator>
   std::unique_ptr<column> operator()(column_view const& source_column,
                                      MapIterator gather_map_begin,
                                      MapIterator gather_map_end,
@@ -195,8 +236,8 @@ struct column_gatherer_impl {
  *
  * @tparam MapIterator Iterator type for the gather map
  */
-template <typename MapItType>
-struct column_gatherer_impl<string_view, MapItType> {
+template <>
+struct column_gatherer_impl<string_view> {
   /**
    * @brief Type-dispatched function to gather from one column to another based
    * on a `gather_map`. This handles string_view type column_views only.
@@ -209,6 +250,7 @@ struct column_gatherer_impl<string_view, MapItType> {
    * @param stream CUDA stream used for device memory operations and kernel launches.
    * @param mr Device memory resource used to allocate the returned column's device memory
    */
+  template <typename MapItType>
   std::unique_ptr<column> operator()(column_view const& source_column,
                                      MapItType gather_map_begin,
                                      MapItType gather_map_end,
@@ -234,8 +276,8 @@ struct column_gatherer_impl<string_view, MapItType> {
  * This functor is invoked only on the root column of a hierarchy of list
  * columns. Recursion is handled internally.
  */
-template <typename MapItRoot>
-struct column_gatherer_impl<list_view, MapItRoot> {
+template <>
+struct column_gatherer_impl<list_view> {
   /**
    * @brief Gather a list column from a hierarchy of list columns.
    *
@@ -282,6 +324,7 @@ struct column_gatherer_impl<list_view, MapItRoot> {
    * @returns column with elements gathered based on the gather map
    *
    */
+  template <typename MapItRoot>
   std::unique_ptr<column> operator()(column_view const& column,
                                      MapItRoot gather_map_begin,
                                      MapItRoot gather_map_end,
@@ -326,45 +369,11 @@ struct column_gatherer_impl<list_view, MapItRoot> {
   }
 };
 
-/**
- * @brief Function object for gathering a type-erased
- * column. To be used with the cudf::type_dispatcher.
- */
-struct column_gatherer {
-  /**
-   * @brief Type-dispatched function to gather from one column to another based
-   * on a `gather_map`.
-   *
-   * @tparam Element Dispatched type for the column being gathered
-   * @tparam MapIterator Iterator type for the gather map
-   * @param source_column View into the column to gather from
-   * @param gather_map_begin Beginning of iterator range of integral values representing the gather
-   * map
-   * @param gather_map_end End of iterator range of integral values representing the gather map
-   * @param nullify_out_of_bounds Nullify values in `gather_map` that are out of bounds
-   * @param stream CUDA stream used for device memory operations and kernel launches.
-   * @param mr Device memory resource used to allocate the returned column's device memory
-   */
-  template <typename Element, typename MapIterator>
-  std::unique_ptr<column> operator()(column_view const& source_column,
-                                     MapIterator gather_map_begin,
-                                     MapIterator gather_map_end,
-                                     bool nullify_out_of_bounds,
-                                     rmm::cuda_stream_view stream,
-                                     rmm::mr::device_memory_resource* mr)
-  {
-    column_gatherer_impl<Element, MapIterator> gatherer{};
-
-    return gatherer(
-      source_column, gather_map_begin, gather_map_end, nullify_out_of_bounds, stream, mr);
-  }
-};
-
 /**
  * @brief Column gather specialization for dictionary column type.
  */
-template <typename MapItType>
-struct column_gatherer_impl<dictionary32, MapItType> {
+template <>
+struct column_gatherer_impl<dictionary32> {
   /**
    * @brief Type-dispatched function to gather from one column to another based
    * on a `gather_map`.
@@ -378,6 +387,7 @@ struct column_gatherer_impl<dictionary32, MapItType> {
    * @param mr Device memory resource used to allocate the returned column's device memory
    * @return New dictionary column with gathered rows.
    */
+  template <typename MapItType>
   std::unique_ptr<column> operator()(column_view const& source_column,
                                      MapItType gather_map_begin,
                                      MapItType gather_map_end,
@@ -426,6 +436,56 @@ struct column_gatherer_impl<dictionary32, MapItType> {
   }
 };
 
+template <>
+struct column_gatherer_impl<struct_view> {
+  template <typename MapItRoot>
+  std::unique_ptr<column> operator()(column_view const& column,
+                                     MapItRoot gather_map_begin,
+                                     MapItRoot gather_map_end,
+                                     bool nullify_out_of_bounds,
+                                     rmm::cuda_stream_view stream,
+                                     rmm::mr::device_memory_resource* mr)
+  {
+    structs_column_view structs_column(column);
+    auto gather_map_size{std::distance(gather_map_begin, gather_map_end)};
+    if (gather_map_size == 0) { return empty_like(column); }
+
+    std::vector<std::unique_ptr<cudf::column>> output_struct_members;
+    std::transform(structs_column.child_begin(),
+                   structs_column.child_end(),
+                   std::back_inserter(output_struct_members),
+                   [&gather_map_begin, &gather_map_end, nullify_out_of_bounds, stream, mr](
+                     cudf::column_view const& col) {
+                     return cudf::type_dispatcher<dispatch_storage_type>(col.type(),
+                                                                         column_gatherer{},
+                                                                         col,
+                                                                         gather_map_begin,
+                                                                         gather_map_end,
+                                                                         nullify_out_of_bounds,
+                                                                         stream,
+                                                                         mr);
+                   });
+
+    gather_bitmask(
+      // Table view of struct column.
+      cudf::table_view{
+        std::vector<cudf::column_view>{structs_column.child_begin(), structs_column.child_end()}},
+      gather_map_begin,
+      output_struct_members,
+      nullify_out_of_bounds ? gather_bitmask_op::NULLIFY : gather_bitmask_op::DONT_CHECK,
+      stream,
+      mr);
+
+    return cudf::make_structs_column(
+      gather_map_size,
+      std::move(output_struct_members),
+      0,
+      rmm::device_buffer{0, stream, mr},  // Null mask will be fixed up in cudf::gather().
+      stream,
+      mr);
+  }
+};
+
 /**
  * @brief Function object for applying a transformation on the gathermap
  * that converts negative indices to positive indices
@@ -538,55 +598,6 @@ void gather_bitmask(table_view const& source,
   }
 }
 
-template <typename MapItRoot>
-struct column_gatherer_impl<struct_view, MapItRoot> {
-  std::unique_ptr<column> operator()(column_view const& column,
-                                     MapItRoot gather_map_begin,
-                                     MapItRoot gather_map_end,
-                                     bool nullify_out_of_bounds,
-                                     rmm::cuda_stream_view stream,
-                                     rmm::mr::device_memory_resource* mr)
-  {
-    structs_column_view structs_column(column);
-    auto gather_map_size{std::distance(gather_map_begin, gather_map_end)};
-    if (gather_map_size == 0) { return empty_like(column); }
-
-    std::vector<std::unique_ptr<cudf::column>> output_struct_members;
-    std::transform(structs_column.child_begin(),
-                   structs_column.child_end(),
-                   std::back_inserter(output_struct_members),
-                   [&gather_map_begin, &gather_map_end, nullify_out_of_bounds, stream, mr](
-                     cudf::column_view const& col) {
-                     return cudf::type_dispatcher<dispatch_storage_type>(col.type(),
-                                                                         column_gatherer{},
-                                                                         col,
-                                                                         gather_map_begin,
-                                                                         gather_map_end,
-                                                                         nullify_out_of_bounds,
-                                                                         stream,
-                                                                         mr);
-                   });
-
-    gather_bitmask(
-      // Table view of struct column.
-      cudf::table_view{
-        std::vector<cudf::column_view>{structs_column.child_begin(), structs_column.child_end()}},
-      gather_map_begin,
-      output_struct_members,
-      nullify_out_of_bounds ? gather_bitmask_op::NULLIFY : gather_bitmask_op::DONT_CHECK,
-      stream,
-      mr);
-
-    return cudf::make_structs_column(
-      gather_map_size,
-      std::move(output_struct_members),
-      0,
-      rmm::device_buffer{0, stream, mr},  // Null mask will be fixed up in cudf::gather().
-      stream,
-      mr);
-  }
-};
-
 /**
  * @brief Gathers the specified rows of a set of columns according to a gather map.
  *
diff --git a/cpp/include/cudf/detail/scatter.cuh b/cpp/include/cudf/detail/scatter.cuh
index 2cb1cbffc68..30764b9b89f 100644
--- a/cpp/include/cudf/detail/scatter.cuh
+++ b/cpp/include/cudf/detail/scatter.cuh
@@ -79,8 +79,14 @@ auto scatter_to_gather(MapIterator scatter_map_begin,
   return gather_map;
 }
 
-template <typename Element, typename MapIterator>
+template <typename Element, typename Enable = void>
 struct column_scatterer_impl {
+  std::unique_ptr<column> operator()(...) const { CUDF_FAIL("Unsupported type for scatter."); }
+};
+
+template <typename Element>
+struct column_scatterer_impl<Element, std::enable_if_t<cudf::is_fixed_width<Element>()>> {
+  template <typename MapIterator>
   std::unique_ptr<column> operator()(column_view const& source,
                                      MapIterator scatter_map_begin,
                                      MapIterator scatter_map_end,
@@ -103,8 +109,9 @@ struct column_scatterer_impl {
   }
 };
 
-template <typename MapIterator>
-struct column_scatterer_impl<string_view, MapIterator> {
+template <>
+struct column_scatterer_impl<string_view> {
+  template <typename MapIterator>
   std::unique_ptr<column> operator()(column_view const& source,
                                      MapIterator scatter_map_begin,
                                      MapIterator scatter_map_end,
@@ -119,8 +126,9 @@ struct column_scatterer_impl<string_view, MapIterator> {
   }
 };
 
-template <typename MapIterator>
-struct column_scatterer_impl<list_view, MapIterator> {
+template <>
+struct column_scatterer_impl<list_view> {
+  template <typename MapIterator>
   std::unique_ptr<column> operator()(column_view const& source,
                                      MapIterator scatter_map_begin,
                                      MapIterator scatter_map_end,
@@ -133,23 +141,9 @@ struct column_scatterer_impl<list_view, MapIterator> {
   }
 };
 
-template <typename MapIterator>
-struct column_scatterer {
-  template <typename Element>
-  std::unique_ptr<column> operator()(column_view const& source,
-                                     MapIterator scatter_map_begin,
-                                     MapIterator scatter_map_end,
-                                     column_view const& target,
-                                     rmm::cuda_stream_view stream,
-                                     rmm::mr::device_memory_resource* mr) const
-  {
-    column_scatterer_impl<Element, MapIterator> scatterer{};
-    return scatterer(source, scatter_map_begin, scatter_map_end, target, stream, mr);
-  }
-};
-
-template <typename MapIterator>
-struct column_scatterer_impl<dictionary32, MapIterator> {
+template <>
+struct column_scatterer_impl<dictionary32> {
+  template <typename MapIterator>
   std::unique_ptr<column> operator()(column_view const& source_in,
                                      MapIterator scatter_map_begin,
                                      MapIterator scatter_map_end,
@@ -206,6 +200,20 @@ struct column_scatterer_impl<dictionary32, MapIterator> {
   }
 };
 
+struct column_scatterer {
+  template <typename Element, typename MapIterator>
+  std::unique_ptr<column> operator()(column_view const& source,
+                                     MapIterator scatter_map_begin,
+                                     MapIterator scatter_map_end,
+                                     column_view const& target,
+                                     rmm::cuda_stream_view stream,
+                                     rmm::mr::device_memory_resource* mr) const
+  {
+    column_scatterer_impl<Element> scatterer{};
+    return scatterer(source, scatter_map_begin, scatter_map_end, target, stream, mr);
+  }
+};
+
 /**
  * @brief Scatters the rows of the source table into a copy of the target table
  * according to a scatter map.
@@ -276,15 +284,13 @@ std::unique_ptr<table> scatter(
 
   auto result = std::vector<std::unique_ptr<column>>(target.num_columns());
 
-  auto scatter_functor = column_scatterer<decltype(updated_scatter_map_begin)>{};
-
   std::transform(source.begin(),
                  source.end(),
                  target.begin(),
                  result.begin(),
                  [=](auto const& source_col, auto const& target_col) {
                    return type_dispatcher<dispatch_storage_type>(source_col.type(),
-                                                                 scatter_functor,
+                                                                 column_scatterer{},
                                                                  source_col,
                                                                  updated_scatter_map_begin,
                                                                  updated_scatter_map_end,
diff --git a/cpp/include/cudf/lists/detail/scatter.cuh b/cpp/include/cudf/lists/detail/scatter.cuh
index 5dd3db1117c..8e2ecdf49a7 100644
--- a/cpp/include/cudf/lists/detail/scatter.cuh
+++ b/cpp/include/cudf/lists/detail/scatter.cuh
@@ -577,15 +577,15 @@ struct list_child_constructor {
     auto child_offsets = cudf::strings::detail::make_offsets_child_column(
       begin, begin + child_list_views.size(), stream, mr);
 
-    auto child_column =
-      cudf::type_dispatcher(source_lists_column_view.child().child(1).type(),
-                            list_child_constructor{},
-                            child_list_views,
-                            child_offsets->view(),
-                            cudf::lists_column_view(source_lists_column_view.child()),
-                            cudf::lists_column_view(target_lists_column_view.child()),
-                            stream,
-                            mr);
+    auto child_column = cudf::type_dispatcher<dispatch_storage_type>(
+      source_lists_column_view.child().child(1).type(),
+      list_child_constructor{},
+      child_list_views,
+      child_offsets->view(),
+      cudf::lists_column_view(source_lists_column_view.child()),
+      cudf::lists_column_view(target_lists_column_view.child()),
+      stream,
+      mr);
 
     auto child_null_mask =
       source_lists_column_view.child().nullable() || target_lists_column_view.child().nullable()
@@ -672,7 +672,7 @@ struct list_child_constructor {
       iter_target_member_as_list,
       std::back_inserter(child_columns),
       [&](auto source_struct_member_as_list, auto target_struct_member_as_list) {
-        return cudf::type_dispatcher(
+        return cudf::type_dispatcher<dispatch_storage_type>(
           source_struct_member_as_list->child(cudf::lists_column_view::child_column_index).type(),
           list_child_constructor{},
           list_vector,
@@ -780,14 +780,14 @@ std::unique_ptr<column> scatter(
   auto offsets_column = cudf::strings::detail::make_offsets_child_column(
     list_size_begin, list_size_begin + target.size(), stream, mr);
 
-  auto child_column = cudf::type_dispatcher(child_column_type,
-                                            list_child_constructor{},
-                                            target_vector,
-                                            offsets_column->view(),
-                                            source_lists_column_view,
-                                            target_lists_column_view,
-                                            stream,
-                                            mr);
+  auto child_column = cudf::type_dispatcher<dispatch_storage_type>(child_column_type,
+                                                                   list_child_constructor{},
+                                                                   target_vector,
+                                                                   offsets_column->view(),
+                                                                   source_lists_column_view,
+                                                                   target_lists_column_view,
+                                                                   stream,
+                                                                   mr);
 
   auto null_mask =
     target.has_nulls() ? copy_bitmask(target, stream, mr) : rmm::device_buffer{0, stream, mr};
diff --git a/cpp/include/cudf/table/row_operators.cuh b/cpp/include/cudf/table/row_operators.cuh
index 5af3c29a3d9..decd2879f54 100644
--- a/cpp/include/cudf/table/row_operators.cuh
+++ b/cpp/include/cudf/table/row_operators.cuh
@@ -28,6 +28,8 @@
 #include <thrust/swap.h>
 #include <thrust/transform_reduce.h>
 
+#include <limits>
+
 namespace cudf {
 
 /**
@@ -407,39 +409,47 @@ class row_lexicographic_comparator {
 template <template <typename> class hash_function, bool has_nulls = true>
 class element_hasher {
  public:
-  template <typename T>
-  __device__ inline hash_value_type operator()(column_device_view col, size_type row_index)
+  template <typename T, CUDF_ENABLE_IF(column_device_view::has_element_accessor<T>())>
+  __device__ hash_value_type operator()(column_device_view col, size_type row_index) const
   {
     if (has_nulls && col.is_null(row_index)) { return std::numeric_limits<hash_value_type>::max(); }
-
     return hash_function<T>{}(col.element<T>(row_index));
   }
+
+  template <typename T, CUDF_ENABLE_IF(not column_device_view::has_element_accessor<T>())>
+  __device__ hash_value_type operator()(column_device_view col, size_type row_index) const
+  {
+    cudf_assert(false && "Unsupported type in hash.");
+    return {};
+  }
 };
 
 template <template <typename> class hash_function, bool has_nulls = true>
 class element_hasher_with_seed {
  public:
-  __device__ element_hasher_with_seed()
-    : _seed{0}, _null_hash(std::numeric_limits<hash_value_type>::max())
-  {
-  }
-  __device__ element_hasher_with_seed(
-    uint32_t seed = 0, hash_value_type null_hash = std::numeric_limits<hash_value_type>::max())
+  element_hasher_with_seed() = default;
+  __device__ element_hasher_with_seed(uint32_t seed, hash_value_type null_hash)
     : _seed{seed}, _null_hash(null_hash)
   {
   }
-  // seed, null_hash, byte endianness
-  template <typename T>
-  __device__ inline hash_value_type operator()(column_device_view col, size_type row_index)
+
+  template <typename T, CUDF_ENABLE_IF(column_device_view::has_element_accessor<T>())>
+  __device__ hash_value_type operator()(column_device_view col, size_type row_index) const
   {
     if (has_nulls && col.is_null(row_index)) { return _null_hash; }
-
     return hash_function<T>{_seed}(col.element<T>(row_index));
   }
 
+  template <typename T, CUDF_ENABLE_IF(not column_device_view::has_element_accessor<T>())>
+  __device__ hash_value_type operator()(column_device_view col, size_type row_index) const
+  {
+    cudf_assert(false && "Unsupported type in hash.");
+    return {};
+  }
+
  private:
-  uint32_t _seed;
-  hash_value_type _null_hash;
+  uint32_t _seed{0};
+  hash_value_type _null_hash{std::numeric_limits<hash_value_type>::max()};
 };
 
 /**
diff --git a/cpp/include/cudf/utilities/traits.hpp b/cpp/include/cudf/utilities/traits.hpp
index 1e0d45d081d..aa5f554ad40 100644
--- a/cpp/include/cudf/utilities/traits.hpp
+++ b/cpp/include/cudf/utilities/traits.hpp
@@ -34,6 +34,19 @@ namespace cudf {
 template <typename...>
 using void_t = void;
 
+/**
+ * @brief Convenience macro for SFINAE as an unnamed template parameter.
+ *
+ * Example:
+ * \code{cpp}
+ * // This function will participate in overload resolution only if T is an integral type
+ * template <typename T, CUDF_ENABLE_IF(std::is_integral<T>::value)>
+ * void foo();
+ * \endcode
+ *
+ */
+#define CUDF_ENABLE_IF(...) std::enable_if_t<(__VA_ARGS__)>* = nullptr
+
 template <typename L, typename R, typename = void>
 struct is_relationally_comparable_impl : std::false_type {
 };
@@ -443,6 +456,23 @@ constexpr inline bool is_chrono(data_type type)
   return cudf::type_dispatcher(type, is_chrono_impl{});
 }
 
+/**
+ * @brief Indicates whether `T` is layout compatible with its "representation" type.
+ *
+ * For example, in a column, a `decimal32` is concretely represented by a single `int32_t`, but the
+ * `decimal32` type itself contains both the integer representation and the scale. Therefore,
+ * `decimal32` is _not_ layout compatible with `int32_t`.
+ *
+ * As further example, `duration_ns` is distinct from its concrete `int64_t` representation type,
+ * but they are layout compatible.
+ *
+ */
+template <typename T>
+constexpr bool is_rep_layout_compatible()
+{
+  return cudf::is_numeric<T>() or cudf::is_chrono<T>() or cudf::is_boolean<T>();
+}
+
 /**
  * @brief Indicates whether the type `T` is a dictionary type.
  *
diff --git a/cpp/src/copying/copy.cu b/cpp/src/copying/copy.cu
index 422fc0821a0..e6adc027acc 100644
--- a/cpp/src/copying/copy.cu
+++ b/cpp/src/copying/copy.cu
@@ -22,16 +22,21 @@
 #include <cudf/fixed_point/fixed_point.hpp>
 #include <cudf/strings/string_view.cuh>
 
+#include <cudf/utilities/traits.hpp>
 #include <rmm/cuda_stream_view.hpp>
 
 namespace cudf {
 namespace detail {
 namespace {
-/**
- * @brief Specialization of copy_if_else_functor for string_views.
- */
-template <typename T, typename Left, typename Right, typename Filter>
+
+template <typename T, typename Enable = void>
 struct copy_if_else_functor_impl {
+  std::unique_ptr<column> operator()(...) { CUDF_FAIL("Unsupported type for copy_if_else."); }
+};
+
+template <typename T>
+struct copy_if_else_functor_impl<T, std::enable_if_t<is_rep_layout_compatible<T>()>> {
+  template <typename Left, typename Right, typename Filter>
   std::unique_ptr<column> operator()(Left const& lhs,
                                      Right const& rhs,
                                      size_type size,
@@ -69,8 +74,9 @@ struct copy_if_else_functor_impl {
 /**
  * @brief Specialization of copy_if_else_functor for string_views.
  */
-template <typename Left, typename Right, typename Filter>
-struct copy_if_else_functor_impl<string_view, Left, Right, Filter> {
+template <>
+struct copy_if_else_functor_impl<string_view> {
+  template <typename Left, typename Right, typename Filter>
   std::unique_ptr<column> operator()(Left const& lhs,
                                      Right const& rhs,
                                      size_type size,
@@ -107,8 +113,9 @@ struct copy_if_else_functor_impl<string_view, Left, Right, Filter> {
 /**
  * @brief Specialization of copy_if_else_functor for list_views.
  */
-template <typename Left, typename Right, typename Filter>
-struct copy_if_else_functor_impl<list_view, Left, Right, Filter> {
+template <>
+struct copy_if_else_functor_impl<list_view> {
+  template <typename Left, typename Right, typename Filter>
   std::unique_ptr<column> operator()(Left const& lhs,
                                      Right const& rhs,
                                      size_type size,
@@ -122,8 +129,9 @@ struct copy_if_else_functor_impl<list_view, Left, Right, Filter> {
   }
 };
 
-template <typename Left, typename Right, typename Filter>
-struct copy_if_else_functor_impl<struct_view, Left, Right, Filter> {
+template <>
+struct copy_if_else_functor_impl<struct_view> {
+  template <typename Left, typename Right, typename Filter>
   std::unique_ptr<column> operator()(Left const& lhs,
                                      Right const& rhs,
                                      size_type size,
@@ -152,7 +160,7 @@ struct copy_if_else_functor {
                                      rmm::cuda_stream_view stream,
                                      rmm::mr::device_memory_resource* mr)
   {
-    copy_if_else_functor_impl<T, Left, Right, Filter> copier{};
+    copy_if_else_functor_impl<T> copier{};
     return copier(lhs, rhs, size, left_nullable, right_nullable, filter, stream, mr);
   }
 };
diff --git a/cpp/src/copying/copy_range.cu b/cpp/src/copying/copy_range.cu
index 31a8796f950..f4ce9ea27ac 100644
--- a/cpp/src/copying/copy_range.cu
+++ b/cpp/src/copying/copy_range.cu
@@ -70,22 +70,19 @@ struct in_place_copy_range_dispatch {
   cudf::column_view const& source;
   cudf::mutable_column_view& target;
 
-  template <typename T>
-  std::enable_if_t<cudf::is_fixed_width<T>(), void> operator()(cudf::size_type source_begin,
-                                                               cudf::size_type source_end,
-                                                               cudf::size_type target_begin,
-                                                               rmm::cuda_stream_view stream)
+  template <typename T, CUDF_ENABLE_IF(cudf::is_rep_layout_compatible<T>())>
+  void operator()(cudf::size_type source_begin,
+                  cudf::size_type source_end,
+                  cudf::size_type target_begin,
+                  rmm::cuda_stream_view stream)
   {
     in_place_copy_range<T>(source, target, source_begin, source_end, target_begin, stream);
   }
 
-  template <typename T>
-  std::enable_if_t<not cudf::is_fixed_width<T>(), void> operator()(cudf::size_type source_begin,
-                                                                   cudf::size_type source_end,
-                                                                   cudf::size_type target_begin,
-                                                                   rmm::cuda_stream_view stream)
+  template <typename T, typename... Args>
+  void operator()(Args&&...)
   {
-    CUDF_FAIL("in-place copy does not work for variable width types.");
+    CUDF_FAIL("Unsupported type for in-place copy.");
   }
 };
 
@@ -93,7 +90,18 @@ struct out_of_place_copy_range_dispatch {
   cudf::column_view const& source;
   cudf::column_view const& target;
 
-  template <typename T>
+  template <typename T, CUDF_ENABLE_IF(not cudf::is_rep_layout_compatible<T>())>
+  std::unique_ptr<cudf::column> operator()(
+    cudf::size_type source_begin,
+    cudf::size_type source_end,
+    cudf::size_type target_begin,
+    rmm::cuda_stream_view stream,
+    rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource())
+  {
+    CUDF_FAIL("Unsupported type for out of place copy.");
+  }
+
+  template <typename T, CUDF_ENABLE_IF(cudf::is_rep_layout_compatible<T>())>
   std::unique_ptr<cudf::column> operator()(
     cudf::size_type source_begin,
     cudf::size_type source_end,
@@ -237,12 +245,12 @@ void copy_range_in_place(column_view const& source,
                "target should be nullable if source has null values.");
 
   if (source_end != source_begin) {  // otherwise no-op
-    cudf::type_dispatcher(target.type(),
-                          in_place_copy_range_dispatch{source, target},
-                          source_begin,
-                          source_end,
-                          target_begin,
-                          stream);
+    cudf::type_dispatcher<dispatch_storage_type>(target.type(),
+                                                 in_place_copy_range_dispatch{source, target},
+                                                 source_begin,
+                                                 source_end,
+                                                 target_begin,
+                                                 stream);
   }
 }
 
diff --git a/cpp/src/filling/fill.cu b/cpp/src/filling/fill.cu
index e7ae51ded9e..9fc64cd15a4 100644
--- a/cpp/src/filling/fill.cu
+++ b/cpp/src/filling/fill.cu
@@ -94,7 +94,17 @@ struct out_of_place_fill_range_dispatch {
   cudf::scalar const& value;
   cudf::column_view const& input;
 
-  template <typename T>
+  template <typename T, CUDF_ENABLE_IF(not cudf::is_rep_layout_compatible<T>())>
+  std::unique_ptr<cudf::column> operator()(
+    cudf::size_type begin,
+    cudf::size_type end,
+    rmm::cuda_stream_view stream,
+    rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource())
+  {
+    CUDF_FAIL("Unsupported type in fill.");
+  }
+
+  template <typename T, CUDF_ENABLE_IF(cudf::is_rep_layout_compatible<T>())>
   std::unique_ptr<cudf::column> operator()(
     cudf::size_type begin,
     cudf::size_type end,
diff --git a/cpp/src/interop/dlpack.cpp b/cpp/src/interop/dlpack.cpp
index 84dd41907d2..571c695e66e 100644
--- a/cpp/src/interop/dlpack.cpp
+++ b/cpp/src/interop/dlpack.cpp
@@ -25,11 +25,18 @@
 #include <dlpack/dlpack.h>
 
 #include <algorithm>
+#include <cudf/utilities/traits.hpp>
 
 namespace cudf {
 namespace {
 struct get_column_data_impl {
-  template <typename T>
+  template <typename T, CUDF_ENABLE_IF(not is_rep_layout_compatible<T>())>
+  void const* operator()(column_view const& col)
+  {
+    CUDF_FAIL("Unsupported type to convert to dlpack.");
+  }
+
+  template <typename T, CUDF_ENABLE_IF(is_rep_layout_compatible<T>())>
   void const* operator()(column_view const& col)
   {
     return col.data<T>();
diff --git a/cpp/src/interop/from_arrow.cpp b/cpp/src/interop/from_arrow.cpp
index 612e2111b66..99c9b386a15 100644
--- a/cpp/src/interop/from_arrow.cpp
+++ b/cpp/src/interop/from_arrow.cpp
@@ -111,7 +111,17 @@ struct dispatch_to_cudf_column {
     return mask;
   }
 
-  template <typename T>
+  template <typename T, CUDF_ENABLE_IF(not is_rep_layout_compatible<T>())>
+  std::unique_ptr<column> operator()(arrow::Array const& array,
+                                     data_type type,
+                                     bool skip_mask,
+                                     rmm::cuda_stream_view stream,
+                                     rmm::mr::device_memory_resource* mr)
+  {
+    CUDF_FAIL("Unsupported type in from_arrow.");
+  }
+
+  template <typename T, CUDF_ENABLE_IF(is_rep_layout_compatible<T>())>
   std::unique_ptr<column> operator()(arrow::Array const& array,
                                      data_type type,
                                      bool skip_mask,
@@ -124,7 +134,7 @@ struct dispatch_to_cudf_column {
     auto col = make_fixed_width_column(type, num_rows, mask_state::UNALLOCATED, stream, mr);
     auto mutable_column_view = col->mutable_view();
     CUDA_TRY(cudaMemcpyAsync(
-      mutable_column_view.data<void*>(),
+      mutable_column_view.data<T>(),
       reinterpret_cast<const uint8_t*>(data_buffer->address()) + array.offset() * sizeof(T),
       sizeof(T) * num_rows,
       cudaMemcpyDefault,
diff --git a/cpp/src/interop/to_arrow.cpp b/cpp/src/interop/to_arrow.cpp
index 7daffc1a3c3..4bc50b21718 100644
--- a/cpp/src/interop/to_arrow.cpp
+++ b/cpp/src/interop/to_arrow.cpp
@@ -113,7 +113,14 @@ struct dispatch_to_arrow {
     return child_arrays;
   }
 
-  template <typename T>
+  template <typename T, CUDF_ENABLE_IF(not is_rep_layout_compatible<T>())>
+  std::shared_ptr<arrow::Array> operator()(
+    column_view, cudf::type_id, column_metadata const&, arrow::MemoryPool*, rmm::cuda_stream_view)
+  {
+    CUDF_FAIL("Unsupported type for to_arrow.");
+  }
+
+  template <typename T, CUDF_ENABLE_IF(is_rep_layout_compatible<T>())>
   std::shared_ptr<arrow::Array> operator()(column_view input_view,
                                            cudf::type_id id,
                                            column_metadata const& metadata,
diff --git a/cpp/src/jit/type.cpp b/cpp/src/jit/type.cpp
index 6b1e8c57c3d..e833a6fa10f 100644
--- a/cpp/src/jit/type.cpp
+++ b/cpp/src/jit/type.cpp
@@ -16,6 +16,7 @@
 
 #include <cudf/column/column_view.hpp>
 #include <cudf/scalar/scalar.hpp>
+#include <cudf/utilities/traits.hpp>
 #include <cudf/utilities/type_dispatcher.hpp>
 #include <string>
 
@@ -25,15 +26,15 @@ struct get_data_ptr_functor {
   /**
    * @brief Gets the data pointer from a column_view
    */
-  template <typename T>
-  std::enable_if_t<is_fixed_width<T>(), const void*> operator()(column_view const& view)
+  template <typename T, CUDF_ENABLE_IF(is_rep_layout_compatible<T>())>
+  void const* operator()(column_view const& view)
   {
     return static_cast<const void*>(view.template data<T>());
   }
 
   // TODO: both the failing operators can be combined into single template
-  template <typename T>
-  std::enable_if_t<not is_fixed_width<T>(), const void*> operator()(column_view const& view)
+  template <typename T, CUDF_ENABLE_IF(not is_rep_layout_compatible<T>())>
+  void const* operator()(column_view const& view)
   {
     CUDF_FAIL("Invalid data type for JIT operation");
   }
@@ -41,16 +42,16 @@ struct get_data_ptr_functor {
   /**
    * @brief Gets the data pointer from a scalar
    */
-  template <typename T>
-  std::enable_if_t<is_fixed_width<T>(), const void*> operator()(scalar const& s)
+  template <typename T, CUDF_ENABLE_IF(is_rep_layout_compatible<T>())>
+  void const* operator()(scalar const& s)
   {
     using ScalarType = scalar_type_t<T>;
     auto s1          = static_cast<ScalarType const*>(&s);
     return static_cast<const void*>(s1->data());
   }
 
-  template <typename T>
-  std::enable_if_t<not is_fixed_width<T>(), const void*> operator()(scalar const& s)
+  template <typename T, CUDF_ENABLE_IF(not is_rep_layout_compatible<T>())>
+  void const* operator()(scalar const& s)
   {
     CUDF_FAIL("Invalid data type for JIT operation");
   }
@@ -58,12 +59,12 @@ struct get_data_ptr_functor {
 
 const void* get_data_ptr(column_view const& view)
 {
-  return type_dispatcher(view.type(), get_data_ptr_functor{}, view);
+  return type_dispatcher<dispatch_storage_type>(view.type(), get_data_ptr_functor{}, view);
 }
 
 const void* get_data_ptr(scalar const& s)
 {
-  return type_dispatcher(s.type(), get_data_ptr_functor{}, s);
+  return type_dispatcher<dispatch_storage_type>(s.type(), get_data_ptr_functor{}, s);
 }
 
 std::string get_type_name(data_type type)
diff --git a/cpp/src/merge/merge.cu b/cpp/src/merge/merge.cu
index be13405b469..24c0af12938 100644
--- a/cpp/src/merge/merge.cu
+++ b/cpp/src/merge/merge.cu
@@ -35,6 +35,7 @@
 
 #include <queue>
 #include <vector>
+#include "cudf/utilities/traits.hpp"
 
 namespace cudf {
 namespace detail {
@@ -235,10 +236,20 @@ rmm::device_vector<index_type> generate_merged_indices(
 struct column_merger {
   explicit column_merger(index_vector const& row_order) : row_order_(row_order) {}
 
+  template <typename Element, CUDF_ENABLE_IF(not is_rep_layout_compatible<Element>())>
+  std::unique_ptr<column> operator()(
+    column_view const& lcol,
+    column_view const& rcol,
+    rmm::cuda_stream_view stream,
+    rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource()) const
+  {
+    CUDF_FAIL("Unsupported type for merge.");
+  }
+
   // column merger operator;
   //
-  template <typename Element>  // required: column type
-  std::unique_ptr<column> operator()(
+  template <typename Element>
+  std::enable_if_t<is_rep_layout_compatible<Element>(), std::unique_ptr<column>> operator()(
     column_view const& lcol,
     column_view const& rcol,
     rmm::cuda_stream_view stream,
diff --git a/cpp/src/replace/nulls.cu b/cpp/src/replace/nulls.cu
index 50b1b7062d9..afc2bbb37bd 100644
--- a/cpp/src/replace/nulls.cu
+++ b/cpp/src/replace/nulls.cu
@@ -36,6 +36,7 @@
 #include <cudf/strings/detail/utilities.hpp>
 #include <cudf/types.hpp>
 #include <cudf/utilities/error.hpp>
+#include <cudf/utilities/traits.hpp>
 #include <cudf/utilities/type_dispatcher.hpp>
 
 #include <rmm/cuda_stream_view.hpp>
@@ -153,7 +154,7 @@ __global__ void replace_nulls(cudf::column_device_view input,
  *        `replace_nulls` with the appropriate data types.
  */
 struct replace_nulls_column_kernel_forwarder {
-  template <typename col_type, std::enable_if_t<cudf::is_fixed_width<col_type>()>* = nullptr>
+  template <typename col_type, CUDF_ENABLE_IF(cudf::is_rep_layout_compatible<col_type>())>
   std::unique_ptr<cudf::column> operator()(cudf::column_view const& input,
                                            cudf::column_view const& replacement,
                                            rmm::cuda_stream_view stream,
@@ -192,7 +193,7 @@ struct replace_nulls_column_kernel_forwarder {
     return output;
   }
 
-  template <typename col_type, std::enable_if_t<not cudf::is_fixed_width<col_type>()>* = nullptr>
+  template <typename col_type, CUDF_ENABLE_IF(not cudf::is_rep_layout_compatible<col_type>())>
   std::unique_ptr<cudf::column> operator()(cudf::column_view const& input,
                                            cudf::column_view const& replacement,
                                            rmm::cuda_stream_view stream,
diff --git a/cpp/tests/copying/copy_tests.cu b/cpp/tests/copying/copy_tests.cu
index e2f5d1eec5c..e9249a6bd0e 100644
--- a/cpp/tests/copying/copy_tests.cu
+++ b/cpp/tests/copying/copy_tests.cu
@@ -26,6 +26,7 @@
 #include <cudf/detail/copy_if_else.cuh>
 #include <cudf/detail/iterator.cuh>
 #include <cudf/scalar/scalar.hpp>
+#include <cudf/utilities/traits.hpp>
 
 #include <rmm/cuda_stream_view.hpp>
 
@@ -66,7 +67,7 @@ TYPED_TEST(CopyTest, CopyIfElseTestManyNulls)
 }
 
 struct copy_if_else_tiny_grid_functor {
-  template <typename T, typename Filter, std::enable_if_t<cudf::is_fixed_width<T>()>* = nullptr>
+  template <typename T, typename Filter, CUDF_ENABLE_IF(cudf::is_rep_layout_compatible<T>())>
   std::unique_ptr<cudf::column> operator()(cudf::column_view const& lhs,
                                            cudf::column_view const& rhs,
                                            Filter filter,
@@ -91,7 +92,7 @@ struct copy_if_else_tiny_grid_functor {
     return out;
   }
 
-  template <typename T, typename Filter, std::enable_if_t<not cudf::is_fixed_width<T>()>* = nullptr>
+  template <typename T, typename Filter, CUDF_ENABLE_IF(not cudf::is_rep_layout_compatible<T>())>
   std::unique_ptr<cudf::column> operator()(cudf::column_view const& lhs,
                                            cudf::column_view const& rhs,
                                            Filter filter,