diff --git a/sycl/include/sycl/accessor_image.hpp b/sycl/include/sycl/accessor_image.hpp
index 420e3468d22ab..f784561bafd95 100644
--- a/sycl/include/sycl/accessor_image.hpp
+++ b/sycl/include/sycl/accessor_image.hpp
@@ -12,20 +12,21 @@
 namespace sycl {
 inline namespace _V1 {
 namespace detail {
-template <int Dim, typename T> struct IsValidCoordDataT;
-template <typename T> struct IsValidCoordDataT<1, T> {
-  constexpr static bool value = detail::is_contained<
-      T, detail::type_list<opencl::cl_int, opencl::cl_float>>::type::value;
+template <int Dim, typename T, bool AllowFP = true> struct IsValidCoordDataT;
+template <typename T, bool AllowFP> struct IsValidCoordDataT<1, T, AllowFP> {
+  constexpr static bool value =
+      std::is_same_v<T, opencl::cl_int> ||
+      (AllowFP && std::is_same_v<T, opencl::cl_float>);
 };
-template <typename T> struct IsValidCoordDataT<2, T> {
-  constexpr static bool value = detail::is_contained<
-      T, detail::type_list<vec<opencl::cl_int, 2>,
-                           vec<opencl::cl_float, 2>>>::type::value;
+template <typename T, bool AllowFP> struct IsValidCoordDataT<2, T, AllowFP> {
+  constexpr static bool value =
+      std::is_same_v<T, vec<opencl::cl_int, 2>> ||
+      (AllowFP && std::is_same_v<T, vec<opencl::cl_float, 2>>);
 };
-template <typename T> struct IsValidCoordDataT<3, T> {
-  constexpr static bool value = detail::is_contained<
-      T, detail::type_list<vec<opencl::cl_int, 4>,
-                           vec<opencl::cl_float, 4>>>::type::value;
+template <typename T, bool AllowFP> struct IsValidCoordDataT<3, T, AllowFP> {
+  constexpr static bool value =
+      std::is_same_v<T, vec<opencl::cl_int, 4>> ||
+      (AllowFP && std::is_same_v<T, vec<opencl::cl_float, 4>>);
 };
 
 template <int Dim, typename T> struct IsValidUnsampledCoord2020DataT;
@@ -448,12 +449,12 @@ class image_accessor
   // (accessTarget == access::target::image && accessMode == access::mode::read)
   // || (accessTarget == access::target::host_image && ( accessMode ==
   // access::mode::read || accessMode == access::mode::read_write))
-  template <typename CoordT, int Dims = Dimensions,
-            typename = std::enable_if_t<
-                (Dims > 0) && (IsValidCoordDataT<Dims, CoordT>::value) &&
-                (detail::is_genint_v<CoordT>) &&
-                ((IsImageAcc && IsImageAccessReadOnly) ||
-                 (IsHostImageAcc && IsImageAccessAnyRead))>>
+  template <
+      typename CoordT, int Dims = Dimensions,
+      typename = std::enable_if_t<
+          (IsValidCoordDataT<Dims, CoordT, /* AllowFP = */ false>::value) &&
+          ((IsImageAcc && IsImageAccessReadOnly) ||
+           (IsHostImageAcc && IsImageAccessAnyRead))>>
   DataT read(const CoordT &Coords) const {
 #ifdef __SYCL_DEVICE_ONLY__
     return __invoke__ImageRead<DataT, OCLImageTy, CoordT>(MImageObj, Coords);
@@ -470,7 +471,7 @@ class image_accessor
   // access::mode::read || accessMode == access::mode::read_write))
   template <typename CoordT, int Dims = Dimensions,
             typename = std::enable_if_t<
-                (Dims > 0) && (IsValidCoordDataT<Dims, CoordT>::value) &&
+                (IsValidCoordDataT<Dims, CoordT>::value) &&
                 ((IsImageAcc && IsImageAccessReadOnly) ||
                  (IsHostImageAcc && IsImageAccessAnyRead))>>
   DataT read(const CoordT &Coords, const sampler &Smpl) const {
@@ -494,10 +495,10 @@ class image_accessor
   // accessMode == access::mode::read_write))
   template <
       typename CoordT, int Dims = Dimensions,
-      typename = std::enable_if_t<(Dims > 0) && (detail::is_genint_v<CoordT>) &&
-                                  (IsValidCoordDataT<Dims, CoordT>::value) &&
-                                  ((IsImageAcc && IsImageAccessWriteOnly) ||
-                                   (IsHostImageAcc && IsImageAccessAnyWrite))>>
+      typename = std::enable_if_t<
+          (IsValidCoordDataT<Dims, CoordT, /* AllowFP = */ false>::value) &&
+          ((IsImageAcc && IsImageAccessWriteOnly) ||
+           (IsHostImageAcc && IsImageAccessAnyWrite))>>
   void write(const CoordT &Coords, const DataT &Color) const {
 #ifdef __SYCL_DEVICE_ONLY__
     __invoke__ImageWrite<OCLImageTy, CoordT, DataT>(MImageObj, Coords, Color);
@@ -546,23 +547,21 @@ class __image_array_slice__ {
       size_t Idx)
       : MBaseAcc(BaseAcc), MIdx(Idx) {}
 
-  template <typename CoordT, int Dims = Dimensions,
-            typename = std::enable_if_t<
-                (Dims > 0) && (IsValidCoordDataT<Dims, CoordT>::value)>>
+  template <
+      typename CoordT, int Dims = Dimensions,
+      typename = std::enable_if_t<(IsValidCoordDataT<Dims, CoordT>::value)>>
   DataT read(const CoordT &Coords) const {
     return MBaseAcc.read(getAdjustedCoords(Coords));
   }
 
   template <typename CoordT, int Dims = Dimensions,
-            typename = std::enable_if_t<(Dims > 0) &&
-                                        IsValidCoordDataT<Dims, CoordT>::value>>
+            typename = std::enable_if_t<IsValidCoordDataT<Dims, CoordT>::value>>
   DataT read(const CoordT &Coords, const sampler &Smpl) const {
     return MBaseAcc.read(getAdjustedCoords(Coords), Smpl);
   }
 
   template <typename CoordT, int Dims = Dimensions,
-            typename = std::enable_if_t<(Dims > 0) &&
-                                        IsValidCoordDataT<Dims, CoordT>::value>>
+            typename = std::enable_if_t<IsValidCoordDataT<Dims, CoordT>::value>>
   void write(const CoordT &Coords, const DataT &Color) const {
     return MBaseAcc.write(getAdjustedCoords(Coords), Color);
   }
diff --git a/sycl/include/sycl/builtins_utils_vec.hpp b/sycl/include/sycl/builtins_utils_vec.hpp
index eeaff9450b031..178c696495c8e 100644
--- a/sycl/include/sycl/builtins_utils_vec.hpp
+++ b/sycl/include/sycl/builtins_utils_vec.hpp
@@ -8,6 +8,8 @@
 
 #pragma once
 
+#include <sycl/detail/type_traits/vec_marray_traits.hpp>
+
 #include <sycl/builtins_utils_scalar.hpp>
 
 #include <sycl/detail/type_traits.hpp>
@@ -41,19 +43,6 @@ template <typename ElementType, typename... Ts>
 struct is_valid_elem_type<ElementType *, Ts...>
     : std::bool_constant<check_type_in_v<ElementType, Ts...>> {};
 
-// Utility trait for getting the number of elements in T.
-template <typename T>
-struct num_elements : std::integral_constant<size_t, 1> {};
-template <typename T, size_t N>
-struct num_elements<marray<T, N>> : std::integral_constant<size_t, N> {};
-template <typename T, int N>
-struct num_elements<vec<T, N>> : std::integral_constant<size_t, size_t(N)> {};
-template <typename VecT, typename OperationLeftT, typename OperationRightT,
-          template <typename> class OperationCurrentT, int... Indexes>
-struct num_elements<SwizzleOp<VecT, OperationLeftT, OperationRightT,
-                              OperationCurrentT, Indexes...>>
-    : std::integral_constant<size_t, sizeof...(Indexes)> {};
-
 // Utilty trait for checking that the number of elements in T is in Ns.
 template <typename T, size_t... Ns>
 struct is_valid_size
diff --git a/sycl/include/sycl/detail/generic_type_lists.hpp b/sycl/include/sycl/detail/generic_type_lists.hpp
deleted file mode 100644
index c6a62504efbec..0000000000000
--- a/sycl/include/sycl/detail/generic_type_lists.hpp
+++ /dev/null
@@ -1,514 +0,0 @@
-//==-------- generic_type_lists.hpp - SYCL Generic type lists --------------==//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <sycl/access/access.hpp>    // for address_space
-#include <sycl/detail/type_list.hpp> // for type_list, address_space_list
-
-#include <cstddef>     // for byte, size_t
-#include <type_traits> // for conditional_t, is_signed_v, is_...
-
-// Generic type name description, which serves as a description for all valid
-// types of parameters to kernel functions
-
-// Forward declarations
-namespace sycl {
-inline namespace _V1 {
-template <typename T, int N> class __SYCL_EBO vec;
-template <typename Type, std::size_t NumElements> class marray;
-
-namespace detail {
-namespace half_impl {
-class half;
-}
-} // namespace detail
-using half = detail::half_impl::half;
-
-namespace ext::oneapi {
-class bfloat16;
-}
-namespace detail {
-namespace gtl {
-// floating point types
-using scalar_half_list = type_list<half>;
-
-using vector_half_list = type_list<vec<half, 1>, vec<half, 2>, vec<half, 3>,
-                                   vec<half, 4>, vec<half, 8>, vec<half, 16>>;
-
-using marray_half_list =
-    type_list<marray<half, 1>, marray<half, 2>, marray<half, 3>,
-              marray<half, 4>, marray<half, 8>, marray<half, 16>>;
-
-using scalar_vector_half_list = tl_append<scalar_half_list, vector_half_list>;
-
-using half_list =
-    tl_append<scalar_half_list, vector_half_list, marray_half_list>;
-
-using scalar_bfloat16_list = type_list<sycl::ext::oneapi::bfloat16>;
-
-using vector_bfloat16_list = type_list<
-    vec<sycl::ext::oneapi::bfloat16, 1>, vec<sycl::ext::oneapi::bfloat16, 2>,
-    vec<sycl::ext::oneapi::bfloat16, 3>, vec<sycl::ext::oneapi::bfloat16, 4>,
-    vec<sycl::ext::oneapi::bfloat16, 8>, vec<sycl::ext::oneapi::bfloat16, 16>>;
-
-using marray_bfloat16_list = type_list<marray<sycl::ext::oneapi::bfloat16, 1>,
-                                       marray<sycl::ext::oneapi::bfloat16, 2>,
-                                       marray<sycl::ext::oneapi::bfloat16, 3>,
-                                       marray<sycl::ext::oneapi::bfloat16, 4>,
-                                       marray<sycl::ext::oneapi::bfloat16, 8>,
-                                       marray<sycl::ext::oneapi::bfloat16, 16>>;
-
-using scalar_vector_bfloat16_list =
-    tl_append<scalar_bfloat16_list, vector_bfloat16_list>;
-
-using bfloat16_list =
-    tl_append<scalar_bfloat16_list, vector_bfloat16_list, marray_bfloat16_list>;
-
-using half_bfloat16_list = tl_append<scalar_half_list, scalar_bfloat16_list>;
-
-using scalar_float_list = type_list<float>;
-
-using vector_float_list =
-    type_list<vec<float, 1>, vec<float, 2>, vec<float, 3>, vec<float, 4>,
-              vec<float, 8>, vec<float, 16>>;
-
-using marray_float_list =
-    type_list<marray<float, 1>, marray<float, 2>, marray<float, 3>,
-              marray<float, 4>, marray<float, 8>, marray<float, 16>>;
-
-using scalar_vector_float_list =
-    tl_append<scalar_float_list, vector_float_list>;
-
-using float_list =
-    tl_append<scalar_float_list, vector_float_list, marray_float_list>;
-
-using scalar_double_list = type_list<double>;
-
-using vector_double_list =
-    type_list<vec<double, 1>, vec<double, 2>, vec<double, 3>, vec<double, 4>,
-              vec<double, 8>, vec<double, 16>>;
-
-using marray_double_list =
-    type_list<marray<double, 1>, marray<double, 2>, marray<double, 3>,
-              marray<double, 4>, marray<double, 8>, marray<double, 16>>;
-
-using scalar_vector_double_list =
-    tl_append<scalar_double_list, vector_double_list>;
-
-using double_list =
-    tl_append<scalar_double_list, vector_double_list, marray_double_list>;
-
-using scalar_floating_list = tl_append<scalar_float_list, scalar_double_list,
-                                       scalar_half_list, scalar_bfloat16_list>;
-
-using vector_floating_list = tl_append<vector_float_list, vector_double_list,
-                                       vector_half_list, vector_bfloat16_list>;
-
-using marray_floating_list = tl_append<marray_float_list, marray_double_list,
-                                       marray_half_list, marray_bfloat16_list>;
-
-using scalar_vector_floating_list =
-    tl_append<scalar_floating_list, vector_floating_list>;
-
-using floating_list =
-    tl_append<scalar_floating_list, vector_floating_list, marray_floating_list>;
-
-using scalar_default_char_list = type_list<char>;
-
-using vector_default_char_list =
-    type_list<vec<char, 1>, vec<char, 2>, vec<char, 3>, vec<char, 4>,
-              vec<char, 8>, vec<char, 16>>;
-
-using marray_default_char_list =
-    type_list<marray<char, 1>, marray<char, 2>, marray<char, 3>,
-              marray<char, 4>, marray<char, 8>, marray<char, 16>>;
-
-using default_char_list =
-    tl_append<scalar_default_char_list, vector_default_char_list,
-              marray_default_char_list>;
-
-using scalar_signed_char_list = type_list<signed char>;
-
-using vector_signed_char_list =
-    type_list<vec<signed char, 1>, vec<signed char, 2>, vec<signed char, 3>,
-              vec<signed char, 4>, vec<signed char, 8>, vec<signed char, 16>>;
-
-using marray_signed_char_list =
-    type_list<marray<signed char, 1>, marray<signed char, 2>,
-              marray<signed char, 3>, marray<signed char, 4>,
-              marray<signed char, 8>, marray<signed char, 16>>;
-
-using scalar_unsigned_char_list = type_list<unsigned char>;
-
-using vector_unsigned_char_list =
-    type_list<vec<unsigned char, 1>, vec<unsigned char, 2>,
-              vec<unsigned char, 3>, vec<unsigned char, 4>,
-              vec<unsigned char, 8>, vec<unsigned char, 16>>;
-
-using marray_unsigned_char_list =
-    type_list<marray<unsigned char, 1>, marray<unsigned char, 2>,
-              marray<unsigned char, 3>, marray<unsigned char, 4>,
-              marray<unsigned char, 8>, marray<unsigned char, 16>>;
-
-// short int types
-using scalar_signed_short_list = type_list<signed short>;
-
-using vector_signed_short_list =
-    type_list<vec<signed short, 1>, vec<signed short, 2>, vec<signed short, 3>,
-              vec<signed short, 4>, vec<signed short, 8>,
-              vec<signed short, 16>>;
-
-using marray_signed_short_list =
-    type_list<marray<signed short, 1>, marray<signed short, 2>,
-              marray<signed short, 3>, marray<signed short, 4>,
-              marray<signed short, 8>, marray<signed short, 16>>;
-
-using scalar_unsigned_short_list = type_list<unsigned short>;
-
-using vector_unsigned_short_list =
-    type_list<vec<unsigned short, 1>, vec<unsigned short, 2>,
-              vec<unsigned short, 3>, vec<unsigned short, 4>,
-              vec<unsigned short, 8>, vec<unsigned short, 16>>;
-
-using marray_unsigned_short_list =
-    type_list<marray<unsigned short, 1>, marray<unsigned short, 2>,
-              marray<unsigned short, 3>, marray<unsigned short, 4>,
-              marray<unsigned short, 8>, marray<unsigned short, 16>>;
-
-using unsigned_short_list =
-    tl_append<scalar_unsigned_short_list, vector_unsigned_short_list,
-              marray_unsigned_short_list>;
-
-using scalar_short_list =
-    tl_append<scalar_signed_short_list, scalar_unsigned_short_list>;
-
-using vector_short_list =
-    tl_append<vector_signed_short_list, vector_unsigned_short_list,
-              marray_unsigned_short_list>;
-
-using short_list = tl_append<scalar_short_list, vector_short_list>;
-
-// int types
-using scalar_signed_int_list = type_list<signed int>;
-
-using vector_signed_int_list =
-    type_list<vec<signed int, 1>, vec<signed int, 2>, vec<signed int, 3>,
-              vec<signed int, 4>, vec<signed int, 8>, vec<signed int, 16>>;
-
-using marray_signed_int_list =
-    type_list<marray<signed int, 1>, marray<signed int, 2>,
-              marray<signed int, 3>, marray<signed int, 4>,
-              marray<signed int, 8>, marray<signed int, 16>>;
-
-using signed_int_list =
-    tl_append<scalar_signed_int_list, vector_signed_int_list,
-              marray_signed_int_list>;
-
-using scalar_unsigned_int_list = type_list<unsigned int>;
-
-using vector_unsigned_int_list =
-    type_list<vec<unsigned int, 1>, vec<unsigned int, 2>, vec<unsigned int, 3>,
-              vec<unsigned int, 4>, vec<unsigned int, 8>,
-              vec<unsigned int, 16>>;
-
-using marray_unsigned_int_list =
-    type_list<marray<unsigned int, 1>, marray<unsigned int, 2>,
-              marray<unsigned int, 3>, marray<unsigned int, 4>,
-              marray<unsigned int, 8>, marray<unsigned int, 16>>;
-
-using unsigned_int_list =
-    tl_append<scalar_unsigned_int_list, vector_unsigned_int_list,
-              marray_unsigned_int_list>;
-
-using scalar_int_list =
-    tl_append<scalar_signed_int_list, scalar_unsigned_int_list>;
-
-using vector_int_list =
-    tl_append<vector_signed_int_list, vector_unsigned_int_list>;
-
-using marray_int_list =
-    tl_append<marray_signed_int_list, marray_unsigned_int_list>;
-
-using int_list = tl_append<scalar_int_list, vector_int_list, marray_int_list>;
-
-// long types
-using scalar_signed_long_list = type_list<signed long>;
-
-using vector_signed_long_list =
-    type_list<vec<signed long, 1>, vec<signed long, 2>, vec<signed long, 3>,
-              vec<signed long, 4>, vec<signed long, 8>, vec<signed long, 16>>;
-
-using marray_signed_long_list =
-    type_list<marray<signed long, 1>, marray<signed long, 2>,
-              marray<signed long, 3>, marray<signed long, 4>,
-              marray<signed long, 8>, marray<signed long, 16>>;
-
-using signed_long_list =
-    tl_append<scalar_signed_long_list, vector_signed_long_list,
-              marray_signed_long_list>;
-
-using scalar_unsigned_long_list = type_list<unsigned long>;
-
-using vector_unsigned_long_list =
-    type_list<vec<unsigned long, 1>, vec<unsigned long, 2>,
-              vec<unsigned long, 3>, vec<unsigned long, 4>,
-              vec<unsigned long, 8>, vec<unsigned long, 16>>;
-
-using marray_unsigned_long_list =
-    type_list<marray<unsigned long, 1>, marray<unsigned long, 2>,
-              marray<unsigned long, 3>, marray<unsigned long, 4>,
-              marray<unsigned long, 8>, marray<unsigned long, 16>>;
-
-using unsigned_long_list =
-    tl_append<scalar_unsigned_long_list, vector_unsigned_long_list,
-              marray_unsigned_long_list>;
-
-using scalar_long_list =
-    tl_append<scalar_signed_long_list, scalar_unsigned_long_list>;
-
-using vector_long_list =
-    tl_append<vector_signed_long_list, vector_unsigned_long_list>;
-
-using marray_long_list =
-    tl_append<marray_signed_long_list, marray_unsigned_long_list>;
-
-using long_list =
-    tl_append<scalar_long_list, vector_long_list, marray_long_list>;
-
-// long long types
-using scalar_signed_longlong_list = type_list<signed long long>;
-
-using vector_signed_longlong_list =
-    type_list<vec<signed long long, 1>, vec<signed long long, 2>,
-              vec<signed long long, 3>, vec<signed long long, 4>,
-              vec<signed long long, 8>, vec<signed long long, 16>>;
-
-using marray_signed_longlong_list =
-    type_list<marray<signed long long, 1>, marray<signed long long, 2>,
-              marray<signed long long, 3>, marray<signed long long, 4>,
-              marray<signed long long, 8>, marray<signed long long, 16>>;
-
-using signed_longlong_list =
-    tl_append<scalar_signed_longlong_list, vector_signed_longlong_list,
-              marray_signed_longlong_list>;
-
-using scalar_unsigned_longlong_list = type_list<unsigned long long>;
-
-using vector_unsigned_longlong_list =
-    type_list<vec<unsigned long long, 1>, vec<unsigned long long, 2>,
-              vec<unsigned long long, 3>, vec<unsigned long long, 4>,
-              vec<unsigned long long, 8>, vec<unsigned long long, 16>>;
-
-using marray_unsigned_longlong_list =
-    type_list<marray<unsigned long long, 1>, marray<unsigned long long, 2>,
-              marray<unsigned long long, 3>, marray<unsigned long long, 4>,
-              marray<unsigned long long, 8>, marray<unsigned long long, 16>>;
-
-using unsigned_longlong_list =
-    tl_append<scalar_unsigned_longlong_list, vector_unsigned_longlong_list,
-              marray_unsigned_longlong_list>;
-
-using scalar_longlong_list =
-    tl_append<scalar_signed_longlong_list, scalar_unsigned_longlong_list>;
-
-using vector_longlong_list =
-    tl_append<vector_signed_longlong_list, vector_unsigned_longlong_list>;
-
-using marray_longlong_list =
-    tl_append<marray_signed_longlong_list, marray_unsigned_longlong_list>;
-
-using longlong_list =
-    tl_append<scalar_longlong_list, vector_longlong_list, marray_longlong_list>;
-
-// long integer types
-using scalar_signed_long_integer_list =
-    tl_append<scalar_signed_long_list, scalar_signed_longlong_list>;
-
-using vector_signed_long_integer_list =
-    tl_append<vector_signed_long_list, vector_signed_longlong_list>;
-
-using marray_signed_long_integer_list =
-    tl_append<marray_signed_long_list, marray_signed_longlong_list>;
-
-using signed_long_integer_list =
-    tl_append<scalar_signed_long_integer_list, vector_signed_long_integer_list,
-              marray_signed_long_integer_list>;
-
-using scalar_unsigned_long_integer_list =
-    tl_append<scalar_unsigned_long_list, scalar_unsigned_longlong_list>;
-
-using vector_unsigned_long_integer_list =
-    tl_append<vector_unsigned_long_list, vector_unsigned_longlong_list>;
-
-using marray_unsigned_long_integer_list =
-    tl_append<marray_unsigned_long_list, marray_unsigned_longlong_list>;
-
-using unsigned_long_integer_list = tl_append<scalar_unsigned_long_integer_list,
-                                             vector_unsigned_long_integer_list,
-                                             marray_unsigned_long_integer_list>;
-
-using scalar_long_integer_list = tl_append<scalar_signed_long_integer_list,
-                                           scalar_unsigned_long_integer_list>;
-
-using vector_long_integer_list = tl_append<vector_signed_long_integer_list,
-                                           vector_unsigned_long_integer_list>;
-
-using marray_long_integer_list = tl_append<marray_signed_long_integer_list,
-                                           marray_unsigned_long_integer_list>;
-
-using long_integer_list =
-    tl_append<scalar_long_integer_list, vector_long_integer_list,
-              marray_long_integer_list>;
-
-#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-// std::byte
-using scalar_byte_list = type_list<std::byte>;
-
-using vector_byte_list =
-    type_list<vec<std::byte, 1>, vec<std::byte, 2>, vec<std::byte, 3>,
-              vec<std::byte, 4>, vec<std::byte, 8>, vec<std::byte, 16>>;
-
-using marray_byte_list = type_list<marray<std::byte, 1>, marray<std::byte, 2>,
-                                   marray<std::byte, 3>, marray<std::byte, 4>,
-                                   marray<std::byte, 8>, marray<std::byte, 16>>;
-#endif
-
-// integer types
-using scalar_signed_integer_list =
-    tl_append<std::conditional_t<
-                  std::is_signed_v<char>,
-                  tl_append<scalar_default_char_list, scalar_signed_char_list>,
-                  scalar_signed_char_list>,
-              scalar_signed_short_list, scalar_signed_int_list,
-              scalar_signed_long_list, scalar_signed_longlong_list>;
-
-using vector_signed_integer_list =
-    tl_append<std::conditional_t<
-                  std::is_signed_v<char>,
-                  tl_append<vector_default_char_list, vector_signed_char_list>,
-                  vector_signed_char_list>,
-              vector_signed_short_list, vector_signed_int_list,
-              vector_signed_long_list, vector_signed_longlong_list>;
-
-using marray_signed_integer_list =
-    tl_append<std::conditional_t<
-                  std::is_signed_v<char>,
-                  tl_append<marray_default_char_list, marray_signed_char_list>,
-                  marray_signed_char_list>,
-              marray_signed_short_list, marray_signed_int_list,
-              marray_signed_long_list, marray_signed_longlong_list>;
-
-using signed_integer_list =
-    tl_append<scalar_signed_integer_list, vector_signed_integer_list,
-              marray_signed_integer_list>;
-
-using scalar_unsigned_integer_list =
-    tl_append<std::conditional_t<std::is_unsigned_v<char>,
-                                 tl_append<scalar_default_char_list,
-                                           scalar_unsigned_char_list>,
-                                 scalar_unsigned_char_list>,
-              scalar_unsigned_short_list, scalar_unsigned_int_list,
-              scalar_unsigned_long_list, scalar_unsigned_longlong_list
-#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-              ,
-              scalar_byte_list
-#endif
-              >;
-
-using vector_unsigned_integer_list =
-    tl_append<std::conditional_t<std::is_unsigned_v<char>,
-                                 tl_append<vector_default_char_list,
-                                           vector_unsigned_char_list>,
-                                 vector_unsigned_char_list>,
-              vector_unsigned_short_list, vector_unsigned_int_list,
-              vector_unsigned_long_list, vector_unsigned_longlong_list
-#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-              ,
-              vector_byte_list
-#endif
-              >;
-
-using marray_unsigned_integer_list =
-    tl_append<std::conditional_t<std::is_unsigned_v<char>,
-                                 tl_append<marray_default_char_list,
-                                           marray_unsigned_char_list>,
-                                 marray_unsigned_char_list>,
-              marray_unsigned_short_list, marray_unsigned_int_list,
-              marray_unsigned_long_list, marray_unsigned_longlong_list
-#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-              ,
-              marray_byte_list
-#endif
-              >;
-
-using unsigned_integer_list =
-    tl_append<scalar_unsigned_integer_list, vector_unsigned_integer_list,
-              marray_unsigned_integer_list>;
-
-using scalar_integer_list =
-    tl_append<scalar_signed_integer_list, scalar_unsigned_integer_list>;
-
-using vector_integer_list =
-    tl_append<vector_signed_integer_list, vector_unsigned_integer_list>;
-
-using marray_integer_list =
-    tl_append<marray_signed_integer_list, marray_unsigned_integer_list>;
-
-using integer_list =
-    tl_append<scalar_integer_list, vector_integer_list, marray_integer_list>;
-
-// bool types
-
-using marray_bool_list =
-    type_list<marray<bool, 1>, marray<bool, 2>, marray<bool, 3>,
-              marray<bool, 4>, marray<bool, 8>, marray<bool, 16>>;
-
-using scalar_bool_list = type_list<bool>;
-
-using bool_list = tl_append<scalar_bool_list, marray_bool_list>;
-
-using vector_bool_list = type_list<vec<bool, 1>, vec<bool, 2>, vec<bool, 3>,
-                                   vec<bool, 4>, vec<bool, 8>, vec<bool, 16>>;
-
-// basic types
-using scalar_signed_basic_list =
-    tl_append<scalar_floating_list, scalar_signed_integer_list>;
-
-using vector_signed_basic_list =
-    tl_append<vector_floating_list, vector_signed_integer_list>;
-
-using marray_signed_basic_list =
-    tl_append<marray_floating_list, marray_signed_integer_list>;
-
-using signed_basic_list =
-    tl_append<scalar_signed_basic_list, vector_signed_basic_list,
-              marray_signed_basic_list>;
-
-using scalar_unsigned_basic_list = tl_append<scalar_unsigned_integer_list>;
-
-using unsigned_basic_list =
-    tl_append<scalar_unsigned_basic_list, vector_unsigned_integer_list,
-              marray_unsigned_integer_list>;
-
-using vector_basic_list =
-    tl_append<vector_signed_basic_list, vector_unsigned_integer_list>;
-
-} // namespace gtl
-namespace gvl {
-// address spaces
-using nonconst_address_space_list = address_space_list<
-    access::address_space::local_space, access::address_space::global_space,
-    access::address_space::private_space, access::address_space::generic_space,
-    access::address_space::ext_intel_global_device_space,
-    access::address_space::ext_intel_global_host_space>;
-
-} // namespace gvl
-} // namespace detail
-} // namespace _V1
-} // namespace sycl
diff --git a/sycl/include/sycl/detail/generic_type_traits.hpp b/sycl/include/sycl/detail/generic_type_traits.hpp
index aafef77a12067..8f977e2247a44 100644
--- a/sycl/include/sycl/detail/generic_type_traits.hpp
+++ b/sycl/include/sycl/detail/generic_type_traits.hpp
@@ -10,7 +10,6 @@
 
 #include <sycl/access/access.hpp>             // for decorated, address_space
 #include <sycl/aliases.hpp>                   // for half, cl_char, cl_double
-#include <sycl/detail/generic_type_lists.hpp> // for nonconst_address_space...
 #include <sycl/detail/helpers.hpp>            // for marray
 #include <sycl/detail/type_list.hpp>          // for is_contained, find_sam...
 #include <sycl/detail/type_traits.hpp>        // for is_gen_based_on_type_s...
@@ -28,76 +27,56 @@ namespace sycl {
 inline namespace _V1 {
 namespace detail {
 template <typename T>
-inline constexpr bool is_svgenfloatf_v =
-    is_contained_v<T, gtl::scalar_vector_float_list>;
-
-template <typename T>
-inline constexpr bool is_svgenfloatd_v =
-    is_contained_v<T, gtl::scalar_vector_double_list>;
-
-template <typename T>
-inline constexpr bool is_half_v = is_contained_v<T, gtl::scalar_half_list>;
-
-template <typename T>
-inline constexpr bool is_bfloat16_v =
-    is_contained_v<T, gtl::scalar_bfloat16_list>;
-
-template <typename T>
-inline constexpr bool is_half_or_bf16_v =
-    is_contained_v<T, gtl::half_bfloat16_list>;
-
-template <typename T>
-inline constexpr bool is_svgenfloath_v =
-    is_contained_v<T, gtl::scalar_vector_half_list>;
+using is_byte = typename
+#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
+    std::is_same<T, std::byte>;
+#else
+    std::false_type;
+#endif
 
-template <typename T>
-inline constexpr bool is_genfloat_v = is_contained_v<T, gtl::floating_list>;
+template <typename T> inline constexpr bool is_byte_v = is_byte<T>::value;
 
 template <typename T>
 inline constexpr bool is_sgenfloat_v =
-    is_contained_v<T, gtl::scalar_floating_list>;
+    check_type_in_v<T, float, double, half, ext::oneapi::bfloat16>;
 
 template <typename T>
 inline constexpr bool is_vgenfloat_v =
-    is_contained_v<T, gtl::vector_floating_list>;
+    is_vec_v<T> && is_sgenfloat_v<element_type_t<T>>;
 
 template <typename T>
-inline constexpr bool is_svgenfloat_v =
-    is_contained_v<T, gtl::scalar_vector_floating_list>;
-
-template <typename T>
-inline constexpr bool is_genint_v = is_contained_v<T, gtl::signed_int_list>;
-
-template <typename T>
-inline constexpr bool is_geninteger_v = is_contained_v<T, gtl::integer_list>;
-
-template <typename T>
-using is_geninteger = std::bool_constant<is_geninteger_v<T>>;
-
-template <typename T>
-inline constexpr bool is_sgeninteger_v =
-    is_contained_v<T, gtl::scalar_integer_list>;
+inline constexpr bool is_genfloat_v =
+    is_sgenfloat_v<T> || is_vgenfloat_v<T> ||
+    (is_marray_v<T> && is_sgenfloat_v<element_type_t<T>> &&
+     is_allowed_vec_size_v<num_elements_v<T>>);
 
 template <typename T>
 inline constexpr bool is_sigeninteger_v =
-    is_contained_v<T, gtl::scalar_signed_integer_list>;
+    check_type_in_v<T, signed char, short, int, long, long long> ||
+    (std::is_same_v<T, char> && std::is_signed_v<char>);
 
 template <typename T>
 inline constexpr bool is_sugeninteger_v =
-    is_contained_v<T, gtl::scalar_unsigned_integer_list>;
+    check_type_in_v<T, unsigned char, unsigned short, unsigned int,
+                    unsigned long, unsigned long long> ||
+    (std::is_same_v<T, char> && std::is_unsigned_v<char>) || is_byte_v<T>;
 
 template <typename T>
-inline constexpr bool is_genbool_v = is_contained_v<T, gtl::bool_list>;
+inline constexpr bool is_sgeninteger_v =
+    is_sigeninteger_v<T> || is_sugeninteger_v<T>;
 
 template <typename T>
-using is_byte = typename
-#if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
-    std::is_same<T, std::byte>;
-#else
-    std::false_type;
-#endif
+inline constexpr bool is_geninteger_v =
+    is_sgeninteger_v<T> ||
+    (is_vec_v<T> && is_sgeninteger_v<element_type_t<T>>) ||
+    (is_marray_v<T> && is_sgeninteger_v<element_type_t<T>> &&
+     is_allowed_vec_size_v<num_elements_v<T>>);
 
-template <typename T> inline constexpr bool is_byte_v = is_byte<T>::value;
+template <typename T>
+inline constexpr bool is_genbool_v =
+    std::is_same_v<T, bool> ||
+    (is_marray_v<T> && std::is_same_v<element_type_t<T>, bool> &&
+     is_allowed_vec_size_v<num_elements_v<T>>);
 
 template <int Size>
 using fixed_width_unsigned = std::conditional_t<
@@ -152,10 +131,11 @@ template <typename T> auto convertToOpenCLType(T &&x) {
     // sycl::half may convert to _Float16, and we would try to instantiate
     // vec class with _Float16 DataType, which is not expected there. As
     // such, leave vector<half, N> as-is.
-    using MatchingVec = vec<std::conditional_t<is_half_v<ElemTy>, ElemTy,
-                                               decltype(convertToOpenCLType(
-                                                   std::declval<ElemTy>()))>,
-                            no_ref::size()>;
+    using MatchingVec =
+        vec<std::conditional_t<std::is_same_v<ElemTy, half>, ElemTy,
+                               decltype(convertToOpenCLType(
+                                   std::declval<ElemTy>()))>,
+            no_ref::size()>;
 #ifdef __SYCL_DEVICE_ONLY__
     return sycl::bit_cast<typename MatchingVec::vector_t>(x);
 #else
@@ -171,11 +151,11 @@ template <typename T> auto convertToOpenCLType(T &&x) {
                                           fixed_width_unsigned<sizeof(no_ref)>>;
     static_assert(sizeof(OpenCLType) == sizeof(T));
     return static_cast<OpenCLType>(x);
-  } else if constexpr (is_half_v<no_ref>) {
+  } else if constexpr (std::is_same_v<no_ref, half>) {
     using OpenCLType = sycl::detail::half_impl::BIsRepresentationT;
     static_assert(sizeof(OpenCLType) == sizeof(T));
     return static_cast<OpenCLType>(x);
-  } else if constexpr (is_bfloat16_v<no_ref>) {
+  } else if constexpr (std::is_same_v<no_ref, ext::oneapi::bfloat16>) {
     // On host, don't interpret BF16 as uint16.
 #ifdef __SYCL_DEVICE_ONLY__
     using OpenCLType = sycl::ext::oneapi::detail::Bfloat16StorageT;
diff --git a/sycl/include/sycl/detail/type_traits.hpp b/sycl/include/sycl/detail/type_traits.hpp
index 90790633faa9f..df5f9ea53a045 100644
--- a/sycl/include/sycl/detail/type_traits.hpp
+++ b/sycl/include/sycl/detail/type_traits.hpp
@@ -8,8 +8,9 @@
 
 #pragma once
 
+#include <sycl/detail/type_traits/vec_marray_traits.hpp>
+
 #include <sycl/access/access.hpp>             // for decorated, address_space
-#include <sycl/detail/generic_type_lists.hpp> // for vec, marray, integer_list
 #include <sycl/detail/type_list.hpp>          // for is_contained, find_twi...
 
 #include <array>       // for array
@@ -171,18 +172,6 @@ template <typename ElementType> struct get_elem_type_unqual<ElementType *> {
   using type = ElementType;
 };
 
-template <typename T, typename = void>
-struct is_ext_vector : std::false_type {};
-
-// FIXME: unguarded use of non-standard built-in
-template <typename T>
-struct is_ext_vector<
-    T, std::void_t<decltype(__builtin_reduce_max(std::declval<T>()))>>
-    : std::true_type {};
-
-template <typename T>
-inline constexpr bool is_ext_vector_v = is_ext_vector<T>::value;
-
 // FIXME: unguarded use of non-standard built-in
 template <typename T>
 struct get_elem_type_unqual<T, std::enable_if_t<is_ext_vector_v<T>>> {
@@ -255,11 +244,6 @@ template <typename T, int N, template <typename> class S>
 inline constexpr bool is_gen_based_on_type_sizeof_v =
     S<T>::value && (sizeof(vector_element_t<T>) == N);
 
-template <typename> struct is_vec : std::false_type {};
-template <typename T, int N> struct is_vec<sycl::vec<T, N>> : std::true_type {};
-
-template <typename T> constexpr bool is_vec_v = is_vec<T>::value;
-
 template <typename> struct get_vec_size {
   static constexpr int size = 1;
 };
@@ -268,27 +252,6 @@ template <typename T, int N> struct get_vec_size<sycl::vec<T, N>> {
   static constexpr int size = N;
 };
 
-// is_swizzle
-template <typename> struct is_swizzle : std::false_type {};
-template <typename VecT, typename OperationLeftT, typename OperationRightT,
-          template <typename> class OperationCurrentT, int... Indexes>
-struct is_swizzle<SwizzleOp<VecT, OperationLeftT, OperationRightT,
-                            OperationCurrentT, Indexes...>> : std::true_type {};
-
-template <typename T> constexpr bool is_swizzle_v = is_swizzle<T>::value;
-
-// is_swizzle_or_vec_v
-
-template <typename T>
-constexpr bool is_vec_or_swizzle_v = is_vec_v<T> || is_swizzle_v<T>;
-
-// is_marray
-template <typename> struct is_marray : std::false_type {};
-template <typename T, size_t N>
-struct is_marray<sycl::marray<T, N>> : std::true_type {};
-
-template <typename T> constexpr bool is_marray_v = is_marray<T>::value;
-
 // is_integral
 template <typename T>
 struct is_integral : std::is_integral<get_elem_type_t<T>> {};
diff --git a/sycl/include/sycl/detail/type_traits/vec_marray_traits.hpp b/sycl/include/sycl/detail/type_traits/vec_marray_traits.hpp
new file mode 100644
index 0000000000000..8097451352e75
--- /dev/null
+++ b/sycl/include/sycl/detail/type_traits/vec_marray_traits.hpp
@@ -0,0 +1,108 @@
+//==---------- Forward declarations and traits for vector/marray types -----==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include <cstddef>
+#include <type_traits>
+
+#include <sycl/detail/defines_elementary.hpp>
+
+namespace sycl {
+inline namespace _V1 {
+template <typename DataT, int NumElements> class __SYCL_EBO vec;
+
+template <typename DataT, std::size_t N> class marray;
+
+namespace detail {
+template <typename VecT, typename OperationLeftT, typename OperationRightT,
+          template <typename> class OperationCurrentT, int... Indexes>
+class SwizzleOp;
+
+// --------- is_* traits ------------------ //
+template <typename> struct is_vec : std::false_type {};
+template <typename T, int N> struct is_vec<vec<T, N>> : std::true_type {};
+template <typename T> constexpr bool is_vec_v = is_vec<T>::value;
+
+template <typename T, typename = void>
+struct is_ext_vector : std::false_type {};
+#if defined(__has_extension)
+#if __has_extension(attribute_ext_vector_type)
+template <typename T, int N>
+struct is_ext_vector<T __attribute__((ext_vector_type(N)))> : std::true_type {};
+#endif
+#endif
+template <typename T>
+inline constexpr bool is_ext_vector_v = is_ext_vector<T>::value;
+
+template <typename> struct is_swizzle : std::false_type {};
+template <typename VecT, typename OperationLeftT, typename OperationRightT,
+          template <typename> class OperationCurrentT, int... Indexes>
+struct is_swizzle<SwizzleOp<VecT, OperationLeftT, OperationRightT,
+                            OperationCurrentT, Indexes...>> : std::true_type {};
+template <typename T> constexpr bool is_swizzle_v = is_swizzle<T>::value;
+
+template <typename T>
+constexpr bool is_vec_or_swizzle_v = is_vec_v<T> || is_swizzle_v<T>;
+
+template <typename> struct is_marray : std::false_type {};
+template <typename T, std::size_t N>
+struct is_marray<marray<T, N>> : std::true_type {};
+template <typename T> constexpr bool is_marray_v = is_marray<T>::value;
+
+// --------- num_elements trait ------------------ //
+template <typename T>
+struct num_elements : std::integral_constant<std::size_t, 1> {};
+template <typename T, std::size_t N>
+struct num_elements<marray<T, N>> : std::integral_constant<std::size_t, N> {};
+template <typename T, int N>
+struct num_elements<vec<T, N>>
+    : std::integral_constant<std::size_t, std::size_t(N)> {};
+#if defined(__has_extension)
+#if __has_extension(attribute_ext_vector_type)
+template <typename T, int N>
+struct num_elements<T __attribute__((ext_vector_type(N)))>
+    : std::integral_constant<std::size_t, N> {};
+#endif
+#endif
+template <typename VecT, typename OperationLeftT, typename OperationRightT,
+          template <typename> class OperationCurrentT, int... Indexes>
+struct num_elements<SwizzleOp<VecT, OperationLeftT, OperationRightT,
+                              OperationCurrentT, Indexes...>>
+    : std::integral_constant<std::size_t, sizeof...(Indexes)> {};
+
+template <typename T>
+inline constexpr std::size_t num_elements_v = num_elements<T>::value;
+
+// --------- element_type trait ------------------ //
+template <typename T, typename = void> struct element_type {
+  using type = T;
+};
+template <typename T, int N> struct element_type<vec<T, N>> {
+  using type = T;
+};
+template <typename T, std::size_t N> struct element_type<marray<T, N>> {
+  using type = T;
+};
+#if defined(__has_extension)
+#if __has_extension(attribute_ext_vector_type)
+template <typename T, int N>
+struct element_type<T __attribute__((ext_vector_type(N)))> {
+  using type = T;
+};
+#endif
+#endif
+template <typename T> using element_type_t = typename element_type<T>::type;
+
+template <int N>
+inline constexpr bool is_allowed_vec_size_v =
+    N == 1 || N == 2 || N == 3 || N == 4 || N == 8 || N == 16;
+
+} // namespace detail
+} // namespace _V1
+} // namespace sycl
diff --git a/sycl/include/sycl/ext/oneapi/bf16_storage_builtins.hpp b/sycl/include/sycl/ext/oneapi/bf16_storage_builtins.hpp
index ee1bea39cae69..4352705693730 100644
--- a/sycl/include/sycl/ext/oneapi/bf16_storage_builtins.hpp
+++ b/sycl/include/sycl/ext/oneapi/bf16_storage_builtins.hpp
@@ -11,7 +11,6 @@
 #include <sycl/__spirv/spirv_ops.hpp>
 #include <sycl/builtins.hpp>
 #include <sycl/detail/builtins/builtins.hpp>
-#include <sycl/detail/generic_type_lists.hpp>
 #include <sycl/detail/generic_type_traits.hpp>
 #include <sycl/detail/type_traits.hpp>
 
diff --git a/sycl/include/sycl/ext/oneapi/experimental/builtins.hpp b/sycl/include/sycl/ext/oneapi/experimental/builtins.hpp
index facc486ca2f84..28d6864750855 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/builtins.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/builtins.hpp
@@ -95,9 +95,13 @@ namespace native {
 // sycl::native::tanh is only implemented on nvptx backend so far. For other
 // backends we revert to the sycl::tanh impl.
 template <typename T>
-inline __SYCL_ALWAYS_INLINE std::enable_if_t<
-    sycl::detail::is_svgenfloatf_v<T> || sycl::detail::is_svgenfloath_v<T>, T>
-tanh(T x) __NOEXC {
+inline __SYCL_ALWAYS_INLINE
+    std::enable_if_t<std::is_same_v<T, float> || std::is_same_v<T, half> ||
+                         (detail::is_vec_v<T> &&
+                          (std::is_same_v<detail::element_type_t<T>, float> ||
+                           std::is_same_v<detail::element_type_t<T>, half>)),
+                     T>
+    tanh(T x) __NOEXC {
 #if defined(__NVPTX__)
   return sycl::detail::convertFromOpenCLTypeFor<T>(
       __clc_native_tanh(sycl::detail::convertToOpenCLType(x)));
@@ -144,7 +148,10 @@ inline __SYCL_ALWAYS_INLINE
 // For other backends we revert to the sycl::exp2 impl.
 template <typename T>
 inline __SYCL_ALWAYS_INLINE
-    std::enable_if_t<sycl::detail::is_svgenfloath_v<T>, T>
+    std::enable_if_t<std::is_same_v<T, half> ||
+                         (detail::is_vec_v<T> &&
+                          std::is_same_v<detail::element_type_t<T>, half>),
+                     T>
     exp2(T x) __NOEXC {
 #if defined(__NVPTX__)
   return sycl::detail::convertFromOpenCLTypeFor<T>(
diff --git a/sycl/include/sycl/ext/oneapi/experimental/cuda/builtins.hpp b/sycl/include/sycl/ext/oneapi/experimental/cuda/builtins.hpp
index 06d5318c525db..f96878a123acf 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/cuda/builtins.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/cuda/builtins.hpp
@@ -44,17 +44,13 @@ using ldg_vector_types = sycl::detail::type_list<
     sycl::vec<half, 2>, sycl::vec<half, 3>, sycl::vec<half, 4>,
     sycl::vec<float, 2>, sycl::vec<float, 3>, sycl::vec<float, 4>,
     sycl::vec<double, 2>, sycl::vec<double, 3>, sycl::vec<double, 4>>;
-
-using ldg_types =
-    sycl::detail::tl_append<ldg_vector_types,
-                            sycl::detail::gtl::scalar_signed_basic_list,
-                            sycl::detail::gtl::scalar_unsigned_basic_list>;
 } // namespace detail
 
 template <typename T>
 inline __SYCL_ALWAYS_INLINE std::enable_if_t<
-    sycl::detail::is_contained<
-        T, sycl::ext::oneapi::experimental::cuda::detail::ldg_types>::value,
+    sycl::detail::is_sgeninteger_v<T> || sycl::detail::is_sgenfloat_v<T> ||
+        sycl::detail::is_contained<T, sycl::ext::oneapi::experimental::cuda::
+                                          detail::ldg_vector_types>::value,
     T>
 ldg(const T *ptr) {
 #if defined(__SYCL_DEVICE_ONLY__)
diff --git a/sycl/include/sycl/types.hpp b/sycl/include/sycl/types.hpp
index 87698c835a3ee..599ba89819241 100644
--- a/sycl/include/sycl/types.hpp
+++ b/sycl/include/sycl/types.hpp
@@ -12,7 +12,6 @@
 #include <sycl/aliases.hpp>                    // for half, cl_char, cl_int
 #include <sycl/detail/common.hpp>              // for ArrayCreator, RepeatV...
 #include <sycl/detail/defines_elementary.hpp>  // for __SYCL2020_DEPRECATED
-#include <sycl/detail/generic_type_lists.hpp>  // for vector_basic_list
 #include <sycl/detail/generic_type_traits.hpp> // for is_sigeninteger, is_s...
 #include <sycl/detail/is_device_copyable.hpp>
 #include <sycl/detail/type_list.hpp>           // for is_contained
diff --git a/sycl/include/sycl/vector.hpp b/sycl/include/sycl/vector.hpp
index c8d2273094c60..01e70f639e7b5 100644
--- a/sycl/include/sycl/vector.hpp
+++ b/sycl/include/sycl/vector.hpp
@@ -30,10 +30,8 @@
 #include <sycl/aliases.hpp>                    // for half, cl_char, cl_int
 #include <sycl/detail/common.hpp>              // for ArrayCreator, RepeatV...
 #include <sycl/detail/defines_elementary.hpp>  // for __SYCL2020_DEPRECATED
-#include <sycl/detail/generic_type_lists.hpp>  // for vector_basic_list
 #include <sycl/detail/generic_type_traits.hpp> // for is_sigeninteger, is_s...
 #include <sycl/detail/memcpy.hpp>              // for memcpy
-#include <sycl/detail/type_list.hpp>           // for is_contained
 #include <sycl/detail/type_traits.hpp>         // for is_floating_point
 #include <sycl/detail/vector_arith.hpp>
 #include <sycl/half_type.hpp>                  // for StorageT, half, Vec16...
@@ -121,6 +119,11 @@ struct ScalarConversionOperatorMixIn<Vec, T, N, std::enable_if_t<N == 1>> {
   operator T() const { return (*static_cast<const Vec *>(this))[0]; }
 };
 
+template <typename T>
+inline constexpr bool is_fundamental_or_half_or_bfloat16 =
+    std::is_fundamental_v<T> || std::is_same_v<std::remove_const_t<T>, half> ||
+    std::is_same_v<std::remove_const_t<T>, ext::oneapi::bfloat16>;
+
 } // namespace detail
 
 ///////////////////////// class sycl::vec /////////////////////////
@@ -134,8 +137,7 @@ class __SYCL_EBO vec
   static_assert(std::is_same_v<DataT, std::remove_cv_t<DataT>>,
                 "DataT must be cv-unqualified");
 
-  static_assert(NumElements == 1 || NumElements == 2 || NumElements == 3 ||
-                    NumElements == 4 || NumElements == 8 || NumElements == 16,
+  static_assert(detail::is_allowed_vec_size_v<NumElements>,
                 "Invalid number of elements for sycl::vec: only 1, 2, 3, 4, 8 "
                 "or 16 are supported");
   static_assert(sizeof(bool) == sizeof(uint8_t), "bool size is not 1 byte");
@@ -290,10 +292,8 @@ class __SYCL_EBO vec
   // when NumElements == 1. The template prevents implicit conversion from
   // vec<_, 1> to DataT.
   template <typename Ty = DataT>
-  typename std::enable_if_t<
-      std::is_fundamental_v<Ty> ||
-          detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
-      vec &>
+  typename std::enable_if_t<detail::is_fundamental_or_half_or_bfloat16<Ty>,
+                            vec &>
   operator=(const DataT &Rhs) {
     *this = vec{Rhs};
     return *this;
@@ -628,16 +628,14 @@ class SwizzleOp {
       1 != IdxNum && SwizzleOp::getNumElements() == IdxNum, T>;
 
   template <typename T>
-  using EnableIfScalarType = typename std::enable_if_t<
-      std::is_convertible_v<DataT, T> &&
-      (std::is_fundamental_v<T> ||
-       detail::is_half_or_bf16_v<typename std::remove_const_t<T>>)>;
+  using EnableIfScalarType =
+      typename std::enable_if_t<std::is_convertible_v<DataT, T> &&
+                                detail::is_fundamental_or_half_or_bfloat16<T>>;
 
   template <typename T>
-  using EnableIfNoScalarType = typename std::enable_if_t<
-      !std::is_convertible_v<DataT, T> ||
-      !(std::is_fundamental_v<T> ||
-        detail::is_half_or_bf16_v<typename std::remove_const_t<T>>)>;
+  using EnableIfNoScalarType =
+      typename std::enable_if_t<!std::is_convertible_v<DataT, T> ||
+                                !detail::is_fundamental_or_half_or_bfloat16<T>>;
 
   template <int... Indices>
   using Swizzle =
@@ -1242,11 +1240,9 @@ class SwizzleOp {
     static_assert((sizeof(Tmp) == sizeof(asT)),
                   "The new SYCL vec type must have the same storage size in "
                   "bytes as this SYCL swizzled vec");
-    static_assert(
-        detail::is_contained<asT, detail::gtl::vector_basic_list>::value ||
-            detail::is_contained<asT, detail::gtl::vector_bool_list>::value,
-        "asT must be SYCL vec of a different element type and "
-        "number of elements specified by asT");
+    static_assert(detail::is_vec_v<asT>,
+                  "asT must be SYCL vec of a different element type and "
+                  "number of elements specified by asT");
     return Tmp.template as<asT>();
   }
 
diff --git a/sycl/test/basic_tests/generic_type_traits.cpp b/sycl/test/basic_tests/generic_type_traits.cpp
index 853473e3c61f3..3586d25cab588 100644
--- a/sycl/test/basic_tests/generic_type_traits.cpp
+++ b/sycl/test/basic_tests/generic_type_traits.cpp
@@ -23,12 +23,6 @@ int main() {
   static_assert(d::is_genfloat_v<s::opencl::cl_float> == true);
   static_assert(d::is_genfloat_v<s::vec<s::opencl::cl_float, 4>> == true);
 
-  static_assert(d::is_half_v<s::half>);
-
-  static_assert(d::is_bfloat16_v<sycl::ext::oneapi::bfloat16>);
-  static_assert(d::is_half_or_bf16_v<s::half>);
-  static_assert(d::is_half_or_bf16_v<sycl::ext::oneapi::bfloat16>);
-
   // TODO add checks for the following type traits
   /*
   is_doublen
diff --git a/sycl/test/include_deps/sycl_accessor.hpp.cpp b/sycl/test/include_deps/sycl_accessor.hpp.cpp
index 2dce0b3d7696b..622ea90da7006 100644
--- a/sycl/test/include_deps/sycl_accessor.hpp.cpp
+++ b/sycl/test/include_deps/sycl_accessor.hpp.cpp
@@ -24,7 +24,7 @@
 // CHECK-NEXT: info/aspects.def
 // CHECK-NEXT: info/aspects_deprecated.def
 // CHECK-NEXT: detail/type_traits.hpp
-// CHECK-NEXT: detail/generic_type_lists.hpp
+// CHECK-NEXT: detail/type_traits/vec_marray_traits.hpp
 // CHECK-NEXT: detail/type_list.hpp
 // CHECK-NEXT: detail/boost/mp11/algorithm.hpp
 // CHECK-NEXT: detail/boost/mp11/list.hpp
@@ -112,5 +112,5 @@
 // CHECK-NEXT: detail/string_view.hpp
 // CHECK-NEXT: detail/util.hpp
 // CHECK-NEXT: device_selector.hpp
-// CHECK-NEXT: buffer_properties.def
+// CHECK-NEXT: properties/buffer_properties.def
 // CHECK-EMPTY:
diff --git a/sycl/test/include_deps/sycl_detail_core.hpp.cpp b/sycl/test/include_deps/sycl_detail_core.hpp.cpp
index 917996b10cfa6..c35c4b558d7d9 100644
--- a/sycl/test/include_deps/sycl_detail_core.hpp.cpp
+++ b/sycl/test/include_deps/sycl_detail_core.hpp.cpp
@@ -25,7 +25,7 @@
 // CHECK-NEXT: info/aspects.def
 // CHECK-NEXT: info/aspects_deprecated.def
 // CHECK-NEXT: detail/type_traits.hpp
-// CHECK-NEXT: detail/generic_type_lists.hpp
+// CHECK-NEXT: detail/type_traits/vec_marray_traits.hpp
 // CHECK-NEXT: detail/type_list.hpp
 // CHECK-NEXT: detail/boost/mp11/algorithm.hpp
 // CHECK-NEXT: detail/boost/mp11/list.hpp