From ae933d43ab7c1a6274eb55e722c83dd552468d80 Mon Sep 17 00:00:00 2001
From: zhuxueling <zhuxueling8121@navinfo.com>
Date: Tue, 24 Sep 2024 15:35:33 +0800
Subject: [PATCH] big update.

---
 CMakeLists.txt                           |   9 +-
 benchmark/CMakeLists.txt                 |   7 -
 benchmark/logger/CMakeLists.txt          |   7 -
 benchmark/logger/glog.cc                 |  11 -
 benchmark/logger/main.cc                 |  29 ---
 benchmark/logger/sfc_log.cc              |  12 --
 benchmark/logger/spdlog.cc               |  12 --
 src/CMakeLists.txt                       |  10 +-
 src/sfc/alloc/alloc.h                    |  11 +-
 src/sfc/alloc/boxed.h                    |   2 +-
 src/sfc/alloc/rc.h                       |   4 +-
 src/sfc/alloc/vec.h                      |  14 +-
 src/sfc/backtrace/frame.cc               |   7 +-
 src/sfc/collections/btree.h              |  95 +++++++++
 src/sfc/collections/circbuf.h            |   2 +-
 src/sfc/collections/queue.h              |   1 -
 src/sfc/core.h                           |   8 +
 src/sfc/core/cmp.h                       |  21 +-
 src/sfc/core/fmt/builders.h              | 106 +++++-----
 src/sfc/core/fmt/fmter.h                 |  40 ++--
 src/sfc/core/fmt/num.cc                  |  22 +-
 src/sfc/core/fmt/num.h                   |  10 +-
 src/sfc/core/fmt/style.cc                |   4 +-
 src/sfc/core/fmt/style.h                 |   4 +-
 src/sfc/core/iter/zip.h                  |   8 +-
 src/sfc/core/mem.h                       |  31 ++-
 src/sfc/core/mod.h                       |  14 +-
 src/sfc/core/num/flt.cc                  |  12 +-
 src/sfc/core/num/int.cc                  |   2 +-
 src/sfc/core/ops/fn.h                    |  14 +-
 src/sfc/core/ops/range.h                 |   2 -
 src/sfc/core/option.h                    | 195 ++++++------------
 src/sfc/core/ptr.h                       | 150 +++++++-------
 src/sfc/core/reflect/enum.h              |   4 +-
 src/sfc/core/reflect/struct.h            |  12 +-
 src/sfc/core/reflect/type.h              |   4 +-
 src/sfc/core/result.h                    | 113 +++-------
 src/sfc/core/slice/mod.h                 |   8 +-
 src/sfc/core/str/mod.h                   |  32 ++-
 src/sfc/core/str/pattern.h               |   4 +-
 src/sfc/core/trait.h                     |  22 +-
 src/sfc/core/tuple.h                     | 129 +++++-------
 src/sfc/core/variant.h                   |  80 +++-----
 src/sfc/env/env.h                        |   2 +-
 src/sfc/io/buf.h                         |  68 ++++++
 src/sfc/io/mod.cc                        |   1 -
 src/sfc/log/backend.h                    |   8 +-
 src/sfc/log/logger.cc                    |   4 +-
 src/sfc/math.h                           |   2 +-
 src/sfc/math/{mod.h => funcs.h}          |   2 +-
 src/sfc/math/ndarray.h                   |   2 +-
 src/sfc/math/ndview.h                    |  66 +++---
 src/sfc/math/sintbl.h                    |   2 +-
 src/sfc/serde/base64.cc                  | 154 ++++++++++++++
 src/sfc/serde/base64.h                   |  12 +-
 src/sfc/serde/base64/base64.cc           | 156 --------------
 src/sfc/serde/base64/base64.h            |  13 --
 src/sfc/serde/des.h                      | 163 ++++++++++++++-
 src/sfc/serde/des/deserialize.h          | 102 ---------
 src/sfc/serde/des/deserializer.h         |  74 -------
 src/sfc/serde/{json/parse.cc => json.cc} |  13 +-
 src/sfc/serde/json.h                     | 129 +++++++++++-
 src/sfc/serde/json/fmt.cc                |   9 -
 src/sfc/serde/json/fmt.h                 | 120 -----------
 src/sfc/serde/json/parse.h               |  11 -
 src/sfc/serde/{mod.cc => node.cc}        |   2 +-
 src/sfc/serde/{mod.h => node.h}          |   3 +-
 src/sfc/serde/ser.h                      | 250 ++++++++++++++++++++++-
 src/sfc/serde/ser/serialize.h            | 199 ------------------
 src/sfc/serde/ser/serializer.h           |  62 ------
 test/core/tuple.cxx                      |   5 +
 test/core/variant.cxx                    |   9 +
 test/serde/ser.cxx                       |  24 +--
 73 files changed, 1393 insertions(+), 1558 deletions(-)
 delete mode 100644 benchmark/CMakeLists.txt
 delete mode 100644 benchmark/logger/CMakeLists.txt
 delete mode 100644 benchmark/logger/glog.cc
 delete mode 100644 benchmark/logger/main.cc
 delete mode 100644 benchmark/logger/sfc_log.cc
 delete mode 100644 benchmark/logger/spdlog.cc
 create mode 100644 src/sfc/collections/btree.h
 create mode 100644 src/sfc/io/buf.h
 rename src/sfc/math/{mod.h => funcs.h} (99%)
 create mode 100644 src/sfc/serde/base64.cc
 delete mode 100644 src/sfc/serde/base64/base64.cc
 delete mode 100644 src/sfc/serde/base64/base64.h
 delete mode 100644 src/sfc/serde/des/deserialize.h
 delete mode 100644 src/sfc/serde/des/deserializer.h
 rename src/sfc/serde/{json/parse.cc => json.cc} (96%)
 delete mode 100644 src/sfc/serde/json/fmt.cc
 delete mode 100644 src/sfc/serde/json/fmt.h
 delete mode 100644 src/sfc/serde/json/parse.h
 rename src/sfc/serde/{mod.cc => node.cc} (99%)
 rename src/sfc/serde/{mod.h => node.h} (97%)
 delete mode 100644 src/sfc/serde/ser/serialize.h
 delete mode 100644 src/sfc/serde/ser/serializer.h
 create mode 100644 test/core/tuple.cxx
 create mode 100644 test/core/variant.cxx

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 1943987..2055810 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -4,9 +4,10 @@ cmake_minimum_required(VERSION 3.21)
 project(sfc)
 
 add_compile_options(-Wall -Wextra -Wconversion)
+if(${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang")
+    add_compile_options(-stdlib=libc++)
+    add_link_options(-stdlib=libc++)
+endif()
+
 add_subdirectory(src)
 add_subdirectory(test)
-
-if(PROJECT_IS_TOP_LEVEL)
-    add_subdirectory(benchmark)
-endif()
diff --git a/benchmark/CMakeLists.txt b/benchmark/CMakeLists.txt
deleted file mode 100644
index 01568ca..0000000
--- a/benchmark/CMakeLists.txt
+++ /dev/null
@@ -1,7 +0,0 @@
-
-
-option(ENABLE_BENCHMARK "benchmark")
-
-if(ENABLE_BENCHMARK)
-    add_subdirectory(logger)
-endif()
diff --git a/benchmark/logger/CMakeLists.txt b/benchmark/logger/CMakeLists.txt
deleted file mode 100644
index 6eb770a..0000000
--- a/benchmark/logger/CMakeLists.txt
+++ /dev/null
@@ -1,7 +0,0 @@
-
-aux_source_directory(. SRC)
-add_executable(benchmark_log ${SRC})
-
-target_link_libraries(benchmark_log sfc)
-target_link_libraries(benchmark_log glog)
-target_link_libraries(benchmark_log fmt)
diff --git a/benchmark/logger/glog.cc b/benchmark/logger/glog.cc
deleted file mode 100644
index a473669..0000000
--- a/benchmark/logger/glog.cc
+++ /dev/null
@@ -1,11 +0,0 @@
-#define GLOG_USE_GLOG_EXPORT
-#include <glog/logging.h>
-
-void benchmark_glog(uint32_t count) {
-  google::InitGoogleLogging("glog");
-  google::SetLogDestination(google::GLOG_INFO, "./out/glog");
-
-  for (auto i = 0U; i < count; ++i) {
-    LOG(INFO) << "channel=" << "NIADS_COMMON_TEST_CHANNEL, " << "val=" << 1.234;
-  }
-}
diff --git a/benchmark/logger/main.cc b/benchmark/logger/main.cc
deleted file mode 100644
index b5d8f89..0000000
--- a/benchmark/logger/main.cc
+++ /dev/null
@@ -1,29 +0,0 @@
-#include "sfc/io.h"
-#include "sfc/time.h"
-
-using namespace sfc;
-
-void benchmark_sfc(u32 count);
-void benchmark_spd(u32 count);
-void benchmark_glog(u32 count);
-
-void show_time(auto s, auto&& f) {
-  const auto t = time::Instant::now();
-  f();
-  const auto d = t.elpased();
-  io::println("dur[{}]: {}", s, d.as_secs_f64());
-}
-
-int main(int argc, const char* argv[]) {
-  auto cnt = 1U;
-  if (argc == 2) {
-    cnt = Str{argv[1]}.parse<u32>().unwrap();
-  }
-  io::println("=== {} ===", cnt);
-
-  benchmark_sfc(cnt);
-  show_time("sfc", [&]() { benchmark_sfc(cnt); });
-  show_time("spd", [&]() { benchmark_spd(cnt); });
-  show_time("glog", [&]() { benchmark_glog(cnt); });
-  return 0;
-}
diff --git a/benchmark/logger/sfc_log.cc b/benchmark/logger/sfc_log.cc
deleted file mode 100644
index 185741b..0000000
--- a/benchmark/logger/sfc_log.cc
+++ /dev/null
@@ -1,12 +0,0 @@
-#include "sfc/log.h"
-
-using namespace sfc;
-
-void benchmark_sfc(u32 count) {
-  auto logger = log::Logger();
-  logger.add_file_backend("./out/sfc.log");
-
-  for (auto i = 0U; i < count; ++i) {
-    logger.write_fmt(log::Level::Info, "channel=NIADS_COMMON_TEST_CHANNEL, val=1.234");
-  }
-}
diff --git a/benchmark/logger/spdlog.cc b/benchmark/logger/spdlog.cc
deleted file mode 100644
index 105b2db..0000000
--- a/benchmark/logger/spdlog.cc
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <spdlog/sinks/basic_file_sink.h>
-#include <spdlog/spdlog.h>
-
-void benchmark_spd(uint32_t count) {
-  auto logger = spdlog::basic_logger_mt("spd", "out/spd.log");
-  spdlog::set_default_logger(logger);
-
-  spdlog::flush_on(spdlog::level::info);
-  for (auto i = 0U; i < count; ++i) {
-    spdlog::info("channel={}, val={}", "NIADS_COMMON_TEST_CHANNEL", 1.234);
-  }
-}
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index b633ccd..f9c41c5 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -5,15 +5,7 @@ set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 file(GLOB_RECURSE SRC CONFIGURE_DEPENDS "${CMAKE_CURRENT_LIST_DIR}/*.cc")
 
 add_library(sfc ${SRC})
-
-if("cxx_std_20" IN_LIST CMAKE_CXX_COMPILE_FEATURES)
-    target_compile_features(sfc PUBLIC cxx_std_20)
-else()
-    target_compile_features(sfc PUBLIC cxx_std_17)
-    if(${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU")
-        target_compile_options(sfc PUBLIC -fconcepts)
-    endif()
-endif()
+target_compile_features(sfc PUBLIC cxx_std_20)
 
 target_link_options(sfc PUBLIC -rdynamic)
 target_include_directories(sfc PUBLIC ${CMAKE_CURRENT_LIST_DIR})
diff --git a/src/sfc/alloc/alloc.h b/src/sfc/alloc/alloc.h
index 218c4d6..7b5f023 100644
--- a/src/sfc/alloc/alloc.h
+++ b/src/sfc/alloc/alloc.h
@@ -62,7 +62,7 @@ struct Global {
   template <class T>
   auto realloc_array(T* old_ptr, usize old_len, usize new_len) -> T* {
     const auto max_len = this->usable_size(old_ptr) / sizeof(T);
-    if (new_len <= max_len) {
+    if (new_len <= max_len || __is_trivially_copyable(T)) {
       const auto layout = Layout::array<T>(old_len);
       const auto new_ptr = this->realloc_imp(old_ptr, layout, new_len * sizeof(T));
       return static_cast<T*>(new_ptr);
@@ -70,16 +70,9 @@ struct Global {
 
     const auto new_ptr = this->alloc_array<T>(new_len);
     ptr::uninit_move(old_ptr, new_ptr, old_len);
-    ptr::drop_in_place(old_ptr, old_len);
+    ptr::drop(old_ptr, old_len);
     return new_ptr;
   }
-
-  template <trait::Copy T>
-  auto realloc_array(T* old_ptr, usize old_len, usize new_len) -> T* {
-    const auto m = Layout::array<T>(old_len);
-    const auto p = this->realloc_imp(old_ptr, m, new_len * sizeof(T));
-    return static_cast<T*>(p);
-  }
 };
 
 }  // namespace sfc::alloc
diff --git a/src/sfc/alloc/boxed.h b/src/sfc/alloc/boxed.h
index bbc1e39..86e0ec8 100644
--- a/src/sfc/alloc/boxed.h
+++ b/src/sfc/alloc/boxed.h
@@ -215,7 +215,7 @@ class Box<R(T...)> {
   auto operator()(T... args) -> R {
     assert_fmt(_ptr._self, "Box::(): deref null object.");
 
-    const auto p = static_cast<trait::Any*>(_ptr._self);
+    const auto p = static_cast<ops::Any*>(_ptr._self);
     const auto f = _ptr._meta->_call;
     (p->*f)(static_cast<T&&>(args)...);
   }
diff --git a/src/sfc/alloc/rc.h b/src/sfc/alloc/rc.h
index 472c06a..dde26f4 100644
--- a/src/sfc/alloc/rc.h
+++ b/src/sfc/alloc/rc.h
@@ -63,7 +63,9 @@ class Rc {
   Rc() noexcept = default;
 
   ~Rc() {
-    if (!_ptr) return;
+    if (!_ptr) {
+      return;
+    }
 
     if (_ptr->dec_strong() == 0) {
       mem::drop(*_ptr);
diff --git a/src/sfc/alloc/vec.h b/src/sfc/alloc/vec.h
index 1c4909c..d8affbd 100644
--- a/src/sfc/alloc/vec.h
+++ b/src/sfc/alloc/vec.h
@@ -170,11 +170,11 @@ class [[nodiscard]] Vec {
     return _len != 0;
   }
 
-  [[sfc_inline]] auto as_slice() const -> Slice<const T> {
+  [[sfc_inline]] auto as_slice() const -> slice::Slice<const T> {
     return {_buf._ptr, _len};
   }
 
-  [[sfc_inline]] auto as_mut_slice() -> Slice<T> {
+  [[sfc_inline]] auto as_mut_slice() -> slice::Slice<T> {
     return {_buf._ptr, _len};
   }
 
@@ -212,11 +212,11 @@ class [[nodiscard]] Vec {
     return _buf[idx];
   }
 
-  [[sfc_inline]] auto operator[](Range<> ids) const -> Slice<const T> {
+  [[sfc_inline]] auto operator[](Range<> ids) const -> slice::Slice<const T> {
     return this->as_slice()[ids];
   }
 
-  [[sfc_inline]] auto operator[](Range<> ids) -> Slice<T> {
+  [[sfc_inline]] auto operator[](Range<> ids) -> slice::Slice<T> {
     return this->as_mut_slice()[ids];
   }
 
@@ -261,7 +261,7 @@ class [[nodiscard]] Vec {
       return;
     }
 
-    ptr::drop_in_place(_buf._ptr + len, _len - len);
+    ptr::drop(_buf._ptr + len, _len - len);
     _len = len;
   }
 
@@ -398,12 +398,12 @@ class [[nodiscard]] Vec {
   }
 
  public:
-  using Iter = typename Slice<T>::Iter;
+  using Iter = typename slice::Iter<const T>;
   auto iter() const -> Iter {
     return this->as_slice().iter();
   }
 
-  using IterMut = typename Slice<T>::IterMut;
+  using IterMut = typename slice::Iter<T>;
   auto iter_mut() -> IterMut {
     return this->as_mut_slice().iter_mut();
   }
diff --git a/src/sfc/backtrace/frame.cc b/src/sfc/backtrace/frame.cc
index 4285f4f..2a35c64 100644
--- a/src/sfc/backtrace/frame.cc
+++ b/src/sfc/backtrace/frame.cc
@@ -20,12 +20,11 @@ static auto cxx_demangle(Str raw) -> String {
     return String{raw};
   }
 
-  auto ret = 0;
   char buf[MAX_LEN];
   auto len = sizeof(buf);
-  auto fun = __cxa_demangle(raw.as_ptr(), buf, &len, &ret);
-  auto res = String{fun ? fun : raw};
-  return res;
+  auto ret = 0;
+  auto res = __cxa_demangle(raw.as_ptr(), buf, &len, &ret);
+  return String{res ?: raw};
 }
 
 Frame::Frame(void* addr) : _addr{addr} {}
diff --git a/src/sfc/collections/btree.h b/src/sfc/collections/btree.h
new file mode 100644
index 0000000..daff91a
--- /dev/null
+++ b/src/sfc/collections/btree.h
@@ -0,0 +1,95 @@
+#pragma once
+
+#include "sfc/alloc.h"
+
+namespace sfc::collections::btree {
+
+template <class K, class V, usize B = 6>
+struct BTree {
+  struct Node;
+
+  struct Entry {};
+
+  Node* _root = nullptr;
+  usize _len = 0;
+
+ public:
+  BTree() {}
+
+  ~BTree() {
+    this->clear();
+  }
+
+  BTree(BTree&& other) noexcept : _root{other._root} {
+    other._root = nullptr;
+  }
+
+  auto len() const -> usize {
+    return _len;
+  }
+
+  void clear();
+
+  void append(BTree& other);
+
+  auto entry(K key) -> Entry;
+
+  auto get(const auto& key) const -> Option<const V&>;
+
+  auto get_mut(const auto& key) -> Option<V&>;
+
+  auto insert(K key, V value) -> Option<V>;
+
+  auto remove(const auto& key) -> Option<V>;
+};
+
+template <class K, class V, usize B>
+struct BTree<K, V, B>::Node {
+  static constexpr usize CAPACITY = 2 * B - 1;
+
+  Node* _parent = nullptr;
+  u16 _idx = 0;
+  u16 _len = 0;
+
+  mem::Uninit<K> _keys[CAPACITY];
+  mem::Uninit<V> _vals[CAPACITY];
+  Node* _edge[CAPACITY + 1];
+
+ public:
+ private:
+  auto search_for_insert(auto& key) -> Tuple<> {
+
+  }
+
+  auto split() -> Node* {
+    if (_parent == nullptr) {
+      _parent = new Node{};
+      _parent->_edge[0] = this;
+    }
+
+    auto lhs = this;
+    auto rhs = new Node{};
+    lhs._len = rhs._len = B - 1;
+    ptr::move(_keys, rhs._keys);
+    ptr::move(_vals, rhs._vals);
+    ptr::move(_edge, rhs._edge);
+    _parent->insert_fit(_idx + 1, mem::move(*&_keys[B - 1]), mem::move(*&_vals[B - 1]), rhs);
+
+    ptr::drop(_keys + B - 1, B);
+    ptr::drop(_vals + B - 1, B);
+  }
+
+  void insert_fit(usize idx, K key, V val, Node* node = nullptr) {
+    ptr::move(_keys + idx, _keys + idx + 1, _len - idx);
+    ptr::move(_vals + idx, _vals + idx + 1, _len - idx);
+    _keys[idx] = static_cast<K&&>(key);
+    _vals[idx] = static_cast<V&&>(val);
+
+    if (node != nullptr) {
+      ptr::move(_edge + idx + 1, _edge + idx + 2, _len - idx);
+      _edge[idx + 1] = node;
+    }
+  }
+};
+
+}  // namespace sfc::collections::btree
diff --git a/src/sfc/collections/circbuf.h b/src/sfc/collections/circbuf.h
index 49b6bbd..c7f7d38 100644
--- a/src/sfc/collections/circbuf.h
+++ b/src/sfc/collections/circbuf.h
@@ -6,7 +6,7 @@ namespace sfc::collections {
 
 template <class T>
 class CircBuf {
-  vec::Buf<T> _buf;
+  vec::Buf<T> _buf = {};
   usize _len = 0;
   usize _first = 0;  // begin of the buffer
   usize _last = 0;   // end of the buffer(behind the last element)
diff --git a/src/sfc/collections/queue.h b/src/sfc/collections/queue.h
index 112a40e..62614af 100644
--- a/src/sfc/collections/queue.h
+++ b/src/sfc/collections/queue.h
@@ -6,7 +6,6 @@ namespace sfc::collections {
 
 template <class T>
 class [[nodiscard]] Queue {
- protected:
   Vec<T> _vec;
   usize _pos = 0;
 
diff --git a/src/sfc/core.h b/src/sfc/core.h
index 6a4ea94..2727ff0 100644
--- a/src/sfc/core.h
+++ b/src/sfc/core.h
@@ -10,3 +10,11 @@
 #include "core/slice.h"
 #include "core/str.h"
 #include "core/variant.h"
+
+namespace sfc {
+using str::Str;
+using tuple::Tuple;
+using slice::Slice;
+using option::Option;
+using variant::Variant;
+}  // namespace sfc
diff --git a/src/sfc/core/cmp.h b/src/sfc/core/cmp.h
index 65ff454..f0bd29b 100644
--- a/src/sfc/core/cmp.h
+++ b/src/sfc/core/cmp.h
@@ -11,32 +11,29 @@ enum Ordering {
 };
 
 struct Lt {
-  template <class T>
-  [[sfc_inline]] auto operator()(const T& a, const T& b) const -> bool {
+  [[sfc_inline]] auto operator()(const auto& a, const auto& b) const -> bool {
     return a < b;
   }
 };
 
 struct Gt {
-  template <class T>
-  [[sfc_inline]] auto operator()(const T& a, const T& b) const -> bool {
-    return !(a < b);
+  [[sfc_inline]] auto operator()(const auto& a, const auto& b) const -> bool {
+    return a > b;
   }
 };
 
-template <class T>
-[[sfc_inline]] auto cmp(const T& a, const T& b) -> Ordering {
-  if (a == b) return Ordering::Equal;
+[[sfc_inline]] auto cmp(const auto& a, const auto& b) -> Ordering {
+  if (a == b) {
+    return Ordering::Equal;
+  }
   return a < b ? Ordering::Less : Ordering::Greater;
 }
 
-template <class T>
-[[sfc_inline]] constexpr auto min(const T& a, const T& b) -> const T& {
+[[sfc_inline]] constexpr auto min(const auto& a, const auto& b) -> auto {
   return a < b ? a : b;
 }
 
-template <class T>
-[[sfc_inline]] constexpr auto max(const T& a, const T& b) -> const T& {
+[[sfc_inline]] constexpr auto max(const auto& a, const auto& b) -> auto {
   return a < b ? b : a;
 }
 
diff --git a/src/sfc/core/fmt/builders.h b/src/sfc/core/fmt/builders.h
index 6a9beca..c94336d 100644
--- a/src/sfc/core/fmt/builders.h
+++ b/src/sfc/core/fmt/builders.h
@@ -6,120 +6,119 @@ namespace sfc::fmt {
 
 template <class W>
 class DebugTuple {
-  ptr::Unique<W> _fmt;
+  W& _fmt;
   usize _cnt = 0;
 
  public:
-  explicit DebugTuple(W& fmt) : _fmt{&fmt} {
-    _fmt->write_str("(");
+  explicit DebugTuple(W& fmt) : _fmt{fmt} {
+    _fmt.write_str("(");
   }
 
   ~DebugTuple() {
-    if (!_fmt) return;
-    _fmt->write_str(")");
+    _fmt.write_str(")");
   }
 
-  DebugTuple(DebugTuple&&) noexcept = default;
+  DebugTuple(const DebugTuple&) = delete;
 
   void entry(const auto& val) {
     if (_cnt != 0) {
-      _fmt->write_str(", ");
+      _fmt.write_str(", ");
     }
-    _fmt->write(val);
+    _fmt.write(val);
     _cnt += 1;
   }
 
-  void entries(auto iter) {
+  void entries(auto&& iter) {
     iter.for_each([&](auto&& val) { this->entrie(val); });
   }
 };
 
 template <class W>
 class DebugList {
-  ptr::Unique<W> _fmt;
+  W& _fmt;
   usize _cnt = 0;
 
  public:
-  explicit DebugList(W& fmt) : _fmt{&fmt}, _cnt{0} {
-    _fmt->write_str("[");
+  explicit DebugList(W& fmt) : _fmt{fmt} {
+    _fmt.write_str("[");
   }
 
   ~DebugList() {
-    if (!_fmt) return;
-    _fmt->write_str("]");
+    _fmt.write_str("]");
   }
 
-  DebugList(DebugList&&) noexcept = default;
+  DebugList(const DebugList&) noexcept = delete;
 
   void entry(const auto& val) {
     if (_cnt != 0) {
-      _fmt->write_str(", ");
+      _fmt.write_str(", ");
     }
-    _fmt->write(val);
+    _fmt.write(val);
     _cnt += 1;
   }
 
-  void entries(auto iter) {
+  void entries(auto&& iter) {
     iter.for_each([&](auto&& val) { this->entry(val); });
   }
 };
 
 template <class W>
 class DebugSet {
-  ptr::Unique<W> _fmt;
+  W& _fmt;
   usize _cnt = 0;
 
  public:
-  explicit DebugSet(W& fmt) : _fmt{&fmt}, _cnt{0} {
-    _fmt->write_str("{");
+  explicit DebugSet(W& fmt) : _fmt{fmt} {
+    _fmt.write_str("{");
   }
 
   ~DebugSet() {
-    if (!_fmt) return;
-    _fmt->write_str("}");
+    if (!_fmt) {
+      return;
+    }
+    _fmt.write_str("}");
   }
 
-  DebugSet(DebugSet&&) noexcept = default;
+  DebugSet(const DebugSet&) noexcept = delete;
 
   void entry(const auto& val) {
     if (_cnt != 0) {
-      _fmt->write_str(", ");
+      _fmt.write_str(", ");
     }
-    _fmt->write(val);
+    _fmt.write(val);
     _cnt += 1;
   }
 
-  void entries(auto iter) {
+  void entries(auto&& iter) {
     iter.for_each([&](auto&& val) { this->entrie(val); });
   }
 };
 
 template <class W>
 class DebugMap {
-  ptr::Unique<W> _fmt;
+  W& _fmt;
   usize _cnt = 0;
 
  public:
-  explicit DebugMap(W& fmt) : _fmt{&fmt} {
-    _fmt->write_str("{");
+  explicit DebugMap(W& fmt) : _fmt{fmt} {
+    _fmt.write_str("{");
   }
 
   ~DebugMap() {
-    if (!_fmt) return;
-    _fmt->write_str("}");
+    _fmt.write_str("}");
   }
 
-  DebugMap(DebugMap&&) noexcept = default;
+  DebugMap(const DebugMap&) noexcept = delete;
 
-  void entry(Str name, const auto& value) {
+  void entry(const auto& name, const auto& value) {
     if (_cnt != 0) {
-      _fmt->write_str(", ");
+      _fmt.write_str(", ");
     }
 
-    _fmt->write_str("\"");
-    _fmt->write_str(name);
-    _fmt->write_str("\": ");
-    _fmt->write(value);
+    _fmt.write_str("\"");
+    _fmt.write_str(name);
+    _fmt.write_str("\": ");
+    _fmt.write(value);
 
     _cnt += 1;
   }
@@ -133,29 +132,28 @@ class DebugMap {
 
 template <class W>
 class DebugStruct {
-  ptr::Unique<W> _fmt;
+  W& _fmt;
   usize _cnt = 0;
 
  public:
-  explicit DebugStruct(W& fmt) : _fmt{&fmt} {
-    _fmt->write_str("{");
+  explicit DebugStruct(W& fmt) : _fmt{fmt} {
+    _fmt.write_str("{");
   }
 
   ~DebugStruct() {
-    if (!_fmt) return;
-    _fmt->write_str("}");
+    _fmt.write_str("}");
   }
 
-  DebugStruct(DebugStruct&&) noexcept = default;
+  DebugStruct(DebugStruct&&) noexcept = delete;
 
-  void field(Str name, const auto& value) {
+  void field(const auto& name, const auto& value) {
     if (_cnt != 0) {
-      _fmt->write_str(", ");
+      _fmt.write_str(", ");
     }
 
-    _fmt->write_str(name);
-    _fmt->write_str(": ");
-    _fmt->write(value);
+    _fmt.write_str(name);
+    _fmt.write_str(": ");
+    _fmt.write(value);
 
     _cnt += 1;
   }
@@ -174,22 +172,22 @@ inline auto Fmter<W>::debug_tuple() {
 
 template <class W>
 inline auto Fmter<W>::debug_list() {
-  return DebugList<Fmter<W>>{*this};
+  return DebugList<Fmter>{*this};
 }
 
 template <class W>
 inline auto Fmter<W>::debug_set() {
-  return DebugSet<Fmter<W>>{*this};
+  return DebugSet<Fmter>{*this};
 }
 
 template <class W>
 inline auto Fmter<W>::debug_map() {
-  return DebugMap<Fmter<W>>{*this};
+  return DebugMap<Fmter>{*this};
 }
 
 template <class W>
 inline auto Fmter<W>::debug_struct() {
-  return DebugStruct<Fmter<W>>{*this};
+  return DebugStruct<Fmter>{*this};
 }
 
 }  // namespace sfc::fmt
diff --git a/src/sfc/core/fmt/fmter.h b/src/sfc/core/fmt/fmter.h
index 78d2e30..b6b4238 100644
--- a/src/sfc/core/fmt/fmter.h
+++ b/src/sfc/core/fmt/fmter.h
@@ -4,9 +4,6 @@
 
 namespace sfc::fmt {
 
-template <class T>
-concept XFmt = requires { &T::template fmt<int>; };
-
 template <class T>
 class IFmt {
   T _val;
@@ -22,11 +19,11 @@ class IFmt {
 
 template <class... T>
 struct Args {
-  Str _pats = {};
-  Tuple<const T*...> _args = {};
+  str::Str _pats = {};
+  tuple::Tuple<const T*...> _args = {};
 
  public:
-  Args(Str pats, const T&... args) noexcept : _pats{pats}, _args{&args...} {}
+  Args(const auto& pats, const T&... args) noexcept : _pats{pats}, _args{&args...} {}
 
   void fmt(auto& f) const {
     auto pats = _pats;
@@ -47,14 +44,11 @@ struct Args {
   }
 };
 
-#if __cplusplus >= 202002L
 template <class... T>
 Args(const auto&, const T&...) -> Args<T...>;
-#endif
 
 template <class W>
 class Fmter {
- protected:
   W& _out;
   Style _style = {};
 
@@ -69,12 +63,12 @@ class Fmter {
     _style = s;
   }
 
-  [[sfc_inline]] void write_str(Str s) {
+  [[sfc_inline]] void write_str(str::Str s) {
     _out.write_str(s);
   }
 
   [[sfc_inline]] void write_chr(char c) {
-    _out.write_str(Str{&c, 1});
+    _out.write_str(str::Str{&c, 1});
   }
 
   [[sfc_inline]] void write_chs(char c, usize n) {
@@ -86,7 +80,7 @@ class Fmter {
     }
   }
 
-  void pad(Str s) {
+  void pad(str::Str s) {
     const auto width = _style.width();
 
     // check first
@@ -117,7 +111,7 @@ class Fmter {
     }
   }
 
-  void pad_num(bool is_neg, Str body) {
+  void pad_num(bool is_neg, str::Str body) {
     const auto width = _style.width();
     const auto sign = _style.sign(is_neg);
     const auto fill = _style.fill();
@@ -151,17 +145,15 @@ class Fmter {
   }
 
   void write(const auto& val) {
-    trait::as<IFmt>(val).fmt(*this);
-  }
-
-  template <XFmt T>
-  void write(const T& val) {
-    val.fmt(*this);
+    if constexpr (requires { val.fmt(*this); }) {
+      val.fmt(*this);
+    } else {
+      trait::as<IFmt>(val).fmt(*this);
+    }
   }
 
-  template <class... T>
-  void write_fmt(Str fmts, const T&... args) {
-    Args<T...>{fmts, args...}.fmt(*this);
+  void write_fmt(str::Str fmts, const auto&... args) {
+    Args{fmts, args...}.fmt(*this);
   }
 
   auto debug_tuple();
@@ -172,8 +164,8 @@ class Fmter {
 };
 
 template <class W>
-void write(W& out, Str fmts, const auto&... args) {
-  Fmter<W>{out}.write_fmt(fmts, args...);
+void write(W& out, str::Str fmts, const auto&... args) {
+  Fmter{out}.write_fmt(fmts, args...);
 }
 
 }  // namespace sfc::fmt
diff --git a/src/sfc/core/fmt/num.cc b/src/sfc/core/fmt/num.cc
index 2390422..434ec18 100644
--- a/src/sfc/core/fmt/num.cc
+++ b/src/sfc/core/fmt/num.cc
@@ -5,16 +5,16 @@ namespace sfc::fmt {
 struct Int2Str {
   Style _style;
 
-  Slice<char> _buf;
+  slice::Slice<char> _buf;
   char* _ptr = _buf._ptr + _buf._len;
 
  public:
-  [[sfc_inline]] auto as_str() const -> Str {
+  [[sfc_inline]] auto as_str() const -> str::Str {
     const auto len = static_cast<usize>(_buf._ptr + _buf._len - _ptr);
     return {_ptr, len};
   }
 
-  [[sfc_inline]] auto operator()(auto val) -> Str {
+  [[sfc_inline]] auto operator()(auto val) -> str::Str {
     const auto uval = val > 0 ? val : 0 - val;
     const auto radix = this->radix();
     if (radix == 10) {
@@ -35,7 +35,7 @@ struct Int2Str {
     *--_ptr = c;
   }
 
-  [[sfc_inline]] void push_str(Str s) {
+  [[sfc_inline]] void push_str(str::Str s) {
     for (auto i = s._len; i != 0; --i) {
       this->push(s._ptr[i - 1]);
     }
@@ -53,7 +53,7 @@ struct Int2Str {
     }
   }
 
-  [[sfc_inline]] auto prefix() const -> Str {
+  [[sfc_inline]] auto prefix() const -> str::Str {
     if (!_style._prefix) {
       return {};
     }
@@ -126,15 +126,15 @@ struct Int2Str {
 struct Flt2Str {
   Style _style;
 
-  Slice<char> _buf;
+  slice::Slice<char> _buf;
   usize _len = 0U;
 
  public:
-  [[sfc_inline]] auto as_str() const -> Str {
+  [[sfc_inline]] auto as_str() const -> str::Str {
     return {_buf._ptr, _len};
   }
 
-  [[sfc_inline]] auto operator()(auto val) -> Str {
+  [[sfc_inline]] auto operator()(auto val) -> str::Str {
     static const auto DEFAULT_PREC = sizeof(val) == sizeof(f32) ? 4 : 6;
 
     const auto uval = num::fabs(val);
@@ -159,16 +159,16 @@ struct Flt2Str {
 };
 
 template <class T>
-auto Int<T>::to_str(const Style& style, Slice<char> sbuf) const -> Str {
+auto Int<T>::to_str(const Style& style, slice::Slice<char> sbuf) const -> str::Str {
   return Int2Str{style, sbuf}(_val);
 }
 
 template <class T>
-auto Flt<T>::to_str(const Style& style, Slice<char> sbuf) const -> Str {
+auto Flt<T>::to_str(const Style& style, slice::Slice<char> sbuf) const -> str::Str {
   return Flt2Str{style, sbuf}(_val);
 }
 
-auto Ptr::to_str(const Style& style, Slice<char> sbuf) const -> Str {
+auto Ptr::to_str(const Style& style, slice::Slice<char> sbuf) const -> str::Str {
   const auto uval = mem::bit_cast<u64>(_val);
 
   auto imp = Int2Str{style, sbuf};
diff --git a/src/sfc/core/fmt/num.h b/src/sfc/core/fmt/num.h
index 058aace..d6ba7c4 100644
--- a/src/sfc/core/fmt/num.h
+++ b/src/sfc/core/fmt/num.h
@@ -9,7 +9,7 @@ struct Int {
   T _val;
 
  public:
-  auto to_str(const Style& style, Slice<char> buf) const -> Str;
+  auto to_str(const Style& style, slice::Slice<char> buf) const -> str::Str;
 
   void fmt(auto& f) const {
     char buf[64 + 16];
@@ -24,7 +24,7 @@ struct Flt {
   T _val;
 
  public:
-  auto to_str(const Style& style, Slice<char> buf) const -> Str;
+  auto to_str(const Style& style, slice::Slice<char> buf) const -> str::Str;
 
   void fmt(auto& f) const {
     char buf[64 + 16];
@@ -38,7 +38,7 @@ struct Ptr {
   const void* _val;
 
  public:
-  auto to_str(const Style& style, Slice<char> buf) const -> Str;
+  auto to_str(const Style& style, slice::Slice<char> buf) const -> str::Str;
 
   void fmt(auto& f) const {
     char buf[64 + 16];
@@ -54,7 +54,7 @@ class IFmt<char> {
 
  public:
   void fmt(auto& f) const {
-    f.pad(Str{&_val, 1});
+    f.pad(str::Str{&_val, 1});
   }
 };
 
@@ -92,7 +92,7 @@ class IFmt<T[N]> {
 
  public:
   void fmt(auto& f) const {
-    const auto v = Slice<const T>{_val};
+    const auto v = slice::Slice<const T>{_val};
     f.debug_list().entries(v.iter());
   }
 };
diff --git a/src/sfc/core/fmt/style.cc b/src/sfc/core/fmt/style.cc
index c725446..b6f9f27 100644
--- a/src/sfc/core/fmt/style.cc
+++ b/src/sfc/core/fmt/style.cc
@@ -3,7 +3,7 @@
 namespace sfc::fmt {
 
 struct StyleParser {
-  Str _buf;
+  str::Str _buf;
 
  public:
   auto parse() -> Style {
@@ -71,7 +71,7 @@ struct StyleParser {
   }
 };
 
-auto Style::from_str(Str s) -> Option<Style> {
+auto Style::from_str(str::Str s) -> Option<Style> {
   if (s.is_empty()) {
     return Style{};
   }
diff --git a/src/sfc/core/fmt/style.h b/src/sfc/core/fmt/style.h
index 0cf577b..333afb2 100644
--- a/src/sfc/core/fmt/style.h
+++ b/src/sfc/core/fmt/style.h
@@ -21,7 +21,7 @@ struct Style {
   Style() = default;
 
   // [[fill]align][sign]['#'][0][width][.][precision][type]
-  static auto from_str(Str s) -> Option<Style>;
+  static auto from_str(str::Str s) -> Option<Style>;
 
   [[sfc_inline]] auto fill() const -> char {
     return _fill ?: ' ';
@@ -31,7 +31,7 @@ struct Style {
     return _align;
   }
 
-  [[sfc_inline]] auto sign(bool is_neg) const -> Str {
+  [[sfc_inline]] auto sign(bool is_neg) const -> str::Str {
     if (is_neg) return "-";
     if (_sign == '+') return "+";
     if (_sign == '-') return " ";
diff --git a/src/sfc/core/iter/zip.h b/src/sfc/core/iter/zip.h
index c4bdc1a..4942686 100644
--- a/src/sfc/core/iter/zip.h
+++ b/src/sfc/core/iter/zip.h
@@ -5,8 +5,8 @@
 namespace sfc::iter {
 
 template <class A, class B>
-struct Zip : Iterator<Zip<A, B>, Tuple<typename A::Item, typename B::Item>> {
-  using Item = Tuple<typename A::Item, typename B::Item>;
+struct Zip : Iterator<Zip<A, B>, tuple::Tuple<typename A::Item, typename B::Item>> {
+  using Item = tuple::Tuple<typename A::Item, typename B::Item>;
 
   A _a;
   B _b;
@@ -14,7 +14,7 @@ struct Zip : Iterator<Zip<A, B>, Tuple<typename A::Item, typename B::Item>> {
  public:
   Zip(A a, B b) : _a{static_cast<A&&>(a)}, _b{static_cast<B&&>(b)} {}
 
-  auto next() -> Option<Item> {
+  auto next() -> option::Option<Item> {
     auto a = _a.next();
     if (!a) return {};
     auto b = _b.next();
@@ -23,9 +23,7 @@ struct Zip : Iterator<Zip<A, B>, Tuple<typename A::Item, typename B::Item>> {
   }
 };
 
-#if __cplusplus >= 202002L
 template <class A, class B>
 Zip(A, B) -> Zip<A, B>;
-#endif
 
 }  // namespace sfc::iter
diff --git a/src/sfc/core/mem.h b/src/sfc/core/mem.h
index f24ed80..00a0ce4 100644
--- a/src/sfc/core/mem.h
+++ b/src/sfc/core/mem.h
@@ -6,16 +6,35 @@ namespace sfc::mem {
 
 struct inplace_t {};
 
+template <class T>
+union Uninit {
+  T _0;
+
+  [[sfc_inline]] Uninit() = default;
+  [[sfc_inline]] ~Uninit() = default;
+  [[sfc_inline]] Uninit(const Uninit&) = delete;
+
+  [[sfc_inline]] auto operator&() -> T* {
+    return &_0;
+  }
+
+  [[sfc_inline]] auto operator&() const -> const T* {
+    return &_0;
+  }
+
+  [[sfc_inline]] auto operator->() -> T* {
+    return &_0;
+  }
+
+  [[sfc_inline]] auto operator->() const -> const T* {
+    return &_0;
+  }
+};
+
 template <class T, class F>
 [[sfc_inline]] inline auto bit_cast(F f) -> T {
   static_assert(sizeof(T) == sizeof(F));
-#if __cplusplus >= 202002L
   return __builtin_bit_cast(T, f);
-#else
-  T res;
-  __builtin_memcpy(&res, &f, sizeof(T));
-  return res;
-#endif
 }
 
 template <class T>
diff --git a/src/sfc/core/mod.h b/src/sfc/core/mod.h
index 32a8774..ad7e6cd 100644
--- a/src/sfc/core/mod.h
+++ b/src/sfc/core/mod.h
@@ -2,18 +2,6 @@
 
 #define sfc_inline gnu::always_inline
 
-#if !defined(__clang__) && defined(__GNUC__)
-
-#if __GNUC__ <= 6
-#define concept concept bool
-#pragma GCC diagnostic ignored "-Wattributes"
-#endif
-
-#if __GNUC__ <= 9
-#define __is_same __is_same_as
-#endif
-#endif
-
 namespace sfc {
 
 using i8 = __INT8_TYPE__;
@@ -38,6 +26,6 @@ struct Dummy {};
 static constexpr Dummy _ = {};
 
 template <class T>
-auto declval() noexcept -> T&&;
+auto declval() -> T&&;
 
 }  // namespace sfc
diff --git a/src/sfc/core/num/flt.cc b/src/sfc/core/num/flt.cc
index fd89512..3835c3a 100644
--- a/src/sfc/core/num/flt.cc
+++ b/src/sfc/core/num/flt.cc
@@ -4,11 +4,11 @@
 namespace sfc::str {
 
 struct Str2Flt {
-  Slice<const char> _s;
+  slice::Slice<const char> _s;
 
  public:
   template <class T>
-  auto parse_flt() -> Option<T> {
+  auto parse_flt() -> option::Option<T> {
     const auto sign = T{this->extract_sign()};
     const auto nan_inf = this->extract_nan_inf(sign);
     if (nan_inf) {
@@ -40,7 +40,7 @@ struct Str2Flt {
   }
 
   template <class T>
-  auto extract_nan_inf(T sign) -> Option<T> {
+  auto extract_nan_inf(T sign) -> option::Option<T> {
     if (_s._len != 3) {
       return {};
     };
@@ -86,12 +86,12 @@ struct Str2Flt {
 };
 
 template <class T>
-auto Str::parse() const -> Option<T> {
+auto Str::parse() const -> option::Option<T> {
   auto imp = Str2Flt{{_ptr, _len}};
   return imp.parse_flt<T>();
 }
 
-template auto Str::parse<f32>() const -> Option<f32>;
-template auto Str::parse<f64>() const -> Option<f64>;
+template auto Str::parse<f32>() const -> option::Option<f32>;
+template auto Str::parse<f64>() const -> option::Option<f64>;
 
 }  // namespace sfc::str
diff --git a/src/sfc/core/num/int.cc b/src/sfc/core/num/int.cc
index c2dc19d..b9145f9 100644
--- a/src/sfc/core/num/int.cc
+++ b/src/sfc/core/num/int.cc
@@ -4,7 +4,7 @@
 namespace sfc::str {
 
 struct Str2Int {
-  Slice<const char> _s;
+  slice::Slice<const char> _s;
 
  public:
   template <trait::UInt T>
diff --git a/src/sfc/core/ops/fn.h b/src/sfc/core/ops/fn.h
index a83a94e..4c45113 100644
--- a/src/sfc/core/ops/fn.h
+++ b/src/sfc/core/ops/fn.h
@@ -4,14 +4,18 @@
 
 namespace sfc::ops {
 
+struct Any{
+  Any() = delete;
+};
+
 template <class X, class R, class... T>
-static auto fn(R (X::*f)(T...)) -> R (trait::Any::*)(T...) {
-  return reinterpret_cast<R (trait::Any::*)(T...)>(f);
+static auto fn(R (X::*f)(T...)) -> R (Any::*)(T...) {
+  return reinterpret_cast<R (Any::*)(T...)>(f);
 }
 
 template <class X, class R, class... T>
-static auto fn(R (X::*f)(T...) const) -> R (trait::Any::*)(T...) {
-  return reinterpret_cast<R (trait::Any::*)(T...)>(f);
+static auto fn(R (X::*f)(T...) const) -> R (Any::*)(T...) {
+  return reinterpret_cast<R (Any::*)(T...)>(f);
 }
 
 template <class F>
@@ -22,7 +26,7 @@ struct Fn<R(T...)> {
   struct Meta {
     usize _size;
     void (*_dtor)(void*);
-    R (trait::Any::*_call)(T...);
+    R (Any::*_call)(T...);
 
     template <class X>
     static auto of(const X*) -> const Meta& {
diff --git a/src/sfc/core/ops/range.h b/src/sfc/core/ops/range.h
index c942472..ae2f5f2 100644
--- a/src/sfc/core/ops/range.h
+++ b/src/sfc/core/ops/range.h
@@ -28,13 +28,11 @@ struct Range {
   }
 };
 
-#if __cplusplus >= 202002L
 template <class T>
 Range(T) -> Range<T>;
 
 template <class T>
 Range(T, T) -> Range<T>;
-#endif
 
 }  // namespace sfc::ops
 
diff --git a/src/sfc/core/option.h b/src/sfc/core/option.h
index 60250b6..627ba7a 100644
--- a/src/sfc/core/option.h
+++ b/src/sfc/core/option.h
@@ -8,12 +8,6 @@ namespace sfc::option {
 
 struct None {};
 
-template <class T>
-concept XBool = requires(const T& x) { T::operator bool; };
-
-template <class T>
-concept XCopy = trait::Copy<T> && !XBool<T>;
-
 namespace detail {
 
 template <class T>
@@ -26,24 +20,47 @@ class Option {
     [[sfc_inline]] ~Imp() noexcept {}
   };
 
-  bool _tag = false;
-  Imp _imp = {};
+  bool _tag;
+  Imp _imp;
 
  public:
-  [[sfc_inline]] Option() noexcept = default;
+  [[sfc_inline]] Option() noexcept : _tag{false}, _imp{} {}
 
-  [[sfc_inline]] Option(None) noexcept : _tag{false} {}
+  [[sfc_inline]] Option(None) noexcept : _tag{false}, _imp{} {}
 
   [[sfc_inline]] Option(T val) noexcept : _tag{true}, _imp{static_cast<T&&>(val)} {}
 
   [[sfc_inline]] ~Option() {
-    if (!_tag) return;
-    _imp._val.~T();
+    if (_tag) {
+      _imp._val.~T();
+      _tag = false;
+    }
+  }
+
+  [[sfc_inline]] ~Option()
+    requires(trait::TvDtor<T>)
+  = default;
+
+  [[sfc_inline]] Option(const Option& other) : _tag{other._tag} {
+    if (_tag) {
+      new (mem::inplace_t{}, &_imp._val) T{other._imp._val};
+    }
   }
 
   [[sfc_inline]] Option(Option&& other) noexcept : _tag{other._tag} {
-    if (!_tag) return;
-    new (mem::inplace_t{}, &_imp._val) T{static_cast<T&&>(other._imp._val)};
+    if (_tag) {
+      new (mem::inplace_t{}, &_imp._val) T{static_cast<T&&>(other._imp._val)};
+    }
+  }
+
+  [[sfc_inline]] auto operator=(const Option& other) noexcept -> Option& {
+    if (_tag == other._tag) {
+      if (_tag) _imp._val = other._imp._val;
+    } else {
+      _tag ? mem::drop(_imp._val) : ptr::write(&_imp._val, other._imp._val);
+      _tag = other._tag;
+    }
+    return *this;
   }
 
   [[sfc_inline]] auto operator=(Option&& other) noexcept -> Option& {
@@ -73,93 +90,62 @@ class Option {
   }
 };
 
-template <XBool T>
-class Option<T> {
-  T _val{};
+template <class T>
+class Option<T&> {
+  T* _ptr = nullptr;
 
  public:
   [[sfc_inline]] Option() = default;
 
-  [[sfc_inline]] Option(None) : _val{} {}
-
-  [[sfc_inline]] Option(T val) : _val{static_cast<T&&>(val)} {}
-
-  [[sfc_inline]] operator bool() const {
-    return static_cast<bool>(_val);
-  }
-
-  [[sfc_inline]] auto get_unchecked() const -> const T& {
-    return _val;
-  }
-
-  [[sfc_inline]] auto get_unchecked_mut() -> T& {
-    return _val;
-  }
-
-  [[sfc_inline]] auto unwrap_unchecked() -> T {
-    return static_cast<T&&>(_val);
-  }
-};
-
-template <XCopy T>
-class Option<T> {
-  union Imp {
-    T _val;
-    u8 _nil = {};
-  };
-
-  bool _tag = false;
-  Imp _imp = {};
-
- public:
-  [[sfc_inline]] Option() noexcept = default;
-
-  [[sfc_inline]] Option(None) noexcept : _tag{false} {}
+  [[sfc_inline]] ~Option() {}
 
-  [[sfc_inline]] Option(T val) noexcept : _tag{true}, _imp{static_cast<T&&>(val)} {}
+  [[sfc_inline]] Option(T& val) : _ptr{&val} {}
 
   [[sfc_inline]] operator bool() const {
-    return _tag;
+    return _ptr != nullptr;
   }
 
   [[sfc_inline]] auto get_unchecked() const -> const T& {
-    return _imp._val;
+    return *_ptr;
   }
 
   [[sfc_inline]] auto get_unchecked_mut() -> T& {
-    return _imp._val;
+    return *_ptr;
   }
 
-  [[sfc_inline]] auto unwrap_unchecked() -> T {
-    return _imp._val;
+  [[sfc_inline]] auto unwrap_unchecked() -> T& {
+    return *_ptr;
   }
 };
 
 template <class T>
-class Option<T&> {
-  T* _ptr = nullptr;
+concept iBool = requires(const T& val) { val.operator bool(); };
+
+template <iBool T>
+class Option<T> {
+  T _val{};
 
  public:
   [[sfc_inline]] Option() = default;
 
-  [[sfc_inline]] ~Option() {}
+  [[sfc_inline]] Option(None) : _val{} {}
 
-  [[sfc_inline]] Option(T& val) : _ptr{&val} {}
+  [[sfc_inline]] Option(T val) : _val{static_cast<T&&>(val)} {}
 
   [[sfc_inline]] operator bool() const {
-    return _ptr != nullptr;
+    return static_cast<bool>(_val);
   }
 
   [[sfc_inline]] auto get_unchecked() const -> const T& {
-    return *_ptr;
+    return _val;
   }
 
   [[sfc_inline]] auto get_unchecked_mut() -> T& {
-    return *_ptr;
+    return _val;
   }
 
-  [[sfc_inline]] auto unwrap_unchecked() -> T& {
-    return *_ptr;
+  [[sfc_inline]] auto unwrap_unchecked() -> T {
+    return static_cast<T&&>(_val);
   }
 };
 
@@ -176,6 +162,8 @@ class Option : detail::Option<T> {
 
   [[sfc_inline]] ~Option() = default;
 
+  [[sfc_inline]] Option(const Option&) noexcept = default;
+
   [[sfc_inline]] Option(Option&&) noexcept = default;
 
   [[sfc_inline]] Option& operator=(Option&&) noexcept = default;
@@ -244,83 +232,14 @@ class Option : detail::Option<T> {
     return Imp::get_unchecked() == rhs;
   }
 
-  auto map(auto pred) && -> Option<decltype(pred(declval<T>()))> {
+  auto map(auto&& pred) && -> Option<decltype(pred(declval<T>()))> {
     if (!*this) {
       return {};
     }
     return pred(static_cast<T&&>(Imp::get_unchecked_mut()));
   }
 
-  void fmt(auto& f) const {
-    if (!*this) {
-      f.write_str("None()");
-    } else {
-      f.write_fmt("Some({})", Imp::get_unchecked());
-    }
-  }
-};
-
-template <trait::Copy T>
-class Option<T> : detail::Option<T> {
-  using Imp = detail::Option<T>;
-
- public:
-  using Imp::Imp;
-
-  [[sfc_inline]] Option() = default;
-
-  using Imp::operator bool;
-
-  using Imp::get_unchecked;
-  using Imp::get_unchecked_mut;
-
-  using Imp::unwrap_unchecked;
-
-  auto operator*() const -> const T& {
-    assert_fmt(*this, "Option::operator*: None.");
-    return Imp::get_unchecked();
-  }
-
-  auto operator*() -> T& {
-    assert_fmt(*this, "Option::operator*: None.");
-    return Imp::get_unchecked_mut();
-  }
-
-  auto unwrap() const -> T {
-    assert_fmt(bool(*this), "Option::unwrap: None.");
-    return Imp::get_unchecked();
-  }
-
-  auto unwrap_or(T default_val) const -> T {
-    if (!*this) {
-      return default_val;
-    }
-
-    return Imp::get_unchecked();
-  }
-
-  auto expect(const auto&... msg) const -> T {
-    if (!*this) {
-      panic_fmt(msg...);
-    }
-    return Imp::get_unchecked();
-  }
-
-  auto operator==(const Option& other) const -> bool {
-    if (!*this) return !other;
-    if (!other) return false;
-
-    return Imp::get_unchecked() == other.get_unchecked();
-  }
-
-  auto operator==(const T& rhs) const -> bool {
-    if (!*this) {
-      return false;
-    }
-    return Imp::get_unchecked() == rhs;
-  }
-
-  auto map(auto pred) const -> Option<decltype(pred(declval<T>()))> {
+  auto map(auto pred) const -> Option<decltype(pred(declval<const T&>()))> {
     if (!*this) {
       return {};
     }
diff --git a/src/sfc/core/ptr.h b/src/sfc/core/ptr.h
index 07c7928..fe518a3 100644
--- a/src/sfc/core/ptr.h
+++ b/src/sfc/core/ptr.h
@@ -2,10 +2,6 @@
 
 #include "mem.h"
 
-#if __cplusplus < 202002L
-#define constexpr
-#endif
-
 namespace sfc::ptr {
 
 template <class T>
@@ -64,21 +60,17 @@ struct Unique {
 
 template <class T, class F>
 auto cast(F* p) -> T* {
-#if __cplusplus >= 202002L
   if constexpr (__is_constructible(T*, F*)) {
     return static_cast<T*>(p);
   }
-#endif
   return reinterpret_cast<T*>(p);
 }
 
 template <class T, class F>
 auto cast(const F* p) -> const T* {
-#if __cplusplus >= 202002L
   if constexpr (__is_constructible(const T*, F*)) {
     return static_cast<const T*>(p);
   }
-#endif
   return reinterpret_cast<const T*>(p);
 }
 
@@ -94,108 +86,112 @@ template <class T>
 
 template <class T>
 [[sfc_inline]] inline void write_bytes(T* dst, u8 val, usize cnt) {
-  if (cnt == 0) return;
+  if (cnt == 0) {
+    return;
+  }
   __builtin_memset(dst, val, cnt * sizeof(T));
 }
 
 template <class T>
-[[sfc_inline]] inline void drop_in_place(T* ptr, usize cnt) {
-  for (const auto end = ptr + cnt; ptr != end; ++ptr) {
-    ptr->~T();
+[[sfc_inline]] inline void drop([[maybe_unused]] T* ptr, [[maybe_unused]] usize cnt) {
+  if constexpr (__is_trivially_copyable(T)) {
+    (void)ptr;
+    (void)cnt;
+  } else {
+    for (const auto end = ptr + cnt; ptr != end; ++ptr) {
+      ptr->~T();
+    }
   }
 }
 
-template <trait::Copy T>
-[[sfc_inline]] inline void drop_in_place(T* ptr, usize cnt) {
-  (void)ptr;
-  (void)cnt;
-}
-
 template <class T>
 [[sfc_inline]] inline void copy(const T* src, T* dst, usize cnt) {
-  if (dst < src) {
-    for (const auto end = src + cnt; src != end; ++src, ++dst) {
-      *dst = *src;
-    }
-  } else if (dst > src) {
-    src += cnt - 1;
-    dst += cnt - 1;
-    for (const auto end = src - cnt; src != end; --src, --dst) {
-      *dst = *src;
+  if (cnt == 0) {
+    return;
+  }
+
+  if constexpr (__is_trivially_copyable(T)) {
+    __builtin_memmove(dst, src, cnt * sizeof(T));
+  } else {
+    if (dst < src) {
+      for (const auto end = src + cnt; src != end; ++src, ++dst) {
+        *dst = *src;
+      }
+    } else if (dst > src) {
+      src += cnt - 1;
+      dst += cnt - 1;
+      for (const auto end = src - cnt; src != end; --src, --dst) {
+        *dst = *src;
+      }
     }
   }
 }
 
-template <trait::Copy T>
-[[sfc_inline]] inline void copy(T* src, T* dst, usize cnt) {
-  if (cnt == 0) return;
-  __builtin_memcpy(dst, src, cnt * sizeof(T));
-}
 
 template <class T>
-[[sfc_inline]] inline void move(T* src, T* dst, usize cnt) {
-  if (cnt == 0 || src == dst) return;
-
-  if (dst < src) {
+[[sfc_inline]] inline void copy_nonoverlapping(const T* src, T* dst, usize cnt) {
+  if (cnt == 0) {
+    return;
+  }
+  if constexpr (__is_trivially_copyable(T)) {
+    __builtin_memcpy(dst, src, cnt * sizeof(T));
+  } else {
     for (const auto end = src + cnt; src != end; ++src, ++dst) {
-      *dst = static_cast<T&&>(*src);
-    }
-  } else if (dst > src) {
-    src += cnt - 1;
-    dst += cnt - 1;
-    for (const auto end = src - cnt; src != end; --src, --dst) {
-      *dst = static_cast<T&&>(*src);
+      *dst = *src;
     }
   }
 }
 
-template <trait::Copy T>
-[[sfc_inline]] inline void move(T* src, T* dst, usize cnt) {
-  if (cnt == 0) return;
-  __builtin_memmove(dst, src, cnt * sizeof(T));
-}
-
 template <class T>
-[[sfc_inline]] inline void copy_nonoverlapping(const T* src, T* dst, usize cnt) {
-  for (const auto end = src + cnt; src != end; ++src, ++dst) {
-    *dst = *src;
+[[sfc_inline]] inline void move(T* src, T* dst, usize cnt) {
+  if (cnt == 0) {
+    return;
+  }
+
+  if constexpr (__is_trivially_copyable(T)) {
+    __builtin_memmove(dst, src, cnt * sizeof(T));
+  } else {
+    if (dst < src) {
+      for (const auto end = src + cnt; src != end; ++src, ++dst) {
+        *dst = static_cast<T&&>(*src);
+      }
+    } else if (dst > src) {
+      src += cnt - 1;
+      dst += cnt - 1;
+      for (const auto end = src - cnt; src != end; --src, --dst) {
+        *dst = static_cast<T&&>(*src);
+      }
+    }
   }
 }
 
-template <trait::Copy T>
-[[sfc_inline]] inline void copy_nonoverlapping(const T* src, T* dst, usize cnt) {
-  if (cnt == 0) return;
-  __builtin_memcpy(dst, src, cnt * sizeof(T));
-}
-
 template <class T>
 [[sfc_inline]] inline void uninit_move(T* src, T* dst, usize cnt) {
-  for (const auto end = src + cnt; src != end; ++src, ++dst) {
-    new (mem::inplace_t{}, dst) T{static_cast<T&&>(*src)};
+  if (cnt == 0) {
+    return;
+  }
+  if constexpr (__is_trivially_copyable(T)) {
+    __builtin_memcpy(dst, src, sizeof(T) * cnt);
+  } else {
+    for (const auto end = src + cnt; src != end; ++src, ++dst) {
+      new (mem::inplace_t{}, dst) T{static_cast<T&&>(*src)};
+    }
   }
-}
-
-template <trait::Copy T>
-[[sfc_inline]] inline void uninit_move(T* src, T* dst, usize cnt) {
-  if (cnt == 0) return;
-  __builtin_memcpy(dst, src, sizeof(T) * cnt);
 }
 
 template <class T>
 [[sfc_inline]] inline void uninit_copy(const T* src, T* dst, usize cnt) {
-  for (const auto end = src + cnt; src != end; ++src, ++dst) {
-    new (mem::inplace_t{}, dst) T{src->clone()};
+  if (cnt == 0) {
+    return;
   }
-}
 
-template <trait::Copy T>
-[[sfc_inline]] inline void uninit_copy(const T* src, T* dst, usize cnt) {
-  if (cnt == 0) return;
-  __builtin_memcpy(dst, src, sizeof(T) * cnt);
+  if constexpr (__is_trivially_copyable(T)) {
+    __builtin_memcpy(dst, src, sizeof(T) * cnt);
+  } else {
+    for (const auto end = src + cnt; src != end; ++src, ++dst) {
+      new (mem::inplace_t{}, dst) T{src->clone()};
+    }
+  }
 }
 
 }  // namespace sfc::ptr
-
-#ifdef constexpr
-#undef constexpr
-#endif
diff --git a/src/sfc/core/reflect/enum.h b/src/sfc/core/reflect/enum.h
index 62be58b..817b1ae 100644
--- a/src/sfc/core/reflect/enum.h
+++ b/src/sfc/core/reflect/enum.h
@@ -25,7 +25,7 @@ struct EnumInfo {
     return nullptr;
   }
 
-  auto get_value_by_name(str::Str name) const -> Option<T> {
+  auto get_value_by_name(str::Str name) const -> option::Option<T> {
     for (const auto& item : _items) {
       if (name == str::Str{item.name}) {
         return item.value;
@@ -42,7 +42,7 @@ auto enum_name(T val) -> cstr_t {
 }
 
 template <class T>
-auto enum_from_name(Str name) -> Option<T> {
+auto enum_from_name(str::Str name) -> Option<T> {
   const auto info = reflect_enum(static_cast<T>(0));
   return info.get_value_by_name(name);
 }
diff --git a/src/sfc/core/reflect/struct.h b/src/sfc/core/reflect/struct.h
index 5621fff..bd77776 100644
--- a/src/sfc/core/reflect/struct.h
+++ b/src/sfc/core/reflect/struct.h
@@ -7,23 +7,21 @@ namespace sfc::reflect {
 
 template <class T>
 struct Field {
-  Str name;
+  str::Str name;
   T& value;
 };
 
-#if __cplusplus >= 202002L
 template <class T>
-Field(Str, T&) -> Field<T>;
-#endif
+Field(str::Str, T&) -> Field<T>;
 
 template <class T>
-auto make_field(Str name, T& val) -> Field<T> {
+auto make_field(str::Str name, T& val) -> Field<T> {
   return {name, val};
 }
 
 template <class... U>
 class StructInfo {
-  using Fields = Tuple<Field<const U>...>;
+  using Fields = tuple::Tuple<Field<const U>...>;
   Fields _fields;
 
  public:
@@ -38,10 +36,8 @@ class StructInfo {
   }
 };
 
-#if __cplusplus >= 202002L
 template <class... U>
 StructInfo(Field<const U>...) -> StructInfo<U...>;
-#endif
 
 template <class T>
 concept iReflect = requires(const T& x) { reflect_struct(x); };
diff --git a/src/sfc/core/reflect/type.h b/src/sfc/core/reflect/type.h
index a52ebc6..d7381f2 100644
--- a/src/sfc/core/reflect/type.h
+++ b/src/sfc/core/reflect/type.h
@@ -11,7 +11,7 @@ auto type_id() -> usize {
 }
 
 template <class T>
-auto type_name() -> Str {
+auto type_name() -> str::Str {
 #if defined(__clang__)
   const auto PREFIX = sizeof("Str sfc::reflect::type_name() [T = ") - 1;
   const auto SUFFIX = sizeof("]") - 1;
@@ -24,7 +24,7 @@ auto type_name() -> Str {
 #endif
   const auto fun = __PRETTY_FUNCTION__;
   const auto len = sizeof(__PRETTY_FUNCTION__) - 1 - PREFIX - SUFFIX;
-  return Str{fun + PREFIX, len};
+  return str::Str{fun + PREFIX, len};
 }
 
 }  // namespace sfc::reflect
diff --git a/src/sfc/core/result.h b/src/sfc/core/result.h
index ae5da77..57e6578 100644
--- a/src/sfc/core/result.h
+++ b/src/sfc/core/result.h
@@ -4,9 +4,6 @@
 
 namespace sfc::result {
 
-template <class T>
-concept XBool = requires(const T& x) { T::operator bool; };
-
 namespace detail {
 
 template <class T, class E>
@@ -36,6 +33,10 @@ class Result {
     }
   }
 
+  [[sfc_inline]] Result(const Result&)
+    requires(trait::TvCopy<T, E>)
+  = default;
+
   [[sfc_inline]] Result(Result&& other) noexcept : _tag{other._tag} {
     if (_tag) {
       new (mem::inplace_t{}, &_imp._ok) T{static_cast<T&&>(other._imp._ok)};
@@ -44,6 +45,18 @@ class Result {
     }
   }
 
+  [[sfc_inline]] Result& operator=(const Result& other) {
+    if (_tag == other._tag) {
+      _tag ? _imp._ok = other._imp._ok : _imp._err = other._err;
+    } else {
+      _tag ? _imp._ok.~T() : _imp._err.~E();
+      _tag = other._tag;
+      _tag ? new (mem::inplace_t{}, &_imp._ok) T{other._imp._ok}
+           : new (mem::inplace_t{}, &_imp._err) E{other._imp._err};
+    }
+    return *this;
+  }
+
   [[sfc_inline]] Result& operator=(Result&& other) noexcept {
     if (_tag == other._tag) {
       _tag ? _imp._ok = static_cast<T&&>(other._imp._ok) : _imp._err = static_cast<E&&>(other._er);
@@ -77,42 +90,6 @@ class Result {
   }
 };
 
-template <trait::Copy T, trait::Copy E>
-class Result<T, E> {
- protected:
-  union Imp {
-    T _ok;
-    E _err;
-  };
-  bool _tag;
-  Imp _imp;
-
- public:
-  [[sfc_inline]] Result(T ok) : _tag{true}, _imp{._ok = ok} {}
-
-  [[sfc_inline]] Result(E err) : _tag{false}, _imp{._err = err} {}
-
-  [[sfc_inline]] operator bool() const {
-    return _tag;
-  }
-
-  [[sfc_inline]] auto get_ok_unchecked() const -> const T& {
-    return _imp._ok;
-  }
-
-  [[sfc_inline]] auto get_ok_unchecked_mut() -> T& {
-    return _imp._ok;
-  }
-
-  [[sfc_inline]] auto get_err_unchecked() const -> const E& {
-    return _imp._err;
-  }
-
-  [[sfc_inline]] auto get_err_unchecked_mut() -> E& {
-    return _imp._err;
-  }
-};
-
 }  // namespace detail
 
 template <class T, class E>
@@ -126,6 +103,8 @@ class Result : detail::Result<T, E> {
 
   [[sfc_inline]] ~Result() = default;
 
+  [[sfc_inline]] Result(const Result&) = default;
+
   [[sfc_inline]] Result(Result&&) noexcept = default;
 
   [[sfc_inline]] Result& operator=(Result&&) noexcept = default;
@@ -149,61 +128,37 @@ class Result : detail::Result<T, E> {
     return static_cast<T&&>(Imp::get_ok_unchecked_mut());
   }
 
+  auto ok() const& -> Option<T> {
+    if (!_tag) return {};
+    return Imp::get_ok_unchecked();
+  }
+
   auto err() && -> Option<E> {
     if (_tag) return {};
     return static_cast<E&&>(Imp::get_err_unchecked_mut());
   }
 
+  auto err() const& -> Option<E> {
+    if (_tag) return {};
+    return Imp::get_err_unchecked();
+  }
+
   auto unwrap() && -> T {
     assert_fmt(_tag, "Result::unwrap: Err({})", _imp._err);
     return static_cast<T&&>(Imp::get_ok_unchecked_mut());
   }
 
-  auto unwrap_err() && -> E {
-    assert_fmt(!_tag, "Option::unwrap_err: Ok({})", _imp._ok);
-    return static_cast<E&&>(Imp::get_err_unchecked_mut());
-  }
-};
-
-template <trait::Copy T, class E>
-class Result<T, E> : detail::Result<T, E> {
-  using Imp = detail::Result<T, E>;
-  using Imp::_tag;
-  using Imp::_imp;
-
- public:
-  using Imp::Imp;
-
-  using Imp::get_ok_unchecked;
-  using Imp::get_ok_unchecked_mut;
-
-  using Imp::get_err_unchecked;
-  using Imp::get_err_unchecked_mut;
-
-  [[sfc_inline]] auto is_ok() const -> bool {
-    return _tag;
-  }
-
-  [[sfc_inline]] auto is_err() const -> bool {
-    return !_tag;
-  }
-
-  auto ok() const -> Option<T> {
-    if (!_tag) return {};
+  auto unwrap() const& -> T {
+    assert_fmt(_tag, "Result::unwrap: Err({})", _imp._err);
     return Imp::get_ok_unchecked();
   }
 
-  auto err() const -> Option<E> {
-    if (_tag) return {};
-    return Imp::get_err_unchecked();
-  }
-
-  auto unwrap() const -> T {
-    assert_fmt(_tag, "Result::unwrap: Err({})", _imp._err);
-    return Imp::get_ok_unchecked();
+  auto unwrap_err() && -> E {
+    assert_fmt(!_tag, "Option::unwrap_err: Ok({})", _imp._ok);
+    return static_cast<E&&>(Imp::get_err_unchecked_mut());
   }
 
-  auto unwrap_err() const -> E {
+  auto unwrap_err() const& -> E {
     assert_fmt(!_tag, "Option::unwrap_err: Ok({})", _imp._ok);
     return Imp::get_err_unchecked();
   }
diff --git a/src/sfc/core/slice/mod.h b/src/sfc/core/slice/mod.h
index 68a52fb..769f0d3 100644
--- a/src/sfc/core/slice/mod.h
+++ b/src/sfc/core/slice/mod.h
@@ -84,12 +84,12 @@ struct Slice {
     return {_ptr + ids._start, ids.len()};
   }
 
-  [[sfc_inline]] auto split_at(usize idx) const -> Tuple<Slice<const T>, Slice<const T>> {
+  [[sfc_inline]] auto split_at(usize idx) const -> tuple::Tuple<Slice<const T>, Slice<const T>> {
     idx = cmp::min(idx, _len);
     return {this->get_unchecked({0, idx}), this->get_unchecked({idx, _len})};
   }
 
-  [[sfc_inline]] auto split_at_mut(usize idx) -> Tuple<Slice, Slice> {
+  [[sfc_inline]] auto split_at_mut(usize idx) -> tuple::Tuple<Slice, Slice> {
     idx = cmp::min(idx, _len);
     return {this->get_unchecked_mut({0, idx}), this->get_unchecked_mut({idx, _len})};
   }
@@ -205,7 +205,3 @@ struct Slice {
 };
 
 }  // namespace sfc::slice
-
-namespace sfc {
-using slice::Slice;
-}  // namespace sfc
diff --git a/src/sfc/core/str/mod.h b/src/sfc/core/str/mod.h
index 07035d4..31323f2 100644
--- a/src/sfc/core/str/mod.h
+++ b/src/sfc/core/str/mod.h
@@ -5,11 +5,8 @@
 
 namespace sfc::str {
 
-template <class T>
-concept XFromStr = requires() { T::from_str; };
-
-struct Str : private Slice<const char> {
-  using Inn = Slice<const char>;
+struct Str : private slice::Slice<const char> {
+  using Inn = slice::Slice<const char>;
   using Inn::_len;
   using Inn::_ptr;
 
@@ -34,11 +31,11 @@ struct Str : private Slice<const char> {
   using Inn::len;
   using Inn::operator bool;
 
-  [[sfc_inline]] auto as_chars() const -> Slice<const char> {
+  [[sfc_inline]] auto as_chars() const -> slice::Slice<const char> {
     return {_ptr, _len};
   }
 
-  [[sfc_inline]] auto as_bytes() const -> Slice<const u8> {
+  [[sfc_inline]] auto as_bytes() const -> slice::Slice<const u8> {
     return {static_cast<const u8*>(static_cast<const void*>(_ptr)), _len};
   }
 
@@ -48,7 +45,7 @@ struct Str : private Slice<const char> {
   }
 
   [[sfc_inline]] auto get_unchecked(Range<> ids) const -> Str {
-    return {_ptr+ids._start, ids.len()};
+    return {_ptr + ids._start, ids.len()};
   }
 
   [[sfc_inline]] auto operator[](usize idx) const -> char {
@@ -60,7 +57,7 @@ struct Str : private Slice<const char> {
     return Str{_ptr + ids._start, ids.len()};
   }
 
-  [[sfc_inline]] auto split_at(usize mid) const -> Tuple<Str, Str> {
+  [[sfc_inline]] auto split_at(usize mid) const -> tuple::Tuple<Str, Str> {
     const auto pos = cmp::min(mid, _len);
     const auto a = Str{_ptr, pos};
     const auto b = Str{_ptr + mid, _len - mid};
@@ -80,8 +77,8 @@ struct Str : private Slice<const char> {
   }
 
  public:
-  auto find(auto&& p) const -> Option<usize>;
-  auto rfind(auto&& p) const -> Option<usize>;
+  auto find(auto&& p) const -> option::Option<usize>;
+  auto rfind(auto&& p) const -> option::Option<usize>;
 
   auto contains(auto&& p) const -> bool;
   auto starts_with(auto&& p) const -> bool;
@@ -105,10 +102,13 @@ struct Str : private Slice<const char> {
 
  public:
   template <class T>
-  auto parse() const -> Option<T>;
+  auto parse() const -> option::Option<T>;
+
+  template <class T>
 
-  template <XFromStr T>
-  auto parse() const -> option::Option<T> {
+  auto parse() const -> option::Option<T>
+    requires(requires() { T::from_str(*this); })
+  {
     return T::from_str(*this);
   }
 
@@ -118,7 +118,3 @@ struct Str : private Slice<const char> {
 };
 
 }  // namespace sfc::str
-
-namespace sfc {
-using str::Str;
-}  // namespace sfc
diff --git a/src/sfc/core/str/pattern.h b/src/sfc/core/str/pattern.h
index 99a96ed..ecd3faf 100644
--- a/src/sfc/core/str/pattern.h
+++ b/src/sfc/core/str/pattern.h
@@ -178,14 +178,12 @@ struct Pattern<Str> {
   }
 };
 
-#if __cplusplus >= 202002L
 template <class P>
 Pattern(P) -> Pattern<P>;
 
 Pattern(char) -> Pattern<char>;
-Pattern(Str) -> Pattern<Str>;
 Pattern(const char*) -> Pattern<Str>;
-#endif
+Pattern(Str) -> Pattern<Str>;
 
 template <class P>
 auto make_pattern(P p) -> Pattern<P> {
diff --git a/src/sfc/core/trait.h b/src/sfc/core/trait.h
index c94b900..0ae59c9 100644
--- a/src/sfc/core/trait.h
+++ b/src/sfc/core/trait.h
@@ -4,14 +4,6 @@
 
 namespace sfc::trait {
 
-struct Any {};
-
-template <class T, class U>
-concept Same = __is_same(T, U);
-
-template <class T, class U>
-concept NotSame = !__is_same(T, U);
-
 template <class T>
 concept Enum = __is_enum(T);
 
@@ -19,7 +11,16 @@ template <class T>
 concept Class = __is_class(T);
 
 template <class T>
-concept Copy = __is_trivially_copyable(T);
+concept Reference = __is_same(T, T&);
+
+template <class T>
+concept Const = __is_same(T, const T);
+
+template <class... T>
+concept TvCopy = (__is_trivially_copyable(T) && ...);
+
+template <class ...T>
+concept TvDtor = (__is_trivially_destructible(T) && ...);
 
 template <class T>
 concept UInt = __is_same(T, unsigned char)      //
@@ -43,9 +44,6 @@ concept Float = __is_same(T, float)      //
                 || __is_same(T, double)  //
                 || __is_same(T, long double);
 
-template <class T>
-concept Reference = __is_same(T, T&);
-
 template <template <class> class X, class T>
 auto as(const T& x) -> const X<T>& {
   return reinterpret_cast<const X<T>&>(x);
diff --git a/src/sfc/core/tuple.h b/src/sfc/core/tuple.h
index ef72359..4d4931d 100644
--- a/src/sfc/core/tuple.h
+++ b/src/sfc/core/tuple.h
@@ -12,83 +12,76 @@ struct idx_t<I> {
   static constexpr const auto VALUE = I;
 };
 
-template <usize I, class... Ts>
-struct Element;
-
-#ifdef __clang__
-template <usize I, class... T>
-struct Element {
-  using Type = __type_pack_element<I, T...>;
+#if __has_builtin(__make_integer_seq)
+template <class T, T... I>
+struct _idxs_helper {
+  using Type = idx_t<I...>;
 };
+
+template <usize N>
+using idx_seq_t = typename __make_integer_seq<_idxs_helper, usize, N>::Type;
+#else
+template <usize N>
+using idx_seq_t = idx_t<__integer_pack(N)...>;
+#endif
+
+#if __has_builtin(__type_pack_element)
+template <usize I, typename... T>
+using element_t = __type_pack_element<I, T...>;
 #else
-template <usize I, class U, class... T>
-struct Element<I, U, T...> : Element<I - 1, T...> {};
+namespace sfc {
+template <usize I, typename... T>
+struct _NthType;
 
-template <class U, class... T>
-struct Element<0, U, T...> {
-  using Type = U;
+template <class T0, class... Ts>
+struct _NthType<0, T0, Ts...> {
+  using Type = T0;
 };
-#endif
 
-namespace detail {
+template <class T0, class T1, class... U>
+struct _NthType<1, T0, T1, U...> {
+  using Type = T1;
+};
 
-template <class T, usize... I>
-struct Idxs {
-  using Type = idx_t<I...>;
+template <class T0, class T1, class T2, class... U>
+struct _NthType<2, T0, T1, T2, U...> {
+  using Type = T2;
 };
 
-// clang-format off
-#if __cplusplus < 202002L
-template<usize N>struct MakeSeq;
-template<>struct MakeSeq<0> : Idxs<usize> {};
-template<>struct MakeSeq<1> : Idxs<usize,0> {};
-template<>struct MakeSeq<2> : Idxs<usize,0,1> {};
-template<>struct MakeSeq<3> : Idxs<usize,0,1,2> {};
-template<>struct MakeSeq<4> : Idxs<usize,0,1,2,3> {};
-template<>struct MakeSeq<5> : Idxs<usize,0,1,2,3,4> {};
-template<>struct MakeSeq<6> : Idxs<usize,0,1,2,3,4,5> {};
-template<>struct MakeSeq<7> : Idxs<usize,0,1,2,3,4,5,6> {};
-template<>struct MakeSeq<8> : Idxs<usize,0,1,2,3,4,5,6,7> {};
-template<>struct MakeSeq<9> : Idxs<usize,0,1,2,3,4,5,6,7,8> {};
-template<>struct MakeSeq<10>: Idxs<usize,0,1,2,3,4,5,6,7,8,9> {};
-template<>struct MakeSeq<11>: Idxs<usize,0,1,2,3,4,5,6,7,8,9,10> {};
-template<>struct MakeSeq<12>: Idxs<usize,0,1,2,3,4,5,6,7,8,9,10,11> {};
-template<>struct MakeSeq<13>: Idxs<usize,0,1,2,3,4,5,6,7,8,9,10,11,12> {};
-template<>struct MakeSeq<14>: Idxs<usize,0,1,2,3,4,5,6,7,8,9,10,11,12,13> {};
-template<>struct MakeSeq<15>: Idxs<usize,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14> {};
-template<>struct MakeSeq<16>: Idxs<usize,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15> {};
-template<>struct MakeSeq<17>: Idxs<usize,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16> {};
-template<>struct MakeSeq<18>: Idxs<usize,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17> {};
-template<>struct MakeSeq<19>: Idxs<usize,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18> {};
-template<>struct MakeSeq<20>: Idxs<usize,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19> {};
+template <usize I, class T0, class T1, class T2, class... U>
+struct _NthType<I, T0, T1, T2, U...> : _NthType<I - 3, U...> {};
+
+}  // namespace sfc
+
+template <usize I, typename... T>
+using element_t = typename sfc::_NthType<I, T...>::Type;
 #endif
-// clang-format on
+
+namespace detail {
+
+template <class I, class... T>
+struct Tuple;
 
 template <usize I, class T>
 struct Entry {
   T _0;
 };
 
-template <class I, class... T>
-struct Tuple;
-
 template <usize... I, class... T>
 struct Tuple<idx_t<I...>, T...> : Entry<I, T>... {
-  static constexpr usize COUNT = sizeof...(T);
-
  public:
   Tuple(T... vals) : Entry<I, T>{static_cast<T&&>(vals)}... {}
 
-  template <usize K>
+  template <usize J>
   [[sfc_inline]] auto get() const -> auto& {
-    using U = typename Element<K, T...>::Type;
-    return static_cast<const Entry<K, U>&>(*this)._0;
+    using U = __type_pack_element<J, T...>;
+    return static_cast<const Entry<J, U>&>(*this)._0;
   }
 
-  template <usize K>
+  template <usize J>
   [[sfc_inline]] auto get() -> auto& {
-    using U = typename Element<K, T...>::Type;
-    return static_cast<Entry<K, U>&>(*this)._0;
+    using U = __type_pack_element<J, T...>;
+    return static_cast<Entry<J, U>&>(*this)._0;
   }
 
   void map(auto&& f) const {
@@ -100,41 +93,25 @@ struct Tuple<idx_t<I...>, T...> : Entry<I, T>... {
   }
 
   void imap(auto&& f) const {
-    (f(idx_t<I>{}, this->get<I>()), ...);
+    (f(I, this->get<I>()), ...);
   }
 
   void imap_mut(auto&& f) {
-    (f(idx_t<I>{}, this->get<I>()), ...);
+    (f(I, this->get<I>()), ...);
   }
 };
 
 }  // namespace detail
 
-template <usize I, class... T>
-using element_t = typename Element<I, T...>::Type;
-
-#ifdef __clang__
-template <usize N>
-using idx_seq_t = __make_integer_seq<detail::Idxs, usize, N>::Type;
-#elif defined(__GNUC__)
-#if __GNUC__ >= 9
-template <usize N>
-using idx_seq_t = idx_t<__integer_pack(N)...>;
-#else
-template <usize N>
-using idx_seq_t = typename detail::MakeSeq<N>::Type;
-#endif
-#endif
-
 template <class... T>
 class Tuple : detail::Tuple<idx_seq_t<sizeof...(T)>, T...> {
   using Inn = detail::Tuple<idx_seq_t<sizeof...(T)>, T...>;
 
  public:
-  using Inn::COUNT;
   using Inn::Inn;
 
   using Inn::get;
+
   using Inn::map;
   using Inn::map_mut;
 
@@ -142,10 +119,8 @@ class Tuple : detail::Tuple<idx_seq_t<sizeof...(T)>, T...> {
   using Inn::imap_mut;
 };
 
-#if __cplusplus >= 202002L
 template <class... T>
 Tuple(T...) -> Tuple<T...>;
-#endif
 
 }  // namespace sfc::tuple
 
@@ -185,9 +160,3 @@ struct tuple_element<I, const sfc::tuple::Tuple<T...>> {
 }  // namespace _LIBCPP_ABI_NAMESPACE
 #endif
 }  // namespace std
-
-namespace sfc {
-using tuple::idx_seq_t;
-using tuple::idx_t;
-using tuple::Tuple;
-}  // namespace sfc
diff --git a/src/sfc/core/variant.h b/src/sfc/core/variant.h
index 5826264..ca94dab 100644
--- a/src/sfc/core/variant.h
+++ b/src/sfc/core/variant.h
@@ -6,8 +6,6 @@ namespace sfc::variant {
 
 using tuple::idx_t;
 
-namespace detail {
-
 template <class... T>
 union Union;
 
@@ -24,7 +22,7 @@ union Union<> {
   template <usize>
   [[sfc_inline]] void get_unchecked_mut() {}
 
-  [[sfc_inline]] void drop(usize) {}
+  [[sfc_inline]] void dtor(usize) {}
 
   [[sfc_inline]] void move_ctor(usize, Union&) {}
   [[sfc_inline]] void copy_ctor(usize, const Union&) {}
@@ -43,9 +41,7 @@ union Union<T0, Ts...> {
   Union<Ts...> _1;
 
  public:
-  [[sfc_inline]] Union() {}
-
-  [[sfc_inline]] ~Union() {}
+  [[sfc_inline]] Union() noexcept {}
 
   template <class... U>
   [[sfc_inline]] Union(idx_t<0>, U&&... args) noexcept : _0{static_cast<U&&>(args)...} {}
@@ -54,43 +50,44 @@ union Union<T0, Ts...> {
   [[sfc_inline]] Union(idx_t<I>, U&&... args) noexcept
       : _1{idx_t<I - 1>{}, static_cast<U&&>(args)...} {}
 
-  template <trait::Same<T0> U>
-  static constexpr auto tag() -> u32 {
-    return 0;
-  }
+  [[sfc_inline]] ~Union() {}
+
+  [[sfc_inline]] ~Union()
+    requires(trait::TvCopy<T0, Ts...>)
+  = default;
 
   template <class U>
   static constexpr auto tag() -> u32 {
-    return Union<Ts...>::template tag<U>() + 1;
-  }
-
-  template <usize I>
-    requires(I == 0)
-  auto get_unchecked() const -> const auto& {
-    return _0;
+    if constexpr (__is_same(T0, U)) {
+      return 0;
+    } else {
+      return Union<Ts...>::template tag<U>() + 1;
+    }
   }
 
   template <usize I>
   [[sfc_inline]] auto get_unchecked() const -> const auto& {
-    return _1.template get_unchecked<I - 1>();
-  }
-
-  template <usize I>
-    requires(I == 0)
-  auto get_unchecked_mut() -> auto& {
-    return _0;
+    if constexpr (I == 0) {
+      return _0;
+    } else {
+      return _1.template get_unchecked<I - 1>();
+    }
   }
 
   template <usize I>
   [[sfc_inline]] auto get_unchecked_mut() -> auto& {
-    return _1.template get_unchecked_mut<I - 1>();
+    if constexpr (I == 0) {
+      return _0;
+    } else {
+      return _1.template get_unchecked_mut<I - 1>();
+    }
   }
 
-  [[sfc_inline]] void drop(usize idx) {
+  [[sfc_inline]] void dtor(usize idx) {
     if (idx == 0) {
-      mem::drop(_0);
+      _0.~T0();
     } else {
-      _1.drop(idx - 1);
+      _1.dtor(idx - 1);
     }
   }
 
@@ -143,26 +140,21 @@ union Union<T0, Ts...> {
   }
 };
 
-}  // namespace detail
-
 template <class... T>
 class Variant {
-  using Tag = u8;
-  using Imp = detail::Union<T...>;
-
   template <class U>
-  using tag_t = idx_t<Imp::template tag<U>()>;
+  using tag_t = idx_t<Union<T...>::template tag<U>()>;
 
-  Tag _tag;
-  Imp _imp;
+  u8 _tag;
+  Union<T...> _imp;
 
  public:
   template <class U>
   explicit Variant(U val) noexcept
-      : _tag{static_cast<Tag>(tag_t<U>::VALUE)}, _imp{tag_t<U>{}, static_cast<U&&>(val)} {}
+      : _tag{static_cast<u8>(tag_t<U>::VALUE)}, _imp{tag_t<U>{}, static_cast<U&&>(val)} {}
 
   ~Variant() {
-    _imp.drop(_tag);
+    _imp.dtor(_tag);
   }
 
   Variant(const Variant& other) noexcept : _tag{other._tag} {
@@ -177,7 +169,7 @@ class Variant {
     if (_tag == other._tag) {
       _imp.move_assign(_tag, other._imp);
     } else {
-      _imp.drop(_tag);
+      _imp.dtor(_tag);
       _imp.move_ctor(other._tag, other._imp);
       _tag = other._tag;
     }
@@ -186,13 +178,13 @@ class Variant {
 
   template <class U>
   auto is() const -> bool {
-    const auto tag = Imp::template tag<U>();
-    return _tag == tag;
+    return _tag == tag_t<U>::VALUE;
   }
 
   template <class U>
   auto as() const -> const U& {
-    assert_fmt(this->is<U>(), "Variant::as<{}>: type not match.", reflect::type_name<U>());
+    panicking::assert_fmt(this->is<U>(), "Variant::as<{}>: type not match.",
+                          reflect::type_name<U>());
     return _imp.template get_unchecked<tag_t<U>::VALUE>();
   }
 
@@ -212,7 +204,3 @@ class Variant {
 };
 
 }  // namespace sfc::variant
-
-namespace sfc {
-using variant::Variant;
-}  // namespace sfc
diff --git a/src/sfc/env/env.h b/src/sfc/env/env.h
index 6dfc486..777f6e0 100644
--- a/src/sfc/env/env.h
+++ b/src/sfc/env/env.h
@@ -6,7 +6,7 @@ namespace sfc::env {
 
 auto var(Str key) -> Str;
 void set_var(Str key, Str val);
-void remove_var(Str key, Str val);
+void remove_var(Str key);
 
 auto current_dir() -> fs::PathBuf;
 void set_current_dir(fs::Path path);
diff --git a/src/sfc/io/buf.h b/src/sfc/io/buf.h
new file mode 100644
index 0000000..a7cab97
--- /dev/null
+++ b/src/sfc/io/buf.h
@@ -0,0 +1,68 @@
+#pragma once
+
+#include "mod.h"
+
+namespace sfc::io {
+
+template <class W>
+class BufWriter {
+  W _inn;
+  Vec<u8> _buf;
+
+ public:
+  static auto from(W inn) -> BufWriter;
+
+  static auto with_capacity(usize capacity, W inn) -> BufWriter;
+
+  auto buffer() const -> Slice<u8>;
+
+  auto capacity() const -> usize;
+
+  auto get_mut() -> W&;
+
+  auto get_ref() const -> const W&;
+
+ public:
+  auto flush() -> Result<> {
+    if (_buf.is_empty()) {
+      return _;
+    }
+    auto res = _inn.write_all(_buf.as_slice());
+    _buf.clear();
+    return _;
+  }
+
+  auto write(Slice<const u8> buf) -> Result<usize> {
+    if (buf.len() + _buf.len() >= _buf.capacity()) {
+      this->flush();
+    }
+    if (buf.len() >= _buf.capacity()) {
+      return _inn.write(buf);
+    }
+    _buf.extend_from_slice(buf);
+    return buf.len();
+  }
+
+  auto write_all(Slice<const u8> buf) -> Result<usize> {
+    if (buf.len() + _buf.len() >= _buf.capacity()) {
+      this->flush();
+    }
+    if (buf.len() >= _buf.capacity()) {
+      return _inn.write_all(buf);
+    }
+    _buf.extend_from_slice(buf);
+    return buf.len();
+  }
+
+  auto write_str(Str s) -> Result<usize> {
+    return this->write_all(s.as_bytes());
+  }
+
+  auto write_fmt(const auto& fmts, const auto&... args) -> Result<> {
+    auto imp = fmt::Fmter<BufWriter>{*this};
+    imp.write_fmt(fmts, args...);
+    return _;
+  }
+};
+
+}  // namespace sfc::io
diff --git a/src/sfc/io/mod.cc b/src/sfc/io/mod.cc
index 915dfc3..d7e071f 100644
--- a/src/sfc/io/mod.cc
+++ b/src/sfc/io/mod.cc
@@ -1,5 +1,4 @@
 #include "error.h"
-
 #include "sfc/sys/io.inl"
 
 namespace sfc::io {
diff --git a/src/sfc/log/backend.h b/src/sfc/log/backend.h
index 43ad2b6..f620a6e 100644
--- a/src/sfc/log/backend.h
+++ b/src/sfc/log/backend.h
@@ -14,8 +14,8 @@ struct IBackend {
   struct Meta {
     usize _size;
     void (*_dtor)(void*);
-    void (trait::Any::*_flush)();
-    void (trait::Any::*_write_entry)(Entry entry);
+    void (ops::Any::*_flush)();
+    void (ops::Any::*_write_entry)(Entry);
 
     template <class X>
     static auto of(const X*) -> const Meta& {
@@ -38,13 +38,13 @@ struct IBackend {
   explicit IBackend(auto* x) : _self{x}, _meta{&Meta::of(x)} {}
 
   void flush() {
-    const auto p = static_cast<trait::Any*>(_self);
+    const auto p = static_cast<ops::Any*>(_self);
     const auto f = _meta->_flush;
     (p->*f)();
   }
 
   void write_entry(Entry entry) {
-    const auto p = static_cast<trait::Any*>(_self);
+    const auto p = static_cast<ops::Any*>(_self);
     const auto f = _meta->_write_entry;
     (p->*f)(entry);
   }
diff --git a/src/sfc/log/logger.cc b/src/sfc/log/logger.cc
index b92640a..949c2c1 100644
--- a/src/sfc/log/logger.cc
+++ b/src/sfc/log/logger.cc
@@ -29,8 +29,8 @@ struct LogTime {
     static constexpr u32 TIME_LEN = sizeof("HH:MM:SS");
     static constexpr u32 LEN = sizeof("[YYYY-MM-DD HH:MM:SS.000]") - 1;
 
-    static char buf[32] = "[YYYY-MM-DD HH:MM:SS.000]";
-    static auto cached = time::DateTime{};
+    static thread_local char buf[32] = "[YYYY-MM-DD HH:MM:SS.000]";
+    static thread_local auto cached = time::DateTime{};
 
     if (!(_inn._date == cached._date)) {
       cached._date = _inn._date;
diff --git a/src/sfc/math.h b/src/sfc/math.h
index d67f6a0..80d4b73 100644
--- a/src/sfc/math.h
+++ b/src/sfc/math.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "math/mod.h"
+#include "math/funcs.h"
 #include "math/ndarray.h"
 #include "math/ndview.h"
 #include "math/sintbl.h"
diff --git a/src/sfc/math/mod.h b/src/sfc/math/funcs.h
similarity index 99%
rename from src/sfc/math/mod.h
rename to src/sfc/math/funcs.h
index 27a6a58..1825c5c 100644
--- a/src/sfc/math/mod.h
+++ b/src/sfc/math/funcs.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "sfc/alloc.h"
+#include "sfc/core.h"
 
 namespace sfc::math {
 
diff --git a/src/sfc/math/ndarray.h b/src/sfc/math/ndarray.h
index 8dcb332..9bae695 100644
--- a/src/sfc/math/ndarray.h
+++ b/src/sfc/math/ndarray.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "ndview.h"
+#include "sfc/math/ndview.h"
 
 namespace sfc::math {
 
diff --git a/src/sfc/math/ndview.h b/src/sfc/math/ndview.h
index 2fa21e0..d7af017 100644
--- a/src/sfc/math/ndview.h
+++ b/src/sfc/math/ndview.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "mod.h"
+#include "sfc/alloc.h"
 
 namespace sfc::math {
 
@@ -9,30 +9,30 @@ struct NdSize {
   usize _inn[N] = {0};
 
   template <usize... I, class V>
-  [[sfc_inline]] NdSize(idx_t<I...>, const V& v) : _inn{v[I]...} {}
+  [[sfc_inline]] NdSize(tuple::idx_t<I...>, const V& v) : _inn{v[I]...} {}
 
  public:
   [[sfc_inline]] NdSize() = default;
 
-  [[sfc_inline]] NdSize(const usize (&s)[N]) : NdSize{idx_seq_t<N>{}, s} {}
+  [[sfc_inline]] NdSize(const usize (&s)[N]) : NdSize{tuple::idx_seq_t<N>{}, s} {}
 
   [[sfc_inline]] auto operator[](usize idx) const -> usize {
     return _inn[idx];
   }
 
   template <usize... I>
-  [[sfc_inline]] auto operator[](idx_t<I...>) const -> NdSize<sizeof...(I)> {
+  [[sfc_inline]] auto operator[](tuple::idx_t<I...>) const -> NdSize<sizeof...(I)> {
     return NdSize<sizeof...(I)>{_inn[I]...};
   }
 
   [[sfc_inline]] auto numel() const -> usize {
-    const auto f = [&]<usize... I>(idx_t<I...>) { return (_inn[I] * ...); };
-    return f(idx_seq_t<N>{});
+    const auto f = [&]<usize... I>(tuple::idx_t<I...>) { return (_inn[I] * ...); };
+    return f(tuple::idx_seq_t<N>{});
   }
 
   [[sfc_inline]] auto operator==(const NdSize& other) const -> bool {
-    const auto f = [&]<usize... I>(idx_t<I...>) { return ((_inn[I] == other._inn[I]) && ...); };
-    return f(idx_seq_t<N>{});
+    const auto f = [&]<usize... I>(tuple::idx_t<I...>) { return ((_inn[I] == other._inn[I]) && ...); };
+    return f(tuple::idx_seq_t<N>{});
   }
 
   void fmt(auto& f) const {
@@ -50,15 +50,15 @@ struct NdStep {
  public:
   [[sfc_inline]] NdStep() = default;
 
-  [[sfc_inline]] NdStep(const usize (&s)[N]) : NdStep{idx_seq_t<N>{}, s} {}
+  [[sfc_inline]] NdStep(const usize (&s)[N]) : NdStep{tuple::idx_seq_t<N>{}, s} {}
 
   [[sfc_inline]] auto operator[](usize idx) const -> usize {
     return _inn[idx];
   }
 
   template <usize... I>
-  [[sfc_inline]] auto operator[](idx_t<I...>) const -> NdStep<sizeof...(I)> {
-    return NdStep<sizeof...(I)>{idx_t<I...>{}, _inn};
+  [[sfc_inline]] auto operator[](tuple::idx_t<I...>) const -> NdStep<sizeof...(I)> {
+    return NdStep<sizeof...(I)>{tuple::idx_t<I...>{}, _inn};
   }
 
   [[sfc_inline]] static auto from_shape(const NdSize<N>& shape) -> NdStep {
@@ -77,7 +77,7 @@ struct NdIdxs {
   usize _inn[N] = {0};
 
   template <usize... I, class V>
-  [[sfc_inline]] NdIdxs(idx_t<I...>, const V& v) : _inn{v[I]...} {}
+  [[sfc_inline]] NdIdxs(tuple::idx_t<I...>, const V& v) : _inn{v[I]...} {}
 
  public:
   [[sfc_inline]] NdIdxs() = default;
@@ -89,35 +89,35 @@ struct NdIdxs {
   }
 
   template <usize... I>
-  [[sfc_inline]] auto operator[](idx_t<I...>) const -> NdIdxs<sizeof...(I)> {
+  [[sfc_inline]] auto operator[](tuple::idx_t<I...>) const -> NdIdxs<sizeof...(I)> {
     return NdIdxs<sizeof...(I)>{_inn[I]...};
   }
 
   [[sfc_inline]] auto operator<(const NdSize<N>& shape) const -> bool {
-    const auto f = [&]<usize... I>(idx_t<I...>) { return ((_inn[I] < shape._inn[I]) && ...); };
-    return f(idx_seq_t<N>{});
+    const auto f = [&]<usize... I>(tuple::idx_t<I...>) { return ((_inn[I] < shape._inn[I]) && ...); };
+    return f(tuple::idx_seq_t<N>{});
   }
 
   [[sfc_inline]] auto operator*(const NdStep<N>& strides) const -> usize {
-    const auto f = [&]<usize... I>(idx_t<I...>) { return ((_inn[I] * strides._inn[I]) + ...); };
-    return f(idx_seq_t<N>{});
+    const auto f = [&]<usize... I>(tuple::idx_t<I...>) { return ((_inn[I] * strides._inn[I]) + ...); };
+    return f(tuple::idx_seq_t<N>{});
   }
 };
 
 template <class T, usize N>
 struct NdView {
-  using Size = NdSize<N>;
-  using Step = NdStep<N>;
+  using shape_t = NdSize<N>;
+  using strides_t = NdStep<N>;
   using Idxs = NdIdxs<N>;
 
   T* _data = nullptr;
-  Size _size = {};
-  Step _step = {};
+  shape_t _size = {};
+  strides_t _step = {};
 
  public:
   [[sfc_inline]] NdView() = default;
 
-  [[sfc_inline]] NdView(T* data, Size shape, Step strides)
+  [[sfc_inline]] NdView(T* data, shape_t shape, strides_t strides)
       : _data{data}, _size{shape}, _step{strides} {}
 
   [[sfc_inline]] static constexpr auto ndim() -> usize {
@@ -128,11 +128,11 @@ struct NdView {
     return _data;
   }
 
-  [[sfc_inline]] auto shape() const -> Size {
+  [[sfc_inline]] auto shape() const -> shape_t {
     return _size;
   }
 
-  [[sfc_inline]] auto strides() const -> Step {
+  [[sfc_inline]] auto strides() const -> strides_t {
     return _step;
   }
 
@@ -142,7 +142,7 @@ struct NdView {
 
   [[sfc_inline]] auto operator[](usize idx) -> NdView<T, N - 1> {
     const auto data = _data + idx * _step[N - 1];
-    return NdView<T, N - 1>{data, _size[idx_seq_t<N - 1>{}], _step[idx_seq_t<N - 1>{}]};
+    return NdView<T, N - 1>{data, _size[tuple::idx_seq_t<N - 1>{}], _step[tuple::idx_seq_t<N - 1>{}]};
   }
 
   [[sfc_inline]] auto operator[](const Idxs& idx) const -> T {
@@ -186,18 +186,18 @@ struct NdView {
 
 template <class T>
 struct NdView<T, 1> {
-  using Size = NdSize<1>;
-  using Step = NdStep<1>;
+  using shape_t = NdSize<1>;
+  using strides_t = NdStep<1>;
   using Idxs = NdIdxs<1>;
 
   T* _data = nullptr;
-  Size _size = {};
-  Step _step = {};
+  shape_t _size = {};
+  strides_t _step = {};
 
  public:
   [[sfc_inline]] NdView() = default;
 
-  [[sfc_inline]] NdView(T* data, Size size, Step step) : _data{data}, _size{size}, _step{step} {}
+  [[sfc_inline]] NdView(T* data, shape_t size, strides_t step) : _data{data}, _size{size}, _step{step} {}
 
   [[sfc_inline]] static constexpr auto ndim() -> usize {
     return 1;
@@ -207,11 +207,11 @@ struct NdView<T, 1> {
     return _data;
   }
 
-  [[sfc_inline]] auto shape() const -> Size {
+  [[sfc_inline]] auto shape() const -> shape_t {
     return _size;
   }
 
-  [[sfc_inline]] auto strides() const -> Step {
+  [[sfc_inline]] auto strides() const -> strides_t {
     return _step;
   }
 
@@ -239,7 +239,7 @@ struct NdView<T, 1> {
     ids = ids % _size[0];
 
     const auto offset = ids._start * _step._inn[0];
-    const auto size = Size{{ids.len()}};
+    const auto size = shape_t{{ids.len()}};
     return NdView{_data + offset, size, _step};
   }
 
diff --git a/src/sfc/math/sintbl.h b/src/sfc/math/sintbl.h
index 0712769..c0dd6f1 100644
--- a/src/sfc/math/sintbl.h
+++ b/src/sfc/math/sintbl.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "mod.h"
+#include "sfc/math/funcs.h"
 
 namespace sfc::math {
 
diff --git a/src/sfc/serde/base64.cc b/src/sfc/serde/base64.cc
new file mode 100644
index 0000000..102696a
--- /dev/null
+++ b/src/sfc/serde/base64.cc
@@ -0,0 +1,154 @@
+
+#include "base64.h"
+
+namespace sfc::serde::base64 {
+
+namespace imp {
+
+static constexpr u8 kENCODE[] = {                                     //
+    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',  //
+    'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',  //
+    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',  //
+    'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',  //
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'};
+
+static constexpr u8 kDECODE[] = {
+    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   // 000
+    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   // 010
+    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   // 020
+    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   // 030
+    0,  0,  0,  62, 0,  0,  0,  63, 52, 53,  // 040
+    54, 55, 56, 57, 58, 59, 60, 61, 0,  0,   // 050
+    0,  0,  0,  0,  0,  0,  1,  2,  3,  4,   // 060
+    5,  6,  7,  8,  9,  10, 11, 12, 13, 14,  // 070
+    15, 16, 17, 18, 19, 20, 21, 22, 23, 24,  // 080
+    25, 0,  0,  0,  0,  0,  0,  26, 27, 28,  // 090
+    29, 30, 31, 32, 33, 34, 35, 36, 37, 38,  // 100
+    39, 40, 41, 42, 43, 44, 45, 46, 47, 48,  // 110
+    49, 50, 51, 0,  0,  0,  0,  0            // 120
+};
+
+static auto encode_len(Slice<const u8> buf) -> usize {
+  if (buf.is_empty()) {
+    return 0U;
+  }
+
+  const auto n = buf.len();
+  const auto m = n / 3 * 4;
+  const auto t = n % 3;
+  return m + (t == 0 ? 0 : t + 1);
+}
+
+static auto decode_len(Slice<const u8> buf) -> usize {
+  // trim
+  while (buf._len != 0 && buf[buf._len - 1] == '=') {
+    buf._len -= 1;
+  }
+
+  if (buf.is_empty()) {
+    return 0U;
+  }
+
+  const auto n = buf.len();
+  const auto m = n / 4 * 3;
+  const auto t = n % 4;
+  return m + (t <= 1 ? 0 : t - 1);
+}
+
+static auto encode(Slice<const u8> src, Slice<u8> dst) -> usize {
+  auto f = [](const u8 src[3], u8 dst[4]) {
+    dst[0] = kENCODE[src[0] >> 2];
+    dst[1] = kENCODE[((src[0] & 0x03) << 4) + (src[1] >> 4)];
+    dst[2] = kENCODE[((src[1] & 0x0F) << 2) + (src[2] >> 6)];
+    dst[3] = kENCODE[src[2] & 0x3F];
+  };
+
+  const auto src_len = src.len();
+  const auto dst_len = encode_len(src);
+  if (dst_len != dst.len() || dst_len == 0) {
+    return dst_len;
+  }
+
+  const auto end = src.as_ptr() + src_len;
+  auto px = src.as_ptr();
+  auto py = dst.as_mut_ptr();
+  for (; px + 3 <= end; px += 3, py += 4) {
+    f(px, py);
+  }
+
+  if (px != end) {
+    u8 xx[3] = {0, 0, 0};
+    u8 yy[4] = {0, 0, 0, 0};
+
+    const auto nn = static_cast<usize>(end - px);
+    ptr::copy_nonoverlapping(px, xx, nn);
+    f(xx, yy);
+    ptr::copy_nonoverlapping(yy, py, nn + 1);
+  }
+
+  return 0;
+}
+
+static auto decode(Slice<const u8> src, Slice<u8> dst) -> usize {
+  auto f = [](const u8 src[4], u8 dst[3]) {
+    const u8 num[4] = {kDECODE[src[0]], kDECODE[src[1]], kDECODE[src[2]], kDECODE[src[3]]};
+    dst[0] = static_cast<u8>((num[0] << 2) + (num[1] >> 4));
+    dst[1] = static_cast<u8>((num[1] << 4) + (num[2] >> 2));
+    dst[2] = static_cast<u8>((num[2] << 6) + num[3]);
+  };
+
+  const auto src_len = src.len();
+  const auto dst_len = decode_len(src);
+  if (dst_len != dst.len() || dst_len == 0) {
+    return dst_len;
+  }
+
+  const auto end = src.as_ptr() + src_len;
+  auto px = src.as_ptr();
+  auto py = dst.as_mut_ptr();
+  for (; px + 4 <= end; px += 4, py += 3) {
+    f(px, py);
+  }
+
+  if (px != end) {
+    u8 xx[4] = {0, 0, 0, 0};
+    u8 yy[3] = {0, 0, 0};
+
+    const auto nn = static_cast<usize>(end - px);
+    ptr::copy_nonoverlapping(px, xx, nn);
+    f(xx, yy);
+    ptr::copy_nonoverlapping(yy, py, nn - 1);
+  }
+
+  return 0;
+}
+
+}  // namespace imp
+
+auto encode(Slice<const u8> src, Slice<u8> dst) -> usize {
+  return imp::encode(src, dst);
+}
+
+auto decode(Slice<const u8> src, Slice<u8> dst) -> usize {
+  return imp::decode(src, dst);
+}
+
+auto encode_vec(Slice<const u8> src) -> Vec<u8> {
+  const auto dst_len = imp::encode_len(src);
+
+  auto dst = Vec<u8>::with_capacity(dst_len);
+  dst.set_len(dst_len);
+  imp::encode(src, dst.as_mut_slice());
+  return dst;
+}
+
+auto decode_vec(Slice<const u8> src) -> Vec<u8> {
+  const auto dst_len = imp::decode_len(src);
+
+  auto dst = Vec<u8>::with_capacity(dst_len);
+  dst.set_len(dst_len);
+  imp::decode(src, dst.as_mut_slice());
+  return dst;
+}
+
+}  // namespace sfc::serde::base64
diff --git a/src/sfc/serde/base64.h b/src/sfc/serde/base64.h
index 2127ade..7216a40 100644
--- a/src/sfc/serde/base64.h
+++ b/src/sfc/serde/base64.h
@@ -1,3 +1,13 @@
 #pragma once
 
-#include "base64/base64.h"
+#include "sfc/alloc.h"
+
+namespace sfc::serde::base64 {
+
+auto encode(Slice<const u8> src, Slice<u8> dst) -> usize;
+auto decode(Slice<const u8> src, Slice<u8> dst) -> usize;
+
+auto encode_vec(Slice<const u8> src) -> Vec<u8>;
+auto decode_vec(Slice<const u8> src) -> Vec<u8>;
+
+}  // namespace sfc::serde::base64
diff --git a/src/sfc/serde/base64/base64.cc b/src/sfc/serde/base64/base64.cc
deleted file mode 100644
index 9e57153..0000000
--- a/src/sfc/serde/base64/base64.cc
+++ /dev/null
@@ -1,156 +0,0 @@
-
-#include "base64.h"
-
-namespace sfc::serde::base64 {
-
-namespace {
-struct Base64 {
- public:
-  static auto encode_len(Slice<const u8> buf) -> usize {
-    if (buf.is_empty()) {
-      return 0U;
-    }
-
-    const auto n = buf.len();
-    const auto m = n / 3 * 4;
-    const auto t = n % 3;
-    return m + (t == 0 ? 0 : t + 1);
-  }
-
-  static auto decode_len(Slice<const u8> buf) -> usize {
-    // trim
-    while (buf._len != 0 && buf[buf._len - 1] == '=') {
-      buf._len -= 1;
-    }
-
-    if (buf.is_empty()) {
-      return 0U;
-    }
-
-    const auto n = buf.len();
-    const auto m = n / 4 * 3;
-    const auto t = n % 4;
-    return m + (t <= 1 ? 0 : t - 1);
-  }
-
-  static auto encode(Slice<const u8> src, Slice<u8> dst) -> usize {
-    const auto src_len = src.len();
-    const auto dst_len = encode_len(src);
-    if (dst_len != dst.len() || dst_len == 0) {
-      return dst_len;
-    }
-
-    const auto end = src.as_ptr() + src_len;
-    auto px = src.as_ptr();
-    auto py = dst.as_mut_ptr();
-    for (; px + 3 <= end; px += 3, py += 4) {
-      encode_imp(px, py);
-    }
-
-    if (px != end) {
-      u8 xx[3] = {0, 0, 0};
-      u8 yy[4] = {0, 0, 0, 0};
-
-      const auto nn = static_cast<usize>(end - px);
-      ptr::copy_nonoverlapping(px, xx, nn);
-      encode_imp(xx, yy);
-      ptr::copy_nonoverlapping(yy, py, nn + 1);
-    }
-
-    return 0;
-  }
-
-  static auto decode(Slice<const u8> src, Slice<u8> dst) -> usize {
-    const auto src_len = src.len();
-    const auto dst_len = decode_len(src);
-    if (dst_len != dst.len() || dst_len == 0) {
-      return dst_len;
-    }
-
-    const auto end = src.as_ptr() + src_len;
-    auto px = src.as_ptr();
-    auto py = dst.as_mut_ptr();
-    for (; px + 4 <= end; px += 4, py += 3) {
-      decode_imp(px, py);
-    }
-
-    if (px != end) {
-      u8 xx[4] = {0, 0, 0, 0};
-      u8 yy[3] = {0, 0, 0};
-
-      const auto nn = static_cast<usize>(end - px);
-      ptr::copy_nonoverlapping(px, xx, nn);
-      decode_imp(xx, yy);
-      ptr::copy_nonoverlapping(yy, py, nn - 1);
-    }
-
-    return 0;
-  }
-
- private:
-  static constexpr u8 kENCODE[] = {                                     //
-      'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',  //
-      'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',  //
-      'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',  //
-      'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',  //
-      '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'};
-
-  static constexpr u8 kDECODE[] = {
-      0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   // 000
-      0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   // 010
-      0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   // 020
-      0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   // 030
-      0,  0,  0,  62, 0,  0,  0,  63, 52, 53,  // 040
-      54, 55, 56, 57, 58, 59, 60, 61, 0,  0,   // 050
-      0,  0,  0,  0,  0,  0,  1,  2,  3,  4,   // 060
-      5,  6,  7,  8,  9,  10, 11, 12, 13, 14,  // 070
-      15, 16, 17, 18, 19, 20, 21, 22, 23, 24,  // 080
-      25, 0,  0,  0,  0,  0,  0,  26, 27, 28,  // 090
-      29, 30, 31, 32, 33, 34, 35, 36, 37, 38,  // 100
-      39, 40, 41, 42, 43, 44, 45, 46, 47, 48,  // 110
-      49, 50, 51, 0,  0,  0,  0,  0            // 120
-  };
-
-  static void encode_imp(const u8 src[3], u8 dst[4]) {
-    dst[0] = kENCODE[src[0] >> 2];
-    dst[1] = kENCODE[((src[0] & 0x03) << 4) + (src[1] >> 4)];
-    dst[2] = kENCODE[((src[1] & 0x0F) << 2) + (src[2] >> 6)];
-    dst[3] = kENCODE[src[2] & 0x3F];
-  }
-
-  static void decode_imp(const u8 src[4], u8 dst[3]) {
-    const u8 num[4] = {kDECODE[src[0]], kDECODE[src[1]], kDECODE[src[2]], kDECODE[src[3]]};
-    dst[0] = static_cast<u8>((num[0] << 2) + (num[1] >> 4));
-    dst[1] = static_cast<u8>((num[1] << 4) + (num[2] >> 2));
-    dst[2] = static_cast<u8>((num[2] << 6) + num[3]);
-  }
-};
-}  // namespace
-
-auto encode(Slice<const u8> src, Slice<u8> dst) -> usize {
-  return Base64::encode(src, dst);
-}
-
-auto decode(Slice<const u8> src, Slice<u8> dst) -> usize {
-  return Base64::decode(src, dst);
-}
-
-auto encode_vec(Slice<const u8> src) -> Vec<u8> {
-  const auto dst_len = Base64::encode_len(src);
-
-  auto dst = Vec<u8>::with_capacity(dst_len);
-  dst.set_len(dst_len);
-  Base64::encode(src, dst.as_mut_slice());
-  return dst;
-}
-
-auto decode_vec(Slice<const u8> src) -> Vec<u8> {
-  const auto dst_len = Base64::decode_len(src);
-
-  auto dst = Vec<u8>::with_capacity(dst_len);
-  dst.set_len(dst_len);
-  Base64::decode(src, dst.as_mut_slice());
-  return dst;
-}
-
-}  // namespace sfc::serde::base64
diff --git a/src/sfc/serde/base64/base64.h b/src/sfc/serde/base64/base64.h
deleted file mode 100644
index 7216a40..0000000
--- a/src/sfc/serde/base64/base64.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#pragma once
-
-#include "sfc/alloc.h"
-
-namespace sfc::serde::base64 {
-
-auto encode(Slice<const u8> src, Slice<u8> dst) -> usize;
-auto decode(Slice<const u8> src, Slice<u8> dst) -> usize;
-
-auto encode_vec(Slice<const u8> src) -> Vec<u8>;
-auto decode_vec(Slice<const u8> src) -> Vec<u8>;
-
-}  // namespace sfc::serde::base64
diff --git a/src/sfc/serde/des.h b/src/sfc/serde/des.h
index 6f384c7..fa8c41f 100644
--- a/src/sfc/serde/des.h
+++ b/src/sfc/serde/des.h
@@ -1,4 +1,163 @@
 #pragma once
 
-#include "des/deserialize.h"
-#include "des/deserializer.h"
+#include "sfc/serde/node.h"
+
+namespace sfc::serde {
+
+template <class T>
+struct Deserialize;
+
+template <trait::Int T>
+struct Deserialize<T> {
+  static auto deserialize(const auto& de) -> T {
+    const auto res = de.des_int();
+    return static_cast<T>(res);
+  }
+};
+
+template <trait::Float T>
+struct Deserialize<T> {
+  static auto deserialize(const auto& de) -> T {
+    const auto res = de.des_flt();
+    return static_cast<T>(res);
+  }
+};
+
+template <trait::Enum T>
+struct Deserialize<T> {
+  static auto deserialize(const auto& de) -> T {
+    const auto str = de.des_str();
+    const auto res = reflect::enum_from_name<T>(str);
+    assert_fmt(res, "serde::des<{}>: cannot parse `{}` to enum.", reflect::type_name<T>(), str);
+    return *res;
+  }
+};
+
+template <>
+struct Deserialize<bool> {
+  static auto deserialize(const auto& de) -> bool {
+    const auto res = de.des_bool();
+    return res;
+  }
+};
+
+template <>
+struct Deserialize<String> {
+  static auto deserialize(const auto& de) -> String {
+    const auto str = de.des_str();
+    return String{str};
+  }
+};
+
+template <class T>
+struct Deserialize<Vec<T>> {
+  template <class D>
+  static auto deserialize(const D& de) -> Vec<T> {
+    const auto& list = de.des_list();
+
+    auto res = Vec<T>::with_capacity(list.len());
+    for (const auto& e : list.as_slice()) {
+      auto val = D{e}.template des<T>();
+      res.push(static_cast<T&&>(val));
+    }
+    return res;
+  }
+};
+
+template <trait::Class T>
+struct Deserialize<T> {
+  template <class D>
+  static auto deserialize(const D& de) -> T {
+    const auto& dict = de.des_dict();
+
+    T res{};
+    auto info = reflect_struct(res);
+    info.fields().map([&](auto& field) {
+      auto name = Str{field.name};
+      auto node = dict.get(name);
+      assert_fmt(node, "serde::des<{}>: `{}` not found.", reflect::type_name<T>(), name);
+      Deserialize::des_field(D{*node}, field.value);
+    });
+    return res;
+  }
+
+ private:
+  template <class D, class U>
+  static void des_field(const D& de, const U& val) {
+    const_cast<U&>(val) = de.template des<U>();
+  }
+
+  template <class D, class U, usize N>
+  static void des_field(const D& de, const U (&val)[N]) {
+    auto& list = de.des_list();
+    assert_fmt(list.len() == N, "serde::des<{}[{}]>: len(=`{}`) not match", reflect::type_name<U>(),
+               N, list.len());
+
+    list.iter_mut().for_each_idx([&](auto j, auto& t) {  //
+      const_cast<U&>(val[j]) = D{t}.template des<U>();   //
+    });
+  }
+};
+
+class Deserializer {
+  const Node& _node;
+
+ public:
+  Deserializer(const Node& node) : _node{node} {}
+
+  auto des_null() const -> Null {
+    return _node.as_null();
+  }
+
+  auto des_bool() const -> bool {
+    return _node.as_bool();
+  }
+
+  auto des_int() const -> i64 {
+    return _node.as_int();
+  }
+
+  auto des_flt() const -> f64 {
+    if (_node.is_int()) {
+      const auto int_val = _node.as_int();
+      return static_cast<f64>(int_val);
+    }
+    return _node.as_flt();
+  }
+
+  auto des_str() const -> Str {
+    if (_node.is_null()) {
+      return "";
+    }
+    return _node.as_str();
+  }
+
+  auto des_list() const -> const List& {
+    return _node.as_list();
+  }
+
+  auto des_dict() const -> const Dict& {
+    return _node.as_dict();
+  }
+
+  template <class T>
+  auto des() const -> T {
+    return Deserialize<T>::deserialize(*this);
+  }
+
+  template <class T>
+  auto des() const -> T
+    requires(requires() { T::deserialize(*this); })
+  {
+    return T::deserialize(*this);
+  }
+};
+
+template <class T>
+auto deserialize(const Node& node) -> T {
+  auto imp = Deserializer{node};
+  auto res = imp.des<T>();
+  return res;
+}
+
+}  // namespace sfc::serde
diff --git a/src/sfc/serde/des/deserialize.h b/src/sfc/serde/des/deserialize.h
deleted file mode 100644
index 225fca9..0000000
--- a/src/sfc/serde/des/deserialize.h
+++ /dev/null
@@ -1,102 +0,0 @@
-#pragma once
-
-#include "sfc/serde/mod.h"
-
-namespace sfc::serde::des {
-
-template <class T>
-struct Deserialize;
-
-template <trait::Int T>
-struct Deserialize<T> {
-  static auto deserialize(const auto& de) -> T {
-    const auto res = de.des_int();
-    return static_cast<T>(res);
-  }
-};
-
-template <trait::Float T>
-struct Deserialize<T> {
-  static auto deserialize(const auto& de) -> T {
-    const auto res = de.des_flt();
-    return static_cast<T>(res);
-  }
-};
-
-template <trait::Enum T>
-struct Deserialize<T> {
-  static auto deserialize(const auto& de) -> T {
-    const auto str = de.des_str();
-    const auto res = reflect::enum_from_name<T>(str);
-    assert_fmt(res, "serde::des<{}>: cannot parse `{}` to enum.", reflect::type_name<T>(), str);
-    return *res;
-  }
-};
-
-template <>
-struct Deserialize<bool> {
-  static auto deserialize(const auto& de) -> bool {
-    const auto res = de.des_bool();
-    return res;
-  }
-};
-
-template <>
-struct Deserialize<String> {
-  static auto deserialize(const auto& de) -> String {
-    const auto str = de.des_str();
-    return String{str};
-  }
-};
-
-template <class T>
-struct Deserialize<Vec<T>> {
-  template <class D>
-  static auto deserialize(const D& de) -> Vec<T> {
-    const auto& list = de.des_list();
-
-    auto res = Vec<T>::with_capacity(list.len());
-    for (const auto& e : list.as_slice()) {
-      auto val = D{e}.template des<T>();
-      res.push(static_cast<T&&>(val));
-    }
-    return res;
-  }
-};
-
-template <trait::Class T>
-struct Deserialize<T> {
-  template <class D>
-  static auto deserialize(const D& de) -> T {
-    const auto& dict = de.des_dict();
-
-    T res{};
-    auto info = reflect_struct(res);
-    info.fields().map([&](auto& field) {
-      auto name = Str{field.name};
-      auto node = dict.get(name);
-      assert_fmt(node, "serde::des<{}>: `{}` not found.", reflect::type_name<T>(), name);
-      Deserialize::des_field(D{*node}, field.value);
-    });
-    return res;
-  }
-
- private:
-  template <class D, class U>
-  static void des_field(const D& de, const U& val) {
-    const_cast<U&>(val) = de.template des<U>();
-  }
-
-  template <class D, class U, usize N>
-  static void des_field(const D& de, const U (&val)[N]) {
-    auto& list = de.des_list();
-    assert_fmt(list.len() == N, "serde::des<{}[{}]>: len(=`{}`) not match", reflect::type_name<U>(),
-               N, list.len());
-
-    list.iter_mut().for_each_idx([&](auto j, auto& t) {  //
-      const_cast<U&>(val[j]) = D{t}.template des<U>();   //
-    });
-  }
-};
-
-}  // namespace sfc::serde::des
diff --git a/src/sfc/serde/des/deserializer.h b/src/sfc/serde/des/deserializer.h
deleted file mode 100644
index b48f58d..0000000
--- a/src/sfc/serde/des/deserializer.h
+++ /dev/null
@@ -1,74 +0,0 @@
-#pragma once
-
-#include "deserialize.h"
-
-namespace sfc::serde::des {
-
-class Deserializer {
-  const serde::Node& _node;
-
- public:
-  using Node = serde::Node;
-
-  Deserializer(const Node& node) : _node{node} {}
-
-  auto des_null() const -> Null {
-    return _node.as_null();
-  }
-
-  auto des_bool() const -> bool {
-    return _node.as_bool();
-  }
-
-  auto des_int() const -> i64 {
-    return _node.as_int();
-  }
-
-  auto des_flt() const -> f64 {
-    if (_node.is_int()) {
-      const auto int_val = _node.as_int();
-      return static_cast<f64>(int_val);
-    }
-    return _node.as_flt();
-  }
-
-  auto des_str() const -> Str {
-    if (_node.is_null()) {
-      return "";
-    }
-    return _node.as_str();
-  }
-
-  auto des_list() const -> const List& {
-    return _node.as_list();
-  }
-
-  auto des_dict() const -> const Dict& {
-    return _node.as_dict();
-  }
-
-  template <class T>
-  auto des() const -> T {
-    return Deserialize<T>::deserialize(*this);
-  }
-
-  template <class T>
-  auto des() const -> T
-    requires(requires() { T::deserialize(*this); })
-  {
-    return T::deserialize(*this);
-  }
-};
-
-template <class T>
-[[nodiscard]] auto deserialize(const Node& node) -> T {
-  auto imp = Deserializer{node};
-  auto res = imp.des<T>();
-  return res;
-}
-
-}  // namespace sfc::serde::des
-
-namespace sfc::serde {
-using des::deserialize;
-}  // namespace sfc::serde
diff --git a/src/sfc/serde/json/parse.cc b/src/sfc/serde/json.cc
similarity index 96%
rename from src/sfc/serde/json/parse.cc
rename to src/sfc/serde/json.cc
index 297aeb3..f8de489 100644
--- a/src/sfc/serde/json/parse.cc
+++ b/src/sfc/serde/json.cc
@@ -1,6 +1,5 @@
-#include "parse.h"
-
-#include "sfc/fs.h"
+#include "json.h"
+#include "sfc/fs/file.h"
 
 namespace sfc::serde::json {
 
@@ -226,11 +225,3 @@ auto load(fs::Path path) -> Option<Node> {
 }
 
 }  // namespace sfc::serde::json
-
-namespace sfc::serde {
-
-auto Node::from_json(Str text) -> Option<Node> {
-  return json::parse(text);
-}
-
-}  // namespace sfc::serde
diff --git a/src/sfc/serde/json.h b/src/sfc/serde/json.h
index 4673246..edfdce4 100644
--- a/src/sfc/serde/json.h
+++ b/src/sfc/serde/json.h
@@ -1,4 +1,129 @@
 #pragma once
 
-#include "json/fmt.h"
-#include "json/parse.h"
+#include "sfc/fs/path.h"
+#include "sfc/serde/node.h"
+
+namespace sfc::serde::json {
+
+template <class W>
+class Fmter : fmt::Fmter<W> {
+  using Imp = fmt::Fmter<W>;
+
+  class DebugStruct {
+    Fmter& _fmt;
+    usize _cnt = 0;
+
+   public:
+    explicit DebugStruct(Fmter& fmt) : _fmt{fmt} {
+      _fmt.write_str("{");
+    }
+
+    ~DebugStruct() {
+      _fmt.write_str("}");
+    }
+
+    DebugStruct(const DebugStruct&) = delete;
+
+    void field(Str name, const auto& value) {
+      if (_cnt != 0) {
+        _fmt.write_str(", ");
+      }
+
+      _fmt.write_str("\"");
+      _fmt.write_str(name);
+      _fmt.write_str("\": ");
+      _fmt.write(value);
+
+      _cnt += 1;
+    }
+
+    void fields(auto iter) {
+      iter.for_each([&](auto&& item) {
+        const auto& k = item.template get<0>();
+        const auto& v = item.template get<1>();
+        this->entry(k, v);
+      });
+    }
+  };
+
+ public:
+  using Imp::Imp;
+
+  using Imp::set_style;
+  using Imp::style;
+
+  using Imp::pad_num;
+  using Imp::write_chr;
+  using Imp::write_str;
+
+  void pad(Str val) {
+    this->write_chr('"');
+    this->write_str(val);
+    this->write_chr('"');
+  }
+
+  void write(const auto& val) {
+    return this->write_imp(val);
+  }
+
+  void write_fmt(const auto& fmts, const auto&... args) {
+    fmt::Args{fmts, args...}.fmt(*this);
+  }
+
+  auto debug_tuple() {
+    return fmt::DebugList<Fmter>{*this};
+  }
+
+  auto debug_list() {
+    return fmt::DebugList<Fmter>{*this};
+  }
+
+  auto debug_set() {
+    return fmt::DebugList<Fmter>{*this};
+  }
+
+  auto debug_map() {
+    return fmt::DebugMap<Fmter>{*this};
+  }
+
+  auto debug_struct() {
+    return DebugStruct{*this};
+  }
+
+ private:
+  void write_imp(const auto& val) {
+    if constexpr (requires { val.fmt(*this); }) {
+      val.fmt(*this);
+    } else {
+      trait::as<fmt::IFmt>(val).fmt(*this);
+    }
+  }
+};
+
+void write(auto& out, const auto& val) {
+  Fmter{out}.write(val);
+}
+
+auto format(const auto& val) -> String {
+  auto res = String{};
+  Fmter<String>{res}.write(val);
+  return res;
+}
+
+auto parse(Str json_str) -> Option<Node>;
+
+auto load(fs::Path path) -> Option<Node>;
+
+}  // namespace sfc::serde::json
+
+namespace sfc::serde {
+
+inline auto Node::from_json(Str text) -> Option<Node> {
+  return json::parse(text);
+}
+
+inline auto Node::to_json() const -> String {
+  return json::format(*this);
+}
+
+}  // namespace sfc::serde
diff --git a/src/sfc/serde/json/fmt.cc b/src/sfc/serde/json/fmt.cc
deleted file mode 100644
index af5a6cc..0000000
--- a/src/sfc/serde/json/fmt.cc
+++ /dev/null
@@ -1,9 +0,0 @@
-#include "fmt.h"
-
-namespace sfc::serde {
-
-auto Node::to_json() const -> String {
-  return json::format(*this);
-}
-
-}  // namespace sfc::serde
diff --git a/src/sfc/serde/json/fmt.h b/src/sfc/serde/json/fmt.h
deleted file mode 100644
index e5fb394..0000000
--- a/src/sfc/serde/json/fmt.h
+++ /dev/null
@@ -1,120 +0,0 @@
-#pragma once
-
-#include "sfc/serde/mod.h"
-
-namespace sfc::serde::json {
-
-template <class W>
-class Fmter : fmt::Fmter<W> {
-  using Imp = fmt::Fmter<W>;
-  using Imp::_style;
-
-  class DebugStruct {
-    ptr::Unique<Fmter> _fmt;
-    usize _cnt = 0;
-
-   public:
-    explicit DebugStruct(Fmter& fmt) : _fmt{&fmt} {
-      _fmt->write_str("{");
-    }
-
-    ~DebugStruct() {
-      if (!_fmt) return;
-      _fmt->write_str("}");
-    }
-
-    DebugStruct(DebugStruct&&) noexcept = default;
-
-    void field(Str name, const auto& value) {
-      if (_cnt != 0) {
-        _fmt->write_str(", ");
-      }
-
-      _fmt->write_str("\"");
-      _fmt->write_str(name);
-      _fmt->write_str("\": ");
-      _fmt->write(value);
-
-      _cnt += 1;
-    }
-
-    void fields(auto iter) {
-      iter.for_each([&](auto&& item) {
-        const auto& k = item.template get<0>();
-        const auto& v = item.template get<1>();
-        this->entry(k, v);
-      });
-    }
-  };
-
- public:
-  using Imp::Imp;
-
-  using Imp::set_style;
-  using Imp::style;
-
-  using Imp::pad_num;
-  using Imp::write_chr;
-  using Imp::write_str;
-
-  void pad(Str val) {
-    this->write_chr('"');
-    this->write_str(val);
-    this->write_chr('"');
-  }
-
-  void write(const auto& val) {
-    return this->write_imp(val);
-  }
-
-  template <class... U>
-  void write_fmt(Str fmts, const U&... args) {
-    fmt::Args<U...>{fmts, args...}.fmt(*this);
-  }
-
-  auto debug_tuple() {
-    return fmt::DebugList<Fmter>{*this};
-  }
-
-  auto debug_list() {
-    return fmt::DebugList<Fmter>{*this};
-  }
-
-  auto debug_set() {
-    return fmt::DebugList<Fmter>{*this};
-  }
-
-  auto debug_map() {
-    return fmt::DebugMap<Fmter>{*this};
-  }
-
-  auto debug_struct() {
-    return DebugStruct{*this};
-  }
-
- private:
-  template <class T>
-  void write_imp(const T& val) {
-    trait::as<fmt::IFmt>(val).fmt(*this);
-  }
-
-  template <fmt::XFmt T>
-  void write_imp(const T& val) {
-    val.fmt(*this);
-  }
-};
-
-template <class W>
-void write(W& out, const auto& val) {
-  auto imp = Fmter<W>{out};
-  imp.write(val);
-}
-
-auto format(const auto& val) -> String {
-  auto res = String{};
-  auto imp = Fmter<String>{res};
-  imp.write(val);
-  return res;
-}
-
-}  // namespace sfc::serde::json
diff --git a/src/sfc/serde/json/parse.h b/src/sfc/serde/json/parse.h
deleted file mode 100644
index 63352e9..0000000
--- a/src/sfc/serde/json/parse.h
+++ /dev/null
@@ -1,11 +0,0 @@
-#pragma once
-
-#include "sfc/serde/mod.h"
-
-namespace sfc::serde::json {
-
-auto parse(Str json_str) -> Option<Node>;
-
-auto load(fs::Path path) -> Option<Node>;
-
-}  // namespace sfc::serde::json
diff --git a/src/sfc/serde/mod.cc b/src/sfc/serde/node.cc
similarity index 99%
rename from src/sfc/serde/mod.cc
rename to src/sfc/serde/node.cc
index eec9849..ea46c2d 100644
--- a/src/sfc/serde/mod.cc
+++ b/src/sfc/serde/node.cc
@@ -1,4 +1,4 @@
-#include "mod.h"
+#include "node.h"
 
 namespace sfc::serde {
 
diff --git a/src/sfc/serde/mod.h b/src/sfc/serde/node.h
similarity index 97%
rename from src/sfc/serde/mod.h
rename to src/sfc/serde/node.h
index 19bacfe..e5f2c6f 100644
--- a/src/sfc/serde/mod.h
+++ b/src/sfc/serde/node.h
@@ -1,7 +1,6 @@
 #pragma once
 
 #include "sfc/collections.h"
-#include "sfc/fs.h"
 
 namespace sfc::serde {
 
@@ -17,7 +16,7 @@ struct Null {
 using List = Vec<Node>;
 using Dict = VecMap<String, Node>;
 
-class Node {
+class [[nodiscard]] Node {
   using Inn = Variant<Null, bool, i64, f64, String, List, Dict>;
   Inn _inn;
 
diff --git a/src/sfc/serde/ser.h b/src/sfc/serde/ser.h
index 5dd73ba..2aca1e8 100644
--- a/src/sfc/serde/ser.h
+++ b/src/sfc/serde/ser.h
@@ -1,4 +1,250 @@
 #pragma once
 
-#include "ser/serialize.h"
-#include "ser/serializer.h"
+#include "sfc/serde/node.h"
+
+namespace sfc::serde {
+
+template <class T>
+class Serialize;
+
+template <reflect::iReflect T>
+class Serialize<T> : T {
+ public:
+  auto serialize(const auto& se) const {
+    const auto info = reflect_struct(static_cast<const T&>(*this));
+    auto res = se.ser_dict();
+    info.fields().map([&](const auto& item) {
+      auto node = se.ser(item.value);
+      res.insert(item.name, mem::move(node));
+    });
+    return res;
+  }
+};
+
+template <>
+class Serialize<bool> {
+  bool _val;
+
+ public:
+  auto serialize(const auto& se) const {
+    return se.ser_bool(_val);
+  }
+};
+
+template <>
+class Serialize<const char*> {
+  const char* _val;
+
+ public:
+  auto serialize(const auto& se) const {
+    return se.ser_str(_val);
+  }
+};
+
+template <trait::Int T>
+class Serialize<T> {
+  T _val;
+
+ public:
+  auto serialize(const auto& se) const {
+    return se.ser_int(static_cast<i64>(_val));
+  }
+};
+
+template <trait::Float T>
+class Serialize<T> {
+  T _val;
+
+ public:
+  auto serialize(const auto& se) const {
+    auto ret = se.ser_flt(static_cast<f64>(_val));
+    return ret;
+  }
+};
+
+template <trait::Enum T>
+class Serialize<T> {
+  T _val;
+
+ public:
+  auto serialize(const auto& se) const {
+    const auto s = reflect::enum_name(_val);
+    return se.ser_str(s);
+  }
+};
+
+template <class T, usize N>
+class Serialize<T[N]> {
+  T _val[N];
+
+ public:
+  auto serialize(const auto& se) const {
+    auto res = se.ser_list();
+    for (auto& e : _val) {
+      auto node = se.ser(e);
+      res.push(mem::move(node));
+    }
+    return res;
+  }
+};
+
+template <>
+class Serialize<Str> : Str {
+ public:
+  auto serialize(const auto& se) const {
+    return se.ser_str(*this);
+  }
+};
+
+template <>
+class Serialize<String> : String {
+ public:
+  auto serialize(const auto& se) const {
+    return se.ser_str(*this);
+  }
+};
+
+template <class S>
+class FmtAdapter {
+  const S& _ser;
+  Node& _node;
+
+ public:
+  FmtAdapter(const S& ser, Node& node) : _ser{ser}, _node{node} {}
+
+  struct DebugList {
+    const S& _ser;
+    Node& _root;
+
+    void entry(const auto& element) {
+      auto node = _ser.ser(element);
+      _root.push(mem::move(node));
+    }
+
+    void entries(auto iter) {
+      for (; auto e = iter.next();) {
+        this->entry(e.get_unchecked());
+      }
+    }
+  };
+
+  struct DebugMap {
+    const S& _ser;
+    Node& _root;
+
+    void entry(Str name, const auto& element) {
+      auto node = _ser.ser(element);
+      _root.insert(name, mem::move(node));
+    }
+
+    void entries(auto iter) {
+      iter.for_each([&](auto&& item) {  //
+        this->entry(item.template get<0>(), item.template get<1>());
+      });
+    }
+  };
+
+  struct DebugStruct {
+    const S& _ser;
+    Node& _root;
+
+    void field(Str name, const auto& element) {
+      auto node = _ser.ser(element);
+      _root.insert(name, mem::move(node));
+    }
+  };
+
+  auto debug_tuple() -> DebugList {
+    _node = _ser.ser_list();
+    return DebugList{_ser, _node};
+  }
+
+  auto debug_list() -> DebugList {
+    _node = _ser.ser_list();
+    return DebugList{_ser, _node};
+  }
+
+  auto debug_set() -> DebugList {
+    _node = _ser.ser_list();
+    return DebugList{_ser, _node};
+  }
+
+  auto debug_map() -> DebugMap {
+    _node = _ser.ser_dict();
+    return DebugMap{_ser, _node};
+  }
+
+  auto debug_struct() -> DebugStruct {
+    _node = _ser.ser_dict();
+    return DebugStruct{_ser, _node};
+  }
+
+  void write(const auto& val) {
+    _node = _ser.ser(val);
+  }
+};
+
+template <class T>
+class Serialize : T {
+ public:
+  template <class S>
+  auto serialize(const S& se) const {
+    auto res = Node{};
+    auto imp = FmtAdapter<S>{se, res};
+    T::fmt(imp);
+    return res;
+  }
+};
+
+struct Serializer {
+  using Node = serde::Node;
+  using List = serde::List;
+  using Dict = serde::Dict;
+
+  auto ser_null() const -> Node {
+    return Node{};
+  }
+
+  auto ser_bool(bool val) const -> Node {
+    return Node{val};
+  }
+
+  auto ser_int(i64 val) const -> Node {
+    return Node{val};
+  }
+
+  auto ser_flt(f64 val) const -> Node {
+    return Node{val};
+  }
+
+  auto ser_str(Str val) const -> Node {
+    return Node{val};
+  }
+
+  auto ser_list() const -> Node {
+    return Node{List{}};
+  }
+
+  auto ser_dict() const -> Node {
+    return Node{Dict{}};
+  }
+
+  auto ser(const auto& val) const -> Node
+    requires(requires() { val.serialize(*this); })
+  {
+    return val.serialize(*this);
+  }
+
+  template <class T>
+  auto ser(const T& val) const -> Node {
+    return ptr::cast<Serialize<T>>(&val)->serialize(*this);
+  }
+};
+
+auto serialize(const auto& val) -> Node {
+  auto imp = Serializer{};
+  auto res = imp.ser(val);
+  return res;
+}
+
+}  // namespace sfc::serde::ser
diff --git a/src/sfc/serde/ser/serialize.h b/src/sfc/serde/ser/serialize.h
deleted file mode 100644
index 0739c1f..0000000
--- a/src/sfc/serde/ser/serialize.h
+++ /dev/null
@@ -1,199 +0,0 @@
-#pragma once
-
-#include "sfc/serde/mod.h"
-
-namespace sfc::serde::ser {
-
-template <class T>
-class Serialize;
-
-template <reflect::iReflect T>
-class Serialize<T> : T {
- public:
-  auto serialize(const auto& se) const {
-    const auto info = reflect_struct(static_cast<const T&>(*this));
-    auto res = se.ser_dict();
-    info.fields().map([&](const auto& item) {
-      auto node = se.ser(item.value);
-      res.insert(item.name, mem::move(node));
-    });
-    return res;
-  }
-};
-
-template <>
-class Serialize<bool> {
-  bool _val;
-
- public:
-  auto serialize(const auto& se) const {
-    return se.ser_bool(_val);
-  }
-};
-
-template <>
-class Serialize<const char*> {
-  const char* _val;
-
- public:
-  auto serialize(const auto& se) const {
-    return se.ser_str(_val);
-  }
-};
-
-template <trait::Int T>
-class Serialize<T> {
-  T _val;
-
- public:
-  auto serialize(const auto& se) const {
-    return se.ser_int(static_cast<i64>(_val));
-  }
-};
-
-template <trait::Float T>
-class Serialize<T> {
-  T _val;
-
- public:
-  auto serialize(const auto& se) const {
-    auto ret = se.ser_flt(static_cast<f64>(_val));
-    return ret;
-  }
-};
-
-template <trait::Enum T>
-class Serialize<T> {
-  T _val;
-
- public:
-  auto serialize(const auto& se) const {
-    const auto s = reflect::enum_name(_val);
-    return se.ser_str(s);
-  }
-};
-
-template <class T, usize N>
-class Serialize<T[N]> {
-  T _val[N];
-
- public:
-  auto serialize(const auto& se) const {
-    auto res = se.ser_list();
-    for (auto& e : _val) {
-      auto node = se.ser(e);
-      res.push(mem::move(node));
-    }
-    return res;
-  }
-};
-
-template <>
-class Serialize<Str> : Str {
- public:
-  auto serialize(const auto& se) const {
-    return se.ser_str(*this);
-  }
-};
-
-template <>
-class Serialize<String> : String {
- public:
-  auto serialize(const auto& se) const {
-    return se.ser_str(*this);
-  }
-};
-
-template <class S>
-class FmtAdapter {
-  const S& _ser;
-  Node& _node;
-
- public:
-  FmtAdapter(const S& ser, Node& node) : _ser{ser}, _node{node} {}
-
-  struct DebugList {
-    const S& _ser;
-    Node& _root;
-
-    void entry(const auto& element) {
-      auto node = _ser.ser(element);
-      _root.push(mem::move(node));
-    }
-
-    void entries(auto iter) {
-      for (; auto e = iter.next();) {
-        this->entry(e.get_unchecked());
-      }
-    }
-  };
-
-  struct DebugMap {
-    const S& _ser;
-    Node& _root;
-
-    void entry(Str name, const auto& element) {
-      auto node = _ser.ser(element);
-      _root.insert(name, mem::move(node));
-    }
-
-    void entries(auto iter) {
-      iter.for_each([&](auto&& item) {  //
-        this->entry(item.template get<0>(), item.template get<1>());
-      });
-    }
-  };
-
-  struct DebugStruct {
-    const S& _ser;
-    Node& _root;
-
-    void field(Str name, const auto& element) {
-      auto node = _ser.ser(element);
-      _root.insert(name, mem::move(node));
-    }
-  };
-
-  auto debug_tuple() -> DebugList {
-    _node = _ser.ser_list();
-    return DebugList{_ser, _node};
-  }
-
-  auto debug_list() -> DebugList {
-    _node = _ser.ser_list();
-    return DebugList{_ser, _node};
-  }
-
-  auto debug_set() -> DebugList {
-    _node = _ser.ser_list();
-    return DebugList{_ser, _node};
-  }
-
-  auto debug_map() -> DebugMap {
-    _node = _ser.ser_dict();
-    return DebugMap{_ser, _node};
-  }
-
-  auto debug_struct() -> DebugStruct {
-    _node = _ser.ser_dict();
-    return DebugStruct{_ser, _node};
-  }
-
-  void write(const auto& val) {
-    _node = _ser.ser(val);
-  }
-};
-
-template <class T>
-class Serialize : T {
- public:
-  template <class S>
-  auto serialize(const S& se) const {
-    auto res = Node{};
-    auto imp = FmtAdapter<S>{se, res};
-    T::fmt(imp);
-    return res;
-  }
-};
-
-}  // namespace sfc::serde::ser
diff --git a/src/sfc/serde/ser/serializer.h b/src/sfc/serde/ser/serializer.h
deleted file mode 100644
index 2065901..0000000
--- a/src/sfc/serde/ser/serializer.h
+++ /dev/null
@@ -1,62 +0,0 @@
-#pragma once
-
-#include "serialize.h"
-
-namespace sfc::serde::ser {
-
-struct Serializer {
-  using Node = serde::Node;
-  using List = serde::List;
-  using Dict = serde::Dict;
-
-  auto ser_null() const -> Node {
-    return Node{};
-  }
-
-  auto ser_bool(bool val) const -> Node {
-    return Node{val};
-  }
-
-  auto ser_int(i64 val) const -> Node {
-    return Node{val};
-  }
-
-  auto ser_flt(f64 val) const -> Node {
-    return Node{val};
-  }
-
-  auto ser_str(Str val) const -> Node {
-    return Node{val};
-  }
-
-  auto ser_list() const -> Node {
-    return Node{List{}};
-  }
-
-  auto ser_dict() const -> Node {
-    return Node{Dict{}};
-  }
-
-  auto ser(const auto& val) const -> Node
-    requires(requires() { val.serialize(*this); })
-  {
-    return val.serialize(*this);
-  }
-
-  template <class T>
-  auto ser(const T& val) const -> Node {
-    return ptr::cast<Serialize<T>>(&val)->serialize(*this);
-  }
-};
-
-[[nodiscard]] auto serialize(const auto& val) -> Node {
-  auto imp = ser::Serializer{};
-  auto res = imp.ser(val);
-  return res;
-}
-
-}  // namespace sfc::serde::ser
-
-namespace sfc::serde {
-using ser::serialize;
-}  // namespace sfc::serde
diff --git a/test/core/tuple.cxx b/test/core/tuple.cxx
new file mode 100644
index 0000000..ffb844f
--- /dev/null
+++ b/test/core/tuple.cxx
@@ -0,0 +1,5 @@
+#include "sfc/core.h"
+
+namespace sfc::tuple {
+
+}
diff --git a/test/core/variant.cxx b/test/core/variant.cxx
new file mode 100644
index 0000000..d31fa67
--- /dev/null
+++ b/test/core/variant.cxx
@@ -0,0 +1,9 @@
+#include <variant>
+
+#include "sfc/test.h"
+
+namespace sfc::variant {
+
+
+
+}  // namespace sfc::variant
diff --git a/test/serde/ser.cxx b/test/serde/ser.cxx
index d48260a..51b0273 100644
--- a/test/serde/ser.cxx
+++ b/test/serde/ser.cxx
@@ -4,17 +4,17 @@
 #include "sfc/serde.h"
 #include "sfc/test.h"
 
-namespace sfc::serde::ser {
+namespace sfc::serde {
 
 SFC_TEST(ser_bool) {
   {
-    auto node = ser::serialize(true);
+    auto node = serde::serialize(true);
     test::assert_true(node.is_bool());
     test::assert_true(node.as_bool());
   }
 
   {
-    auto node = ser::serialize(false);
+    auto node = serde::serialize(false);
     test::assert_true(node.is_bool());
     test::assert_false(node.as_bool());
   }
@@ -22,13 +22,13 @@ SFC_TEST(ser_bool) {
 
 SFC_TEST(ser_int) {
   {
-    auto node = ser::serialize(-123);
+    auto node = serde::serialize(-123);
     test::assert_true(node.is_int());
     test::assert_eq(node.as_int(), -123);
   }
 
   {
-    auto node = ser::serialize(12345678910U);
+    auto node = serde::serialize(12345678910U);
     test::assert_true(node.is_int());
     test::assert_eq(node.as_int(), static_cast<i64>(12345678910U));
   }
@@ -36,13 +36,13 @@ SFC_TEST(ser_int) {
 
 SFC_TEST(ser_flt) {
   {
-    auto node = ser::serialize(-1.23);
+    auto node = serde::serialize(-1.23);
     test::assert_true(node.is_flt());
     test::assert_flt_eq(node.as_flt(), -1.23);
   }
 
   {
-    auto node = ser::serialize(+1.23f);
+    auto node = serde::serialize(+1.23f);
     test::assert_true(node.is_flt());
     test::assert_flt_eq(node.as_flt(), +1.23f);
   }
@@ -50,13 +50,13 @@ SFC_TEST(ser_flt) {
 
 SFC_TEST(ser_str) {
   {
-    auto node = ser::serialize(Str{""});
+    auto node = serde::serialize(Str{""});
     test::assert_true(node.is_str());
     test::assert_eq(node.as_str(), Str{""});
   }
 
   {
-    auto node = ser::serialize(Str{"abc"});
+    auto node = serde::serialize(Str{"abc"});
     test::assert_true(node.is_str());
     test::assert_eq(node.as_str(), Str{"abc"});
   }
@@ -65,7 +65,7 @@ SFC_TEST(ser_str) {
 SFC_TEST(ser_array) {
   {
     const int v[] = {1, 2, 3};
-    auto node = ser::serialize(v);
+    auto node = serde::serialize(v);
     test::assert_true(node.is_list());
 
     const auto& list = node.as_list();
@@ -86,7 +86,7 @@ SFC_TEST(ser_vector) {
     v.push(2);
     v.push(3);
 
-    auto node = ser::serialize(v);
+    auto node = serde::serialize(v);
     test::assert_true(node.is_list());
 
     const auto& list = node.as_list();
@@ -106,7 +106,7 @@ SFC_TEST(ser_dict) {
     v.insert(String::from("a"), 1);
     v.insert(String::from("b"), 2);
 
-    auto node = ser::serialize(v);
+    auto node = serde::serialize(v);
     test::assert_true(node.is_dict());
 
     auto& dict = node.as_dict();