From 699f15a924fda31b4a7883cbf9552e62f64a03ba Mon Sep 17 00:00:00 2001
From: "Yu-Hsiang M. Tsai" <yhmtsai@gmail.com>
Date: Thu, 26 Mar 2026 15:07:36 +0100
Subject: [PATCH 1/3] initilize descriptor

---
 include/spblas/views/collection.hpp | 329 ++++++++++++++++++++++++++++
 test/gtest/CMakeLists.txt           |   1 +
 test/gtest/tag_test.cpp             | 203 +++++++++++++++++
 3 files changed, 533 insertions(+)
 create mode 100644 include/spblas/views/collection.hpp
 create mode 100644 test/gtest/tag_test.cpp

diff --git a/include/spblas/views/collection.hpp b/include/spblas/views/collection.hpp
new file mode 100644
index 0000000..31a4ce1
--- /dev/null
+++ b/include/spblas/views/collection.hpp
@@ -0,0 +1,329 @@
+#pragma once
+#include <spblas/views/view_base.hpp>
+
+namespace spblas {
+namespace view_v {
+namespace diag {
+class implicit_unit {};
+class implicit_zero {};
+class explicit_diag {};
+
+template <typename d>
+concept diag =
+    std::is_same_v<d, implicit_unit> || std::is_same_v<d, implicit_zero> ||
+    std::is_same_v<d, explicit_diag>;
+} // namespace diag
+
+namespace uplo {
+class full {};
+class lower {};
+class upper {};
+class diag {};
+
+template <typename d>
+concept uplo = std::is_same_v<d, full> || std::is_same_v<d, lower> ||
+               std::is_same_v<d, upper> || std::is_same_v<d, diag>;
+} // namespace uplo
+
+class none {};
+class conj {};
+class trans {};
+
+template <typename T, typename U>
+struct decide_diag {};
+
+template <typename T>
+struct decide_diag<T, diag::implicit_unit> {
+  using type = diag::implicit_unit;
+};
+
+template <typename T>
+struct decide_diag<T, diag::implicit_zero> {
+  using type = diag::implicit_zero;
+};
+
+template <typename T>
+struct decide_diag<T, diag::explicit_diag> {
+  using type = T;
+};
+
+/**
+ * This is a view contain all possiblitity how kernel can intepret the matrix
+ * with specific order. This will not touch the matrix_opt itself, it will leave
+ * the operation to backend to decide what to do.
+ *
+ * @tparam Conjugate  we conjugate the matrix
+ * @tparam Transpose  transpose the matrix
+ * @tparam Diagonal how do we treat the diagonal
+ * @tparam UpLo  whether we access the upper or lower part
+ * @tparam matrix_opt  matrix handle
+ */
+template <typename matrix_opt, typename Conjugate = none,
+          typename Transpose = none, diag::diag Diagonal = diag::explicit_diag,
+          uplo::uplo UpLo = uplo::full>
+class general : public spblas::view_base {
+public:
+using scalar_type = typename std::remove_cvref_t<matrix_opt>::scalar_type;
+  using scalar_reference = typename std::remove_cvref_t<matrix_opt>::scalar_reference;
+  using index_type = typename std::remove_cvref_t<matrix_opt>::index_type;
+  using offset_type = typename std::remove_cvref_t<matrix_opt>::offset_type;
+  using uplo = UpLo;
+  general(matrix_opt&& t) : obj(t) {}
+  auto& base() {
+    return obj;
+  }
+
+  auto& base() const {
+    return obj;
+  }
+
+  matrix_opt& obj;
+};
+
+
+template <typename T>
+struct is_instantiation_of_general {
+  static constexpr bool value = false;
+};
+
+template <typename matrix_opt, typename Conjugate, typename Transpose, diag::diag Diagonal,
+          uplo::uplo UpLo>
+struct is_instantiation_of_general<general<matrix_opt, Conjugate, Transpose, Diagonal, UpLo>> {
+  static constexpr bool value = true;
+};
+
+template <typename T>
+static constexpr bool is_general_v =
+    is_instantiation_of_general<std::remove_cvref_t<T>>::value;
+
+template <typename matrix_opt>
+auto conjugate(matrix_opt&& matrix) {
+  return general<matrix_opt, conj>(matrix);
+}
+
+template <typename matrix_opt, typename Transpose, typename Diagonal,
+          typename UpLo>
+auto conjugate(general<matrix_opt, conj, Transpose, Diagonal, UpLo>&& matrix) {
+  return general<matrix_opt, none, Transpose, Diagonal, UpLo>(matrix.obj);
+}
+
+template <typename Transpose, typename Diagonal, typename UpLo,
+          typename matrix_opt>
+auto conjugate(general<matrix_opt, none, Transpose, Diagonal, UpLo>&& matrix) {
+  return general<matrix_opt, conj, Transpose, Diagonal, UpLo>(matrix.obj);
+}
+
+template <typename matrix_opt>
+auto transpose(matrix_opt&& matrix) {
+  return general<matrix_opt, none, trans>(matrix);
+}
+
+template <typename Conjugate, typename Diagonal, typename UpLo,
+          typename matrix_opt>
+  requires(!std::is_same_v<UpLo, uplo::diag>)
+auto transpose(general<matrix_opt, Conjugate, none, Diagonal, UpLo>&& matrix) {
+  return general<matrix_opt, Conjugate, trans, Diagonal, UpLo>(matrix.obj);
+}
+
+template <typename Conjugate, typename Diagonal, typename UpLo,
+          typename matrix_opt>
+  requires(!std::is_same_v<UpLo, uplo::diag>)
+auto transpose(general<matrix_opt, Conjugate, trans, Diagonal, UpLo>&& matrix) {
+  return general<matrix_opt, Conjugate, none, Diagonal, UpLo>(matrix.obj);
+}
+
+template <typename Conjugate, typename Diagonal, typename Transpose,
+          typename matrix_opt>
+auto transpose(
+    general<matrix_opt, Conjugate, Transpose, Diagonal, uplo::diag>&& matrix) {
+  return general<matrix_opt, Conjugate, none, Diagonal, uplo::diag>(matrix.obj);
+}
+
+template <typename matrix_opt, typename TreatDiag = diag::explicit_diag>
+auto diagonal(matrix_opt&& matrix, TreatDiag = {}) {
+  return general<matrix_opt, none, none, TreatDiag, uplo::diag>(matrix);
+}
+
+template <typename Conjugate, typename Transpose, typename Diagonal,
+          typename UpLo, typename matrix_opt, typename TreatDiag>
+auto diagonal(
+    general<matrix_opt, Conjugate, Transpose,
+            typename decide_diag<Diagonal, TreatDiag>::type, UpLo>&& matrix,
+    TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, none,
+                 typename decide_diag<Diagonal, TreatDiag>::type, uplo::diag>(
+      matrix.obj);
+}
+
+template <typename matrix_opt, typename TreatDiag = diag::explicit_diag>
+auto triangle(matrix_opt&& matrix, uplo::lower, TreatDiag = {}) {
+  return general<matrix_opt, none, none, TreatDiag, uplo::lower>(matrix);
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(
+    general<matrix_opt, Conjugate, none, Diagonal, uplo::full>&& matrix,
+    uplo::lower, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, none,
+                 typename decide_diag<Diagonal, TreatDiag>::type, uplo::lower>(
+      matrix.obj);
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(
+    general<matrix_opt, Conjugate, none, Diagonal, uplo::lower>&& matrix,
+    uplo::lower, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, none,
+                 typename decide_diag<Diagonal, TreatDiag>::type, uplo::lower>(
+      matrix.obj);
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(
+    general<matrix_opt, Conjugate, none, Diagonal, uplo::upper>&& matrix,
+    uplo::lower, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, none,
+                 typename decide_diag<Diagonal, TreatDiag>::type, uplo::diag>(
+      matrix.obj);
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(
+    general<matrix_opt, Conjugate, none, Diagonal, uplo::diag>&& matrix,
+    uplo::lower, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, none,
+                 typename decide_diag<Diagonal, TreatDiag>::type, uplo::diag>(
+      matrix.obj);
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(
+    general<matrix_opt, Conjugate, trans, Diagonal, uplo::full>&& matrix,
+    uplo::lower, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, trans,
+                 typename decide_diag<Diagonal, TreatDiag>::type, uplo::upper>(
+      matrix.obj);
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(
+    general<matrix_opt, Conjugate, trans, Diagonal, uplo::lower>&& matrix,
+    uplo::lower, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, none,
+                 typename decide_diag<Diagonal, TreatDiag>::type, uplo::diag>(
+      matrix.obj);
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(
+    general<matrix_opt, Conjugate, trans, Diagonal, uplo::upper>&& matrix,
+    uplo::lower, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, trans,
+                 typename decide_diag<Diagonal, TreatDiag>::type, uplo::upper>(
+      matrix.obj);
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(
+    general<matrix_opt, Conjugate, trans, Diagonal, uplo::diag>&& matrix,
+    uplo::lower, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, none,
+                 typename decide_diag<Diagonal, TreatDiag>::type, uplo::diag>(
+      matrix.obj);
+}
+
+template <typename matrix_opt, typename TreatDiag = diag::explicit_diag>
+auto triangle(matrix_opt&& matrix, uplo::upper, TreatDiag = {}) {
+  return general<matrix_opt, none, none, TreatDiag, uplo::upper>(matrix);
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(
+    general<matrix_opt, Conjugate, none, Diagonal, uplo::full>&& matrix,
+    uplo::upper, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, none,
+                 typename decide_diag<Diagonal, TreatDiag>::type, uplo::upper>(
+      matrix.obj);
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(
+    general<matrix_opt, Conjugate, none, Diagonal, uplo::lower>&& matrix,
+    uplo::upper, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, none,
+                 typename decide_diag<Diagonal, TreatDiag>::type, uplo::diag>(
+      matrix.obj);
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(
+    general<matrix_opt, Conjugate, none, Diagonal, uplo::upper>&& matrix,
+    uplo::upper, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, none,
+                 typename decide_diag<Diagonal, TreatDiag>::type, uplo::upper>(
+      matrix.obj);
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(
+    general<matrix_opt, Conjugate, none, Diagonal, uplo::diag>&& matrix,
+    uplo::upper, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, none,
+                 typename decide_diag<Diagonal, TreatDiag>::type, uplo::diag>(
+      matrix.obj);
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(
+    general<matrix_opt, Conjugate, trans, Diagonal, uplo::full>&& matrix,
+    uplo::upper, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, trans,
+                 typename decide_diag<Diagonal, TreatDiag>::type, uplo::lower>(
+      matrix.obj);
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(
+    general<matrix_opt, Conjugate, trans, Diagonal, uplo::lower>&& matrix,
+    uplo::upper, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, trans,
+                 typename decide_diag<Diagonal, TreatDiag>::type, uplo::lower>(
+      matrix.obj);
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(
+    general<matrix_opt, Conjugate, trans, Diagonal, uplo::upper>&& matrix,
+    uplo::upper, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, none,
+                 typename decide_diag<Diagonal, TreatDiag>::type, uplo::diag>(
+      matrix.obj);
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(
+    general<matrix_opt, Conjugate, trans, Diagonal, uplo::diag>&& matrix,
+    uplo::upper, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, none,
+                 typename decide_diag<Diagonal, TreatDiag>::type, uplo::diag>(
+      matrix.obj);
+}
+
+} // namespace view
+} // namespace spblas
diff --git a/test/gtest/CMakeLists.txt b/test/gtest/CMakeLists.txt
index b458a17..db562fe 100644
--- a/test/gtest/CMakeLists.txt
+++ b/test/gtest/CMakeLists.txt
@@ -5,6 +5,7 @@ set(TEST_SOURCES)
 # CPU tests
 if (SPBLAS_CPU_BACKEND)
   list(APPEND TEST_SOURCES
+       tag_test.cpp
        spmv_test.cpp
        spmm_test.cpp
        spgemm_test.cpp
diff --git a/test/gtest/tag_test.cpp b/test/gtest/tag_test.cpp
new file mode 100644
index 0000000..b4f2e0f
--- /dev/null
+++ b/test/gtest/tag_test.cpp
@@ -0,0 +1,203 @@
+#include <gtest/gtest.h>
+#include <spblas/views/collection.hpp>
+#include <type_traits>
+
+class temp {
+public:
+    using scalar_type = float;
+  using scalar_reference = float&;
+  using index_type = int;
+  using offset_type = int;
+};
+
+using ::testing::StaticAssertTypeEq;
+// only for the testing
+using namespace spblas::view_v;
+
+TEST(Tag, Conjugate) {
+  temp t;
+  StaticAssertTypeEq<
+      decltype(conjugate(t)),
+      general<temp&, conj, none, diag::explicit_diag, uplo::full>>();
+  StaticAssertTypeEq<
+      decltype(conjugate(conjugate(t))),
+      general<temp&, none, none, diag::explicit_diag, uplo::full>>();
+  EXPECT_EQ(&(conjugate(t).obj), &t);
+  EXPECT_EQ(&(conjugate(conjugate(t)).obj), &t);
+}
+
+TEST(Tag, Tranpose) {
+  temp t;
+  StaticAssertTypeEq<
+      decltype(transpose(t)),
+      general<temp&, none, trans, diag::explicit_diag, uplo::full>>();
+  StaticAssertTypeEq<
+      decltype(transpose(transpose(t))),
+      general<temp&, none, none, diag::explicit_diag, uplo::full>>();
+  EXPECT_EQ(&(transpose(t).obj), &t);
+  EXPECT_EQ(&(transpose(transpose(t)).obj), &t);
+}
+
+TEST(Tag, Diagonal) {
+  temp t;
+  StaticAssertTypeEq<
+      decltype(diagonal(t)),
+      general<temp&, none, none, diag::explicit_diag, uplo::diag>>();
+  EXPECT_EQ(&(diagonal(t).obj), &t);
+}
+
+TEST(Tag, Lower) {
+  temp t;
+  StaticAssertTypeEq<
+      decltype(triangle(t, uplo::lower())),
+      general<temp&, none, none, diag::explicit_diag, uplo::lower>>();
+  StaticAssertTypeEq<
+      decltype(triangle(triangle(t, uplo::lower()), uplo::lower())),
+      general<temp&, none, none, diag::explicit_diag, uplo::lower>>();
+  StaticAssertTypeEq<
+      decltype(triangle(t, uplo::lower(), diag::implicit_unit())),
+      general<temp&, none, none, diag::implicit_unit, uplo::lower>>();
+  StaticAssertTypeEq<
+      decltype(triangle(t, uplo::lower(), diag::implicit_zero())),
+      general<temp&, none, none, diag::implicit_zero, uplo::lower>>();
+  StaticAssertTypeEq<
+      decltype(triangle(triangle(t, uplo::lower(), diag::implicit_unit()),
+                        uplo::lower(), diag::explicit_diag())),
+      general<temp&, none, none, diag::implicit_unit, uplo::lower>>();
+  StaticAssertTypeEq<
+      decltype(triangle(triangle(t, uplo::lower(), diag::implicit_zero()),
+                        uplo::lower(), diag::explicit_diag())),
+      general<temp&, none, none, diag::implicit_zero, uplo::lower>>();
+  StaticAssertTypeEq<
+      decltype(triangle(triangle(t, uplo::lower(), diag::implicit_unit()),
+                        uplo::lower(), diag::implicit_unit())),
+      general<temp&, none, none, diag::implicit_unit, uplo::lower>>();
+  StaticAssertTypeEq<
+      decltype(triangle(triangle(t, uplo::lower(), diag::implicit_zero()),
+                        uplo::lower(), diag::implicit_zero())),
+      general<temp&, none, none, diag::implicit_zero, uplo::lower>>();
+  //   Unit or Zero Diag will overwrite the old one
+  StaticAssertTypeEq<
+      decltype(triangle(triangle(t, uplo::lower(), diag::implicit_unit()),
+                        uplo::lower(), diag::implicit_zero())),
+      general<temp&, none, none, diag::implicit_zero, uplo::lower>>();
+  StaticAssertTypeEq<
+      decltype(triangle(triangle(t, uplo::lower(), diag::implicit_zero()),
+                        uplo::lower(), diag::implicit_unit())),
+      general<temp&, none, none, diag::implicit_unit, uplo::lower>>();
+
+  EXPECT_EQ(&(triangle(t, uplo::lower()).obj), &t);
+  EXPECT_EQ(&(triangle(t, uplo::lower(), diag::implicit_zero()).obj), &t);
+  EXPECT_EQ(&(triangle(t, uplo::lower(), diag::implicit_unit()).obj), &t);
+  EXPECT_EQ(&(triangle(triangle(t, uplo::lower(), diag::implicit_zero()),
+                       uplo::lower(), diag::implicit_unit())
+                  .obj),
+            &t);
+  EXPECT_EQ(&(triangle(triangle(t, uplo::lower(), diag::implicit_unit()),
+                       uplo::lower(), diag::implicit_zero())
+                  .obj),
+            &t);
+}
+
+TEST(Tag, Upper) {
+  temp t;
+  StaticAssertTypeEq<
+      decltype(triangle(t, uplo::upper())),
+      general<temp&, none, none, diag::explicit_diag, uplo::upper>>();
+  StaticAssertTypeEq<
+      decltype(triangle(triangle(t, uplo::upper()), uplo::upper())),
+      general<temp&, none, none, diag::explicit_diag, uplo::upper>>();
+  StaticAssertTypeEq<
+      decltype(triangle(t, uplo::upper(), diag::implicit_unit())),
+      general<temp&, none, none, diag::implicit_unit, uplo::upper>>();
+  StaticAssertTypeEq<
+      decltype(triangle(t, uplo::upper(), diag::implicit_zero())),
+      general<temp&, none, none, diag::implicit_zero, uplo::upper>>();
+  StaticAssertTypeEq<
+      decltype(triangle(triangle(t, uplo::upper(), diag::implicit_unit()),
+                        uplo::upper(), diag::explicit_diag())),
+      general<temp&, none, none, diag::implicit_unit, uplo::upper>>();
+  StaticAssertTypeEq<
+      decltype(triangle(triangle(t, uplo::upper(), diag::implicit_zero()),
+                        uplo::upper(), diag::explicit_diag())),
+      general<temp&, none, none, diag::implicit_zero, uplo::upper>>();
+  StaticAssertTypeEq<
+      decltype(triangle(triangle(t, uplo::upper(), diag::implicit_unit()),
+                        uplo::upper(), diag::implicit_unit())),
+      general<temp&, none, none, diag::implicit_unit, uplo::upper>>();
+  StaticAssertTypeEq<
+      decltype(triangle(triangle(t, uplo::upper(), diag::implicit_zero()),
+                        uplo::upper(), diag::implicit_zero())),
+      general<temp&, none, none, diag::implicit_zero, uplo::upper>>();
+  //   Unit or Zero Diag will overwrite the old one
+  StaticAssertTypeEq<
+      decltype(triangle(triangle(t, uplo::upper(), diag::implicit_unit()),
+                        uplo::upper(), diag::implicit_zero())),
+      general<temp&, none, none, diag::implicit_zero, uplo::upper>>();
+  StaticAssertTypeEq<
+      decltype(triangle(triangle(t, uplo::upper(), diag::implicit_zero()),
+                        uplo::upper(), diag::implicit_unit())),
+      general<temp&, none, none, diag::implicit_unit, uplo::upper>>();
+
+  EXPECT_EQ(&(triangle(t, uplo::upper()).obj), &t);
+  EXPECT_EQ(&(triangle(t, uplo::upper(), diag::implicit_zero()).obj), &t);
+  EXPECT_EQ(&(triangle(t, uplo::upper(), diag::implicit_unit()).obj), &t);
+  EXPECT_EQ(&(triangle(triangle(t, uplo::upper(), diag::implicit_zero()),
+                       uplo::upper(), diag::implicit_unit())
+                  .obj),
+            &t);
+  EXPECT_EQ(&(triangle(triangle(t, uplo::upper(), diag::implicit_unit()),
+                       uplo::upper(), diag::implicit_zero())
+                  .obj),
+            &t);
+}
+
+TEST(Tag, MixUpperAndLower) {
+  temp t;
+  StaticAssertTypeEq<
+      decltype(triangle(triangle(t, uplo::upper()), uplo::lower())),
+      general<temp&, none, none, diag::explicit_diag, uplo::diag>>();
+  StaticAssertTypeEq<
+      decltype(triangle(triangle(t, uplo::lower()), uplo::upper())),
+      general<temp&, none, none, diag::explicit_diag, uplo::diag>>();
+}
+
+TEST(Tag, GetTransposeOfUpper) {
+  temp t;
+  StaticAssertTypeEq<
+      decltype(transpose(triangle(t, uplo::upper()))),
+      general<temp&, none, trans, diag::explicit_diag, uplo::upper>>();
+  // Lower(M^T) = Upper(M)^T
+  StaticAssertTypeEq<
+      decltype(triangle(transpose(t), uplo::lower())),
+      general<temp&, none, trans, diag::explicit_diag, uplo::upper>>();
+}
+
+TEST(Tag, GetTransposeOfLower) {
+  temp t;
+  StaticAssertTypeEq<
+      decltype(transpose(triangle(t, uplo::lower()))),
+      general<temp&, none, trans, diag::explicit_diag, uplo::lower>>();
+  // Upper(M^T) = Lower(M)^T
+  StaticAssertTypeEq<
+      decltype(triangle(transpose(t), uplo::upper())),
+      general<temp&, none, trans, diag::explicit_diag, uplo::lower>>();
+}
+
+TEST(Tag, LongChain) {
+  temp t;
+
+  StaticAssertTypeEq<
+      decltype(triangle(transpose(triangle(t, uplo::lower())), uplo::upper(),
+                        diag::implicit_zero())),
+      general<temp&, none, trans, diag::implicit_zero, uplo::lower>>();
+  StaticAssertTypeEq<
+      decltype(conjugate(triangle(transpose(triangle(t, uplo::lower())),
+                                  uplo::lower(), diag::implicit_zero()))),
+      general<temp&, conj, none, diag::implicit_zero, uplo::diag>>();
+  StaticAssertTypeEq<
+      decltype(transpose(conjugate(
+          triangle(transpose(triangle(t, uplo::lower(), diag::implicit_zero())),
+                   uplo::lower(), diag::implicit_unit())))),
+      general<temp&, conj, none, diag::implicit_unit, uplo::diag>>();
+}

From 3a29cbf1359d2e96bf15a57916302850000bd662 Mon Sep 17 00:00:00 2001
From: "Yu-Hsiang M. Tsai" <yhmtsai@gmail.com>
Date: Fri, 10 Apr 2026 12:59:25 +0200
Subject: [PATCH 2/3] rename it to matrix_view, using std for conj/trans, add
 comment

---
 include/spblas/views/collection.hpp  | 329 --------------------------
 include/spblas/views/matrix_view.hpp | 338 +++++++++++++++++++++++++++
 test/gtest/CMakeLists.txt            |   4 +-
 test/gtest/matrix_view_test.cpp      | 230 ++++++++++++++++++
 test/gtest/tag_test.cpp              | 203 ----------------
 5 files changed, 570 insertions(+), 534 deletions(-)
 delete mode 100644 include/spblas/views/collection.hpp
 create mode 100644 include/spblas/views/matrix_view.hpp
 create mode 100644 test/gtest/matrix_view_test.cpp
 delete mode 100644 test/gtest/tag_test.cpp

diff --git a/include/spblas/views/collection.hpp b/include/spblas/views/collection.hpp
deleted file mode 100644
index 31a4ce1..0000000
--- a/include/spblas/views/collection.hpp
+++ /dev/null
@@ -1,329 +0,0 @@
-#pragma once
-#include <spblas/views/view_base.hpp>
-
-namespace spblas {
-namespace view_v {
-namespace diag {
-class implicit_unit {};
-class implicit_zero {};
-class explicit_diag {};
-
-template <typename d>
-concept diag =
-    std::is_same_v<d, implicit_unit> || std::is_same_v<d, implicit_zero> ||
-    std::is_same_v<d, explicit_diag>;
-} // namespace diag
-
-namespace uplo {
-class full {};
-class lower {};
-class upper {};
-class diag {};
-
-template <typename d>
-concept uplo = std::is_same_v<d, full> || std::is_same_v<d, lower> ||
-               std::is_same_v<d, upper> || std::is_same_v<d, diag>;
-} // namespace uplo
-
-class none {};
-class conj {};
-class trans {};
-
-template <typename T, typename U>
-struct decide_diag {};
-
-template <typename T>
-struct decide_diag<T, diag::implicit_unit> {
-  using type = diag::implicit_unit;
-};
-
-template <typename T>
-struct decide_diag<T, diag::implicit_zero> {
-  using type = diag::implicit_zero;
-};
-
-template <typename T>
-struct decide_diag<T, diag::explicit_diag> {
-  using type = T;
-};
-
-/**
- * This is a view contain all possiblitity how kernel can intepret the matrix
- * with specific order. This will not touch the matrix_opt itself, it will leave
- * the operation to backend to decide what to do.
- *
- * @tparam Conjugate  we conjugate the matrix
- * @tparam Transpose  transpose the matrix
- * @tparam Diagonal how do we treat the diagonal
- * @tparam UpLo  whether we access the upper or lower part
- * @tparam matrix_opt  matrix handle
- */
-template <typename matrix_opt, typename Conjugate = none,
-          typename Transpose = none, diag::diag Diagonal = diag::explicit_diag,
-          uplo::uplo UpLo = uplo::full>
-class general : public spblas::view_base {
-public:
-using scalar_type = typename std::remove_cvref_t<matrix_opt>::scalar_type;
-  using scalar_reference = typename std::remove_cvref_t<matrix_opt>::scalar_reference;
-  using index_type = typename std::remove_cvref_t<matrix_opt>::index_type;
-  using offset_type = typename std::remove_cvref_t<matrix_opt>::offset_type;
-  using uplo = UpLo;
-  general(matrix_opt&& t) : obj(t) {}
-  auto& base() {
-    return obj;
-  }
-
-  auto& base() const {
-    return obj;
-  }
-
-  matrix_opt& obj;
-};
-
-
-template <typename T>
-struct is_instantiation_of_general {
-  static constexpr bool value = false;
-};
-
-template <typename matrix_opt, typename Conjugate, typename Transpose, diag::diag Diagonal,
-          uplo::uplo UpLo>
-struct is_instantiation_of_general<general<matrix_opt, Conjugate, Transpose, Diagonal, UpLo>> {
-  static constexpr bool value = true;
-};
-
-template <typename T>
-static constexpr bool is_general_v =
-    is_instantiation_of_general<std::remove_cvref_t<T>>::value;
-
-template <typename matrix_opt>
-auto conjugate(matrix_opt&& matrix) {
-  return general<matrix_opt, conj>(matrix);
-}
-
-template <typename matrix_opt, typename Transpose, typename Diagonal,
-          typename UpLo>
-auto conjugate(general<matrix_opt, conj, Transpose, Diagonal, UpLo>&& matrix) {
-  return general<matrix_opt, none, Transpose, Diagonal, UpLo>(matrix.obj);
-}
-
-template <typename Transpose, typename Diagonal, typename UpLo,
-          typename matrix_opt>
-auto conjugate(general<matrix_opt, none, Transpose, Diagonal, UpLo>&& matrix) {
-  return general<matrix_opt, conj, Transpose, Diagonal, UpLo>(matrix.obj);
-}
-
-template <typename matrix_opt>
-auto transpose(matrix_opt&& matrix) {
-  return general<matrix_opt, none, trans>(matrix);
-}
-
-template <typename Conjugate, typename Diagonal, typename UpLo,
-          typename matrix_opt>
-  requires(!std::is_same_v<UpLo, uplo::diag>)
-auto transpose(general<matrix_opt, Conjugate, none, Diagonal, UpLo>&& matrix) {
-  return general<matrix_opt, Conjugate, trans, Diagonal, UpLo>(matrix.obj);
-}
-
-template <typename Conjugate, typename Diagonal, typename UpLo,
-          typename matrix_opt>
-  requires(!std::is_same_v<UpLo, uplo::diag>)
-auto transpose(general<matrix_opt, Conjugate, trans, Diagonal, UpLo>&& matrix) {
-  return general<matrix_opt, Conjugate, none, Diagonal, UpLo>(matrix.obj);
-}
-
-template <typename Conjugate, typename Diagonal, typename Transpose,
-          typename matrix_opt>
-auto transpose(
-    general<matrix_opt, Conjugate, Transpose, Diagonal, uplo::diag>&& matrix) {
-  return general<matrix_opt, Conjugate, none, Diagonal, uplo::diag>(matrix.obj);
-}
-
-template <typename matrix_opt, typename TreatDiag = diag::explicit_diag>
-auto diagonal(matrix_opt&& matrix, TreatDiag = {}) {
-  return general<matrix_opt, none, none, TreatDiag, uplo::diag>(matrix);
-}
-
-template <typename Conjugate, typename Transpose, typename Diagonal,
-          typename UpLo, typename matrix_opt, typename TreatDiag>
-auto diagonal(
-    general<matrix_opt, Conjugate, Transpose,
-            typename decide_diag<Diagonal, TreatDiag>::type, UpLo>&& matrix,
-    TreatDiag = {}) {
-  return general<matrix_opt, Conjugate, none,
-                 typename decide_diag<Diagonal, TreatDiag>::type, uplo::diag>(
-      matrix.obj);
-}
-
-template <typename matrix_opt, typename TreatDiag = diag::explicit_diag>
-auto triangle(matrix_opt&& matrix, uplo::lower, TreatDiag = {}) {
-  return general<matrix_opt, none, none, TreatDiag, uplo::lower>(matrix);
-}
-
-template <typename Conjugate, typename Diagonal, typename matrix_opt,
-          typename TreatDiag = diag::explicit_diag>
-auto triangle(
-    general<matrix_opt, Conjugate, none, Diagonal, uplo::full>&& matrix,
-    uplo::lower, TreatDiag = {}) {
-  return general<matrix_opt, Conjugate, none,
-                 typename decide_diag<Diagonal, TreatDiag>::type, uplo::lower>(
-      matrix.obj);
-}
-
-template <typename Conjugate, typename Diagonal, typename matrix_opt,
-          typename TreatDiag = diag::explicit_diag>
-auto triangle(
-    general<matrix_opt, Conjugate, none, Diagonal, uplo::lower>&& matrix,
-    uplo::lower, TreatDiag = {}) {
-  return general<matrix_opt, Conjugate, none,
-                 typename decide_diag<Diagonal, TreatDiag>::type, uplo::lower>(
-      matrix.obj);
-}
-
-template <typename Conjugate, typename Diagonal, typename matrix_opt,
-          typename TreatDiag = diag::explicit_diag>
-auto triangle(
-    general<matrix_opt, Conjugate, none, Diagonal, uplo::upper>&& matrix,
-    uplo::lower, TreatDiag = {}) {
-  return general<matrix_opt, Conjugate, none,
-                 typename decide_diag<Diagonal, TreatDiag>::type, uplo::diag>(
-      matrix.obj);
-}
-
-template <typename Conjugate, typename Diagonal, typename matrix_opt,
-          typename TreatDiag = diag::explicit_diag>
-auto triangle(
-    general<matrix_opt, Conjugate, none, Diagonal, uplo::diag>&& matrix,
-    uplo::lower, TreatDiag = {}) {
-  return general<matrix_opt, Conjugate, none,
-                 typename decide_diag<Diagonal, TreatDiag>::type, uplo::diag>(
-      matrix.obj);
-}
-
-template <typename Conjugate, typename Diagonal, typename matrix_opt,
-          typename TreatDiag = diag::explicit_diag>
-auto triangle(
-    general<matrix_opt, Conjugate, trans, Diagonal, uplo::full>&& matrix,
-    uplo::lower, TreatDiag = {}) {
-  return general<matrix_opt, Conjugate, trans,
-                 typename decide_diag<Diagonal, TreatDiag>::type, uplo::upper>(
-      matrix.obj);
-}
-
-template <typename Conjugate, typename Diagonal, typename matrix_opt,
-          typename TreatDiag = diag::explicit_diag>
-auto triangle(
-    general<matrix_opt, Conjugate, trans, Diagonal, uplo::lower>&& matrix,
-    uplo::lower, TreatDiag = {}) {
-  return general<matrix_opt, Conjugate, none,
-                 typename decide_diag<Diagonal, TreatDiag>::type, uplo::diag>(
-      matrix.obj);
-}
-
-template <typename Conjugate, typename Diagonal, typename matrix_opt,
-          typename TreatDiag = diag::explicit_diag>
-auto triangle(
-    general<matrix_opt, Conjugate, trans, Diagonal, uplo::upper>&& matrix,
-    uplo::lower, TreatDiag = {}) {
-  return general<matrix_opt, Conjugate, trans,
-                 typename decide_diag<Diagonal, TreatDiag>::type, uplo::upper>(
-      matrix.obj);
-}
-
-template <typename Conjugate, typename Diagonal, typename matrix_opt,
-          typename TreatDiag = diag::explicit_diag>
-auto triangle(
-    general<matrix_opt, Conjugate, trans, Diagonal, uplo::diag>&& matrix,
-    uplo::lower, TreatDiag = {}) {
-  return general<matrix_opt, Conjugate, none,
-                 typename decide_diag<Diagonal, TreatDiag>::type, uplo::diag>(
-      matrix.obj);
-}
-
-template <typename matrix_opt, typename TreatDiag = diag::explicit_diag>
-auto triangle(matrix_opt&& matrix, uplo::upper, TreatDiag = {}) {
-  return general<matrix_opt, none, none, TreatDiag, uplo::upper>(matrix);
-}
-
-template <typename Conjugate, typename Diagonal, typename matrix_opt,
-          typename TreatDiag = diag::explicit_diag>
-auto triangle(
-    general<matrix_opt, Conjugate, none, Diagonal, uplo::full>&& matrix,
-    uplo::upper, TreatDiag = {}) {
-  return general<matrix_opt, Conjugate, none,
-                 typename decide_diag<Diagonal, TreatDiag>::type, uplo::upper>(
-      matrix.obj);
-}
-
-template <typename Conjugate, typename Diagonal, typename matrix_opt,
-          typename TreatDiag = diag::explicit_diag>
-auto triangle(
-    general<matrix_opt, Conjugate, none, Diagonal, uplo::lower>&& matrix,
-    uplo::upper, TreatDiag = {}) {
-  return general<matrix_opt, Conjugate, none,
-                 typename decide_diag<Diagonal, TreatDiag>::type, uplo::diag>(
-      matrix.obj);
-}
-
-template <typename Conjugate, typename Diagonal, typename matrix_opt,
-          typename TreatDiag = diag::explicit_diag>
-auto triangle(
-    general<matrix_opt, Conjugate, none, Diagonal, uplo::upper>&& matrix,
-    uplo::upper, TreatDiag = {}) {
-  return general<matrix_opt, Conjugate, none,
-                 typename decide_diag<Diagonal, TreatDiag>::type, uplo::upper>(
-      matrix.obj);
-}
-
-template <typename Conjugate, typename Diagonal, typename matrix_opt,
-          typename TreatDiag = diag::explicit_diag>
-auto triangle(
-    general<matrix_opt, Conjugate, none, Diagonal, uplo::diag>&& matrix,
-    uplo::upper, TreatDiag = {}) {
-  return general<matrix_opt, Conjugate, none,
-                 typename decide_diag<Diagonal, TreatDiag>::type, uplo::diag>(
-      matrix.obj);
-}
-
-template <typename Conjugate, typename Diagonal, typename matrix_opt,
-          typename TreatDiag = diag::explicit_diag>
-auto triangle(
-    general<matrix_opt, Conjugate, trans, Diagonal, uplo::full>&& matrix,
-    uplo::upper, TreatDiag = {}) {
-  return general<matrix_opt, Conjugate, trans,
-                 typename decide_diag<Diagonal, TreatDiag>::type, uplo::lower>(
-      matrix.obj);
-}
-
-template <typename Conjugate, typename Diagonal, typename matrix_opt,
-          typename TreatDiag = diag::explicit_diag>
-auto triangle(
-    general<matrix_opt, Conjugate, trans, Diagonal, uplo::lower>&& matrix,
-    uplo::upper, TreatDiag = {}) {
-  return general<matrix_opt, Conjugate, trans,
-                 typename decide_diag<Diagonal, TreatDiag>::type, uplo::lower>(
-      matrix.obj);
-}
-
-template <typename Conjugate, typename Diagonal, typename matrix_opt,
-          typename TreatDiag = diag::explicit_diag>
-auto triangle(
-    general<matrix_opt, Conjugate, trans, Diagonal, uplo::upper>&& matrix,
-    uplo::upper, TreatDiag = {}) {
-  return general<matrix_opt, Conjugate, none,
-                 typename decide_diag<Diagonal, TreatDiag>::type, uplo::diag>(
-      matrix.obj);
-}
-
-template <typename Conjugate, typename Diagonal, typename matrix_opt,
-          typename TreatDiag = diag::explicit_diag>
-auto triangle(
-    general<matrix_opt, Conjugate, trans, Diagonal, uplo::diag>&& matrix,
-    uplo::upper, TreatDiag = {}) {
-  return general<matrix_opt, Conjugate, none,
-                 typename decide_diag<Diagonal, TreatDiag>::type, uplo::diag>(
-      matrix.obj);
-}
-
-} // namespace view
-} // namespace spblas
diff --git a/include/spblas/views/matrix_view.hpp b/include/spblas/views/matrix_view.hpp
new file mode 100644
index 0000000..cca047b
--- /dev/null
+++ b/include/spblas/views/matrix_view.hpp
@@ -0,0 +1,338 @@
+#pragma once
+#include <spblas/views/view_base.hpp>
+#include <type_traits>
+
+namespace spblas {
+namespace matrix_view {
+namespace diag {
+// always treat the diagonal value as unit
+class implicit_unit {};
+
+// always treat the diagonal value as zero
+class implicit_zero {};
+
+// use the matrix diagonal
+class explicit_diag {};
+
+template <typename d>
+concept diag =
+    std::is_same_v<d, implicit_unit> || std::is_same_v<d, implicit_zero> ||
+    std::is_same_v<d, explicit_diag>;
+} // namespace diag
+
+namespace uplo {
+// full matrix
+class full {};
+
+// take the lower triangular part of the matrix
+class lower {};
+
+// take the upper triangular part of the matrix
+class upper {};
+
+// take the diagonal part of the matrix
+class diag {};
+
+template <typename d>
+concept uplo = std::is_same_v<d, full> || std::is_same_v<d, lower> ||
+               std::is_same_v<d, upper> || std::is_same_v<d, diag>;
+} // namespace uplo
+
+namespace __detail {
+
+// help the diagonal transformation
+// implicit_* will overwite the previous type
+// explicit_diag keeps the type
+template <typename T, typename U>
+struct decide_diag {};
+
+template <typename T>
+struct decide_diag<T, diag::implicit_unit> {
+  using type = diag::implicit_unit;
+};
+
+template <typename T>
+struct decide_diag<T, diag::implicit_zero> {
+  using type = diag::implicit_zero;
+};
+
+template <typename T>
+struct decide_diag<T, diag::explicit_diag> {
+  using type = T;
+};
+
+} // namespace __detail
+
+/**
+ * This is a view contain all possiblitity how kernel can intepret the matrix
+ * with specific order. This will not touch the matrix_opt itself, it will leave
+ * the operation to backend to decide what to do.
+ *
+ * @tparam Conjugate  whether to conjugate the matrix
+ * @tparam Transpose  whether to transpose the matrix
+ * @tparam Diagonal  how to handle diagonal
+ * @tparam UpLo  how to access the part of matrix
+ */
+template <typename matrix_opt, typename Conjugate = std::false_type,
+          typename Transpose = std::false_type,
+          diag::diag Diagonal = diag::explicit_diag,
+          uplo::uplo UpLo = uplo::full>
+class general : public spblas::view_base {
+public:
+  general(matrix_opt&& t) : obj(t) {}
+
+  auto& base() {
+    return obj;
+  }
+
+  auto& base() const {
+    return obj;
+  }
+
+private:
+  matrix_opt& obj;
+};
+
+template <typename matrix_opt>
+auto conjugate(matrix_opt&& matrix) {
+  return general<matrix_opt, std::true_type>(matrix);
+}
+
+template <typename matrix_opt, typename Transpose, typename Diagonal,
+          typename UpLo>
+auto conjugate(
+    general<matrix_opt, std::true_type, Transpose, Diagonal, UpLo>&& matrix) {
+  return general<matrix_opt, std::false_type, Transpose, Diagonal, UpLo>(
+      matrix.base());
+}
+
+template <typename Transpose, typename Diagonal, typename UpLo,
+          typename matrix_opt>
+auto conjugate(
+    general<matrix_opt, std::false_type, Transpose, Diagonal, UpLo>&& matrix) {
+  return general<matrix_opt, std::true_type, Transpose, Diagonal, UpLo>(
+      matrix.base());
+}
+
+template <typename matrix_opt>
+auto transpose(matrix_opt&& matrix) {
+  return general<matrix_opt, std::false_type, std::true_type>(matrix);
+}
+
+template <typename Conjugate, typename Diagonal, typename UpLo,
+          typename matrix_opt>
+  requires(!std::is_same_v<UpLo, uplo::diag>)
+auto transpose(
+    general<matrix_opt, Conjugate, std::false_type, Diagonal, UpLo>&& matrix) {
+  return general<matrix_opt, Conjugate, std::true_type, Diagonal, UpLo>(
+      matrix.base());
+}
+
+template <typename Conjugate, typename Diagonal, typename UpLo,
+          typename matrix_opt>
+  requires(!std::is_same_v<UpLo, uplo::diag>)
+auto transpose(
+    general<matrix_opt, Conjugate, std::true_type, Diagonal, UpLo>&& matrix) {
+  return general<matrix_opt, Conjugate, std::false_type, Diagonal, UpLo>(
+      matrix.base());
+}
+
+template <typename Conjugate, typename Diagonal, typename Transpose,
+          typename matrix_opt>
+auto transpose(
+    general<matrix_opt, Conjugate, Transpose, Diagonal, uplo::diag>&& matrix) {
+  return general<matrix_opt, Conjugate, std::false_type, Diagonal, uplo::diag>(
+      matrix.base());
+}
+
+template <typename matrix_opt, typename TreatDiag = diag::explicit_diag>
+auto diagonal(matrix_opt&& matrix, TreatDiag = {}) {
+  return general<matrix_opt, std::false_type, std::false_type, TreatDiag,
+                 uplo::diag>(matrix);
+}
+
+template <typename Conjugate, typename Transpose, typename Diagonal,
+          typename UpLo, typename matrix_opt, typename TreatDiag>
+auto diagonal(general<matrix_opt, Conjugate, Transpose,
+                      typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                      UpLo>&& matrix,
+              TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, std::false_type,
+                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                 uplo::diag>(matrix.base());
+}
+
+template <typename matrix_opt, typename TreatDiag = diag::explicit_diag>
+auto triangle(matrix_opt&& matrix, uplo::lower, TreatDiag = {}) {
+  return general<matrix_opt, std::false_type, std::false_type, TreatDiag,
+                 uplo::lower>(matrix);
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(general<matrix_opt, Conjugate, std::false_type, Diagonal,
+                      uplo::full>&& matrix,
+              uplo::lower, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, std::false_type,
+                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                 uplo::lower>(matrix.base());
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(general<matrix_opt, Conjugate, std::false_type, Diagonal,
+                      uplo::lower>&& matrix,
+              uplo::lower, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, std::false_type,
+                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                 uplo::lower>(matrix.base());
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(general<matrix_opt, Conjugate, std::false_type, Diagonal,
+                      uplo::upper>&& matrix,
+              uplo::lower, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, std::false_type,
+                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                 uplo::diag>(matrix.base());
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(general<matrix_opt, Conjugate, std::false_type, Diagonal,
+                      uplo::diag>&& matrix,
+              uplo::lower, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, std::false_type,
+                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                 uplo::diag>(matrix.base());
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(general<matrix_opt, Conjugate, std::true_type, Diagonal,
+                      uplo::full>&& matrix,
+              uplo::lower, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, std::true_type,
+                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                 uplo::upper>(matrix.base());
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(general<matrix_opt, Conjugate, std::true_type, Diagonal,
+                      uplo::lower>&& matrix,
+              uplo::lower, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, std::false_type,
+                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                 uplo::diag>(matrix.base());
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(general<matrix_opt, Conjugate, std::true_type, Diagonal,
+                      uplo::upper>&& matrix,
+              uplo::lower, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, std::true_type,
+                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                 uplo::upper>(matrix.base());
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(general<matrix_opt, Conjugate, std::true_type, Diagonal,
+                      uplo::diag>&& matrix,
+              uplo::lower, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, std::false_type,
+                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                 uplo::diag>(matrix.base());
+}
+
+template <typename matrix_opt, typename TreatDiag = diag::explicit_diag>
+auto triangle(matrix_opt&& matrix, uplo::upper, TreatDiag = {}) {
+  return general<matrix_opt, std::false_type, std::false_type, TreatDiag,
+                 uplo::upper>(matrix);
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(general<matrix_opt, Conjugate, std::false_type, Diagonal,
+                      uplo::full>&& matrix,
+              uplo::upper, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, std::false_type,
+                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                 uplo::upper>(matrix.base());
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(general<matrix_opt, Conjugate, std::false_type, Diagonal,
+                      uplo::lower>&& matrix,
+              uplo::upper, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, std::false_type,
+                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                 uplo::diag>(matrix.base());
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(general<matrix_opt, Conjugate, std::false_type, Diagonal,
+                      uplo::upper>&& matrix,
+              uplo::upper, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, std::false_type,
+                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                 uplo::upper>(matrix.base());
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(general<matrix_opt, Conjugate, std::false_type, Diagonal,
+                      uplo::diag>&& matrix,
+              uplo::upper, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, std::false_type,
+                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                 uplo::diag>(matrix.base());
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(general<matrix_opt, Conjugate, std::true_type, Diagonal,
+                      uplo::full>&& matrix,
+              uplo::upper, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, std::true_type,
+                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                 uplo::lower>(matrix.base());
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(general<matrix_opt, Conjugate, std::true_type, Diagonal,
+                      uplo::lower>&& matrix,
+              uplo::upper, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, std::true_type,
+                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                 uplo::lower>(matrix.base());
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(general<matrix_opt, Conjugate, std::true_type, Diagonal,
+                      uplo::upper>&& matrix,
+              uplo::upper, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, std::false_type,
+                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                 uplo::diag>(matrix.base());
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(general<matrix_opt, Conjugate, std::true_type, Diagonal,
+                      uplo::diag>&& matrix,
+              uplo::upper, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, std::false_type,
+                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                 uplo::diag>(matrix.base());
+}
+
+} // namespace matrix_view
+} // namespace spblas
diff --git a/test/gtest/CMakeLists.txt b/test/gtest/CMakeLists.txt
index db562fe..79ec433 100644
--- a/test/gtest/CMakeLists.txt
+++ b/test/gtest/CMakeLists.txt
@@ -5,7 +5,6 @@ set(TEST_SOURCES)
 # CPU tests
 if (SPBLAS_CPU_BACKEND)
   list(APPEND TEST_SOURCES
-       tag_test.cpp
        spmv_test.cpp
        spmm_test.cpp
        spgemm_test.cpp
@@ -13,7 +12,8 @@ if (SPBLAS_CPU_BACKEND)
        add_test.cpp
        transpose_test.cpp
        triangular_solve_test.cpp
-       mdspan_overlays.cpp)
+       mdspan_overlays.cpp
+       matrix_view_test.cpp)
 
   if (ENABLE_ONEMKL_SYCL OR SPBLAS_REFERENCE_BACKEND)
     list(APPEND TEST_SOURCES conjugate_test.cpp)
diff --git a/test/gtest/matrix_view_test.cpp b/test/gtest/matrix_view_test.cpp
new file mode 100644
index 0000000..81cc994
--- /dev/null
+++ b/test/gtest/matrix_view_test.cpp
@@ -0,0 +1,230 @@
+#include <gtest/gtest.h>
+#include <spblas/views/matrix_view.hpp>
+#include <type_traits>
+
+namespace {
+
+class temp {};
+
+using ::testing::StaticAssertTypeEq;
+// only for the testing
+using namespace spblas::matrix_view;
+
+TEST(Tag, Conjugate) {
+  temp t;
+
+  StaticAssertTypeEq<decltype(conjugate(t)),
+                     general<temp&, std::true_type, std::false_type,
+                             diag::explicit_diag, uplo::full>>();
+  StaticAssertTypeEq<decltype(conjugate(conjugate(t))),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::explicit_diag, uplo::full>>();
+  EXPECT_EQ(&(conjugate(t).base()), &t);
+  EXPECT_EQ(&(conjugate(conjugate(t)).base()), &t);
+}
+
+TEST(Tag, Tranpose) {
+  temp t;
+
+  StaticAssertTypeEq<decltype(transpose(t)),
+                     general<temp&, std::false_type, std::true_type,
+                             diag::explicit_diag, uplo::full>>();
+  StaticAssertTypeEq<decltype(transpose(transpose(t))),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::explicit_diag, uplo::full>>();
+  EXPECT_EQ(&(transpose(t).base()), &t);
+  EXPECT_EQ(&(transpose(transpose(t)).base()), &t);
+}
+
+TEST(Tag, Diagonal) {
+  temp t;
+
+  StaticAssertTypeEq<decltype(diagonal(t)),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::explicit_diag, uplo::diag>>();
+  EXPECT_EQ(&(diagonal(t).base()), &t);
+}
+
+TEST(Tag, Lower) {
+  temp t;
+
+  StaticAssertTypeEq<decltype(triangle(t, uplo::lower())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::explicit_diag, uplo::lower>>();
+  StaticAssertTypeEq<decltype(triangle(triangle(t, uplo::lower()),
+                                       uplo::lower())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::explicit_diag, uplo::lower>>();
+  StaticAssertTypeEq<decltype(triangle(t, uplo::lower(),
+                                       diag::implicit_unit())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::implicit_unit, uplo::lower>>();
+  StaticAssertTypeEq<decltype(triangle(t, uplo::lower(),
+                                       diag::implicit_zero())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::implicit_zero, uplo::lower>>();
+  StaticAssertTypeEq<decltype(triangle(
+                         triangle(t, uplo::lower(), diag::implicit_unit()),
+                         uplo::lower(), diag::explicit_diag())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::implicit_unit, uplo::lower>>();
+  StaticAssertTypeEq<decltype(triangle(
+                         triangle(t, uplo::lower(), diag::implicit_zero()),
+                         uplo::lower(), diag::explicit_diag())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::implicit_zero, uplo::lower>>();
+  StaticAssertTypeEq<decltype(triangle(
+                         triangle(t, uplo::lower(), diag::implicit_unit()),
+                         uplo::lower(), diag::implicit_unit())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::implicit_unit, uplo::lower>>();
+  StaticAssertTypeEq<decltype(triangle(
+                         triangle(t, uplo::lower(), diag::implicit_zero()),
+                         uplo::lower(), diag::implicit_zero())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::implicit_zero, uplo::lower>>();
+  //   Unit or Zero Diag will overwrite the old one
+  StaticAssertTypeEq<decltype(triangle(
+                         triangle(t, uplo::lower(), diag::implicit_unit()),
+                         uplo::lower(), diag::implicit_zero())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::implicit_zero, uplo::lower>>();
+  StaticAssertTypeEq<decltype(triangle(
+                         triangle(t, uplo::lower(), diag::implicit_zero()),
+                         uplo::lower(), diag::implicit_unit())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::implicit_unit, uplo::lower>>();
+
+  EXPECT_EQ(&(triangle(t, uplo::lower()).base()), &t);
+  EXPECT_EQ(&(triangle(t, uplo::lower(), diag::implicit_zero()).base()), &t);
+  EXPECT_EQ(&(triangle(t, uplo::lower(), diag::implicit_unit()).base()), &t);
+  EXPECT_EQ(&(triangle(triangle(t, uplo::lower(), diag::implicit_zero()),
+                       uplo::lower(), diag::implicit_unit())
+                  .base()),
+            &t);
+  EXPECT_EQ(&(triangle(triangle(t, uplo::lower(), diag::implicit_unit()),
+                       uplo::lower(), diag::implicit_zero())
+                  .base()),
+            &t);
+}
+
+TEST(Tag, Upper) {
+  temp t;
+
+  StaticAssertTypeEq<decltype(triangle(t, uplo::upper())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::explicit_diag, uplo::upper>>();
+  StaticAssertTypeEq<decltype(triangle(triangle(t, uplo::upper()),
+                                       uplo::upper())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::explicit_diag, uplo::upper>>();
+  StaticAssertTypeEq<decltype(triangle(t, uplo::upper(),
+                                       diag::implicit_unit())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::implicit_unit, uplo::upper>>();
+  StaticAssertTypeEq<decltype(triangle(t, uplo::upper(),
+                                       diag::implicit_zero())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::implicit_zero, uplo::upper>>();
+  StaticAssertTypeEq<decltype(triangle(
+                         triangle(t, uplo::upper(), diag::implicit_unit()),
+                         uplo::upper(), diag::explicit_diag())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::implicit_unit, uplo::upper>>();
+  StaticAssertTypeEq<decltype(triangle(
+                         triangle(t, uplo::upper(), diag::implicit_zero()),
+                         uplo::upper(), diag::explicit_diag())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::implicit_zero, uplo::upper>>();
+  StaticAssertTypeEq<decltype(triangle(
+                         triangle(t, uplo::upper(), diag::implicit_unit()),
+                         uplo::upper(), diag::implicit_unit())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::implicit_unit, uplo::upper>>();
+  StaticAssertTypeEq<decltype(triangle(
+                         triangle(t, uplo::upper(), diag::implicit_zero()),
+                         uplo::upper(), diag::implicit_zero())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::implicit_zero, uplo::upper>>();
+  //   Unit or Zero Diag will overwrite the old one
+  StaticAssertTypeEq<decltype(triangle(
+                         triangle(t, uplo::upper(), diag::implicit_unit()),
+                         uplo::upper(), diag::implicit_zero())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::implicit_zero, uplo::upper>>();
+  StaticAssertTypeEq<decltype(triangle(
+                         triangle(t, uplo::upper(), diag::implicit_zero()),
+                         uplo::upper(), diag::implicit_unit())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::implicit_unit, uplo::upper>>();
+  EXPECT_EQ(&(triangle(t, uplo::upper()).base()), &t);
+  EXPECT_EQ(&(triangle(t, uplo::upper(), diag::implicit_zero()).base()), &t);
+  EXPECT_EQ(&(triangle(t, uplo::upper(), diag::implicit_unit()).base()), &t);
+  EXPECT_EQ(&(triangle(triangle(t, uplo::upper(), diag::implicit_zero()),
+                       uplo::upper(), diag::implicit_unit())
+                  .base()),
+            &t);
+  EXPECT_EQ(&(triangle(triangle(t, uplo::upper(), diag::implicit_unit()),
+                       uplo::upper(), diag::implicit_zero())
+                  .base()),
+            &t);
+}
+
+TEST(Tag, MixUpperAndLower) {
+  temp t;
+
+  StaticAssertTypeEq<decltype(triangle(triangle(t, uplo::upper()),
+                                       uplo::lower())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::explicit_diag, uplo::diag>>();
+  StaticAssertTypeEq<decltype(triangle(triangle(t, uplo::lower()),
+                                       uplo::upper())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::explicit_diag, uplo::diag>>();
+}
+
+TEST(Tag, GetTransposeOfUpper) {
+  temp t;
+
+  StaticAssertTypeEq<decltype(transpose(triangle(t, uplo::upper()))),
+                     general<temp&, std::false_type, std::true_type,
+                             diag::explicit_diag, uplo::upper>>();
+  // Lower(M^T) = Upper(M)^T
+  StaticAssertTypeEq<decltype(triangle(transpose(t), uplo::lower())),
+                     general<temp&, std::false_type, std::true_type,
+                             diag::explicit_diag, uplo::upper>>();
+}
+
+TEST(Tag, GetTransposeOfLower) {
+  temp t;
+
+  StaticAssertTypeEq<decltype(transpose(triangle(t, uplo::lower()))),
+                     general<temp&, std::false_type, std::true_type,
+                             diag::explicit_diag, uplo::lower>>();
+  // Upper(M^T) = Lower(M)^T
+  StaticAssertTypeEq<decltype(triangle(transpose(t), uplo::upper())),
+                     general<temp&, std::false_type, std::true_type,
+                             diag::explicit_diag, uplo::lower>>();
+}
+
+TEST(Tag, LongChain) {
+  temp t;
+
+  StaticAssertTypeEq<decltype(triangle(transpose(triangle(t, uplo::lower())),
+                                       uplo::upper(), diag::implicit_zero())),
+                     general<temp&, std::false_type, std::true_type,
+                             diag::implicit_zero, uplo::lower>>();
+  StaticAssertTypeEq<decltype(conjugate(
+                         triangle(transpose(triangle(t, uplo::lower())),
+                                  uplo::lower(), diag::implicit_zero()))),
+                     general<temp&, std::true_type, std::false_type,
+                             diag::implicit_zero, uplo::diag>>();
+  StaticAssertTypeEq<
+      decltype(transpose(conjugate(
+          triangle(transpose(triangle(t, uplo::lower(), diag::implicit_zero())),
+                   uplo::lower(), diag::implicit_unit())))),
+      general<temp&, std::true_type, std::false_type, diag::implicit_unit,
+              uplo::diag>>();
+}
+
+} // namespace
diff --git a/test/gtest/tag_test.cpp b/test/gtest/tag_test.cpp
deleted file mode 100644
index b4f2e0f..0000000
--- a/test/gtest/tag_test.cpp
+++ /dev/null
@@ -1,203 +0,0 @@
-#include <gtest/gtest.h>
-#include <spblas/views/collection.hpp>
-#include <type_traits>
-
-class temp {
-public:
-    using scalar_type = float;
-  using scalar_reference = float&;
-  using index_type = int;
-  using offset_type = int;
-};
-
-using ::testing::StaticAssertTypeEq;
-// only for the testing
-using namespace spblas::view_v;
-
-TEST(Tag, Conjugate) {
-  temp t;
-  StaticAssertTypeEq<
-      decltype(conjugate(t)),
-      general<temp&, conj, none, diag::explicit_diag, uplo::full>>();
-  StaticAssertTypeEq<
-      decltype(conjugate(conjugate(t))),
-      general<temp&, none, none, diag::explicit_diag, uplo::full>>();
-  EXPECT_EQ(&(conjugate(t).obj), &t);
-  EXPECT_EQ(&(conjugate(conjugate(t)).obj), &t);
-}
-
-TEST(Tag, Tranpose) {
-  temp t;
-  StaticAssertTypeEq<
-      decltype(transpose(t)),
-      general<temp&, none, trans, diag::explicit_diag, uplo::full>>();
-  StaticAssertTypeEq<
-      decltype(transpose(transpose(t))),
-      general<temp&, none, none, diag::explicit_diag, uplo::full>>();
-  EXPECT_EQ(&(transpose(t).obj), &t);
-  EXPECT_EQ(&(transpose(transpose(t)).obj), &t);
-}
-
-TEST(Tag, Diagonal) {
-  temp t;
-  StaticAssertTypeEq<
-      decltype(diagonal(t)),
-      general<temp&, none, none, diag::explicit_diag, uplo::diag>>();
-  EXPECT_EQ(&(diagonal(t).obj), &t);
-}
-
-TEST(Tag, Lower) {
-  temp t;
-  StaticAssertTypeEq<
-      decltype(triangle(t, uplo::lower())),
-      general<temp&, none, none, diag::explicit_diag, uplo::lower>>();
-  StaticAssertTypeEq<
-      decltype(triangle(triangle(t, uplo::lower()), uplo::lower())),
-      general<temp&, none, none, diag::explicit_diag, uplo::lower>>();
-  StaticAssertTypeEq<
-      decltype(triangle(t, uplo::lower(), diag::implicit_unit())),
-      general<temp&, none, none, diag::implicit_unit, uplo::lower>>();
-  StaticAssertTypeEq<
-      decltype(triangle(t, uplo::lower(), diag::implicit_zero())),
-      general<temp&, none, none, diag::implicit_zero, uplo::lower>>();
-  StaticAssertTypeEq<
-      decltype(triangle(triangle(t, uplo::lower(), diag::implicit_unit()),
-                        uplo::lower(), diag::explicit_diag())),
-      general<temp&, none, none, diag::implicit_unit, uplo::lower>>();
-  StaticAssertTypeEq<
-      decltype(triangle(triangle(t, uplo::lower(), diag::implicit_zero()),
-                        uplo::lower(), diag::explicit_diag())),
-      general<temp&, none, none, diag::implicit_zero, uplo::lower>>();
-  StaticAssertTypeEq<
-      decltype(triangle(triangle(t, uplo::lower(), diag::implicit_unit()),
-                        uplo::lower(), diag::implicit_unit())),
-      general<temp&, none, none, diag::implicit_unit, uplo::lower>>();
-  StaticAssertTypeEq<
-      decltype(triangle(triangle(t, uplo::lower(), diag::implicit_zero()),
-                        uplo::lower(), diag::implicit_zero())),
-      general<temp&, none, none, diag::implicit_zero, uplo::lower>>();
-  //   Unit or Zero Diag will overwrite the old one
-  StaticAssertTypeEq<
-      decltype(triangle(triangle(t, uplo::lower(), diag::implicit_unit()),
-                        uplo::lower(), diag::implicit_zero())),
-      general<temp&, none, none, diag::implicit_zero, uplo::lower>>();
-  StaticAssertTypeEq<
-      decltype(triangle(triangle(t, uplo::lower(), diag::implicit_zero()),
-                        uplo::lower(), diag::implicit_unit())),
-      general<temp&, none, none, diag::implicit_unit, uplo::lower>>();
-
-  EXPECT_EQ(&(triangle(t, uplo::lower()).obj), &t);
-  EXPECT_EQ(&(triangle(t, uplo::lower(), diag::implicit_zero()).obj), &t);
-  EXPECT_EQ(&(triangle(t, uplo::lower(), diag::implicit_unit()).obj), &t);
-  EXPECT_EQ(&(triangle(triangle(t, uplo::lower(), diag::implicit_zero()),
-                       uplo::lower(), diag::implicit_unit())
-                  .obj),
-            &t);
-  EXPECT_EQ(&(triangle(triangle(t, uplo::lower(), diag::implicit_unit()),
-                       uplo::lower(), diag::implicit_zero())
-                  .obj),
-            &t);
-}
-
-TEST(Tag, Upper) {
-  temp t;
-  StaticAssertTypeEq<
-      decltype(triangle(t, uplo::upper())),
-      general<temp&, none, none, diag::explicit_diag, uplo::upper>>();
-  StaticAssertTypeEq<
-      decltype(triangle(triangle(t, uplo::upper()), uplo::upper())),
-      general<temp&, none, none, diag::explicit_diag, uplo::upper>>();
-  StaticAssertTypeEq<
-      decltype(triangle(t, uplo::upper(), diag::implicit_unit())),
-      general<temp&, none, none, diag::implicit_unit, uplo::upper>>();
-  StaticAssertTypeEq<
-      decltype(triangle(t, uplo::upper(), diag::implicit_zero())),
-      general<temp&, none, none, diag::implicit_zero, uplo::upper>>();
-  StaticAssertTypeEq<
-      decltype(triangle(triangle(t, uplo::upper(), diag::implicit_unit()),
-                        uplo::upper(), diag::explicit_diag())),
-      general<temp&, none, none, diag::implicit_unit, uplo::upper>>();
-  StaticAssertTypeEq<
-      decltype(triangle(triangle(t, uplo::upper(), diag::implicit_zero()),
-                        uplo::upper(), diag::explicit_diag())),
-      general<temp&, none, none, diag::implicit_zero, uplo::upper>>();
-  StaticAssertTypeEq<
-      decltype(triangle(triangle(t, uplo::upper(), diag::implicit_unit()),
-                        uplo::upper(), diag::implicit_unit())),
-      general<temp&, none, none, diag::implicit_unit, uplo::upper>>();
-  StaticAssertTypeEq<
-      decltype(triangle(triangle(t, uplo::upper(), diag::implicit_zero()),
-                        uplo::upper(), diag::implicit_zero())),
-      general<temp&, none, none, diag::implicit_zero, uplo::upper>>();
-  //   Unit or Zero Diag will overwrite the old one
-  StaticAssertTypeEq<
-      decltype(triangle(triangle(t, uplo::upper(), diag::implicit_unit()),
-                        uplo::upper(), diag::implicit_zero())),
-      general<temp&, none, none, diag::implicit_zero, uplo::upper>>();
-  StaticAssertTypeEq<
-      decltype(triangle(triangle(t, uplo::upper(), diag::implicit_zero()),
-                        uplo::upper(), diag::implicit_unit())),
-      general<temp&, none, none, diag::implicit_unit, uplo::upper>>();
-
-  EXPECT_EQ(&(triangle(t, uplo::upper()).obj), &t);
-  EXPECT_EQ(&(triangle(t, uplo::upper(), diag::implicit_zero()).obj), &t);
-  EXPECT_EQ(&(triangle(t, uplo::upper(), diag::implicit_unit()).obj), &t);
-  EXPECT_EQ(&(triangle(triangle(t, uplo::upper(), diag::implicit_zero()),
-                       uplo::upper(), diag::implicit_unit())
-                  .obj),
-            &t);
-  EXPECT_EQ(&(triangle(triangle(t, uplo::upper(), diag::implicit_unit()),
-                       uplo::upper(), diag::implicit_zero())
-                  .obj),
-            &t);
-}
-
-TEST(Tag, MixUpperAndLower) {
-  temp t;
-  StaticAssertTypeEq<
-      decltype(triangle(triangle(t, uplo::upper()), uplo::lower())),
-      general<temp&, none, none, diag::explicit_diag, uplo::diag>>();
-  StaticAssertTypeEq<
-      decltype(triangle(triangle(t, uplo::lower()), uplo::upper())),
-      general<temp&, none, none, diag::explicit_diag, uplo::diag>>();
-}
-
-TEST(Tag, GetTransposeOfUpper) {
-  temp t;
-  StaticAssertTypeEq<
-      decltype(transpose(triangle(t, uplo::upper()))),
-      general<temp&, none, trans, diag::explicit_diag, uplo::upper>>();
-  // Lower(M^T) = Upper(M)^T
-  StaticAssertTypeEq<
-      decltype(triangle(transpose(t), uplo::lower())),
-      general<temp&, none, trans, diag::explicit_diag, uplo::upper>>();
-}
-
-TEST(Tag, GetTransposeOfLower) {
-  temp t;
-  StaticAssertTypeEq<
-      decltype(transpose(triangle(t, uplo::lower()))),
-      general<temp&, none, trans, diag::explicit_diag, uplo::lower>>();
-  // Upper(M^T) = Lower(M)^T
-  StaticAssertTypeEq<
-      decltype(triangle(transpose(t), uplo::upper())),
-      general<temp&, none, trans, diag::explicit_diag, uplo::lower>>();
-}
-
-TEST(Tag, LongChain) {
-  temp t;
-
-  StaticAssertTypeEq<
-      decltype(triangle(transpose(triangle(t, uplo::lower())), uplo::upper(),
-                        diag::implicit_zero())),
-      general<temp&, none, trans, diag::implicit_zero, uplo::lower>>();
-  StaticAssertTypeEq<
-      decltype(conjugate(triangle(transpose(triangle(t, uplo::lower())),
-                                  uplo::lower(), diag::implicit_zero()))),
-      general<temp&, conj, none, diag::implicit_zero, uplo::diag>>();
-  StaticAssertTypeEq<
-      decltype(transpose(conjugate(
-          triangle(transpose(triangle(t, uplo::lower(), diag::implicit_zero())),
-                   uplo::lower(), diag::implicit_unit())))),
-      general<temp&, conj, none, diag::implicit_unit, uplo::diag>>();
-}

From a92284824f131a8c4fc61ba990d1e5ddb34a6103 Mon Sep 17 00:00:00 2001
From: "Yu-Hsiang M. Tsai" <yhmtsai@gmail.com>
Date: Wed, 29 Apr 2026 10:38:03 +0200
Subject: [PATCH 3/3] rename general matrix_view to lagacy pattern

---
 include/spblas/views/matrix_view.hpp | 244 ++++++++++++++-------------
 test/gtest/matrix_view_test.cpp      | 136 +++++++--------
 2 files changed, 199 insertions(+), 181 deletions(-)

diff --git a/include/spblas/views/matrix_view.hpp b/include/spblas/views/matrix_view.hpp
index cca047b..fac1310 100644
--- a/include/spblas/views/matrix_view.hpp
+++ b/include/spblas/views/matrix_view.hpp
@@ -77,9 +77,9 @@ template <typename matrix_opt, typename Conjugate = std::false_type,
           typename Transpose = std::false_type,
           diag::diag Diagonal = diag::explicit_diag,
           uplo::uplo UpLo = uplo::full>
-class general : public spblas::view_base {
+class legacy_pattern : public spblas::view_base {
 public:
-  general(matrix_opt&& t) : obj(t) {}
+  legacy_pattern(matrix_opt&& t) : obj(t) {}
 
   auto& base() {
     return obj;
@@ -95,243 +95,261 @@ class general : public spblas::view_base {
 
 template <typename matrix_opt>
 auto conjugate(matrix_opt&& matrix) {
-  return general<matrix_opt, std::true_type>(matrix);
+  return legacy_pattern<matrix_opt, std::true_type>(matrix);
 }
 
 template <typename matrix_opt, typename Transpose, typename Diagonal,
           typename UpLo>
-auto conjugate(
-    general<matrix_opt, std::true_type, Transpose, Diagonal, UpLo>&& matrix) {
-  return general<matrix_opt, std::false_type, Transpose, Diagonal, UpLo>(
+auto conjugate(legacy_pattern<matrix_opt, std::true_type, Transpose, Diagonal,
+                              UpLo>&& matrix) {
+  return legacy_pattern<matrix_opt, std::false_type, Transpose, Diagonal, UpLo>(
       matrix.base());
 }
 
 template <typename Transpose, typename Diagonal, typename UpLo,
           typename matrix_opt>
-auto conjugate(
-    general<matrix_opt, std::false_type, Transpose, Diagonal, UpLo>&& matrix) {
-  return general<matrix_opt, std::true_type, Transpose, Diagonal, UpLo>(
+auto conjugate(legacy_pattern<matrix_opt, std::false_type, Transpose, Diagonal,
+                              UpLo>&& matrix) {
+  return legacy_pattern<matrix_opt, std::true_type, Transpose, Diagonal, UpLo>(
       matrix.base());
 }
 
 template <typename matrix_opt>
 auto transpose(matrix_opt&& matrix) {
-  return general<matrix_opt, std::false_type, std::true_type>(matrix);
+  return legacy_pattern<matrix_opt, std::false_type, std::true_type>(matrix);
 }
 
 template <typename Conjugate, typename Diagonal, typename UpLo,
           typename matrix_opt>
   requires(!std::is_same_v<UpLo, uplo::diag>)
-auto transpose(
-    general<matrix_opt, Conjugate, std::false_type, Diagonal, UpLo>&& matrix) {
-  return general<matrix_opt, Conjugate, std::true_type, Diagonal, UpLo>(
+auto transpose(legacy_pattern<matrix_opt, Conjugate, std::false_type, Diagonal,
+                              UpLo>&& matrix) {
+  return legacy_pattern<matrix_opt, Conjugate, std::true_type, Diagonal, UpLo>(
       matrix.base());
 }
 
 template <typename Conjugate, typename Diagonal, typename UpLo,
           typename matrix_opt>
   requires(!std::is_same_v<UpLo, uplo::diag>)
-auto transpose(
-    general<matrix_opt, Conjugate, std::true_type, Diagonal, UpLo>&& matrix) {
-  return general<matrix_opt, Conjugate, std::false_type, Diagonal, UpLo>(
+auto transpose(legacy_pattern<matrix_opt, Conjugate, std::true_type, Diagonal,
+                              UpLo>&& matrix) {
+  return legacy_pattern<matrix_opt, Conjugate, std::false_type, Diagonal, UpLo>(
       matrix.base());
 }
 
 template <typename Conjugate, typename Diagonal, typename Transpose,
           typename matrix_opt>
-auto transpose(
-    general<matrix_opt, Conjugate, Transpose, Diagonal, uplo::diag>&& matrix) {
-  return general<matrix_opt, Conjugate, std::false_type, Diagonal, uplo::diag>(
-      matrix.base());
+auto transpose(legacy_pattern<matrix_opt, Conjugate, Transpose, Diagonal,
+                              uplo::diag>&& matrix) {
+  return legacy_pattern<matrix_opt, Conjugate, std::false_type, Diagonal,
+                        uplo::diag>(matrix.base());
 }
 
 template <typename matrix_opt, typename TreatDiag = diag::explicit_diag>
 auto diagonal(matrix_opt&& matrix, TreatDiag = {}) {
-  return general<matrix_opt, std::false_type, std::false_type, TreatDiag,
-                 uplo::diag>(matrix);
+  return legacy_pattern<matrix_opt, std::false_type, std::false_type, TreatDiag,
+                        uplo::diag>(matrix);
 }
 
 template <typename Conjugate, typename Transpose, typename Diagonal,
           typename UpLo, typename matrix_opt, typename TreatDiag>
-auto diagonal(general<matrix_opt, Conjugate, Transpose,
-                      typename __detail::decide_diag<Diagonal, TreatDiag>::type,
-                      UpLo>&& matrix,
-              TreatDiag = {}) {
-  return general<matrix_opt, Conjugate, std::false_type,
-                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
-                 uplo::diag>(matrix.base());
+auto diagonal(
+    legacy_pattern<matrix_opt, Conjugate, Transpose,
+                   typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                   UpLo>&& matrix,
+    TreatDiag = {}) {
+  return legacy_pattern<
+      matrix_opt, Conjugate, std::false_type,
+      typename __detail::decide_diag<Diagonal, TreatDiag>::type, uplo::diag>(
+      matrix.base());
 }
 
 template <typename matrix_opt, typename TreatDiag = diag::explicit_diag>
 auto triangle(matrix_opt&& matrix, uplo::lower, TreatDiag = {}) {
-  return general<matrix_opt, std::false_type, std::false_type, TreatDiag,
-                 uplo::lower>(matrix);
+  return legacy_pattern<matrix_opt, std::false_type, std::false_type, TreatDiag,
+                        uplo::lower>(matrix);
 }
 
 template <typename Conjugate, typename Diagonal, typename matrix_opt,
           typename TreatDiag = diag::explicit_diag>
-auto triangle(general<matrix_opt, Conjugate, std::false_type, Diagonal,
-                      uplo::full>&& matrix,
+auto triangle(legacy_pattern<matrix_opt, Conjugate, std::false_type, Diagonal,
+                             uplo::full>&& matrix,
               uplo::lower, TreatDiag = {}) {
-  return general<matrix_opt, Conjugate, std::false_type,
-                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
-                 uplo::lower>(matrix.base());
+  return legacy_pattern<
+      matrix_opt, Conjugate, std::false_type,
+      typename __detail::decide_diag<Diagonal, TreatDiag>::type, uplo::lower>(
+      matrix.base());
 }
 
 template <typename Conjugate, typename Diagonal, typename matrix_opt,
           typename TreatDiag = diag::explicit_diag>
-auto triangle(general<matrix_opt, Conjugate, std::false_type, Diagonal,
-                      uplo::lower>&& matrix,
+auto triangle(legacy_pattern<matrix_opt, Conjugate, std::false_type, Diagonal,
+                             uplo::lower>&& matrix,
               uplo::lower, TreatDiag = {}) {
-  return general<matrix_opt, Conjugate, std::false_type,
-                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
-                 uplo::lower>(matrix.base());
+  return legacy_pattern<
+      matrix_opt, Conjugate, std::false_type,
+      typename __detail::decide_diag<Diagonal, TreatDiag>::type, uplo::lower>(
+      matrix.base());
 }
 
 template <typename Conjugate, typename Diagonal, typename matrix_opt,
           typename TreatDiag = diag::explicit_diag>
-auto triangle(general<matrix_opt, Conjugate, std::false_type, Diagonal,
-                      uplo::upper>&& matrix,
+auto triangle(legacy_pattern<matrix_opt, Conjugate, std::false_type, Diagonal,
+                             uplo::upper>&& matrix,
               uplo::lower, TreatDiag = {}) {
-  return general<matrix_opt, Conjugate, std::false_type,
-                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
-                 uplo::diag>(matrix.base());
+  return legacy_pattern<
+      matrix_opt, Conjugate, std::false_type,
+      typename __detail::decide_diag<Diagonal, TreatDiag>::type, uplo::diag>(
+      matrix.base());
 }
 
 template <typename Conjugate, typename Diagonal, typename matrix_opt,
           typename TreatDiag = diag::explicit_diag>
-auto triangle(general<matrix_opt, Conjugate, std::false_type, Diagonal,
-                      uplo::diag>&& matrix,
+auto triangle(legacy_pattern<matrix_opt, Conjugate, std::false_type, Diagonal,
+                             uplo::diag>&& matrix,
               uplo::lower, TreatDiag = {}) {
-  return general<matrix_opt, Conjugate, std::false_type,
-                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
-                 uplo::diag>(matrix.base());
+  return legacy_pattern<
+      matrix_opt, Conjugate, std::false_type,
+      typename __detail::decide_diag<Diagonal, TreatDiag>::type, uplo::diag>(
+      matrix.base());
 }
 
 template <typename Conjugate, typename Diagonal, typename matrix_opt,
           typename TreatDiag = diag::explicit_diag>
-auto triangle(general<matrix_opt, Conjugate, std::true_type, Diagonal,
-                      uplo::full>&& matrix,
+auto triangle(legacy_pattern<matrix_opt, Conjugate, std::true_type, Diagonal,
+                             uplo::full>&& matrix,
               uplo::lower, TreatDiag = {}) {
-  return general<matrix_opt, Conjugate, std::true_type,
-                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
-                 uplo::upper>(matrix.base());
+  return legacy_pattern<
+      matrix_opt, Conjugate, std::true_type,
+      typename __detail::decide_diag<Diagonal, TreatDiag>::type, uplo::upper>(
+      matrix.base());
 }
 
 template <typename Conjugate, typename Diagonal, typename matrix_opt,
           typename TreatDiag = diag::explicit_diag>
-auto triangle(general<matrix_opt, Conjugate, std::true_type, Diagonal,
-                      uplo::lower>&& matrix,
+auto triangle(legacy_pattern<matrix_opt, Conjugate, std::true_type, Diagonal,
+                             uplo::lower>&& matrix,
               uplo::lower, TreatDiag = {}) {
-  return general<matrix_opt, Conjugate, std::false_type,
-                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
-                 uplo::diag>(matrix.base());
+  return legacy_pattern<
+      matrix_opt, Conjugate, std::false_type,
+      typename __detail::decide_diag<Diagonal, TreatDiag>::type, uplo::diag>(
+      matrix.base());
 }
 
 template <typename Conjugate, typename Diagonal, typename matrix_opt,
           typename TreatDiag = diag::explicit_diag>
-auto triangle(general<matrix_opt, Conjugate, std::true_type, Diagonal,
-                      uplo::upper>&& matrix,
+auto triangle(legacy_pattern<matrix_opt, Conjugate, std::true_type, Diagonal,
+                             uplo::upper>&& matrix,
               uplo::lower, TreatDiag = {}) {
-  return general<matrix_opt, Conjugate, std::true_type,
-                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
-                 uplo::upper>(matrix.base());
+  return legacy_pattern<
+      matrix_opt, Conjugate, std::true_type,
+      typename __detail::decide_diag<Diagonal, TreatDiag>::type, uplo::upper>(
+      matrix.base());
 }
 
 template <typename Conjugate, typename Diagonal, typename matrix_opt,
           typename TreatDiag = diag::explicit_diag>
-auto triangle(general<matrix_opt, Conjugate, std::true_type, Diagonal,
-                      uplo::diag>&& matrix,
+auto triangle(legacy_pattern<matrix_opt, Conjugate, std::true_type, Diagonal,
+                             uplo::diag>&& matrix,
               uplo::lower, TreatDiag = {}) {
-  return general<matrix_opt, Conjugate, std::false_type,
-                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
-                 uplo::diag>(matrix.base());
+  return legacy_pattern<
+      matrix_opt, Conjugate, std::false_type,
+      typename __detail::decide_diag<Diagonal, TreatDiag>::type, uplo::diag>(
+      matrix.base());
 }
 
 template <typename matrix_opt, typename TreatDiag = diag::explicit_diag>
 auto triangle(matrix_opt&& matrix, uplo::upper, TreatDiag = {}) {
-  return general<matrix_opt, std::false_type, std::false_type, TreatDiag,
-                 uplo::upper>(matrix);
+  return legacy_pattern<matrix_opt, std::false_type, std::false_type, TreatDiag,
+                        uplo::upper>(matrix);
 }
 
 template <typename Conjugate, typename Diagonal, typename matrix_opt,
           typename TreatDiag = diag::explicit_diag>
-auto triangle(general<matrix_opt, Conjugate, std::false_type, Diagonal,
-                      uplo::full>&& matrix,
+auto triangle(legacy_pattern<matrix_opt, Conjugate, std::false_type, Diagonal,
+                             uplo::full>&& matrix,
               uplo::upper, TreatDiag = {}) {
-  return general<matrix_opt, Conjugate, std::false_type,
-                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
-                 uplo::upper>(matrix.base());
+  return legacy_pattern<
+      matrix_opt, Conjugate, std::false_type,
+      typename __detail::decide_diag<Diagonal, TreatDiag>::type, uplo::upper>(
+      matrix.base());
 }
 
 template <typename Conjugate, typename Diagonal, typename matrix_opt,
           typename TreatDiag = diag::explicit_diag>
-auto triangle(general<matrix_opt, Conjugate, std::false_type, Diagonal,
-                      uplo::lower>&& matrix,
+auto triangle(legacy_pattern<matrix_opt, Conjugate, std::false_type, Diagonal,
+                             uplo::lower>&& matrix,
               uplo::upper, TreatDiag = {}) {
-  return general<matrix_opt, Conjugate, std::false_type,
-                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
-                 uplo::diag>(matrix.base());
+  return legacy_pattern<
+      matrix_opt, Conjugate, std::false_type,
+      typename __detail::decide_diag<Diagonal, TreatDiag>::type, uplo::diag>(
+      matrix.base());
 }
 
 template <typename Conjugate, typename Diagonal, typename matrix_opt,
           typename TreatDiag = diag::explicit_diag>
-auto triangle(general<matrix_opt, Conjugate, std::false_type, Diagonal,
-                      uplo::upper>&& matrix,
+auto triangle(legacy_pattern<matrix_opt, Conjugate, std::false_type, Diagonal,
+                             uplo::upper>&& matrix,
               uplo::upper, TreatDiag = {}) {
-  return general<matrix_opt, Conjugate, std::false_type,
-                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
-                 uplo::upper>(matrix.base());
+  return legacy_pattern<
+      matrix_opt, Conjugate, std::false_type,
+      typename __detail::decide_diag<Diagonal, TreatDiag>::type, uplo::upper>(
+      matrix.base());
 }
 
 template <typename Conjugate, typename Diagonal, typename matrix_opt,
           typename TreatDiag = diag::explicit_diag>
-auto triangle(general<matrix_opt, Conjugate, std::false_type, Diagonal,
-                      uplo::diag>&& matrix,
+auto triangle(legacy_pattern<matrix_opt, Conjugate, std::false_type, Diagonal,
+                             uplo::diag>&& matrix,
               uplo::upper, TreatDiag = {}) {
-  return general<matrix_opt, Conjugate, std::false_type,
-                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
-                 uplo::diag>(matrix.base());
+  return legacy_pattern<
+      matrix_opt, Conjugate, std::false_type,
+      typename __detail::decide_diag<Diagonal, TreatDiag>::type, uplo::diag>(
+      matrix.base());
 }
 
 template <typename Conjugate, typename Diagonal, typename matrix_opt,
           typename TreatDiag = diag::explicit_diag>
-auto triangle(general<matrix_opt, Conjugate, std::true_type, Diagonal,
-                      uplo::full>&& matrix,
+auto triangle(legacy_pattern<matrix_opt, Conjugate, std::true_type, Diagonal,
+                             uplo::full>&& matrix,
               uplo::upper, TreatDiag = {}) {
-  return general<matrix_opt, Conjugate, std::true_type,
-                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
-                 uplo::lower>(matrix.base());
+  return legacy_pattern<
+      matrix_opt, Conjugate, std::true_type,
+      typename __detail::decide_diag<Diagonal, TreatDiag>::type, uplo::lower>(
+      matrix.base());
 }
 
 template <typename Conjugate, typename Diagonal, typename matrix_opt,
           typename TreatDiag = diag::explicit_diag>
-auto triangle(general<matrix_opt, Conjugate, std::true_type, Diagonal,
-                      uplo::lower>&& matrix,
+auto triangle(legacy_pattern<matrix_opt, Conjugate, std::true_type, Diagonal,
+                             uplo::lower>&& matrix,
               uplo::upper, TreatDiag = {}) {
-  return general<matrix_opt, Conjugate, std::true_type,
-                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
-                 uplo::lower>(matrix.base());
+  return legacy_pattern<
+      matrix_opt, Conjugate, std::true_type,
+      typename __detail::decide_diag<Diagonal, TreatDiag>::type, uplo::lower>(
+      matrix.base());
 }
 
 template <typename Conjugate, typename Diagonal, typename matrix_opt,
           typename TreatDiag = diag::explicit_diag>
-auto triangle(general<matrix_opt, Conjugate, std::true_type, Diagonal,
-                      uplo::upper>&& matrix,
+auto triangle(legacy_pattern<matrix_opt, Conjugate, std::true_type, Diagonal,
+                             uplo::upper>&& matrix,
               uplo::upper, TreatDiag = {}) {
-  return general<matrix_opt, Conjugate, std::false_type,
-                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
-                 uplo::diag>(matrix.base());
+  return legacy_pattern<
+      matrix_opt, Conjugate, std::false_type,
+      typename __detail::decide_diag<Diagonal, TreatDiag>::type, uplo::diag>(
+      matrix.base());
 }
 
 template <typename Conjugate, typename Diagonal, typename matrix_opt,
           typename TreatDiag = diag::explicit_diag>
-auto triangle(general<matrix_opt, Conjugate, std::true_type, Diagonal,
-                      uplo::diag>&& matrix,
+auto triangle(legacy_pattern<matrix_opt, Conjugate, std::true_type, Diagonal,
+                             uplo::diag>&& matrix,
               uplo::upper, TreatDiag = {}) {
-  return general<matrix_opt, Conjugate, std::false_type,
-                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
-                 uplo::diag>(matrix.base());
+  return legacy_pattern<
+      matrix_opt, Conjugate, std::false_type,
+      typename __detail::decide_diag<Diagonal, TreatDiag>::type, uplo::diag>(
+      matrix.base());
 }
 
 } // namespace matrix_view
diff --git a/test/gtest/matrix_view_test.cpp b/test/gtest/matrix_view_test.cpp
index 81cc994..c449b16 100644
--- a/test/gtest/matrix_view_test.cpp
+++ b/test/gtest/matrix_view_test.cpp
@@ -14,11 +14,11 @@ TEST(Tag, Conjugate) {
   temp t;
 
   StaticAssertTypeEq<decltype(conjugate(t)),
-                     general<temp&, std::true_type, std::false_type,
-                             diag::explicit_diag, uplo::full>>();
+                     legacy_pattern<temp&, std::true_type, std::false_type,
+                                    diag::explicit_diag, uplo::full>>();
   StaticAssertTypeEq<decltype(conjugate(conjugate(t))),
-                     general<temp&, std::false_type, std::false_type,
-                             diag::explicit_diag, uplo::full>>();
+                     legacy_pattern<temp&, std::false_type, std::false_type,
+                                    diag::explicit_diag, uplo::full>>();
   EXPECT_EQ(&(conjugate(t).base()), &t);
   EXPECT_EQ(&(conjugate(conjugate(t)).base()), &t);
 }
@@ -27,11 +27,11 @@ TEST(Tag, Tranpose) {
   temp t;
 
   StaticAssertTypeEq<decltype(transpose(t)),
-                     general<temp&, std::false_type, std::true_type,
-                             diag::explicit_diag, uplo::full>>();
+                     legacy_pattern<temp&, std::false_type, std::true_type,
+                                    diag::explicit_diag, uplo::full>>();
   StaticAssertTypeEq<decltype(transpose(transpose(t))),
-                     general<temp&, std::false_type, std::false_type,
-                             diag::explicit_diag, uplo::full>>();
+                     legacy_pattern<temp&, std::false_type, std::false_type,
+                                    diag::explicit_diag, uplo::full>>();
   EXPECT_EQ(&(transpose(t).base()), &t);
   EXPECT_EQ(&(transpose(transpose(t)).base()), &t);
 }
@@ -40,8 +40,8 @@ TEST(Tag, Diagonal) {
   temp t;
 
   StaticAssertTypeEq<decltype(diagonal(t)),
-                     general<temp&, std::false_type, std::false_type,
-                             diag::explicit_diag, uplo::diag>>();
+                     legacy_pattern<temp&, std::false_type, std::false_type,
+                                    diag::explicit_diag, uplo::diag>>();
   EXPECT_EQ(&(diagonal(t).base()), &t);
 }
 
@@ -49,51 +49,51 @@ TEST(Tag, Lower) {
   temp t;
 
   StaticAssertTypeEq<decltype(triangle(t, uplo::lower())),
-                     general<temp&, std::false_type, std::false_type,
-                             diag::explicit_diag, uplo::lower>>();
+                     legacy_pattern<temp&, std::false_type, std::false_type,
+                                    diag::explicit_diag, uplo::lower>>();
   StaticAssertTypeEq<decltype(triangle(triangle(t, uplo::lower()),
                                        uplo::lower())),
-                     general<temp&, std::false_type, std::false_type,
-                             diag::explicit_diag, uplo::lower>>();
+                     legacy_pattern<temp&, std::false_type, std::false_type,
+                                    diag::explicit_diag, uplo::lower>>();
   StaticAssertTypeEq<decltype(triangle(t, uplo::lower(),
                                        diag::implicit_unit())),
-                     general<temp&, std::false_type, std::false_type,
-                             diag::implicit_unit, uplo::lower>>();
+                     legacy_pattern<temp&, std::false_type, std::false_type,
+                                    diag::implicit_unit, uplo::lower>>();
   StaticAssertTypeEq<decltype(triangle(t, uplo::lower(),
                                        diag::implicit_zero())),
-                     general<temp&, std::false_type, std::false_type,
-                             diag::implicit_zero, uplo::lower>>();
+                     legacy_pattern<temp&, std::false_type, std::false_type,
+                                    diag::implicit_zero, uplo::lower>>();
   StaticAssertTypeEq<decltype(triangle(
                          triangle(t, uplo::lower(), diag::implicit_unit()),
                          uplo::lower(), diag::explicit_diag())),
-                     general<temp&, std::false_type, std::false_type,
-                             diag::implicit_unit, uplo::lower>>();
+                     legacy_pattern<temp&, std::false_type, std::false_type,
+                                    diag::implicit_unit, uplo::lower>>();
   StaticAssertTypeEq<decltype(triangle(
                          triangle(t, uplo::lower(), diag::implicit_zero()),
                          uplo::lower(), diag::explicit_diag())),
-                     general<temp&, std::false_type, std::false_type,
-                             diag::implicit_zero, uplo::lower>>();
+                     legacy_pattern<temp&, std::false_type, std::false_type,
+                                    diag::implicit_zero, uplo::lower>>();
   StaticAssertTypeEq<decltype(triangle(
                          triangle(t, uplo::lower(), diag::implicit_unit()),
                          uplo::lower(), diag::implicit_unit())),
-                     general<temp&, std::false_type, std::false_type,
-                             diag::implicit_unit, uplo::lower>>();
+                     legacy_pattern<temp&, std::false_type, std::false_type,
+                                    diag::implicit_unit, uplo::lower>>();
   StaticAssertTypeEq<decltype(triangle(
                          triangle(t, uplo::lower(), diag::implicit_zero()),
                          uplo::lower(), diag::implicit_zero())),
-                     general<temp&, std::false_type, std::false_type,
-                             diag::implicit_zero, uplo::lower>>();
+                     legacy_pattern<temp&, std::false_type, std::false_type,
+                                    diag::implicit_zero, uplo::lower>>();
   //   Unit or Zero Diag will overwrite the old one
   StaticAssertTypeEq<decltype(triangle(
                          triangle(t, uplo::lower(), diag::implicit_unit()),
                          uplo::lower(), diag::implicit_zero())),
-                     general<temp&, std::false_type, std::false_type,
-                             diag::implicit_zero, uplo::lower>>();
+                     legacy_pattern<temp&, std::false_type, std::false_type,
+                                    diag::implicit_zero, uplo::lower>>();
   StaticAssertTypeEq<decltype(triangle(
                          triangle(t, uplo::lower(), diag::implicit_zero()),
                          uplo::lower(), diag::implicit_unit())),
-                     general<temp&, std::false_type, std::false_type,
-                             diag::implicit_unit, uplo::lower>>();
+                     legacy_pattern<temp&, std::false_type, std::false_type,
+                                    diag::implicit_unit, uplo::lower>>();
 
   EXPECT_EQ(&(triangle(t, uplo::lower()).base()), &t);
   EXPECT_EQ(&(triangle(t, uplo::lower(), diag::implicit_zero()).base()), &t);
@@ -112,51 +112,51 @@ TEST(Tag, Upper) {
   temp t;
 
   StaticAssertTypeEq<decltype(triangle(t, uplo::upper())),
-                     general<temp&, std::false_type, std::false_type,
-                             diag::explicit_diag, uplo::upper>>();
+                     legacy_pattern<temp&, std::false_type, std::false_type,
+                                    diag::explicit_diag, uplo::upper>>();
   StaticAssertTypeEq<decltype(triangle(triangle(t, uplo::upper()),
                                        uplo::upper())),
-                     general<temp&, std::false_type, std::false_type,
-                             diag::explicit_diag, uplo::upper>>();
+                     legacy_pattern<temp&, std::false_type, std::false_type,
+                                    diag::explicit_diag, uplo::upper>>();
   StaticAssertTypeEq<decltype(triangle(t, uplo::upper(),
                                        diag::implicit_unit())),
-                     general<temp&, std::false_type, std::false_type,
-                             diag::implicit_unit, uplo::upper>>();
+                     legacy_pattern<temp&, std::false_type, std::false_type,
+                                    diag::implicit_unit, uplo::upper>>();
   StaticAssertTypeEq<decltype(triangle(t, uplo::upper(),
                                        diag::implicit_zero())),
-                     general<temp&, std::false_type, std::false_type,
-                             diag::implicit_zero, uplo::upper>>();
+                     legacy_pattern<temp&, std::false_type, std::false_type,
+                                    diag::implicit_zero, uplo::upper>>();
   StaticAssertTypeEq<decltype(triangle(
                          triangle(t, uplo::upper(), diag::implicit_unit()),
                          uplo::upper(), diag::explicit_diag())),
-                     general<temp&, std::false_type, std::false_type,
-                             diag::implicit_unit, uplo::upper>>();
+                     legacy_pattern<temp&, std::false_type, std::false_type,
+                                    diag::implicit_unit, uplo::upper>>();
   StaticAssertTypeEq<decltype(triangle(
                          triangle(t, uplo::upper(), diag::implicit_zero()),
                          uplo::upper(), diag::explicit_diag())),
-                     general<temp&, std::false_type, std::false_type,
-                             diag::implicit_zero, uplo::upper>>();
+                     legacy_pattern<temp&, std::false_type, std::false_type,
+                                    diag::implicit_zero, uplo::upper>>();
   StaticAssertTypeEq<decltype(triangle(
                          triangle(t, uplo::upper(), diag::implicit_unit()),
                          uplo::upper(), diag::implicit_unit())),
-                     general<temp&, std::false_type, std::false_type,
-                             diag::implicit_unit, uplo::upper>>();
+                     legacy_pattern<temp&, std::false_type, std::false_type,
+                                    diag::implicit_unit, uplo::upper>>();
   StaticAssertTypeEq<decltype(triangle(
                          triangle(t, uplo::upper(), diag::implicit_zero()),
                          uplo::upper(), diag::implicit_zero())),
-                     general<temp&, std::false_type, std::false_type,
-                             diag::implicit_zero, uplo::upper>>();
+                     legacy_pattern<temp&, std::false_type, std::false_type,
+                                    diag::implicit_zero, uplo::upper>>();
   //   Unit or Zero Diag will overwrite the old one
   StaticAssertTypeEq<decltype(triangle(
                          triangle(t, uplo::upper(), diag::implicit_unit()),
                          uplo::upper(), diag::implicit_zero())),
-                     general<temp&, std::false_type, std::false_type,
-                             diag::implicit_zero, uplo::upper>>();
+                     legacy_pattern<temp&, std::false_type, std::false_type,
+                                    diag::implicit_zero, uplo::upper>>();
   StaticAssertTypeEq<decltype(triangle(
                          triangle(t, uplo::upper(), diag::implicit_zero()),
                          uplo::upper(), diag::implicit_unit())),
-                     general<temp&, std::false_type, std::false_type,
-                             diag::implicit_unit, uplo::upper>>();
+                     legacy_pattern<temp&, std::false_type, std::false_type,
+                                    diag::implicit_unit, uplo::upper>>();
   EXPECT_EQ(&(triangle(t, uplo::upper()).base()), &t);
   EXPECT_EQ(&(triangle(t, uplo::upper(), diag::implicit_zero()).base()), &t);
   EXPECT_EQ(&(triangle(t, uplo::upper(), diag::implicit_unit()).base()), &t);
@@ -175,36 +175,36 @@ TEST(Tag, MixUpperAndLower) {
 
   StaticAssertTypeEq<decltype(triangle(triangle(t, uplo::upper()),
                                        uplo::lower())),
-                     general<temp&, std::false_type, std::false_type,
-                             diag::explicit_diag, uplo::diag>>();
+                     legacy_pattern<temp&, std::false_type, std::false_type,
+                                    diag::explicit_diag, uplo::diag>>();
   StaticAssertTypeEq<decltype(triangle(triangle(t, uplo::lower()),
                                        uplo::upper())),
-                     general<temp&, std::false_type, std::false_type,
-                             diag::explicit_diag, uplo::diag>>();
+                     legacy_pattern<temp&, std::false_type, std::false_type,
+                                    diag::explicit_diag, uplo::diag>>();
 }
 
 TEST(Tag, GetTransposeOfUpper) {
   temp t;
 
   StaticAssertTypeEq<decltype(transpose(triangle(t, uplo::upper()))),
-                     general<temp&, std::false_type, std::true_type,
-                             diag::explicit_diag, uplo::upper>>();
+                     legacy_pattern<temp&, std::false_type, std::true_type,
+                                    diag::explicit_diag, uplo::upper>>();
   // Lower(M^T) = Upper(M)^T
   StaticAssertTypeEq<decltype(triangle(transpose(t), uplo::lower())),
-                     general<temp&, std::false_type, std::true_type,
-                             diag::explicit_diag, uplo::upper>>();
+                     legacy_pattern<temp&, std::false_type, std::true_type,
+                                    diag::explicit_diag, uplo::upper>>();
 }
 
 TEST(Tag, GetTransposeOfLower) {
   temp t;
 
   StaticAssertTypeEq<decltype(transpose(triangle(t, uplo::lower()))),
-                     general<temp&, std::false_type, std::true_type,
-                             diag::explicit_diag, uplo::lower>>();
+                     legacy_pattern<temp&, std::false_type, std::true_type,
+                                    diag::explicit_diag, uplo::lower>>();
   // Upper(M^T) = Lower(M)^T
   StaticAssertTypeEq<decltype(triangle(transpose(t), uplo::upper())),
-                     general<temp&, std::false_type, std::true_type,
-                             diag::explicit_diag, uplo::lower>>();
+                     legacy_pattern<temp&, std::false_type, std::true_type,
+                                    diag::explicit_diag, uplo::lower>>();
 }
 
 TEST(Tag, LongChain) {
@@ -212,19 +212,19 @@ TEST(Tag, LongChain) {
 
   StaticAssertTypeEq<decltype(triangle(transpose(triangle(t, uplo::lower())),
                                        uplo::upper(), diag::implicit_zero())),
-                     general<temp&, std::false_type, std::true_type,
-                             diag::implicit_zero, uplo::lower>>();
+                     legacy_pattern<temp&, std::false_type, std::true_type,
+                                    diag::implicit_zero, uplo::lower>>();
   StaticAssertTypeEq<decltype(conjugate(
                          triangle(transpose(triangle(t, uplo::lower())),
                                   uplo::lower(), diag::implicit_zero()))),
-                     general<temp&, std::true_type, std::false_type,
-                             diag::implicit_zero, uplo::diag>>();
+                     legacy_pattern<temp&, std::true_type, std::false_type,
+                                    diag::implicit_zero, uplo::diag>>();
   StaticAssertTypeEq<
       decltype(transpose(conjugate(
           triangle(transpose(triangle(t, uplo::lower(), diag::implicit_zero())),
                    uplo::lower(), diag::implicit_unit())))),
-      general<temp&, std::true_type, std::false_type, diag::implicit_unit,
-              uplo::diag>>();
+      legacy_pattern<temp&, std::true_type, std::false_type,
+                     diag::implicit_unit, uplo::diag>>();
 }
 
 } // namespace