[deque] erase should check boundary correctly when on move left

.gitignore

@@ -20,3 +20,6 @@ compile_commands.json
 # --- Exceptions ---
 # Allow documentation HTMLs
 !docs/**/*.html
+# Claw Code local artifacts
+.claude/settings.local.json
+.claude/sessions/

benchmark/0011.containers/deque/0007.insert_single/fast_io.cc

@@ -0,0 +1,32 @@
+#include <fast_io.h>
+#include <fast_io_driver/timer.h>
+#include <fast_io_dsal/deque.h>
+#include <cstddef>
+
+int main()
+{
+	fast_io::timer tm(u8"fast_io::deque insert single");
+	fast_io::deque<std::size_t> dq;
+	constexpr std::size_t n{50000};
+
+	{
+		fast_io::timer t(u8"insert_index");
+		for (std::size_t i{}; i != n; ++i)
+		{
+			::std::size_t dqsz{dq.size()};
+			std::size_t pos = dqsz ? (i % dqsz) : 0;
+			dq.insert_index(pos, i);
+		}
+	}
+
+	std::size_t sum{};
+	{
+		fast_io::timer t(u8"loop");
+		for (auto const e : dq)
+		{
+			sum += e;
+		}
+	}
+
+	fast_io::io::perrln("sum=", sum);
+}

benchmark/0011.containers/deque/0007.insert_single/fast_io_emplace.cc

@@ -0,0 +1,32 @@
+#include <fast_io.h>
+#include <fast_io_driver/timer.h>
+#include <fast_io_dsal/deque.h>
+#include <cstddef>
+
+int main()
+{
+	fast_io::timer tm(u8"fast_io::deque emplace single");
+	fast_io::deque<std::size_t> dq;
+	constexpr std::size_t n{50000};
+
+	{
+		fast_io::timer t(u8"emplace_index");
+		for (std::size_t i{}; i != n; ++i)
+		{
+			::std::size_t dqsz{dq.size()};
+			std::size_t pos = dqsz ? (i % dqsz) : 0;
+			dq.emplace_index(pos, i);
+		}
+	}
+
+	std::size_t sum{};
+	{
+		fast_io::timer t(u8"loop");
+		for (auto const e : dq)
+		{
+			sum += e;
+		}
+	}
+
+	fast_io::io::perrln("sum=", sum);
+}

benchmark/0011.containers/deque/0007.insert_single/fast_io_iter.cc

@@ -0,0 +1,32 @@
+#include <fast_io.h>
+#include <fast_io_driver/timer.h>
+#include <fast_io_dsal/deque.h>
+#include <cstddef>
+
+int main()
+{
+	fast_io::timer tm(u8"fast_io::deque insert iterator");
+	fast_io::deque<std::size_t> dq;
+	constexpr std::size_t n{50000};
+
+	{
+		fast_io::timer t(u8"insert(iterator)");
+		for (std::size_t i{}; i != n; ++i)
+		{
+			::std::size_t dqsz{dq.size()};
+			std::size_t pos = dqsz ? (i % dqsz) : 0;
+			dq.insert(dq.begin() + pos, i);
+		}
+	}
+
+	std::size_t sum{};
+	{
+		fast_io::timer t(u8"loop");
+		for (auto const e : dq)
+		{
+			sum += e;
+		}
+	}
+
+	fast_io::io::perrln("sum=", sum);
+}

benchmark/0011.containers/deque/0007.insert_single/std.cc

@@ -0,0 +1,32 @@
+#include <fast_io.h>
+#include <fast_io_driver/timer.h>
+#include <deque>
+#include <cstddef>
+
+int main()
+{
+	fast_io::timer tm(u8"std::deque insert single");
+	::std::deque<std::size_t> dq;
+	constexpr std::size_t n{50000};
+
+	{
+		fast_io::timer t(u8"insert");
+		for (std::size_t i{}; i != n; ++i)
+		{
+			::std::size_t dqsz{dq.size()};
+			std::size_t pos = dqsz ? (i % dqsz) : 0;
+			dq.insert(dq.begin() + pos, i);
+		}
+	}
+
+	std::size_t sum{};
+	{
+		fast_io::timer t(u8"loop");
+		for (auto const e : dq)
+		{
+			sum += e;
+		}
+	}
+
+	fast_io::io::perrln("sum=", sum);
+}

fuzzing/0007.containers/deque/fuzz_deque_insert_single.cc

@@ -0,0 +1,75 @@
+#include <fast_io.h>
+#include <fast_io_dsal/deque.h>
+#include <deque>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <ranges>
+
+extern "C" int LLVMFuzzerTestOneInput(uint8_t const *data, size_t size)
+{
+	::fast_io::deque<std::size_t> dq;
+	std::deque<std::size_t> ref;
+
+	for (size_t i{}; i != size; ++i)
+	{
+		uint8_t b = data[i];
+
+		// 4 operations: insert single at various positions
+		uint8_t op = b & 0x3u;
+
+		// Position: [0, size]
+		std::size_t pos = dq.size() == 0 ? 0 : (static_cast<std::size_t>(b) * 37u) % (dq.size() + 1);
+
+		std::size_t value = i * 1315423911ull;
+
+		switch (op)
+		{
+		case 0: // insert_index (single element)
+		{
+			dq.insert_index(pos, value);
+			ref.insert(ref.begin() + pos, value);
+			break;
+		}
+
+		case 1: // insert using iterator (single element)
+		{
+			auto it = dq.insert(dq.cbegin() + pos, value);
+			(void)it;
+			ref.insert(ref.begin() + pos, value);
+			break;
+		}
+
+		case 2: // erase single element (to keep sizes bounded)
+		{
+			if (!ref.empty())
+			{
+				std::size_t p = pos % ref.size();
+				dq.erase_index(p);
+				ref.erase(ref.begin() + p);
+			}
+			break;
+		}
+
+		case 3: // emplace_index (single element)
+		{
+			dq.emplace_index(pos, value);
+			ref.emplace(ref.begin() + pos, value);
+			break;
+		}
+		}
+
+		// Validate correctness
+		if (dq.size() != ref.size())
+		{
+			__builtin_trap();
+		}
+
+		if (!std::ranges::equal(dq, ref))
+		{
+			__builtin_trap();
+		}
+	}
+
+	return 0;
+}

include/fast_io_dsal/impl/debug/common.h

@@ -0,0 +1,24 @@
+#pragma once
+
+namespace fast_io
+{
+
+namespace manipulators
+{
+
+template <typename T>
+struct debug_view_t
+{
+	using manip_tag = manip_tag_t;
+	T reference;
+};
+
+template <typename T>
+inline constexpr debug_view_t<T const &> debug_view(T const &v) noexcept
+{
+	return ::fast_io::manipulators::debug_view_t<T const &>{v};
+}
+
+} // namespace manipulators
+
+} // namespace fast_io