From 4489d513be66e46abdb2bb54ee77047a65232582 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Fri, 24 Jul 2026 21:28:58 +0300
Subject: [PATCH] migrate to std::ranges

Move the various seq_ functions, as well as std::(stable_)sort,
std::accumulate, std::transform, std::find, std::find_if to their C++20
std::ranges counterparts.
---
 lib/message/mu-contact.cc       |  2 +-
 lib/message/mu-document.cc      |  7 ++---
 lib/message/mu-fields.cc        |  4 +--
 lib/message/mu-labels.cc        |  4 +--
 lib/message/mu-message-part.cc  |  6 ++--
 lib/message/mu-message.cc       |  4 +--
 lib/message/mu-mime-object.cc   |  2 +-
 lib/message/mu-mime-object.hh   |  2 +-
 lib/message/test-mu-message.cc  |  2 +-
 lib/mu-contacts-cache.cc        |  6 ++--
 lib/mu-query-parser.cc          |  2 +-
 lib/mu-query-threads.cc         | 11 +++-----
 lib/mu-scanner.cc               | 10 +++----
 lib/mu-script.cc                |  4 +--
 lib/mu-server.cc                |  6 ++--
 lib/mu-store-labels.cc          |  7 ++---
 lib/mu-store.cc                 |  6 ++--
 lib/tests/test-mu-store.cc      | 10 +++----
 lib/utils/mu-command-handler.hh |  2 +-
 lib/utils/mu-html-to-text.cc    |  6 ++--
 lib/utils/mu-utils.cc           | 24 ++++++----------
 lib/utils/mu-utils.hh           | 50 ---------------------------------
 lib/utils/tests/test-utils.cc   |  4 +++
 mu/mu-cmd-extract.cc            |  2 +-
 mu/mu-cmd-info.cc               |  4 +--
 mu/mu-cmd-move.cc               |  2 +-
 mu/mu-cmd-script.cc             |  2 +-
 mu/mu-cmd-view.cc               |  2 +-
 scm/mu-scm.cc                   |  9 +++---
 29 files changed, 71 insertions(+), 131 deletions(-)

diff --git a/lib/message/mu-contact.cc b/lib/message/mu-contact.cc
index 22795db8..0b232f49 100644
--- a/lib/message/mu-contact.cc
+++ b/lib/message/mu-contact.cc
@@ -51,7 +51,7 @@ Mu::to_string(const Mu::Contacts& contacts)
 {
 	std::string res;
 
-	seq_for_each(contacts, [&](auto&& contact) {
+	std::ranges::for_each(contacts, [&](auto&& contact) {
 		if (res.empty())
 			res = contact.display_name();
 		else
diff --git a/lib/message/mu-document.cc b/lib/message/mu-document.cc
index 6d090fc4..1be1eebc 100644
--- a/lib/message/mu-document.cc
+++ b/lib/message/mu-document.cc
@@ -145,9 +145,8 @@ Document::add(Field::Id id, const std::vector<std::string>& vals)
 		xdoc_.add_value(field.value_no(), Mu::join(vals, SepaChar1));
 
 	if (field.is_searchable())
-		std::for_each(vals.begin(), vals.end(),
-			      [&](const auto& val) {
-				      add_search_term(field, val); });
+		std::ranges::for_each(vals, [&](const auto& val) {
+			add_search_term(field, val); });
 
 	if (field.include_in_sexp()) {
 		Sexp elms{};
@@ -169,7 +168,7 @@ make_contacts_sexp(const Contacts& contacts)
 {
 	Sexp contacts_sexp;
 
-	seq_for_each(contacts, [&](auto&& c) {
+	std::ranges::for_each(contacts, [&](auto&& c) {
 		Sexp contact(":email"_sym, c.email);
 		if (!c.name.empty())
 			contact.add(":name"_sym, c.name);
diff --git a/lib/message/mu-fields.cc b/lib/message/mu-fields.cc
index f653a04a..b2618b85 100644
--- a/lib/message/mu-fields.cc
+++ b/lib/message/mu-fields.cc
@@ -61,7 +61,7 @@ Mu::fields_from_name(const std::string& name) {
 
 	static const FieldsVec empty;
 	const auto& cfields{combi_fields()};
-	const auto it = seq_find_if(cfields, [&](const auto& cfield) {
+	const auto it = std::ranges::find_if(cfields, [&](const auto& cfield) {
 		return cfield.name == name;
 	});
 
@@ -71,7 +71,7 @@ Mu::fields_from_name(const std::string& name) {
 bool
 Mu::field_is_combi(const std::string& name)
 {
-	return !name.empty() && seq_some(combi_fields(),[&](const auto& cfield) {
+	return !name.empty() && std::ranges::any_of(combi_fields(),[&](const auto& cfield) {
 		return cfield.name == name;
 	});
 }
diff --git a/lib/message/mu-labels.cc b/lib/message/mu-labels.cc
index fd56be28..b50ee6d6 100644
--- a/lib/message/mu-labels.cc
+++ b/lib/message/mu-labels.cc
@@ -246,8 +246,8 @@ test_updated_labels()
 
 	const auto delta_labels = [](std::initializer_list<std::string> strs)->DeltaLabelVec {
 		DeltaLabelVec deltas;
-		std::transform(strs.begin(), strs.end(), std::back_inserter(deltas),
-			       [](auto str) {
+		std::ranges::transform(strs, std::back_inserter(deltas),
+				       [](auto str) {
 				       const auto res = parse_delta_label(str);
 				       assert_valid_result(res);
 				       return *res;
diff --git a/lib/message/mu-message-part.cc b/lib/message/mu-message-part.cc
index e97534b3..129b11ce 100644
--- a/lib/message/mu-message-part.cc
+++ b/lib/message/mu-message-part.cc
@@ -51,7 +51,7 @@ cook(const std::string& fname, const std::vector<char>& forbidden)
 	clean.reserve(fname.length());
 
 	for (auto& c: basename(fname))
-		if (seq_some(forbidden,[&](char fc){
+		if (std::ranges::any_of(forbidden,[&](char fc){
 			return is_ascii_cntrl(c) || c == fc;}))
 			clean += '-';
 		else
@@ -190,8 +190,8 @@ MessagePart::looks_like_attachment() const noexcept
 {
 	auto matches=[](const MimeContentType& ctype,
 			const std::initializer_list<std::pair<const char*, const char*>>& ctypes) {
-		return std::find_if(ctypes.begin(), ctypes.end(), [&](auto&& item){
-			return ctype.is_type(item.first, item.second); }) != ctypes.end();
+		return std::ranges::any_of(ctypes, [&](auto&& item){
+			return ctype.is_type(item.first, item.second); });
 	};
 
 	const auto ctype{mime_object().content_type()};
diff --git a/lib/message/mu-message.cc b/lib/message/mu-message.cc
index 57230098..fbd6df60 100644
--- a/lib/message/mu-message.cc
+++ b/lib/message/mu-message.cc
@@ -314,7 +314,7 @@ get_priority(const MimeMessage& mime_msg)
 	if (!opt_str)
 		return  Priority::Normal;
 
-	const auto it = seq_find_if(prio_alist, [&](auto&& item) {
+	const auto it = std::ranges::find_if(prio_alist, [&](auto&& item) {
 		return g_ascii_strncasecmp(item.first.data(), opt_str->c_str(),
 					   item.first.size()) == 0; });
 
@@ -331,7 +331,7 @@ extract_tags(const MimeMessage& mime_msg)
 	});
 
 	std::vector<std::string> tags;
-	seq_for_each(tag_headers, [&](auto&& item) {
+	std::ranges::for_each(tag_headers, [&](auto&& item) {
 		if (auto&& hdr = mime_msg.header(item.first); hdr) {
 			for (auto&& tagval : split(*hdr, item.second)) {
 				tagval.erase(0, tagval.find_first_not_of(' '));
diff --git a/lib/message/mu-mime-object.cc b/lib/message/mu-mime-object.cc
index 1ab43d33..684b41a1 100644
--- a/lib/message/mu-mime-object.cc
+++ b/lib/message/mu-mime-object.cc
@@ -447,7 +447,7 @@ MimeMessage::references() const noexcept
 {
 	// is ref already in the list? O(n) but with small n.
 	auto is_dup = [](auto&& seq, const std::string& ref) {
-		return seq_some(seq, [&](auto&& str) { return ref == str; });
+		return std::ranges::any_of(seq, [&](auto&& str) { return ref == str; });
 	};
 
 	auto on_blacklist = [](auto&& msgid) {
diff --git a/lib/message/mu-mime-object.hh b/lib/message/mu-mime-object.hh
index 45f4d2bb..d0839faf 100644
--- a/lib/message/mu-mime-object.hh
+++ b/lib/message/mu-mime-object.hh
@@ -313,7 +313,7 @@ private:
 
 template<typename S, typename T>
 constexpr Option<std::string_view> to_string_view_opt(const S& seq, T t) {
-	auto&& it = seq_find_if(seq, [&](auto&& item){return item.first == t;});
+	auto&& it = std::ranges::find_if(seq, [&](auto&& item){return item.first == t;});
 	if (it == seq.cend())
 		return Nothing;
 	else
diff --git a/lib/message/test-mu-message.cc b/lib/message/test-mu-message.cc
index e09e9758..f1da499e 100644
--- a/lib/message/test-mu-message.cc
+++ b/lib/message/test-mu-message.cc
@@ -119,7 +119,7 @@ goto * instructions[pOp->opcode];
 
 	auto all_contacts{message->all_contacts()};
 	g_assert_cmpuint(all_contacts.size(), ==, 4);
-	seq_sort(all_contacts, [](auto&& c1, auto&& c2){return c1.email < c2.email; });
+	std::ranges::sort(all_contacts, [](auto&& c1, auto&& c2){return c1.email < c2.email; });
 	assert_equal(all_contacts[0].email, "anon@example.com");
 	assert_equal(all_contacts[1].email, "sqlite-dev-bounces@sqlite.org");
 	assert_equal(all_contacts[2].email, "sqlite-dev@sqlite.org");
diff --git a/lib/mu-contacts-cache.cc b/lib/mu-contacts-cache.cc
index 186639fe..3525d2d0 100644
--- a/lib/mu-contacts-cache.cc
+++ b/lib/mu-contacts-cache.cc
@@ -74,7 +74,9 @@ private:
 	}
 
 	template<Config::Id Id> StringVec make_matchers() const {
-		return seq_remove(config_db_.get<Id>(), is_rx);
+		auto matchers{config_db_.get<Id>()};
+		std::erase_if(matchers, is_rx);
+		return matchers;
 	}
 	template<Config::Id Id> std::vector<Regex> make_rx_matchers() const {
 		std::vector<Regex> rxvec;
@@ -234,7 +236,7 @@ ContactsCache::add(Contact&& contact)
 void
 ContactsCache::add(Contacts&& contacts, bool& personal)
 {
-	personal = seq_find_if(contacts,[&](auto&& c){
+	personal = std::ranges::find_if(contacts,[&](auto&& c){
 		return is_personal(c.email); }) != contacts.cend();
 
 	for (auto&& contact: contacts) {
diff --git a/lib/mu-query-parser.cc b/lib/mu-query-parser.cc
index 577b1703..9f75322a 100644
--- a/lib/mu-query-parser.cc
+++ b/lib/mu-query-parser.cc
@@ -55,7 +55,7 @@ looks_like_matcher(const Sexp& sexp)
 		return false;
 
 	const auto symbol{sexp.front().symbol()};
-	if (seq_some(value_syms, [&](auto &&sym) { return symbol == sym; }))
+	if (std::ranges::any_of(value_syms, [&](auto &&sym) { return symbol == sym; }))
 		return true;
 	else if (!!field_from_name(symbol.name) || field_is_combi(symbol.name))
 		 return true;
diff --git a/lib/mu-query-threads.cc b/lib/mu-query-threads.cc
index 93fa4327..69921cb7 100644
--- a/lib/mu-query-threads.cc
+++ b/lib/mu-query-threads.cc
@@ -489,10 +489,7 @@ sort_container(Container& container)
 
 	// now sort this level; use a stable sort so messages with equal
 	// dates keep their original (mset) order.
-	std::stable_sort(container.children.begin(), container.children.end(),
-			 [](auto&& c1, auto&& c2) {
-		return c1->thread_date_key < c2->thread_date_key;
-	});
+	std::ranges::stable_sort(container.children, {}, &Container::thread_date_key);
 
 	// and 'bubble up' the date of the *newest* message with a date. We
 	// reasonably assume that it's later than its parent.
@@ -527,7 +524,7 @@ sort_siblings(IdTable& id_table, bool descending)
 	//
 	// Note that unless we're testing, _xapian_ will handle
 	// the ascending/descending of the top level.
-	std::stable_sort(root_vec.begin(), root_vec.end(), [&](auto&& c1, auto&& c2) {
+	std::ranges::stable_sort(root_vec, [&](auto&& c1, auto&& c2) {
 #ifdef BUILD_TESTS
 		if (descending)
 			return c2->thread_date_key < c1->thread_date_key;
@@ -558,7 +555,7 @@ operator<<(std::ostream& os, const IdTable& id_table)
 	}
 
 	for (auto&& id : ids) {
-		auto it = std::find_if(id_table.begin(), id_table.end(), [&](auto&& item) {
+		auto it = std::ranges::find_if(id_table, [&](auto&& item) {
 			return item.second.query_match &&
 			       item.second.query_match->thread_path == id;
 		});
@@ -664,7 +661,7 @@ static void
 assert_thread_paths(const MockQueryResults& qrs, const Expected& expected)
 {
 	for (auto&& exp : expected) {
-		auto it = std::find_if(qrs.begin(), qrs.end(), [&](auto&& qr) {
+		auto it = std::ranges::find_if(qrs, [&](auto&& qr) {
 			return qr.message_id().value_or("") == exp.first ||
 			       qr.path().value_or("") == exp.first;
 		});
diff --git a/lib/mu-scanner.cc b/lib/mu-scanner.cc
index b49d8c2f..2d646dcc 100644
--- a/lib/mu-scanner.cc
+++ b/lib/mu-scanner.cc
@@ -250,8 +250,8 @@ Scanner::Private::process_dir(const std::string& path, bool is_maildir)
 #if HAVE_DIRENT_D_INO
 	// sort by i-node; much faster on rotational (HDDs) devices and on SSDs
 	// sort is quick enough to not matter much
-	std::sort(dir_entries.begin(), dir_entries.end(),
-		  [](auto&& d1, auto&& d2){ return d1.d_ino < d2.d_ino; });
+	std::ranges::sort(dir_entries,
+			  [](auto&& d1, auto&& d2){ return d1.d_ino < d2.d_ino; });
 #endif /*HAVEN_DIRENT_D_INO*/
 
 	// now process...
@@ -379,9 +379,9 @@ test_count_maildirs()
 	while (scanner.is_running()) { g_usleep(1000); }
 
 	g_assert_cmpuint(dirs.size(),==,3);
-	g_assert_true(seq_find_if(dirs, [](auto& p){return p == "bar";}) != dirs.end());
-	g_assert_true(seq_find_if(dirs, [](auto& p){return p == "Foo";}) != dirs.end());
-	g_assert_true(seq_find_if(dirs, [](auto& p){return p == "wom_bat";}) != dirs.end());
+	g_assert_true(std::ranges::find(dirs, "bar") != dirs.end());
+	g_assert_true(std::ranges::find(dirs, "Foo") != dirs.end());
+	g_assert_true(std::ranges::find(dirs, "wom_bat") != dirs.end());
 }
 
 static void
diff --git a/lib/mu-script.cc b/lib/mu-script.cc
index e69b1488..b89c2fb8 100644
--- a/lib/mu-script.cc
+++ b/lib/mu-script.cc
@@ -125,9 +125,7 @@ Mu::script_infos(const Mu::ScriptPaths& paths)
 		script_infos_in_dir(dir, infos);
 	}
 
-	std::sort(infos.begin(), infos.end(), [](auto&& i1, auto&& i2) {
-		return i1.name < i2.name;
-	});
+	std::ranges::sort(infos, {}, &ScriptInfo::name);
 
 	return infos;
 }
diff --git a/lib/mu-server.cc b/lib/mu-server.cc
index a98f97fd..c60fea00 100644
--- a/lib/mu-server.cc
+++ b/lib/mu-server.cc
@@ -571,8 +571,8 @@ std::string quoted_join(const T& items, F&& func)
 {
 	std::vector<std::string> vec;
 
-	std::transform(items.begin(), items.end(), std::back_inserter(vec),
-		       [&](const auto& item) { return quote(func(item)); });
+	std::ranges::transform(items, std::back_inserter(vec),
+			       [&](const auto& item) { return quote(func(item)); });
 
 	return join(vec,  " ");
 }
@@ -827,7 +827,7 @@ Server::Private::help_handler(const Command& cmd)
 	for (auto&& name_cmd: info_map)
 		names.emplace_back(name_cmd.first);
 
-	std::sort(names.begin(), names.end());
+	std::ranges::sort(names);
 
 	for (auto&& name : names) {
 		const auto& info{info_map.find(name)->second};
diff --git a/lib/mu-store-labels.cc b/lib/mu-store-labels.cc
index 11f125c3..84d1c9a7 100644
--- a/lib/mu-store-labels.cc
+++ b/lib/mu-store-labels.cc
@@ -143,10 +143,9 @@ import_labels_for_message(Mu::Store& store, bool dry_run, Level level,
 	using namespace Labels;
 
 	Labels::DeltaLabelVec delta_labels{};
-	std::transform(labels.begin(), labels.end(),
-		       std::back_inserter(delta_labels),
-		       [](const auto& label) {
-			       return DeltaLabel{Delta::Add, label}; });
+	std::ranges::transform(labels, std::back_inserter(delta_labels),
+			       [](const auto& label) {
+				       return DeltaLabel{Delta::Add, label}; });
 
 	const auto qres = [&]()->Result<QueryResults>{
 		// plan A: match by path
diff --git a/lib/mu-store.cc b/lib/mu-store.cc
index 51cee6e1..cec5b089 100644
--- a/lib/mu-store.cc
+++ b/lib/mu-store.cc
@@ -650,8 +650,8 @@ Store::move_message(Store::Id id,
 	}
 
 	// sort the dup paths by name;
-	std::sort(id_paths.begin() + 1, id_paths.end(),
-		  [](const auto& idp1, const auto& idp2) { return idp1.second < idp2.second; });
+	std::ranges::sort(id_paths.begin() + 1, id_paths.end(),
+			  [](const auto& idp1, const auto& idp2) { return idp1.second < idp2.second; });
 
 	return Ok(std::move(id_paths));
 }
@@ -811,7 +811,7 @@ Store::maildirs() const
 
 	Scanner scanner{root_maildir(), handler, Scanner::Mode::MaildirsOnly};
 	scanner.start();
-	std::sort(mdirs.begin(), mdirs.end());
+	std::ranges::sort(mdirs);
 
 	return mdirs;
 }
diff --git a/lib/tests/test-mu-store.cc b/lib/tests/test-mu-store.cc
index b4db62e9..409abb72 100644
--- a/lib/tests/test-mu-store.cc
+++ b/lib/tests/test-mu-store.cc
@@ -101,8 +101,8 @@ test_store_reinit()
 
 		const auto addrs{store->config().get<Config::Id::PersonalAddresses>()};
 		g_assert_cmpuint(addrs.size(),==,2);
-		g_assert_true(seq_some(addrs, [](auto&& a){return a=="foo@example.com";}));
-		g_assert_true(seq_some(addrs, [](auto&& a){return a=="bar@example.com";}));
+		g_assert_true(std::ranges::any_of(addrs, [](auto&& a){return a=="foo@example.com";}));
+		g_assert_true(std::ranges::any_of(addrs, [](auto&& a){return a=="bar@example.com";}));
 
 		const auto msgpath{MuTestMaildir + "/cur/1283599333.1840_11.cthulhu!2,"};
 		const auto id = store->add_message(msgpath);
@@ -597,9 +597,9 @@ test_store_maildirs()
 	const auto mdirs = store->maildirs();
 
 	g_assert_cmpuint(mdirs.size(), ==, 3);
-	g_assert(seq_some(mdirs, [](auto&& m){return m == "/Foo";}));
-	g_assert(seq_some(mdirs, [](auto&& m){return m == "/bar";}));
-	g_assert(seq_some(mdirs, [](auto&& m){return m == "/wom_bat";}));
+	g_assert(std::ranges::any_of(mdirs, [](auto&& m){return m == "/Foo";}));
+	g_assert(std::ranges::any_of(mdirs, [](auto&& m){return m == "/bar";}));
+	g_assert(std::ranges::any_of(mdirs, [](auto&& m){return m == "/wom_bat";}));
 }
 
 
diff --git a/lib/utils/mu-command-handler.hh b/lib/utils/mu-command-handler.hh
index 09515369..891dc8cf 100644
--- a/lib/utils/mu-command-handler.hh
+++ b/lib/utils/mu-command-handler.hh
@@ -224,7 +224,7 @@ struct CommandHandler {
 			std::vector<std::string> names;
 			for (auto&& arg : args)
 				names.emplace_back(arg.first);
-			std::sort(names.begin(), names.end(), [&](const auto& name1, const auto& name2) {
+			std::ranges::sort(names, [&](const auto& name1, const auto& name2) {
 				const auto& arg1{args.find(name1)->second};
 				const auto& arg2{args.find(name2)->second};
 				if (arg1.required != arg2.required)
diff --git a/lib/utils/mu-html-to-text.cc b/lib/utils/mu-html-to-text.cc
index 0512c7bb..81331e4b 100644
--- a/lib/utils/mu-html-to-text.cc
+++ b/lib/utils/mu-html-to-text.cc
@@ -354,7 +354,7 @@ needs_separator(std::string_view tagname)
 	constexpr auto nosep_tags = std::to_array<const char*>({
 		"b", "em", "i", "s", "strike", "tt", "u"
 	});
-	return !seq_some(nosep_tags, [&](auto&& t){return matches(tagname, t);});
+	return !std::ranges::any_of(nosep_tags, [&](auto&& t){return matches(tagname, t);});
 }
 
 static bool // do we need to skip the element completely?
@@ -363,7 +363,7 @@ is_skip_element(std::string_view tagname)
 	constexpr auto skip_tags = std::to_array<const char*>({
 		"head", "title"
 	});
-	return seq_some(skip_tags, [&](auto&& t){return matches(tagname, t);});
+	return std::ranges::any_of(skip_tags, [&](auto&& t){return matches(tagname, t);});
 }
 
 // skip the end-tag
@@ -518,7 +518,7 @@ html_escape_char(Context& ctx)
 			if (matches(esc, n.name))
 				return std::string{n.repl};
 
-		if (seq_some(accents, [&](auto&& a){
+		if (std::ranges::any_of(accents, [&](auto&& a){
 			return starts_with(esc.substr(1), a);}))
 			return std::string(1, to_ascii_lower(esc.front()));
 
diff --git a/lib/utils/mu-utils.cc b/lib/utils/mu-utils.cc
index 145adca7..e53c2ecb 100644
--- a/lib/utils/mu-utils.cc
+++ b/lib/utils/mu-utils.cc
@@ -34,7 +34,6 @@
 #include <string.h>
 #include <iostream>
 #include <algorithm>
-#include <numeric>
 #include <functional>
 #include <cinttypes>
 #include <charconv>
@@ -339,25 +338,18 @@ Mu::join(const std::vector<std::string>& svec, const std::string& sepa)
 
 
 	/* calculate the overall size beforehand, to avoid re-allocations. */
-	size_t value_len =
-		std::accumulate(svec.cbegin(), svec.cend(), std::size_t{},
-				[](size_t size, const std::string& s) {
-					return size + s.size();
-				}) + (svec.size() - 1) * sepa.length();
+	size_t value_len{(svec.size() - 1) * sepa.length()};
+	for (const auto& s : svec)
+		value_len += s.size();
 
 	std::string value;
 	value.reserve(value_len);
 
-	std::accumulate(svec.cbegin(), svec.cend(), std::ref(value),
-			[&](std::string& s1, const std::string& s2)->std::string& {
-				if (s1.empty())
-					s1 = s2;
-				else {
-					s1.append(sepa);
-					s1.append(s2);
-				}
-				return s1;
-			});
+	value.append(svec.front());
+	for (auto it = std::next(svec.cbegin()); it != svec.cend(); ++it) {
+		value.append(sepa);
+		value.append(*it);
+	}
 
 	return value;
 }
diff --git a/lib/utils/mu-utils.hh b/lib/utils/mu-utils.hh
index 93efc105..edb39a2a 100644
--- a/lib/utils/mu-utils.hh
+++ b/lib/utils/mu-utils.hh
@@ -656,56 +656,6 @@ inline std::string shell_quote(const std::string& str) {
 std::string to_lexnum(int64_t val);
 int64_t from_lexnum(const std::string& str);
 
-/**
- * Like std::find_if, but using sequence instead of a range.
- *
- * @param seq some std::find_if compatible sequence
- * @param pred a predicate
- *
- * @return an iterator
- */
-template<typename Sequence, typename UnaryPredicate>
-typename Sequence::const_iterator seq_find_if(const Sequence& seq, UnaryPredicate pred) {
-	return std::find_if(seq.cbegin(), seq.cend(), pred);
-}
-
-/**
- * Is pred(element) true for at least one element of sequence?
- *
- * @param seq sequence
- * @param pred a predicate
- *
- * @return true or false
- */
-template<typename Sequence, typename UnaryPredicate>
-bool seq_some(const Sequence& seq, UnaryPredicate pred) {
-	return seq_find_if(seq, pred) != seq.cend();
-}
-
-/**
- * Create a sequence that has all element of seq for which pred is false
- *
- * @param seq sequence
- * @param pred false
- *
- * @return sequence
- */
-template<typename Sequence, typename UnaryPredicate>
-Sequence seq_remove(const Sequence& seq, UnaryPredicate pred) {
-	Sequence res;
-	std::remove_copy_if(seq.begin(), seq.end(), std::back_inserter(res), pred);
-	return res;
-}
-
-template<typename Sequence, typename Compare>
-void seq_sort(Sequence& seq, Compare cmp) { std::sort(seq.begin(), seq.end(), cmp); }
-
-
-template<typename Sequence, typename UnaryOp>
-void seq_for_each(const Sequence& seq, UnaryOp op) {
-	std::for_each(seq.cbegin(), seq.cend(), op);
-}
-
 struct MaybeAnsi {
 	explicit MaybeAnsi(bool use_color) : color_{use_color} {}
 
diff --git a/lib/utils/tests/test-utils.cc b/lib/utils/tests/test-utils.cc
index 34238258..6acc4d75 100644
--- a/lib/utils/tests/test-utils.cc
+++ b/lib/utils/tests/test-utils.cc
@@ -260,6 +260,10 @@ test_join()
 	assert_equal(join({"a", "b", "c"}, ""), "abc");
 	assert_equal(join({},"foo"), "");
 	assert_equal(join({"d", "e", "f"}, "foo"), "dfooefoof");
+	// empty elements are joined, too
+	assert_equal(join({"", "a"}, ","), ",a");
+	assert_equal(join({"", ""}, ","), ",");
+	assert_equal(join({"a"}, ","), "a");
 }
 
 
diff --git a/mu/mu-cmd-extract.cc b/mu/mu-cmd-extract.cc
index 28793b3a..36319fec 100644
--- a/mu/mu-cmd-extract.cc
+++ b/mu/mu-cmd-extract.cc
@@ -63,7 +63,7 @@ save_parts(const Message& message, const std::string& filename_rx,
 			else if (opts.extract.save_attachments &&
 			    part.looks_like_attachment())
 				return true;
-			else if (seq_some(opts.extract.parts,
+			else if (std::ranges::any_of(opts.extract.parts,
 				     [&](auto&& num){return num==partnum;}))
 				return true;
 			else if (!filename_rx.empty() && part.raw_filename()) {
diff --git a/mu/mu-cmd-info.cc b/mu/mu-cmd-info.cc
index 219f1415..2c2eb437 100644
--- a/mu/mu-cmd-info.cc
+++ b/mu/mu-cmd-info.cc
@@ -144,10 +144,10 @@ topic_combi_fields(const Options& opts)
 	Table fields;
 	fields.add_row({"combi-field", "fields"});
 
-	seq_for_each(combi_fields(), [&](const auto& cfield) {
+	std::ranges::for_each(combi_fields(), [&](const auto& cfield) {
 
 		std::string fnames;
-		seq_for_each(cfield.fields, [&](auto&& field) {
+		std::ranges::for_each(cfield.fields, [&](auto&& field) {
 			if (!fnames.empty())
 				fnames += ", ";
 			fnames +=  mu_format("{}", field.name);
diff --git a/mu/mu-cmd-move.cc b/mu/mu-cmd-move.cc
index c0c2ecc4..dcbc9b32 100644
--- a/mu/mu-cmd-move.cc
+++ b/mu/mu-cmd-move.cc
@@ -49,7 +49,7 @@ Mu::mu_cmd_move(Mu::Store& store, const Options& opts)
 			   "Must have at least one of destination and flags");
 	else if (!dest.empty()) {
 		const auto mdirs{store.maildirs()};
-		if (!seq_some(mdirs, [&](auto &&d){ return d == dest;}))
+		if (!std::ranges::any_of(mdirs, [&](auto &&d){ return d == dest;}))
 			return Err(Error{Error::Code::InvalidArgument,
 					"No maildir '{}' in store", dest}
 				.add_hint("Try 'mu mkdir'"));
diff --git a/mu/mu-cmd-script.cc b/mu/mu-cmd-script.cc
index 2302dd75..c0642963 100644
--- a/mu/mu-cmd-script.cc
+++ b/mu/mu-cmd-script.cc
@@ -30,7 +30,7 @@ Mu::mu_cmd_script(const Options& opts)
 {
 	ScriptPaths paths = { MU_SCRIPTS_DIR };
 	const auto&& scriptinfos{script_infos(paths)};
-	auto script_it = Mu::seq_find_if(scriptinfos, [&](auto&& item) {
+	auto script_it = std::ranges::find_if(scriptinfos, [&](auto&& item) {
 		return item.name == opts.script.name;
 	});
 
diff --git a/mu/mu-cmd-view.cc b/mu/mu-cmd-view.cc
index 27fcfca0..e1a140c3 100644
--- a/mu/mu-cmd-view.cc
+++ b/mu/mu-cmd-view.cc
@@ -46,7 +46,7 @@ static std::string /* return comma-sep'd list of attachments */
 get_attach_str(const Message& message, const Options& opts)
 {
 	std::string str;
-	seq_for_each(message.parts(), [&](auto&& part) {
+	std::ranges::for_each(message.parts(), [&](auto&& part) {
 		if (auto fname = part.raw_filename(); fname) {
 			if (str.empty())
 				str = fname.value();
diff --git a/scm/mu-scm.cc b/scm/mu-scm.cc
index 068c2c8e..395c6298 100644
--- a/scm/mu-scm.cc
+++ b/scm/mu-scm.cc
@@ -196,11 +196,10 @@ run_scm(const Mu::Store& store, const Mu::Options& opts)
 		       [](auto _data, auto _argc, auto _argv) {
 			       mu_mod = scm_c_define_module ("mu", init_module_mu, &mu_data);
 		std::vector<char*> args;
-		std::transform(scm_args.begin(),
-			       scm_args.end(), std::back_inserter(args),
-			       [&](const std::string& strarg){
-				       /* ahem...*/
-				       return const_cast<char*>(strarg.c_str());
+		std::ranges::transform(scm_args, std::back_inserter(args),
+				       [](const std::string& strarg){
+					       /* ahem...*/
+					       return const_cast<char*>(strarg.c_str());
 		});
 		scm_shell(args.size(), args.data());