diff --git a/.development/test_subsetting.cpp b/.development/test_subsetting.cpp
index e5003b4..209db08 100644
--- a/.development/test_subsetting.cpp
+++ b/.development/test_subsetting.cpp
@@ -1,372 +1,25 @@
 #define STANDALONE_ETR
-#include "../inst/include/etr_bits/Core.hpp"
-#include "../inst/include/etr_bits/Subsetting/LazySubsetting.hpp"
-#include "../inst/include/etr_bits/BufferVector.hpp"
+#include "../inst/include/etr_bits/Allocation.hpp"
 #include "../inst/include/etr_bits/BinaryCalculations.hpp"
-#include "../inst/include/etr_bits/UnaryCalculations.hpp"
+#include "../inst/include/etr_bits/BufferVector.hpp"
 #include "../inst/include/etr_bits/Coca.hpp"
+#include "../inst/include/etr_bits/Core.hpp"
 #include "../inst/include/etr_bits/Printing.hpp"
-#include "../inst/include/etr_bits/Allocation.hpp"
+#include "../inst/include/etr_bits/Subsetting/LazySubsetting.hpp"
+#include "../inst/include/etr_bits/UnaryCalculations.hpp"
 using namespace etr;
 
-void test_subsetting_l_vector() {
+int main() {
   Vec<double> a;
-  Vec<int> b;
-  Vec<double> c;
-  Vec<double> d;
-  Vec<bool> e;
   a = coca(1, 2, 3, 4);
-
-  {
-    std::cout << "Test subsetting L Vec with bool value" << std::endl;
-    c = subset_test(a, true);
-    ass<"Size should be 4">(c.size() == 4);
-    try {
-      c = subset_test(a, false);
-    } catch(std::exception& e) {
-      std::string expected = "Size has to be larger than 0!";
-      ass<"Using false should throw an error">(e.what() == expected);
-    }
-  }
-  {
-    std::cout << "Test subsetting L Vec with integers" << std::endl;
-    c = subset_test(a, 1);
-    ass<"Size should be 1">(c.size() == 1);
-    ass<"c value should be 1">(c.d[0] == 1);
-    c = subset_test(a, 4);
-    ass<"Size should be 1">(c.size() == 1);
-    ass<"c value should be 4">(c.d[0] == 4);
-    try {
-      c = subset_test(a, 0);
-    } catch(std::exception& e) {
-      std::string expected = "Error: out of boundaries";
-      ass<"Index == 0">(e.what() == expected);
-    }
-    try {
-      c = subset_test(a, -1);
-    } catch(std::exception& e) {
-      std::string expected = "Negative indices are not supported";
-      ass<"Negative indices are not supported">(e.what() == expected);
-    }
-    try {
-      c = subset_test(a, 100);
-    } catch(std::exception& e) {
-      std::string expected = "Error: out of boundaries";
-      ass<"Indices > size">(e.what() == expected);
-    }
-  }
-  {
-    std::cout << "Test subsetting L Vec with doubles" << std::endl;
-    c = subset_test(a, 1.1);
-    ass<"Size should be 1">(c.size() == 1);
-    ass<"c value should be 1">(c.d[0] == 1);
-    c = subset_test(a, 4.2);
-    ass<"Size should be 1">(c.size() == 1);
-    ass<"c value should be 4">(c.d[0] == 4);
-    try {
-      c = subset_test(a, 0.000);
-    } catch(std::exception& e) {
-      std::string expected = "Error: out of boundaries";
-      ass<"Index == 0">(e.what() == expected);
-    }
-    try {
-      c = subset_test(a, -4.5);
-    } catch(std::exception& e) {
-      std::string expected = "Negative indices are not supported";
-      ass<"Negative indices are not supported">(e.what() == expected);
-    }
-    try {
-      c = subset_test(a, 100.3);
-    } catch(std::exception& e) {
-      std::string expected = "Error: out of boundaries";
-      ass<"Indices > size">(e.what() == expected);
-    }
-  }
-  {
-    b = coca(1, 2, 1, 4, 1, 2);
-    std::cout << "Test subsetting L Vec with integer Vector" << std::endl;
-    c = subset_test(a, b);
-    ass<"Size should be 6">(c.size() == 6);
-    ass<"c[0] == 1">(c.d[0] == 1);
-    ass<"c[4] == 1">(c.d[4] == 1);
-    try {
-      b = coca(-1, -2, 3, 4);
-      c = subset_test(a, b);
-    } catch(std::exception& e) {
-      std::string expected = "Error: out of boundaries";
-      ass<"Invalid indices">(e.what() == expected);
-    }
-    try {
-      b = coca(100);
-      c = subset_test(a, b);
-    } catch(std::exception& e) {
-      std::string expected = "Error: out of boundaries";
-      ass<"Invalid indices">(e.what() == expected);
-    }
-  }
-  {
-    d = coca(1.0, 2.0, 1.0, 4.0, 1.0, 2.0);
-    std::cout << "Test subsetting L Vec with double Vector" << std::endl;
-    c = subset_test(a, d);
-    ass<"Size should be 6">(c.size() == 6);
-    ass<"c[0] == 1">(c.d[0] == 1);
-    ass<"c[4] == 1">(c.d[4] == 1);
-    try {
-      d = coca(-1.0, -2.0, 3.0, 4.0);
-      c = subset_test(a, d);
-    } catch(std::exception& e) {
-      std::string expected = "Error: out of boundaries";
-      ass<"Invalid indices">(e.what() == expected);
-    }
-    try {
-      d = coca(100.0);
-      c = subset_test(a, d);
-    } catch(std::exception& e) {
-      std::string expected = "Error: out of boundaries";
-      ass<"Invalid indices">(e.what() == expected);
-    }
-    try {
-      d = vector_numeric(0);
-      c = subset_test(a, d);
-    } catch(std::exception& e) {
-      std::string expected = "invalid times argument"; // TODO: better error message
-      ass<"Invalid indices">(e.what() == expected);
-    }
-  }
-  {
-    a = coca(1, 2, 3, 5, 6, 7);
-    b = coca(1, 4);
-    std::cout << "Test subsetting L Vec with another Subset" << std::endl;
-    c = subset_test(a, subset_test(a, b));
-    ass<"Size should be 2">(c.size() == 2);
-    ass<"c[0] == 1">(c.d[0] == 1);
-    ass<"c[1] == 1">(c.d[1] == 6);
-  }
-  {
-    std::cout << "Test subsetting L Vec with bool Vector" << std::endl;
-    a = coca(1, 2, 3, 4);
-    e = coca(true, false, true);
-    c = subset_test(a, e);
-    ass<"Size should be 3">(c.size() == 3);
-    ass<"c[0] == 1">(c.d[0] == 1);
-    ass<"c[1] == 3">(c.d[1] == 3);
-    ass<"c[2] == 4">(c.d[2] == 4);
-
-    a = coca(1, 2, 3, 4);
-    e = coca(false, false, false);
-    try{
-      c = subset_test(a, e);
-    } catch (std::exception& e) {
-      std::string expected = "Size has to be larger than 0!!!";
-      ass<"Invalid size argument">(e.what() == expected);
-    }
-
-    a = coca(1, 2, 3, 4);
-    e = coca(true, true, false, true, true);
-    c = subset_test(a, e);
-    ass<"Size should be 4">(c.size() == 3);
-    ass<"c[0] == 1">(c.d[0] == 1);
-    ass<"c[1] == 2">(c.d[1] == 2);
-    ass<"c[2] == 4">(c.d[2] == 4);
-  }
-
-}
-
-void test_subsetting_r_vector() {
-  Vec<int> b;
-  Vec<double> c;
-  Vec<double> d;
-  Vec<bool> e;
-
-  {
-    std::cout << "Test subsetting R Vec with bool value" << std::endl;
-    c = subset_test(coca(1, 2, 3, 4), true);
-    ass<"Size should be 4">(c.size() == 4);
-    try {
-      c = subset_test(coca(1, 2, 3, 4), false);
-    } catch(std::exception& e) {
-      std::string expected = "Size has to be larger than 0!";
-      ass<"Using false should throw an error">(e.what() == expected);
-    }
-  }
-  {
-    std::cout << "Test subsetting R Vec with integers" << std::endl;
-    c = subset_test(coca(1, 2, 3, 4), 1);
-    ass<"Size should be 1">(c.size() == 1);
-    ass<"c value should be 1">(c.d[0] == 1);
-    c = subset_test(coca(1, 2, 3, 4), 4);
-    ass<"Size should be 1">(c.size() == 1);
-    ass<"c value should be 4">(c.d[0] == 4);
-    try {
-      c = subset_test(coca(1, 2, 3, 4), 0);
-    } catch(std::exception& e) {
-      std::string expected = "Error: out of boundaries";
-      ass<"Index == 0">(e.what() == expected);
-    }
-    try {
-      c = subset_test(coca(1, 2, 3, 4), -1);
-    } catch(std::exception& e) {
-      std::string expected = "Negative indices are not supported";
-      ass<"Negative indices are not supported">(e.what() == expected);
-    }
-    try {
-      c = subset_test(coca(1, 2, 3, 4), 100);
-    } catch(std::exception& e) {
-      std::string expected = "Error: out of boundaries";
-      ass<"Indices > size">(e.what() == expected);
-    }
-  }
-  {
-    std::cout << "Test subsetting R Vec with doubles" << std::endl;
-    c = subset_test(coca(1, 2, 3, 4), 1.1);
-    ass<"Size should be 1">(c.size() == 1);
-    ass<"c value should be 1">(c.d[0] == 1);
-    c = subset_test(coca(1, 2, 3, 4), 4.2);
-    ass<"Size should be 1">(c.size() == 1);
-    ass<"c value should be 4">(c.d[0] == 4);
-    try {
-      c = subset_test(coca(1, 2, 3, 4), 0.000);
-    } catch(std::exception& e) {
-      std::string expected = "Error: out of boundaries";
-      ass<"Index == 0">(e.what() == expected);
-    }
-    try {
-      c = subset_test(coca(1, 2, 3, 4), -4.5);
-    } catch(std::exception& e) {
-      std::string expected = "Negative indices are not supported";
-      ass<"Negative indices are not supported">(e.what() == expected);
-    }
-    try {
-      c = subset_test(coca(1, 2, 3, 4), 100.3);
-    } catch(std::exception& e) {
-      std::string expected = "Error: out of boundaries";
-      ass<"Indices > size">(e.what() == expected);
-    }
-  }
-  {
-    b = coca(1, 2, 1, 4, 1, 2);
-    std::cout << "Test subsetting R Vec with integer Vector" << std::endl;
-    c = subset_test(coca(1, 2, 3, 4), b);
-    ass<"Size should be 6">(c.size() == 6);
-    ass<"c[0] == 1">(c.d[0] == 1);
-    ass<"c[4] == 1">(c.d[4] == 1);
-    try {
-      b = coca(-1, -2, 3, 4);
-      c = subset_test(coca(1, 2, 3, 4), b);
-    } catch(std::exception& e) {
-      std::string expected = "Error: out of boundaries";
-      ass<"Invalid indices">(e.what() == expected);
-    }
-    try {
-      b = coca(100);
-      c = subset_test(coca(1, 2, 3, 4), b);
-    } catch(std::exception& e) {
-      std::string expected = "Error: out of boundaries";
-      ass<"Invalid indices">(e.what() == expected);
-    }
-  }
-  {
-    d = coca(1.0, 2.0, 1.0, 4.0, 1.0, 2.0);
-    std::cout << "Test subsetting R Vec with double Vector" << std::endl;
-    c = subset_test(coca(1, 2, 3, 4), d);
-    ass<"Size should be 6">(c.size() == 6);
-    ass<"c[0] == 1">(c.d[0] == 1);
-    ass<"c[4] == 1">(c.d[4] == 1);
-    try {
-      d = coca(-1.0, -2.0, 3.0, 4.0);
-      c = subset_test(coca(1, 2, 3, 4), d);
-    } catch(std::exception& e) {
-      std::string expected = "Error: out of boundaries";
-      ass<"Invalid indices">(e.what() == expected);
-    }
-    try {
-      d = coca(100.0);
-      c = subset_test(coca(1, 2, 3, 4), d);
-    } catch(std::exception& e) {
-      std::string expected = "Error: out of boundaries";
-      ass<"Invalid indices">(e.what() == expected);
-    }
-    try {
-      d = vector_numeric(0);
-      c = subset_test(coca(1, 2, 3, 4), d);
-    } catch(std::exception& e) {
-      std::string expected = "invalid times argument"; // TODO: better error message
-      ass<"Invalid indices">(e.what() == expected);
-    }
-  }
-  {
-    b = coca(1, 4);
-    std::cout << "Test subsetting R Vec with another Subset" << std::endl;
-    c = subset_test(coca(1, 2, 3, 5, 6, 7), subset_test(coca(1,2,3, 5, 6, 7), b));
-    ass<"Size should be 2">(c.size() == 2);
-    ass<"c[0] == 1">(c.d[0] == 1);
-    ass<"c[1] == 1">(c.d[1] == 6);
-  }
-  {
-    std::cout << "Test subsetting R Vec with bool Vector" << std::endl;
-    e = coca(true, false, true);
-    c = subset_test(coca(1, 2, 3, 4), e);
-    ass<"Size should be 3">(c.size() == 3);
-    ass<"c[0] == 1">(c.d[0] == 1);
-    ass<"c[1] == 3">(c.d[1] == 3);
-    ass<"c[2] == 4">(c.d[2] == 4);
-
-    e = coca(false, false, false);
-    try{
-      c = subset_test(coca(1, 2, 3, 4), e);
-    } catch (std::exception& e) {
-      std::string expected = "Size has to be larger than 0!!!";
-      ass<"Invalid size argument">(e.what() == expected);
-    }
-
-    e = coca(true, true, false, true, true);
-    c = subset_test(coca(1, 2, 3, 4), e);
-    ass<"Size should be 4">(c.size() == 3);
-    ass<"c[0] == 1">(c.d[0] == 1);
-    ass<"c[1] == 2">(c.d[1] == 2);
-    ass<"c[2] == 4">(c.d[2] == 4);
-  }
-
-}
-
-
-void test_subsetting_with_r_val() {
-  Vec<double> a;
-  Vec<int> b;
-  Vec<double> c;
-  Vec<double> d;
-  Vec<bool> e;
-  {
-    // b = coca(1, 2, 1, 4, 1, 2);
-    // std::cout << "Test subsetting Vec with calculation" << std::endl;
-    // c = subset_test(coca(1, 2, 3, 4), b * 1.1);
-    // ass<"Size should be 6">(c.size() == 6);
-    // ass<"c[0] == 1">(c.d[0] == 1);
-    // ass<"c[4] == 1">(c.d[4] == 1);
-    //
-    // a = coca(1, 2, 3, 4);
-    // b = coca(1, 2, 1, 4, 1, 2);
-    // c = subset_test(a, b * 1.1);
-    // ass<"Size should be 6">(c.size() == 6);
-    // ass<"c[0] == 1">(c.d[0] == 1);
-    // ass<"c[4] == 1">(c.d[4] == 1);
-    //
-    a = coca(4, 5, 6, 7);
-    b = coca(1, 2, 1, 4, 1, 2);
-    c = 1;
-    auto test2 = subset_test(a, subset_test(coca(1.1, 2.2, 3.3), coca(1, 3)));
-    printTAST<decltype(test2)>();
-    std::cout << test2.size() << std::endl;
-    std::cout << test2.d.size() << std::endl;
-    std::cout << test2.d.l.size() << std::endl;
-    std::cout << test2.d.r.size() << std::endl;
-    print(test2.d.l);
-    // c = subset_test(a, subset_test(coca(1.1, 2.2, 3.3), coca(1, 3)));
-  }
-}
-
-int main() {
-  // test_subsetting_l_vector();
-  // test_subsetting_r_vector();
-  test_subsetting_with_r_val();
+  std::cout << "Start" << std::endl;
+  // print(a);
+  // sub[0] = 3.14;
+  // print(a);
+  // subset_test(a, 2) = 40;
+  // print(a);
+  // subset_test(a, true) = 3.1;
+  // print(a);
+  subset_test(a, coca(1, 3)) = coca(10, 20);
+  // print(a);
 }
diff --git a/inst/include/etr_bits/BinaryCalculations.hpp b/inst/include/etr_bits/BinaryCalculations.hpp
index 2e311ae..4a530c9 100644
--- a/inst/include/etr_bits/BinaryCalculations.hpp
+++ b/inst/include/etr_bits/BinaryCalculations.hpp
@@ -9,9 +9,9 @@ template <typename L, typename R, typename Trait> struct BinaryOpClassIterator {
   const L &l;
   const R &r;
   size_t index;
-  
+
   BinaryOpClassIterator(const L &l, const R &r, size_t index = 0)
-  : l(l), r(r), index(index) {}
+      : l(l), r(r), index(index) {}
 
   auto operator*() const {
     if constexpr (!IsArithV<L> && IsArithV<R>) {
@@ -33,24 +33,24 @@ template <typename L, typename R, typename Trait> struct BinaryOpClassIterator {
   }
 };
 
-template<typename L, typename R, typename BTrait>
+template <typename L, typename R, typename BTrait>
 inline auto determine_type_binary_op() {
   if constexpr (IsComparison<BTrait>) {
     return bool{};
-  } else if constexpr (IsClassV<L> &&IsClassV<R>) {
-    using RetType = std::common_type_t<typename L::RetType, typename R::RetType>;
+  } else if constexpr (IsClassV<L> && IsClassV<R>) {
+    using RetType =
+        std::common_type_t<typename L::RetType, typename R::RetType>;
     return RetType{};
-  } else if constexpr(!IsClassV<L> &&IsClassV<R>) {
+  } else if constexpr (!IsClassV<L> && IsClassV<R>) {
     using RetType = std::common_type_t<L, typename R::RetType>;
     return RetType{};
-  } else if constexpr(IsClassV<L> && !IsClassV<R>) {
+  } else if constexpr (IsClassV<L> && !IsClassV<R>) {
     using RetType = std::common_type_t<typename L::RetType, R>;
     return RetType{};
   }
 }
 
-template <typename L, typename R, typename BTrait>
-struct BinaryOperation {
+template <typename L, typename R, typename BTrait> struct BinaryOperation {
   using Trait = BTrait;
   using RetType = decltype(determine_type_binary_op<L, R, BTrait>());
   const L &l;
@@ -136,79 +136,93 @@ struct BinaryOperation {
   }
 
   auto begin() const { return BinaryOpClassIterator<L, R, BTrait>{l, r, 0}; }
-  auto end() const { return BinaryOpClassIterator<L, R, BTrait>{l, r, this->size()}; }
-
+  auto end() const {
+    return BinaryOpClassIterator<L, R, BTrait>{l, r, this->size()};
+  }
 };
 
 template <typename L, typename R, typename Trait>
 using BinaryOpResult = decltype(determine_type_binary_op<L, R, Trait>());
 
 template <typename L, typename R, typename Trait>
-using BinaryVec = Vec<BinaryOpResult<L, R, Trait>, BinaryOperation<L, R, Trait>>;
+using BinaryVec =
+    Vec<BinaryOpResult<L, R, Trait>, BinaryOperation<L, R, Trait>>;
 
 template <typename L, typename R, typename Trait>
 inline auto create_bin_vec(const L &l, const R &r) {
   if constexpr (!IsArithV<L> && IsArithV<R>) {
-      return BinaryVec<decltype(l.d), R, Trait>(
+    return BinaryVec<decltype(l.d), R, Trait>(
         BinaryOperation<decltype(l.d), R, Trait>(l.d, r));
   } else if constexpr (IsArithV<L> && !IsArithV<R>) {
-      return BinaryVec<L, decltype(r.d), Trait>(
+    return BinaryVec<L, decltype(r.d), Trait>(
         BinaryOperation<L, decltype(r.d), Trait>(l, r.d));
   } else if constexpr (!IsArithV<L> && !IsArithV<R>) {
-     return BinaryVec<decltype(l.d), decltype(r.d), Trait>(
+    return BinaryVec<decltype(l.d), decltype(r.d), Trait>(
         BinaryOperation<decltype(l.d), decltype(r.d), Trait>(l.d, r.d));
   } else {
     ass<"This case should not be reached. Contact author">(false);
   }
 }
 
-// TODO: does this work with R values? If not use either approach as in LazySubsetting or change to const L&
+// TODO: does this work with R values? If not use either approach as in
+// LazySubsetting or change to const L&
 template <typename L, typename R> auto operator+(L &&l, R &&r) {
-  return create_bin_vec<std::decay_t<L>, std::decay_t<R>, PlusTrait>(std::forward<L>(l), std::forward<R>(r));
+  return create_bin_vec<std::decay_t<L>, std::decay_t<R>, PlusTrait>(
+      std::forward<L>(l), std::forward<R>(r));
 }
 
 template <typename L, typename R> auto operator-(L &&l, R &&r) {
-  return create_bin_vec<std::decay_t<L>, std::decay_t<R>, MinusTrait>(std::forward<L>(l), std::forward<R>(r));
+  return create_bin_vec<std::decay_t<L>, std::decay_t<R>, MinusTrait>(
+      std::forward<L>(l), std::forward<R>(r));
 }
 
 template <typename L, typename R> auto operator*(L &&l, R &&r) {
-  return create_bin_vec<std::decay_t<L>, std::decay_t<R>, TimesTrait>(std::forward<L>(l), std::forward<R>(r));
+  return create_bin_vec<std::decay_t<L>, std::decay_t<R>, TimesTrait>(
+      std::forward<L>(l), std::forward<R>(r));
 }
 
 template <typename L, typename R> auto operator/(L &&l, R &&r) {
-  return create_bin_vec<std::decay_t<L>, std::decay_t<R>, DivideTrait>(std::forward<L>(l), std::forward<R>(r));
+  return create_bin_vec<std::decay_t<L>, std::decay_t<R>, DivideTrait>(
+      std::forward<L>(l), std::forward<R>(r));
 }
 
 template <typename L, typename R> auto power(L &&l, R &&r) {
-  return create_bin_vec<std::decay_t<L>, std::decay_t<R>, PowTrait>(std::forward<L>(l), std::forward<R>(r));
+  return create_bin_vec<std::decay_t<L>, std::decay_t<R>, PowTrait>(
+      std::forward<L>(l), std::forward<R>(r));
 }
 
-template <typename L, typename R> 
-requires (IsVec<L> || IsVec<R>)
+template <typename L, typename R>
+  requires(IsVec<L> || IsVec<R>)
 auto operator==(L &&l, R &&r) {
-  return create_bin_vec<std::decay_t<L>, std::decay_t<R>, EqualTrait>(std::forward<L>(l), std::forward<R>(r));
+  return create_bin_vec<std::decay_t<L>, std::decay_t<R>, EqualTrait>(
+      std::forward<L>(l), std::forward<R>(r));
 }
 
 template <typename L, typename R>
-requires (IsVec<L> || IsVec<R>)
+  requires(IsVec<L> || IsVec<R>)
 auto operator!=(L &&l, R &&r) {
-  return create_bin_vec<std::decay_t<L>, std::decay_t<R>, UnEqualTrait>(std::forward<L>(l), std::forward<R>(r));
+  return create_bin_vec<std::decay_t<L>, std::decay_t<R>, UnEqualTrait>(
+      std::forward<L>(l), std::forward<R>(r));
 }
 
 template <typename L, typename R> auto operator>(L &&l, R &&r) {
-  return create_bin_vec<std::decay_t<L>, std::decay_t<R>, LargerTrait>(std::forward<L>(l), std::forward<R>(r));
+  return create_bin_vec<std::decay_t<L>, std::decay_t<R>, LargerTrait>(
+      std::forward<L>(l), std::forward<R>(r));
 }
 
 template <typename L, typename R> auto operator>=(L &&l, R &&r) {
-  return create_bin_vec<std::decay_t<L>, std::decay_t<R>, LargerEqualTrait>(std::forward<L>(l), std::forward<R>(r));
+  return create_bin_vec<std::decay_t<L>, std::decay_t<R>, LargerEqualTrait>(
+      std::forward<L>(l), std::forward<R>(r));
 }
 
 template <typename L, typename R> auto operator<(L &&l, R &&r) {
-  return create_bin_vec<std::decay_t<L>, std::decay_t<R>, SmallerTrait>(std::forward<L>(l), std::forward<R>(r));
+  return create_bin_vec<std::decay_t<L>, std::decay_t<R>, SmallerTrait>(
+      std::forward<L>(l), std::forward<R>(r));
 }
 
 template <typename L, typename R> auto operator<=(L &&l, R &&r) {
-  return create_bin_vec<std::decay_t<L>, std::decay_t<R>, SmallerEqualTrait>(std::forward<L>(l), std::forward<R>(r));
+  return create_bin_vec<std::decay_t<L>, std::decay_t<R>, SmallerEqualTrait>(
+      std::forward<L>(l), std::forward<R>(r));
 }
 
 } // namespace etr
diff --git a/inst/include/etr_bits/Core/BaseStore.hpp b/inst/include/etr_bits/Core/BaseStore.hpp
index aeaa198..9c1ca59 100644
--- a/inst/include/etr_bits/Core/BaseStore.hpp
+++ b/inst/include/etr_bits/Core/BaseStore.hpp
@@ -33,7 +33,7 @@ template <typename T, typename BaseTrait> struct BaseStore {
   }
 
   // constructors
-  BaseStore(const BaseStore<T> &other)
+  BaseStore(const BaseStore &other)
       : sz(other.sz), capacity(other.capacity), allocated(other.allocated) {
     if (other.allocated) {
       p = new T[capacity];
@@ -42,14 +42,11 @@ template <typename T, typename BaseTrait> struct BaseStore {
       p = nullptr;
     }
   }
-  BaseStore(BaseStore<T> &&other) noexcept
-      : sz(other.sz), capacity(other.capacity), allocated(other.allocated),
-        p(other.p) {
-    other.capacity = 0;
-    other.sz = 0;
-    other.allocated = false;
-    other.p = nullptr;
-  }
+  BaseStore(BaseStore &&other) noexcept
+      : p(std::exchange(other.p, nullptr)), sz(std::exchange(other.sz, 0)),
+        capacity(std::exchange(other.capacity, 0)),
+        allocated(std::exchange(other.allocated, false)),
+        mp(std::move(other.mp)) {}
 #ifdef STANDALONE_ETR
 #else
   BaseStore(SEXP s) {
@@ -101,7 +98,8 @@ template <typename T, typename BaseTrait> struct BaseStore {
   };
 #endif
   BaseStore(std::size_t sz_)
-      : sz(sz_), capacity(static_cast<std::size_t>(static_cast<double>(sz_)* 1.15)) {
+      : sz(sz_),
+        capacity(static_cast<std::size_t>(static_cast<double>(sz_) * 1.15)) {
     ass<"Size has to be larger than 0!">(sz_ > 0);
     p = new T[capacity];
     for (std::size_t i = 0; i < capacity; i++) {
@@ -138,6 +136,17 @@ template <typename T, typename BaseTrait> struct BaseStore {
     }
     return *this;
   }
+  BaseStore &operator=(BaseStore &&other) noexcept {
+    if (this != &other) {
+      delete[] p;
+      p = std::exchange(other.p, nullptr);
+      sz = std::exchange(other.sz, 0);
+      capacity = std::exchange(other.capacity, 0);
+      allocated = std::exchange(other.allocated, false);
+      mp = std::move(other.mp);
+    }
+    return *this;
+  }
 
   template <typename TInp>
     requires(IsArithV<TInp>)
@@ -150,8 +159,8 @@ template <typename T, typename BaseTrait> struct BaseStore {
     }
   }
 
-  template <typename TInp> 
-requires (!IsArithV<TInp>)
+  template <typename TInp>
+    requires(!IsArithV<TInp>)
   void fill(TInp &&inp) {
     ass<"cannot use fill with vectors of different lengths">(inp.size() == sz);
     using DataType = typename ReRef<TInp>::type::RetType;
@@ -266,7 +275,8 @@ requires (!IsArithV<TInp>)
       if (newSize > capacity) {
         ass<"try to delete nullptr">(p != nullptr);
         delete[] p;
-        capacity = static_cast<std::size_t>(static_cast<double>(newSize) * 1.15);
+        capacity =
+            static_cast<std::size_t>(static_cast<double>(newSize) * 1.15);
         p = new T[capacity];
         sz = newSize;
         allocated = true;
diff --git a/inst/include/etr_bits/Core/Concepts.hpp b/inst/include/etr_bits/Core/Concepts.hpp
index 6bb2539..b14b549 100644
--- a/inst/include/etr_bits/Core/Concepts.hpp
+++ b/inst/include/etr_bits/Core/Concepts.hpp
@@ -11,89 +11,88 @@ template <typename T> struct AddConst {
 
 namespace etr {
 template <typename T>
-concept isBID = requires {
-  requires IS<T, bool> || IS<T, int> ||
-               IS<T, double>;
-};
+concept isBID =
+    requires { requires IS<T, bool> || IS<T, int> || IS<T, double>; };
 
 // Test R class
 // ===================================================================
+// TODO: Test whether these really work
+// SubsetClassTrait didn't work in one test
 template <typename T>
 concept IsSubset = requires {
-    typename ReRef<T>::type::Trait;
-    requires IS<typename ReRef<T>::type::Trait, SubsetTrait>;
+  typename ReRef<T>::type::Trait;
+  requires IS<typename ReRef<T>::type::Trait, SubsetTrait>;
 };
 template <typename T>
 concept IsSubsetClass = requires {
-    typename ReRef<T>::type::Trait;
-    requires IS<typename ReRef<T>::type::Trait, SubsetClassTrait>;
+  typename ReRef<T>::type::Trait;
+  requires IS<typename ReRef<T>::type::Trait, SubsetClassTrait>;
 };
 template <typename T>
 concept IsLBuffer = requires {
-    typename ReRef<T>::type::Trait;
-    requires IS<typename ReRef<T>::type::Trait, LBufferTrait>;
+  typename ReRef<T>::type::Trait;
+  requires IS<typename ReRef<T>::type::Trait, LBufferTrait>;
 };
 template <typename T>
 concept IsRBuffer = requires {
-    typename ReRef<T>::type::Trait;
-    requires IS<typename ReRef<T>::type::Trait, RBufferTrait>;
+  typename ReRef<T>::type::Trait;
+  requires IS<typename ReRef<T>::type::Trait, RBufferTrait>;
 };
 template <typename T>
 concept IsBorrow = requires {
-    typename ReRef<T>::type::Trait;
-    requires IS<typename ReRef<T>::type::Trait, BorrowTrait>;
+  typename ReRef<T>::type::Trait;
+  requires IS<typename ReRef<T>::type::Trait, BorrowTrait>;
 };
 template <typename T>
 concept IsBorrowSEXP = requires {
-    typename ReRef<T>::type::Trait;
-    requires IS<typename ReRef<T>::type::Trait, BorrowSEXPTrait>;
+  typename ReRef<T>::type::Trait;
+  requires IS<typename ReRef<T>::type::Trait, BorrowSEXPTrait>;
 };
 
 template <typename T>
 concept IsUnary = requires {
-    typename ReRef<decltype(T{})>::type::Trait;
-    requires IS<typename ReRef<decltype(T{})>::type::Trait, SinusTrait> ||
-        IS<typename ReRef<decltype(T{})>::type::Trait, ASinusTrait> ||
-        IS<typename ReRef<decltype(T{})>::type::Trait, SinusHTrait> ||
-        IS<typename ReRef<decltype(T{})>::type::Trait, CosinusTrait> ||
-        IS<typename ReRef<decltype(T{})>::type::Trait, ACosinusTrait> ||
-        IS<typename ReRef<decltype(T{})>::type::Trait, CosinusHTrait> ||
-        IS<typename ReRef<decltype(T{})>::type::Trait, TangensTrait> ||
-        IS<typename ReRef<decltype(T{})>::type::Trait, ATangensTrait> ||
-        IS<typename ReRef<decltype(T{})>::type::Trait, TangensHTrait> ||
-        IS<typename ReRef<decltype(T{})>::type::Trait, ExpTrait> ||
-        IS<typename ReRef<decltype(T{})>::type::Trait, LogTrait> ||
-        IS<typename ReRef<decltype(T{})>::type::Trait, SquareRootTrait> ||
-        IS<typename ReRef<decltype(T{})>::type::Trait, MinusUnaryTrait>;
+  typename ReRef<decltype(T{})>::type::Trait;
+  requires IS<typename ReRef<decltype(T{})>::type::Trait, SinusTrait> ||
+               IS<typename ReRef<decltype(T{})>::type::Trait, ASinusTrait> ||
+               IS<typename ReRef<decltype(T{})>::type::Trait, SinusHTrait> ||
+               IS<typename ReRef<decltype(T{})>::type::Trait, CosinusTrait> ||
+               IS<typename ReRef<decltype(T{})>::type::Trait, ACosinusTrait> ||
+               IS<typename ReRef<decltype(T{})>::type::Trait, CosinusHTrait> ||
+               IS<typename ReRef<decltype(T{})>::type::Trait, TangensTrait> ||
+               IS<typename ReRef<decltype(T{})>::type::Trait, ATangensTrait> ||
+               IS<typename ReRef<decltype(T{})>::type::Trait, TangensHTrait> ||
+               IS<typename ReRef<decltype(T{})>::type::Trait, ExpTrait> ||
+               IS<typename ReRef<decltype(T{})>::type::Trait, LogTrait> ||
+               IS<typename ReRef<decltype(T{})>::type::Trait,
+                  SquareRootTrait> ||
+               IS<typename ReRef<decltype(T{})>::type::Trait, MinusUnaryTrait>;
 };
 template <typename T>
 concept IsBinary = requires {
-    typename ReRef<T>::type::Trait;
-    requires IS<typename ReRef<T>::type::Trait, PlusTrait> ||
-        IS<typename ReRef<T>::type::Trait, MinusTrait> ||
-        IS<typename ReRef<T>::type::Trait, TimesTrait> ||
-        IS<typename ReRef<T>::type::Trait, DivideTrait> ||
-        IS<typename ReRef<T>::type::Trait, PowTrait> ||
-        IS<typename ReRef<T>::type::Trait, EqualTrait> ||
-        IS<typename ReRef<T>::type::Trait, SmallerTrait> ||
-        IS<typename ReRef<T>::type::Trait, SmallerEqualTrait> ||
-        IS<typename ReRef<T>::type::Trait, LargerTrait> ||
-        IS<typename ReRef<T>::type::Trait, LargerEqualTrait> ||
-        IS<typename ReRef<T>::type::Trait, UnEqualTrait>;
+  typename ReRef<T>::type::Trait;
+  requires IS<typename ReRef<T>::type::Trait, PlusTrait> ||
+               IS<typename ReRef<T>::type::Trait, MinusTrait> ||
+               IS<typename ReRef<T>::type::Trait, TimesTrait> ||
+               IS<typename ReRef<T>::type::Trait, DivideTrait> ||
+               IS<typename ReRef<T>::type::Trait, PowTrait> ||
+               IS<typename ReRef<T>::type::Trait, EqualTrait> ||
+               IS<typename ReRef<T>::type::Trait, SmallerTrait> ||
+               IS<typename ReRef<T>::type::Trait, SmallerEqualTrait> ||
+               IS<typename ReRef<T>::type::Trait, LargerTrait> ||
+               IS<typename ReRef<T>::type::Trait, LargerEqualTrait> ||
+               IS<typename ReRef<T>::type::Trait, UnEqualTrait>;
 };
 template <typename T>
 concept IsComparison = requires {
-    typename ReRef<T>::type::Trait;
-    requires
-        IS<typename ReRef<T>::type::Trait, EqualTrait> ||
-        IS<typename ReRef<T>::type::Trait, SmallerTrait> ||
-        IS<typename ReRef<T>::type::Trait, SmallerEqualTrait> ||
-        IS<typename ReRef<T>::type::Trait, LargerTrait> ||
-        IS<typename ReRef<T>::type::Trait, LargerEqualTrait> ||
-        IS<typename ReRef<T>::type::Trait, UnEqualTrait>;
+  typename ReRef<T>::type::Trait;
+  requires IS<typename ReRef<T>::type::Trait, EqualTrait> ||
+               IS<typename ReRef<T>::type::Trait, SmallerTrait> ||
+               IS<typename ReRef<T>::type::Trait, SmallerEqualTrait> ||
+               IS<typename ReRef<T>::type::Trait, LargerTrait> ||
+               IS<typename ReRef<T>::type::Trait, LargerEqualTrait> ||
+               IS<typename ReRef<T>::type::Trait, UnEqualTrait>;
 };
 
-
 // Test Vec class
 // ===================================================================
 template <typename T>
@@ -119,7 +118,7 @@ concept IsOpVec = requires(T t) {
 };
 
 template <typename T>
-concept IsVecRorCalc= requires(T t) {
+concept IsVecRorCalc = requires(T t) {
   typename T::DType;
   requires IsOpVec<T> || IsRBufferVec<T>;
 };
@@ -127,14 +126,11 @@ concept IsVecRorCalc= requires(T t) {
 // Test Input class
 // ===================================================================
 // Vector
-template <typename T>
-struct is_vec: std::false_type {};
+template <typename T> struct is_vec : std::false_type {};
 
-template <typename T>
-struct is_vec<Vec<T>> : std::true_type {};
+template <typename T> struct is_vec<Vec<T>> : std::true_type {};
 
-template <typename T>
-inline constexpr bool is_vec_v = is_vec <T>::value;
+template <typename T> inline constexpr bool is_vec_v = is_vec<T>::value;
 template <typename T>
 concept IsVec = is_vec_v<T>;
 
@@ -144,10 +140,8 @@ concept IsRVec = requires(T t) {
   requires IsVec<T> && IsRBuffer<typename T::DType>;
 };
 
-
 // Binary
-template <typename T>
-struct is_binary_operation : std::false_type {};
+template <typename T> struct is_binary_operation : std::false_type {};
 
 template <typename L2, typename R2, typename OperationTrait>
 struct is_binary_operation<BinaryOperation<L2, R2, OperationTrait>>
@@ -159,8 +153,6 @@ inline constexpr bool is_binary_operation_v = is_binary_operation<T>::value;
 template <typename T>
 concept IsBinaryOperation = is_binary_operation_v<T>;
 
-
-
 } // namespace etr
 
 #endif
diff --git a/inst/include/etr_bits/Core/Traits.hpp b/inst/include/etr_bits/Core/Traits.hpp
index d30a831..fdca3fc 100644
--- a/inst/include/etr_bits/Core/Traits.hpp
+++ b/inst/include/etr_bits/Core/Traits.hpp
@@ -13,13 +13,13 @@ struct ComparisonTrait {
 
 struct BaseStoreTrait {};
 struct LBufferTrait {};
-struct RBufferTrait{};
+struct RBufferTrait {};
 struct SubsetTrait {};
 struct SubsetClassTrait {};
 struct BorrowTrait {};
 struct BorrowSEXPTrait {};
-struct BinaryTrait{};
-struct UnaryTrait{};
+struct BinaryTrait {};
+struct UnaryTrait {};
 
 struct PlusTrait {
   template <typename L = BaseType, typename R = BaseType>
diff --git a/inst/include/etr_bits/Subsetting/LazySubsetting.hpp b/inst/include/etr_bits/Subsetting/LazySubsetting.hpp
index c9e03d3..b8cd99b 100644
--- a/inst/include/etr_bits/Subsetting/LazySubsetting.hpp
+++ b/inst/include/etr_bits/Subsetting/LazySubsetting.hpp
@@ -25,14 +25,14 @@ void precalcVecBool(V &vec, Indices &ind, I *idx) {
 }
 
 template <typename L, typename R> struct SubsetClassIterator {
-  const L &l;
+  L &l;
   const R &r;
   size_t index;
 
-  SubsetClassIterator(const L &l, const R &r, size_t index = 0)
+  SubsetClassIterator(L &l, const R &r, size_t index = 0)
       : l(l), r(r), index(index) {}
 
-  auto operator*() const {
+  auto &operator*() const {
     if constexpr (IsArithV<R>) {
       return l[r];
     } else if constexpr (!IsArithV<R>) {
@@ -50,12 +50,38 @@ template <typename L, typename R> struct SubsetClassIterator {
   }
 };
 
+template <typename L, typename R> struct SubsetClassConstantIterator {
+  L &l;
+  const R &r;
+  size_t index;
+
+  SubsetClassConstantIterator(L &l, const R &r, size_t index = 0)
+      : l(l), r(r), index(index) {}
+
+  auto operator*() const {
+    if constexpr (IsArithV<R>) {
+      return l[r];
+    } else if constexpr (!IsArithV<R>) {
+      return l[r[index % r.size()] - 1];
+    }
+  }
+
+  SubsetClassConstantIterator &operator++() {
+    ++index;
+    return *this;
+  }
+
+  bool operator!=(const SubsetClassConstantIterator &other) const {
+    return index != other.index;
+  }
+};
+
+// NOTE: Subset L values
 template <typename L, typename R, typename Trait> struct SubsetClass {
-  using RetType = typename ExtractDataType<L>::RetType;
+  using RetType = typename ReRef<L>::type::RetType;
   using TypeTrait = Trait;
-  std::optional<L> storedL;
   std::optional<R> storedR;
-  const L &l;
+  L &l;
   const R &r;
 
   using typeTraitL = L;
@@ -78,37 +104,106 @@ template <typename L, typename R, typename Trait> struct SubsetClass {
   std::size_t nr() const { return calculateDim(); }
 
   // Constructor for lvalues (both `l_` and `r_`)
-  SubsetClass(const L &l_, const R &r_) : l(l_), r(r_) {}
+  SubsetClass(L &l_, R &r_) : l(l_), r(r_) {}
+
+  // Constructor for lvalue `l_` and rvalue `r_`
+  SubsetClass(L &l_, R &&r_) : storedR(std::move(r_)), l(l_), r(*storedR) {
+    std::cout << "Constructor SubsetClass" << std::endl;
+    std::cout << r.size() << std::endl;
+    std::cout << storedR->size() << std::endl;
+  }
+
+  template <typename LType, typename RType, typename TraitL>
+  SubsetClass(SubsetClass<LType, RType, TraitL> &other)
+      : l(other.l), r(other.r) {}
+
+  auto &operator[](std::size_t i) {
+    if constexpr (IsArithV<R>) {
+      return l[i];
+    } else {
+      return l[r[i % l.size()] - 1];
+    }
+  }
+  std::size_t size() const {
+    if constexpr (IsArithV<R>) {
+      return l.size();
+    } else {
+      std::cout << "size method SubsetClass" << std::endl;
+      std::cout << r.size() << std::endl;
+      std::cout << storedR->size() << std::endl;
+      return r.size();
+    }
+  }
+
+  void setMatrix(bool i, std::size_t nrow, std::size_t ncol) {
+    mp.setMatrix(i, nrow, ncol);
+  }
+  void setMatrix(MatrixParameter &mp_) {
+    mp.setMatrix(mp_.ismatrix, mp_.rows, mp_.cols);
+  }
+  void setMatrix(const MatrixParameter &mp_) {
+    mp.setMatrix(mp_.ismatrix, mp_.rows, mp_.cols);
+  }
+  auto begin() const { return SubsetClassIterator<L, R>{l, r, 0}; }
+  auto end() const { return SubsetClassIterator<L, R>{l, r, this->size()}; }
+};
+
+// NOTE: Subset R Value
+template <typename L, typename R, typename Trait>
+struct SubsetClass<const L, R, Trait> {
+  using RetType = typename ExtractDataType<L>::RetType;
+  using TypeTrait = Trait;
+  std::optional<L> storedL;
+  std::optional<R> storedR;
+  L &l;
+  const R &r;
+
+  using typeTraitL = L;
+  using typeTraitR = R;
+  MatrixParameter mp;
+
+  bool im() const { return l.im() || r.im(); }
+  std::size_t calculateDim() const {
+    if (l.im() && r.im())
+      return (l.nr() > r.nr()) ? l.nr() : r.nr();
+    if (!l.im() && r.im())
+      return r.nr();
+    if (l.im() && !r.im())
+      return l.nr();
+    ass<"Matrix calculation failed!">(false);
+    return 0;
+  }
+
+  std::size_t nc() const { return calculateDim(); }
+  std::size_t nr() const { return calculateDim(); }
 
   // Constructor for rvalues (both `l_` and `r_`)
   SubsetClass(L &&l_, R &&r_)
       : storedL(std::move(l_)), storedR(std::move(r_)), l(*storedL),
         r(*storedR) {}
 
-  // Constructor for lvalue `l_` and rvalue `r_`
-  SubsetClass(const L &l_, R &&r_)
-      : storedR(std::move(r_)), l(l_), r(*storedR) {}
-
   // Constructor for rvalue `l_` and lvalue `r_`
   SubsetClass(L &&l_, const R &r_)
       : storedL(std::move(l_)), l(*storedL), r(r_) {}
 
-  SubsetClass(const SubsetClass &other) : l(other.l), r(other.r) {}
-  // Move constructor
-  SubsetClass(const SubsetClass &&other)
-      : storedL(other.storedL ? std::move(other.storedL) : std::optional<L>{}),
-        storedR(other.storedR ? std::move(other.storedR) : std::optional<R>{}),
-        l(other.storedL.has_value() ? *storedL : other.l),
-        r(other.storedR.has_value() ? *storedR : other.r) {}
   template <typename LType, typename RType, typename TraitL>
-  SubsetClass(const SubsetClass<LType, RType, TraitL> &other)
+  SubsetClass(SubsetClass<LType, RType, TraitL> &other)
       : l(other.l), r(other.r) {}
 
-  auto operator[](std::size_t i) const { return l[r[i % l.size()] - 1]; }
-  // TODO: it is possible to use indices larger than length of l. It is safe
-  // but not the behaviour in R
-  std::size_t size() const { return r.size(); }
-
+  const auto operator[](std::size_t i) {
+    if constexpr (IsArithV<R>) {
+      return l[i];
+    } else {
+      return l[r[i % l.size()] - 1];
+    }
+  }
+  std::size_t size() const {
+    if constexpr (IsArithV<R>) {
+      return l.size();
+    } else {
+      return r.size();
+    }
+  }
   void setMatrix(bool i, std::size_t nrow, std::size_t ncol) {
     mp.setMatrix(i, nrow, ncol);
   }
@@ -118,53 +213,41 @@ template <typename L, typename R, typename Trait> struct SubsetClass {
   void setMatrix(const MatrixParameter &mp_) {
     mp.setMatrix(mp_.ismatrix, mp_.rows, mp_.cols);
   }
-  auto begin() const { return SubsetClassIterator<L, R>{l, r, 0}; }
-  auto end() const { return SubsetClassIterator<L, R>{l, r, this->size()}; }
+  auto begin() const { return SubsetClassConstantIterator<L, R>{l, r, 0}; }
+  auto end() const {
+    return SubsetClassConstantIterator<L, R>{l, r, this->size()};
+  }
 };
 
-// NOTE: the following subsetArithmetic, subsetBoolean, subsetVector and
-// subsetSubset functions mean that a vector is subsetted by something which
-// can be either a scalar (int or double), a bool, a vector or a SubsetClass
-// (wrapped in a Vec).
-template <typename L, typename R> auto subsetArithmeticR(L &&l, R &&r) {
+// NOTE: R = int | double
+template <typename L, typename R> inline auto &subsetArithmeticL(L &&l, R &&r) {
   using RetType = typename ExtractDataType<Decayed<L>>::RetType;
   if constexpr (IsFloatingPointV<R>) {
     ass<"Negative indices are not supported">(r >= 0);
-    return static_cast<RetType>(l[static_cast<size_t>(std::floor(r)) - 1]);
-  } else if constexpr (IsBool<R>) {
-    if (r) {
-      return l;
-    } else {
-      return Vec<RetType, Buffer<RetType, RBufferTrait>>(SI{0});
-    }
+    return static_cast<RetType &>(l[static_cast<size_t>(std::floor(r)) - 1]);
   } else if constexpr (IsIntegral<R>) {
     ass<"Negative indices are not supported">(r >= 0);
-    return static_cast<RetType>(l.d[r - 1]);
+    return static_cast<RetType &>(l.d[r - 1]);
   } else {
     ass<"Found unsupported arithmetic value">(false);
   }
 }
 
-template <typename L, typename R> auto subsetArithmeticL(L &&l, R &&r) {
+template <typename L, typename R>
+inline const auto &subsetArithmeticR(L &&l, R &&r) {
   using RetType = typename ExtractDataType<Decayed<L>>::RetType;
   if constexpr (IsFloatingPointV<R>) {
     ass<"Negative indices are not supported">(r >= 0);
-    return static_cast<RetType &>(l[static_cast<size_t>(std::floor(r)) - 1]);
-  } else if constexpr (IsBool<R>) {
-    if (r) {
-      return l;
-    } else {
-      return Vec<RetType>(SI{0});
-    }
+    return static_cast<RetType>(l[static_cast<size_t>(std::floor(r)) - 1]);
   } else if constexpr (IsIntegral<R>) {
     ass<"Negative indices are not supported">(r >= 0);
-    return static_cast<RetType &>(l.d[r - 1]);
+    return static_cast<RetType>(l.d[r - 1]);
   } else {
     ass<"Found unsupported arithmetic value">(false);
   }
 }
 
-template <typename L, typename R> auto subsetArithmetic(L &&l, R &&r) {
+template <typename L, typename R> inline auto &subsetArithmetic(L &&l, R &&r) {
   using RetType = typename ExtractDataType<Decayed<L>>::RetType;
   constexpr bool isLArgRvalue = IsRvalue<L &&>;
   if constexpr (isLArgRvalue) {
@@ -176,83 +259,65 @@ template <typename L, typename R> auto subsetArithmetic(L &&l, R &&r) {
   }
 }
 
-template <typename L, typename R> auto subsetBoolean(L &&l, R &&r) {
+template <typename L, typename R>
+  requires((IsFloatingPointV<R> || IsIntegral<R>) && !IsBool<R>)
+inline auto &subset_test(L &&l, R &&r) {
+  static_assert(!IsArithV<Decayed<L>>,
+                "\n\nYou cannot subset a scalar value\n\n");
+  constexpr bool isArithmeticL = IsArithV<Decayed<L>>;
+  constexpr bool isArithmeticR = IsArithV<Decayed<R>>;
+  using LType = ReRef<L>;
+  using RType = ReRef<R>;
   constexpr bool isLArgRvalue = IsRvalue<L &&>;
   constexpr bool isRArgRvalue = IsRvalue<R &&>;
-  using dataType = typename ExtractDataType<Decayed<L>>::RetType;
-  Indices ind;
-  precalcVecBool(l, ind, &r);
-  if constexpr (isLArgRvalue) {
-    return Vec<dataType,
-               SubsetClass<decltype(l.d), decltype(ind), SubsetClassTrait>>(
-        SubsetClass<decltype(l.d), decltype(ind), SubsetClassTrait>(
-            std::move(l.d), std::move(ind)));
-  } else {
-    return Vec<dataType,
-               SubsetClass<decltype(l.d), decltype(ind), SubsetClassTrait>>(
-        SubsetClass<decltype(l.d), decltype(ind), SubsetClassTrait>(
-            l.d, std::move(ind)));
-  }
+  return subsetArithmetic(std::forward<decltype(l)>(l),
+                          std::forward<Decayed<R>>(r));
 }
 
-template <typename L, typename R> auto subsetSubset(L &&l, R &&r) {
+// NOTE: R = bool
+template <typename L, typename R>
+inline auto subsetArithmeticBool(L &&l, R &&r) {
+  using RetType = typename ExtractDataType<Decayed<L>>::RetType;
   constexpr bool isLArgRvalue = IsRvalue<L &&>;
-  constexpr bool isRArgRvalue = IsRvalue<R &&>;
-  using dataType = typename ExtractDataType<std::decay_t<L>>::RetType;
-  Indices ind(r.size());
-  for (std::size_t i = 0; i < r.size(); i++) {
-    ind[i] = r.d[i];
-  }
   if constexpr (isLArgRvalue) {
-    return Vec<dataType,
-               SubsetClass<decltype(l.d), decltype(ind), SubsetClassTrait>>(
-        SubsetClass<decltype(l.d), decltype(ind), SubsetClassTrait>(
-            std::move(l.d), std::move(ind)));
+    SubsetClass<const decltype(l.d), R, SubsetClassTrait> sub(std::move(l.d),
+                                                              r);
+    return Vec<RetType, decltype(sub)>(std::move(sub));
   } else {
-    return Vec<dataType,
-               SubsetClass<decltype(l.d), decltype(ind), SubsetClassTrait>>(
-        SubsetClass<decltype(l.d), decltype(ind), SubsetClassTrait>(
-            l.d, std::move(ind)));
+    SubsetClass<decltype(l.d), R, SubsetClassTrait> sub(l.d, r);
+    return Vec<RetType, decltype(sub)>(std::move(sub));
   }
 }
+template <typename L> inline auto subset_test(L &&l, bool &&r) {
+  static_assert(!IsArithV<Decayed<L>>,
+                "\n\nYou cannot subset a scalar value\n\n");
+  return subsetArithmeticBool(std::forward<decltype(l)>(l),
+                              std::forward<Decayed<bool>>(r));
+}
 
-template <typename L, typename R> auto subsetVector(L &&l, R &&r) {
+// NOTE: R = Vec<int|double>
+template <typename L, typename R> inline auto subset_test(L &&l, R &&r) {
+  static_assert(!IsArithV<Decayed<L>>,
+                "\n\nYou cannot subset a scalar value\n\n");
   using RetType = typename ExtractDataType<Decayed<L>>::RetType;
   using SubsetType =
       SubsetClass<decltype(l.d), decltype(r.d), SubsetClassTrait>;
   if constexpr (IsRvalue<L &&> && IsRvalue<R &&>) {
-    return subsetSubset(std::forward<L>(l), std::forward<R>(r));
-  } else if constexpr (IsRvalue<L &&>) {
-    return Vec<RetType, SubsetType>(SubsetType(std::move(l.d), r.d));
-  } else if constexpr (IsRvalue<R &&>) {
-    return Vec<RetType, SubsetType>(SubsetType(l.d, std::move(r.d)));
-  } else {
-    return Vec<RetType, SubsetType>(SubsetType(l.d, r.d));
-  }
-}
-
-template <typename L, typename R> auto subset_test(L &&l, R &&r) {
-  static_assert(!IsArithV<Decayed<L>>,
-                "\n\nYou cannot subset a scalar value\n\n");
-  constexpr bool isArithmeticL = IsArithV<Decayed<L>>;
-  constexpr bool isArithmeticR = IsArithV<Decayed<R>>;
-  using LType = ReRef<L>;
-  using RType = ReRef<R>;
-  constexpr bool isLArgRvalue = IsRvalue<L &&>;
-  constexpr bool isRArgRvalue = IsRvalue<R &&>;
-  if constexpr (isArithmeticR) {
-    return subsetArithmetic(std::forward<decltype(l)>(l),
-                            std::forward<Decayed<R>>(r));
+    SubsetClass<const decltype(l.d), R, SubsetClassTrait> sub(std::move(l.d),
+                                                              std::move(r.d));
+    return Vec<RetType, decltype(sub)>(std::move(sub));
+  } else if constexpr (IsRvalue<L &&> && !IsRvalue<R &&>) {
+    SubsetClass<const decltype(l.d), R, SubsetClassTrait> sub(std::move(l.d),
+                                                              r.d);
+    return Vec<RetType, decltype(sub)>(std::move(sub));
+  } else if constexpr (!IsRvalue<L &&> && IsRvalue<R &&>) {
+    return Vec<RetType,
+               SubsetClass<decltype(l.d), decltype(r.d), SubsetClassTrait>>(
+        SubsetClass<decltype(l.d), decltype(r.d), SubsetClassTrait>(
+            l.d, std::move(r.d)));
   } else {
-    using dataType = typename ExtractDataType<Decayed<L>>::RetType;
-    using dataTypeR = typename ExtractDataType<Decayed<R>>::RetType;
-    if constexpr (IS<dataTypeR, bool>) {
-      return subsetBoolean(std::forward<decltype(l)>(l),
-                           std::forward<decltype(r)>(r));
-    } else {
-      return subsetVector(std::forward<decltype(l)>(l),
-                          std::forward<decltype(r)>(r));
-    }
+    SubsetClass<decltype(l.d), R, SubsetClassTrait> sub(l.d, r.d);
+    return Vec<RetType, decltype(sub)>(std::move(sub));
   }
 }
 
diff --git a/inst/include/etr_bits/Vector/VectorClass.hpp b/inst/include/etr_bits/Vector/VectorClass.hpp
index d75b417..745e40e 100644
--- a/inst/include/etr_bits/Vector/VectorClass.hpp
+++ b/inst/include/etr_bits/Vector/VectorClass.hpp
@@ -15,7 +15,6 @@ template <typename T, typename R> struct Vec {
   using DType = R;
   using RetType = typename ReRef<decltype(d)>::type::RetType;
 
-
   template <typename T2> Vec(T2 n) = delete;
 
 #ifdef DERIV_ETR
@@ -43,28 +42,28 @@ template <typename T, typename R> struct Vec {
 
   // NOTE: Borrow
   template <typename U = R, typename T2>
-  requires IS<U, Borrow<BaseType>>
+    requires IS<U, Borrow<BaseType>>
   explicit Vec(const Borrow<T2> &&borrowed) : d(borrowed), deriv(borrowed.sz) {
     d.setMatrix(borrowed.mp);
   }
   template <typename U = R, typename T2>
-  requires IS<U, Borrow<T>>
+    requires IS<U, Borrow<T>>
   explicit Vec(const Borrow<T2> &borrowed) : d(borrowed), deriv(borrowed.sz) {
     d.setMatrix(borrowed.mp);
   }
   template <typename U = R>
-  requires IS<U, Borrow<T>>
+    requires IS<U, Borrow<T>>
   explicit Vec(T *ptr, std::size_t s) : d(ptr, s), deriv(s) {}
 
   // NOTE: BorrowSEXP
 #ifdef STANDALONE_ETR
 #else
   template <typename U = R>
-  requires IS<U, BorrowSEXP<T>>
+    requires IS<U, BorrowSEXP<T>>
   explicit Vec(SEXP &&inp) = delete;
 
   template <typename U = R>
-  requires IS<U, BorrowSEXP<T>>
+    requires IS<U, BorrowSEXP<T>>
   explicit Vec(SEXP inp) : d(inp) {
     deriv.resize(d.sz);
     deriv.fill(0.0);
@@ -82,35 +81,35 @@ template <typename T, typename R> struct Vec {
   }
   // NOTE: Subset lazy
   template <typename L2, typename R2, typename TraitInp>
-  requires IS<TraitInp, SubsetClassTrait>
+    requires IS<TraitInp, SubsetClassTrait>
   explicit Vec(const SubsetClass<L2, R2, TraitInp> &&inp)
-  : d(inp), deriv(inp.size()) {
+      : d(inp), deriv(inp.size()) {
     d.setMatrix(inp.mp);
   }
   template <typename L2, typename R2, typename TraitInp>
-  requires IS<TraitInp, SubsetClassTrait>
+    requires IS<TraitInp, SubsetClassTrait>
   explicit Vec(SubsetClass<L2, R2, TraitInp> &inp) : d(inp), deriv(inp.size()) {
     d.setMatrix(inp.mp);
   }
 
   // NOTE: Binary operation
   template <typename L2, typename R2, typename OperationTrait>
-  requires IsBinaryOperation<BinaryOperation<L2, R2, OperationTrait>>
+    requires IsBinaryOperation<BinaryOperation<L2, R2, OperationTrait>>
   explicit Vec(const BinaryOperation<L2, R2, OperationTrait> &&inp)
-  : d(inp), deriv(inp.size()) {
+      : d(inp), deriv(inp.size()) {
     using TypeTrait = OperationTrait;
     d.setMatrix(inp.mp);
   }
   template <typename L2, typename R2, typename OperationTrait,
-  typename DetailTrait> // NOTE: only for comparison!
+            typename DetailTrait> // NOTE: only for comparison!
   explicit Vec(const BinaryOperation<L2, R2, OperationTrait, DetailTrait> &&inp)
-  : d(inp), deriv(inp.size()) {
+      : d(inp), deriv(inp.size()) {
     using TypeTrait = OperationTrait;
     d.setMatrix(inp.mp);
   }
   template <typename L2, typename R2, typename OperationTrait>
   explicit Vec(BinaryOperation<L2, R2, OperationTrait> &inp)
-  : d(inp), deriv(inp.size()) {
+      : d(inp), deriv(inp.size()) {
     using TypeTrait = OperationTrait;
     d.setMatrix(inp.mp);
   }
@@ -118,13 +117,13 @@ template <typename T, typename R> struct Vec {
   // NOTE: Unary operation
   template <typename L2, typename OperationTrait>
   explicit Vec(const UnaryOperation<L2, OperationTrait> &&inp)
-  : d(inp), deriv(inp.size()) {
+      : d(inp), deriv(inp.size()) {
     using TypeTrait = OperationTrait;
     d.setMatrix(inp.mp);
   }
   template <typename L2, typename OperationTrait>
   explicit Vec(UnaryOperation<L2, OperationTrait> &inp)
-  : d(inp), deriv(inp.size()) {
+      : d(inp), deriv(inp.size()) {
     using TypeTrait = OperationTrait;
     d.setMatrix(inp.mp);
   }
@@ -144,17 +143,17 @@ template <typename T, typename R> struct Vec {
 
   // NOTE: matrix constructors
   explicit Vec(std::size_t rows, std::size_t cols)
-  : d(rows * cols), deriv(rows * cols) {
+      : d(rows * cols), deriv(rows * cols) {
     d.setMatrix(true, rows, cols);
   }
   explicit Vec(std::size_t rows, std::size_t cols, const double value)
-  : d(rows * cols), deriv(rows * cols) {
+      : d(rows * cols), deriv(rows * cols) {
     d.setMatrix(true, rows, cols);
     d.fill(value);
   }
   // NOTE: other vector which is not of type RVec and has to be copied
   template <typename T2, typename R2, typename Trait2>
-  requires IsVec<const Vec<T2, R2, Trait2>>
+    requires IsVec<const Vec<T2, R2, Trait2>>
   Vec(const Vec<T2, R2, Trait2> &&other_vec) {
     using TypeTrait = Trait2;
     using CaseTrait = Trait2;
@@ -189,7 +188,7 @@ template <typename T, typename R> struct Vec {
 
   // NOTE: other vector which is of type RVec and has different base type
   template <typename T2, typename R2, typename Trait2>
-  requires(IsRVec<const Vec<T2, R2, Trait2>> && !IS<T, T2>)
+    requires(IsRVec<const Vec<T2, R2, Trait2>> && !IS<T, T2>)
   Vec(const Vec<T2, R2, Trait2> &&other_vec) {
     using TypeTrait = Trait2;
     using CaseTrait = Trait2;
@@ -224,7 +223,7 @@ template <typename T, typename R> struct Vec {
 
   // NOTE: other vector which is of type RVec and with same base type
   template <typename T2, typename R2, typename Trait2>
-  requires(IsRVec<const Vec<T2, R2, Trait2>> && IS<T, T2>)
+    requires(IsRVec<const Vec<T2, R2, Trait2>> && IS<T, T2>)
   Vec(Vec<T2, R2, Trait2> &&other_vec) {
     using TypeTrait = Trait2;
     using CaseTrait = Trait2;
@@ -267,7 +266,7 @@ template <typename T, typename R> struct Vec {
     deriv.fill(0.0);
   }
   Vec(BaseType *ptr, std::size_t rows, std::size_t cols)
-  : d(rows * cols), deriv(rows * cols) {
+      : d(rows * cols), deriv(rows * cols) {
     for (std::size_t i = 0; i < d.size(); i++)
       d[i] = ptr[i];
     d.setMatrix(true, rows, cols);
@@ -293,28 +292,28 @@ template <typename T, typename R> struct Vec {
 
   // NOTE: Borrow
   template <typename U = R, typename T2>
-  requires IS<U, Borrow<BaseType>>
+    requires IS<U, Borrow<BaseType>>
   explicit Vec(const Borrow<T2> &&borrowed) : d(borrowed) {
     d.setMatrix(borrowed.mp);
   }
   template <typename U = R, typename T2>
-  requires IS<U, Borrow<T>>
+    requires IS<U, Borrow<T>>
   explicit Vec(const Borrow<T2> &borrowed) : d(borrowed) {
     d.setMatrix(borrowed.mp);
   }
   template <typename U = R>
-  requires IS<U, Borrow<T>>
+    requires IS<U, Borrow<T>>
   explicit Vec(T *ptr, std::size_t s) : d(ptr, s) {}
 
   // NOTE: BorrowSEXP
 #ifdef STANDALONE_ETR
 #else
   template <typename U = R>
-  requires IS<U, BorrowSEXP<T>>
+    requires IS<U, BorrowSEXP<T>>
   explicit Vec(SEXP &&inp) = delete;
 
   template <typename U = R>
-  requires IS<U, BorrowSEXP<T>>
+    requires IS<U, BorrowSEXP<T>>
   explicit Vec(SEXP inp) : d(inp) {}
 #endif
 
@@ -327,12 +326,12 @@ template <typename T, typename R> struct Vec {
   }
   // NOTE: Subset lazy
   template <typename L2, typename R2, typename TraitL>
-  requires IS<TraitL, SubsetClassTrait>
+    requires IS<TraitL, SubsetClassTrait>
   explicit Vec(const SubsetClass<L2, R2, TraitL> &&inp) : d(std::move(inp)) {
     d.setMatrix(inp.mp);
   }
   template <typename L2, typename R2, typename TraitL>
-  requires IS<TraitL, SubsetClassTrait>
+    requires IS<TraitL, SubsetClassTrait>
   explicit Vec(SubsetClass<L2, R2, TraitL> &inp) : d(std::move(inp)) {
     d.setMatrix(inp.mp);
   }
@@ -375,13 +374,13 @@ template <typename T, typename R> struct Vec {
     d.setMatrix(true, rows, cols);
   }
   explicit Vec(std::size_t rows, std::size_t cols, const double value)
-  : d(rows * cols) {
+      : d(rows * cols) {
     d.setMatrix(true, rows, cols);
     d.fill(value);
   }
   // NOTE: other vector which is not of type RVec and has to be copied
   template <typename T2, typename R2, typename Trait2>
-  requires IsVec<const Vec<T2, R2>>
+    requires IsVec<const Vec<T2, R2>>
   Vec(const Vec<T2, R2> &&other_vec) {
     if constexpr (IsBorrow<R>) {
       ass<"Sizes do not match">(d.sz <=
@@ -410,7 +409,7 @@ template <typename T, typename R> struct Vec {
 
   // NOTE: other vector which is of type RVec and has different base type
   template <typename T2, typename R2>
-  requires(IsRVec<const Vec<T2, R2>> && !IS<T, T2>)
+    requires(IsRVec<const Vec<T2, R2>> && !IS<T, T2>)
   Vec(const Vec<T2, R2> &&other_vec) {
     if constexpr (IsBorrow<R>) {
       ass<"Sizes do not match">(d.sz <= other_vec.size());
@@ -465,7 +464,7 @@ template <typename T, typename R> struct Vec {
 
   // NOTE: other vector which is of type RVec and with same base type
   template <typename T2, typename R2>
-  requires(IsRVec<const Vec<T2, R2>> && IS<T, T2>)
+    requires(IsRVec<const Vec<T2, R2>> && IS<T, T2>)
   Vec(Vec<T2, R2> &&other_vec) {
     if constexpr (IsBorrow<R>) {
       ass<"Sizes do not match">(d.sz <= other_vec.size());
@@ -507,291 +506,296 @@ template <typename T, typename R> struct Vec {
   }
 #endif
 
-
-// Assignments
-template <typename TD>
-  requires IsArithV<TD>
-Vec &operator=(const TD inp) {
-  static_assert(!IsUnary<R>, "Cannot assign to unary calculation");
-  static_assert(!IsBinary<R>, "Cannot assign to binary calculation");
-  static_assert(!IsRBuffer<R>,
-                "Cannot assign to an r value. E.g. c(1, 2, 3) <- 1");
-  if constexpr (is<TD, T>) {
-    if constexpr (IsSubset<R>) {
-      for (std::size_t i = 0; i < d.ind.size(); i++) {
-        d[i] = inp;
-      }
+  // Assignments
+  template <typename TD>
+    requires IsArithV<TD>
+  Vec &operator=(const TD inp) {
+    static_assert(!IsUnary<R>, "Cannot assign to unary calculation");
+    static_assert(!IsBinary<R>, "Cannot assign to binary calculation");
+    static_assert(!IsRBuffer<R>,
+                  "Cannot assign to an r value. E.g. c(1, 2, 3) <- 1");
+    // Same Type
+    // ---------------------------------------------------------------------
+    if constexpr (is<TD, T>) {
+      if constexpr (IS<SubsetClassTrait, typename ReRef<R>::type::TypeTrait>) {
+        for (std::size_t i = 0; i < d.size(); i++) {
+          d[i] = inp;
+        }
 #ifdef DERIV_ETR
-      for (std::size_t i = 0; i < d.ind.size(); i++) {
-        deriv[i] = 0;
-      }
+        for (std::size_t i = 0; i < d.size(); i++) {
+          deriv[i] = 0;
+        }
 #endif
-    } else if constexpr (IsBorrow<R>) {
-      d.sz = 1;
-      d[0] = inp;
+      } else if constexpr (IsBorrow<R>) {
+        d.sz = 1;
+        d[0] = inp;
 #ifdef DERIV_ETR
-      deriv.resize(1);
-      deriv[0] = 0;
+        deriv.resize(1);
+        deriv[0] = 0;
 #endif
 
-    } else {
-      d.resize(1);
-      d[0] = inp;
+      } else {
+        d.resize(1);
+        d[0] = inp;
 #ifdef DERIV_ETR
-      deriv.resize(1);
-      deriv[0] = 0;
+        deriv.resize(1);
+        deriv[0] = 0;
 #endif
-    }
-    return *this;
-  } else {
-    if constexpr (IsSubset<R>) {
-      for (std::size_t i = 0; i < d.ind.size(); i++) {
-        d[i] = static_cast<T>(inp);
       }
+      return *this;
+      // Different Type
+      // ---------------------------------------------------------------------
+    } else {
+      if constexpr (IS<SubsetClassTrait, typename ReRef<R>::type::TypeTrait>) {
+        for (std::size_t i = 0; i < d.size(); i++) {
+          d[i] = static_cast<T>(inp);
+        }
 #ifdef DERIV_ETR
-      for (std::size_t i = 0; i < d.ind.size(); i++) {
-        deriv[i] = 0;
-      }
+        for (std::size_t i = 0; i < d.size(); i++) {
+          deriv[i] = 0;
+        }
 #endif
 
-    } else if constexpr (IsBorrow<R>) {
-      d.sz = 1;
-      d[0] = static_cast<T>(inp);
+      } else if constexpr (IsBorrow<R>) {
+        d.sz = 1;
+        d[0] = static_cast<T>(inp);
 #ifdef DERIV_ETR
-      deriv.resize(1);
-      deriv[0] = 0;
+        deriv.resize(1);
+        deriv[0] = 0;
 #endif
 
-    } else {
-      d.resize(1);
-      d[0] = static_cast<T>(inp);
+      } else {
+        d.resize(1);
+        d[0] = static_cast<T>(inp);
 #ifdef DERIV_ETR
-      deriv.resize(1);
-      deriv[0] = 0;
+        deriv.resize(1);
+        deriv[0] = 0;
 #endif
+      }
+      return *this;
     }
-    return *this;
   }
-}
 
-Vec &operator=(const Vec<T, R> &otherVec) {
-  static_assert(!IsUnary<R>, "Cannot assign to unary calculation");
-  static_assert(!IsBinary<R>, "Cannot assign to binary calculation");
-  static_assert(!IsRBuffer<R>,
-                "Cannot assign to an r value. E.g. c(1, 2, 3) <- 1");
+  Vec &operator=(const Vec<T, R> &otherVec) {
+    static_assert(!IsUnary<R>, "Cannot assign to unary calculation");
+    static_assert(!IsBinary<R>, "Cannot assign to binary calculation");
+    static_assert(!IsRBuffer<R>,
+                  "Cannot assign to an r value. E.g. c(1, 2, 3) <- 1");
 
-  using DataTypeOtherVec = const Vec<T, R>::RetType;
-  if constexpr (IsLBuffer<R>) {
-    temp.resize(otherVec.size());
-    for (std::size_t i = 0; i < otherVec.size(); i++) {
-      if constexpr (is<DataTypeOtherVec, T>) {
-        temp[i] = otherVec[i];
-      } else {
-        temp[i] = static_cast<T>(otherVec[i]);
+    using DataTypeOtherVec = const Vec<T, R>::RetType;
+    if constexpr (IsLBuffer<R>) {
+      temp.resize(otherVec.size());
+      for (std::size_t i = 0; i < otherVec.size(); i++) {
+        if constexpr (is<DataTypeOtherVec, T>) {
+          temp[i] = otherVec[i];
+        } else {
+          temp[i] = static_cast<T>(otherVec[i]);
+        }
       }
-    }
-    d.moveit(temp);
-  } else if constexpr (IsBorrow<R>) {
-    ass<"number of items to replace is not a multiple of replacement length">(
-        otherVec.size() <= d.capacity);
-    temp.resize(otherVec.size());
-    for (std::size_t i = 0; i < otherVec.size(); i++) {
-      if constexpr (is<DataTypeOtherVec, T>) {
-        temp[i] = otherVec[i];
-      } else {
-        temp[i] = static_cast<T>(otherVec[i]);
-      }
-    }
-    ass<"size cannot be increased above the size of the borrowed object">(
-        d.sz <= otherVec.size());
-    d.sz = otherVec.size();
-    for (std::size_t i = 0; i < otherVec.size(); i++)
-      d[i] = temp[i];
-  } else if constexpr (IsBorrowSEXP<R>) {
-    temp.resize(otherVec.size());
-    for (std::size_t i = 0; i < otherVec.size(); i++) {
-      if constexpr (is<DataTypeOtherVec, T>) {
-        temp[i] = otherVec[i];
-      } else {
-        temp[i] = static_cast<T>(otherVec[i]);
-      }
-    }
-    if (otherVec.size() > this->size())
-      d.resize(otherVec.size());
-
-    for (std::size_t i = 0; i < otherVec.size(); i++)
-      d[i] = temp[i];
-
-  } else if constexpr (IsSubset<R>) {
-    ass<"number of items to replace is not a multiple of replacement length">(
-        otherVec.size() == d.ind.size());
-    temp.resize(otherVec.size());
-    for (std::size_t i = 0; i < otherVec.size(); i++) {
-      if constexpr (is<DataTypeOtherVec, T>) {
-        temp[i] = otherVec[i];
-      } else {
-        temp[i] = static_cast<T>(otherVec[i]);
+      d.moveit(temp);
+    } else if constexpr (IsBorrow<R>) {
+      ass<"number of items to replace is not a multiple of replacement length">(
+          otherVec.size() <= d.capacity);
+      temp.resize(otherVec.size());
+      for (std::size_t i = 0; i < otherVec.size(); i++) {
+        if constexpr (is<DataTypeOtherVec, T>) {
+          temp[i] = otherVec[i];
+        } else {
+          temp[i] = static_cast<T>(otherVec[i]);
+        }
+      }
+      ass<"size cannot be increased above the size of the borrowed object">(
+          d.sz <= otherVec.size());
+      d.sz = otherVec.size();
+      for (std::size_t i = 0; i < otherVec.size(); i++)
+        d[i] = temp[i];
+    } else if constexpr (IsBorrowSEXP<R>) {
+      temp.resize(otherVec.size());
+      for (std::size_t i = 0; i < otherVec.size(); i++) {
+        if constexpr (is<DataTypeOtherVec, T>) {
+          temp[i] = otherVec[i];
+        } else {
+          temp[i] = static_cast<T>(otherVec[i]);
+        }
+      }
+      if (otherVec.size() > this->size())
+        d.resize(otherVec.size());
+
+      for (std::size_t i = 0; i < otherVec.size(); i++)
+        d[i] = temp[i];
+
+    } else if constexpr (IsSubset<R>) {
+      ass<"number of items to replace is not a multiple of replacement length">(
+          otherVec.size() == d.ind.size());
+      temp.resize(otherVec.size());
+      for (std::size_t i = 0; i < otherVec.size(); i++) {
+        if constexpr (is<DataTypeOtherVec, T>) {
+          temp[i] = otherVec[i];
+        } else {
+          temp[i] = static_cast<T>(otherVec[i]);
+        }
+      }
+      if (d.p->size() < temp.size())
+        d.resize(temp.size());
+      for (std::size_t i = 0; i < d.ind.size(); i++) {
+        d[i % d.ind.size()] = temp[i];
       }
     }
-    if (d.p->size() < temp.size())
-      d.resize(temp.size());
-    for (std::size_t i = 0; i < d.ind.size(); i++) {
-      d[i % d.ind.size()] = temp[i];
+    if (otherVec.d.im()) {
+      d.setMatrix(true, otherVec.d.nr(), otherVec.d.nc());
     }
-  }
-  if (otherVec.d.im()) {
-    d.setMatrix(true, otherVec.d.nr(), otherVec.d.nc());
-  }
 
 #ifdef DERIV_ETR
-  // TODO: what if other Vec is subsetted
-  // deriv.resize(otherVec.size());
-  // for (std::size_t i = 0; i < deriv.size(); i++) {
-  //   deriv[i] = otherVec.deriv[i];
-  // }
-  // TODO: is there something to do here?
+    // TODO: what if other Vec is subsetted
+    // deriv.resize(otherVec.size());
+    // for (std::size_t i = 0; i < deriv.size(); i++) {
+    //   deriv[i] = otherVec.deriv[i];
+    // }
+    // TODO: is there something to do here?
 #endif
 
-  return *this;
-}
-
-// TODO: finish this
-template <typename T2, typename R2>
-  requires(IsRVec<const Vec<T2, R2>> && IS<T, T2>)
-Vec &operator=(Vec<T2, R2> &&otherVec) {
-  static_assert(!IsUnary<R>, "Cannot assign to unary calculation");
-  static_assert(!IsBinary<R>, "Cannot assign to binary calculation");
-  static_assert(!IsRBuffer<R>,
-                "Cannot assign to an r value. E.g. c(1, 2, 3) <- 1");
-  std::size_t tempSize = otherVec.size();
-  std::size_t tempCapacity = otherVec.d.capacity;
-  T *tempP = otherVec.d.p;
-  bool allocated = otherVec.d.allocated;
-
-  otherVec.d.allocated = d.allocated;
-  otherVec.d.sz = this->size();
-  otherVec.d.capacity = d.capacity;
-  otherVec.d.p = d.p;
-
-  d.allocated = allocated;
-  d.sz = tempSize;
-  d.capacity = tempCapacity;
-  d.p = tempP;
-
-  if (otherVec.d.im()) {
-    d.setMatrix(true, otherVec.nr(), otherVec.nc());
+    return *this;
   }
+
+  // TODO: finish this
+  template <typename T2, typename R2>
+    requires(IsRVec<const Vec<T2, R2>> && IS<T, T2>)
+  Vec &operator=(Vec<T2, R2> &&otherVec) {
+    static_assert(!IsUnary<R>, "Cannot assign to unary calculation");
+    static_assert(!IsBinary<R>, "Cannot assign to binary calculation");
+    static_assert(!IsRBuffer<R>,
+                  "Cannot assign to an r value. E.g. c(1, 2, 3) <- 1");
+    std::size_t tempSize = otherVec.size();
+    std::size_t tempCapacity = otherVec.d.capacity;
+    T *tempP = otherVec.d.p;
+    bool allocated = otherVec.d.allocated;
+
+    otherVec.d.allocated = d.allocated;
+    otherVec.d.sz = this->size();
+    otherVec.d.capacity = d.capacity;
+    otherVec.d.p = d.p;
+
+    d.allocated = allocated;
+    d.sz = tempSize;
+    d.capacity = tempCapacity;
+    d.p = tempP;
+
+    if (otherVec.d.im()) {
+      d.setMatrix(true, otherVec.nr(), otherVec.nc());
+    }
 #ifdef DERIV_ETR
-  deriv.resize(this->size());
-  for (std::size_t i = 0; i < deriv.size(); i++) {
-    deriv[i] = 0;
-  }
+    deriv.resize(this->size());
+    for (std::size_t i = 0; i < deriv.size(); i++) {
+      deriv[i] = 0;
+    }
 #endif
 
-  return *this;
-}
+    return *this;
+  }
 
-template <typename T2, typename R2>
-Vec &operator=(const Vec<T2, R2> &otherVec) {
-  static_assert(!IsUnary<R>, "Cannot assign to unary calculation");
-  static_assert(!IsBinary<R>, "Cannot assign to binary calculation");
-  static_assert(!IsRBuffer<R>,
-                "Cannot assign to an r value. E.g. c(1, 2, 3) <- 1");
+  template <typename T2, typename R2>
+  Vec &operator=(const Vec<T2, R2> &otherVec) {
+    static_assert(!IsUnary<R>, "Cannot assign to unary calculation");
+    static_assert(!IsBinary<R>, "Cannot assign to binary calculation");
+    static_assert(!IsRBuffer<R>,
+                  "Cannot assign to an r value. E.g. c(1, 2, 3) <- 1");
     // TODO: replace is with IS
-  using DataTypeOtherVec = typename ReRef<decltype(otherVec.d)>::type::RetType;
-  if constexpr (IsLBuffer<R>) {
-
-    temp.resize(otherVec.size());
-    for (std::size_t i = 0; i < otherVec.size(); i++) {
-      if constexpr (is<DataTypeOtherVec, T>) {
-        temp[i] = otherVec[i];
-      } else {
-        temp[i] = static_cast<T>(otherVec.d[i]);
-      }
-    }
-    d.moveit(temp);
-  } else if constexpr (IsBorrow<R>) {
-    ass<"number of items to replace is not a multiple of replacement length">(
-        otherVec.size() <= d.capacity);
-    temp.resize(otherVec.size());
-    for (std::size_t i = 0; i < otherVec.size(); i++) {
-      if constexpr (is<DataTypeOtherVec, T>) {
-        temp[i] = otherVec[i];
-      } else {
-        temp[i] = static_cast<T>(otherVec[i]);
-      }
-    }
-    ass<"size cannot be increased above the size of the borrowed object">(
-        d.sz <= otherVec.size());
-    d.sz = otherVec.size();
-    for (std::size_t i = 0; i < otherVec.size(); i++)
-      d[i] = temp[i];
-  } else if constexpr (IsBorrowSEXP<R>) {
-    temp.resize(otherVec.size());
-    for (std::size_t i = 0; i < otherVec.size(); i++) {
-      if constexpr (is<DataTypeOtherVec, T>) {
-        temp[i] = otherVec[i];
-      } else {
-        temp[i] = static_cast<T>(otherVec[i]);
+    using DataTypeOtherVec =
+        typename ReRef<decltype(otherVec.d)>::type::RetType;
+    if constexpr (IsLBuffer<R>) {
+
+      temp.resize(otherVec.size());
+      for (std::size_t i = 0; i < otherVec.size(); i++) {
+        if constexpr (is<DataTypeOtherVec, T>) {
+          temp[i] = otherVec[i];
+        } else {
+          temp[i] = static_cast<T>(otherVec.d[i]);
+        }
+      }
+      d.moveit(temp);
+    } else if constexpr (IsBorrow<R>) {
+      ass<"number of items to replace is not a multiple of replacement length">(
+          otherVec.size() <= d.capacity);
+      temp.resize(otherVec.size());
+      for (std::size_t i = 0; i < otherVec.size(); i++) {
+        if constexpr (is<DataTypeOtherVec, T>) {
+          temp[i] = otherVec[i];
+        } else {
+          temp[i] = static_cast<T>(otherVec[i]);
+        }
+      }
+      ass<"size cannot be increased above the size of the borrowed object">(
+          d.sz <= otherVec.size());
+      d.sz = otherVec.size();
+      for (std::size_t i = 0; i < otherVec.size(); i++)
+        d[i] = temp[i];
+    } else if constexpr (IsBorrowSEXP<R>) {
+      temp.resize(otherVec.size());
+      for (std::size_t i = 0; i < otherVec.size(); i++) {
+        if constexpr (is<DataTypeOtherVec, T>) {
+          temp[i] = otherVec[i];
+        } else {
+          temp[i] = static_cast<T>(otherVec[i]);
+        }
+      }
+      if (otherVec.size() > this->size())
+        d.resize(otherVec.size());
+
+      for (std::size_t i = 0; i < otherVec.size(); i++)
+        d[i] = temp[i];
+
+    } else if constexpr (IS<SubsetClassTrait,
+                            typename ReRef<R>::type::TypeTrait>) {
+      std::cout << "operator=" << std::endl;
+      // std::cout << d.size() << " " << otherVec.size() << std::endl;
+      ass<"number of items to replace is not a multiple of replacement length">(
+          otherVec.size() == d.size());
+      temp.resize(otherVec.size());
+      for (std::size_t i = 0; i < otherVec.size(); i++) {
+        if constexpr (is<DataTypeOtherVec, T>) {
+          temp[i] = otherVec[i];
+        } else {
+          temp[i] = static_cast<T>(otherVec[i]);
+        }
       }
-    }
-    if (otherVec.size() > this->size())
-      d.resize(otherVec.size());
-
-    for (std::size_t i = 0; i < otherVec.size(); i++)
-      d[i] = temp[i];
-
-  } else if constexpr (IsSubset<R>) {
-    ass<"number of items to replace is not a multiple of replacement length">(
-        otherVec.size() == d.ind.size());
-    temp.resize(otherVec.size());
-    for (std::size_t i = 0; i < otherVec.size(); i++) {
-      if constexpr (is<DataTypeOtherVec, T>) {
-        temp[i] = otherVec[i];
-      } else {
-        temp[i] = static_cast<T>(otherVec[i]);
+      for (std::size_t i = 0; i < d.size(); i++) {
+        d[i % d.size()] = temp[i];
       }
     }
-    for (std::size_t i = 0; i < d.ind.size(); i++) {
-      d[i % d.ind.size()] = temp[i];
+    if (otherVec.d.im()) {
+      d.setMatrix(true, otherVec.d.nr(), otherVec.d.nc());
     }
-  }
-  if (otherVec.d.im()) {
-    d.setMatrix(true, otherVec.d.nr(), otherVec.d.nc());
-  }
 
 #ifdef DERIV_ETR
-  if constexpr (IsRVec<const Vec<T2, R2, Trait2>> ||
-                Operation<decltype(otherVec.d)>) {
-    deriv.resize(this->size());
-    // for (std::size_t i = 0; i < deriv.size(); i++) {
-    //   deriv[i] = 0;
-    // }
-  } else {
-    // deriv.resize(otherVec.size());
-    // for (std::size_t i = 0; i < deriv.sz; i++) {
-    //   deriv[i] = otherVec.deriv[i];
-    // }
-  }
+    if constexpr (IsRVec<const Vec<T2, R2, Trait2>> ||
+                  Operation<decltype(otherVec.d)>) {
+      deriv.resize(this->size());
+      // for (std::size_t i = 0; i < deriv.size(); i++) {
+      //   deriv[i] = 0;
+      // }
+    } else {
+      // deriv.resize(otherVec.size());
+      // for (std::size_t i = 0; i < deriv.sz; i++) {
+      //   deriv[i] = otherVec.deriv[i];
+      // }
+    }
 #endif
 
-  return *this;
-}
+    return *this;
+  }
 
 #ifdef STANDALONE_ETR
 #else
-Vec &operator=(SEXP s) {
-  d.initSEXP(s);
+  Vec &operator=(SEXP s) {
+    d.initSEXP(s);
 #ifdef DERIV_ETR
-  deriv.resize(d.sz);
-  deriv.fill(0.0);
+    deriv.resize(d.sz);
+    deriv.fill(0.0);
 #endif
-  return *this;
-}
+    return *this;
+  }
 #endif
 
-
-
   RetType &operator[](std::size_t idx) { return d[idx]; }
   RetType operator[](std::size_t idx) const { return d[idx]; }
 
@@ -939,7 +943,6 @@ Vec &operator=(SEXP s) {
     return ret;
   }
 #endif
-
 };
 
 } // namespace etr