diff --git a/applications/test/CircularBuffer/Test-CircularBuffer.C b/applications/test/CircularBuffer/Test-CircularBuffer.C
index 98cde44170..e28b105401 100644
--- a/applications/test/CircularBuffer/Test-CircularBuffer.C
+++ b/applications/test/CircularBuffer/Test-CircularBuffer.C
@@ -34,7 +34,6 @@ Description
 #include "argList.H"
 #include "ListOps.H"
 #include "CircularBuffer.H"
-#include "StringStream.H"
 #include "FlatOutput.H"
 
 using namespace Foam;
@@ -79,7 +78,7 @@ int main(int argc, char *argv[])
 
     Info<< buf1[-12] << nl;
 
-    Info<< "found: " << buf1.found(40) << nl;
+    Info<< "contains: " << buf1.contains(40) << nl;
     buf1.push_uniq(100); report(buf1);
 
     buf1 = Zero; report(buf1);
diff --git a/applications/test/CompactListList/Test-CompactListList.C b/applications/test/CompactListList/Test-CompactListList.C
index a8ad0d471e..892fe58644 100644
--- a/applications/test/CompactListList/Test-CompactListList.C
+++ b/applications/test/CompactListList/Test-CompactListList.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2022 OpenCFD Ltd.
+    Copyright (C) 2022-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -35,7 +35,7 @@ Description
 #include "CompactListList.H"
 #include "IndirectList.H"
 #include "IOstreams.H"
-#include "StringStream.H"
+#include "SpanStream.H"
 #include "faceList.H"
 
 using namespace Foam;
@@ -126,20 +126,20 @@ int main(int argc, char *argv[])
 
     {
         // IO
-        OStringStream ostr;
+        OCharStream ostr;
         ostr << cll4;
 
-        IStringStream istr(ostr.str());
+        ISpanStream istr(ostr.view());
         CompactListList<label> cll5(istr);
         Info<< "cll5 = " << cll5 << endl;
     }
     {
         // IO
         cll4.clear();
-        OStringStream ostr;
+        OCharStream ostr;
         ostr << cll4;
 
-        IStringStream istr(ostr.str());
+        ISpanStream istr(ostr.view());
         CompactListList<label> cll5(istr);
         Info<< "cll5 = " << cll5 << endl;
     }
diff --git a/applications/test/DirLister/DirListerTemplates.C b/applications/test/DirLister/DirListerTemplates.C
index 7de1216c63..2b7cf16905 100644
--- a/applications/test/DirLister/DirListerTemplates.C
+++ b/applications/test/DirLister/DirListerTemplates.C
@@ -76,10 +76,10 @@ Foam::List<StringType> Foam::DirLister::csorted
     const bool prune
 ) const
 {
-    List<StringType> list(list<StringType>(pred, prune));
-    Foam::sort(list, stringOps::natural_sort());
+    List<StringType> result(list<StringType>(pred, prune));
+    Foam::sort(result, stringOps::natural_sort());
 
-    return list;
+    return result;
 }
 
 
diff --git a/applications/test/DynamicList/Test-DynamicList.C b/applications/test/DynamicList/Test-DynamicList.C
index ce6fb4b210..5f9e8b63fe 100644
--- a/applications/test/DynamicList/Test-DynamicList.C
+++ b/applications/test/DynamicList/Test-DynamicList.C
@@ -248,7 +248,7 @@ int main(int argc, char *argv[])
         addr.emplace_back(2);
 
         // Can also use the return value
-        Info<< "adding " << addr.emplace_back(4) << endl;
+        Info<< "adding " << addr.emplace_back(4) << nl;
 
         forAll(dlE2, i)
         {
@@ -325,7 +325,7 @@ int main(int argc, char *argv[])
 
         input1 = list2;
 
-        Info<< nl << "test subset/remove with "
+        Info<< nl << "test remove with "
             << flatOutput(input1) << endl;
 
         for
@@ -344,11 +344,35 @@ int main(int argc, char *argv[])
             list2 = input1;
 
             list1.remove(range);
-            list2.subset(range);
 
             Info<< "input = " << flatOutput(input1) << nl
-                << "remove " << range << " = " << flatOutput(list1) << nl
-                << "subset " << range << " = " << flatOutput(list2) << nl;
+                << "remove " << range << " = " << flatOutput(list1) << nl;
+        }
+
+        {
+            input1 = identity(5);
+            list1 = identity(4, 5);
+            list1.reserve(10);
+
+            Info<< nl << "test swap(List)" << nl;
+            Info<< "  input: " << input1.size()
+                << '/' << input1.capacity() << ' '
+                << flatOutput(input1) << nl;
+            Info<< "  list:  " << list1.size() << '/'
+                << list1.capacity() << ' '
+                << flatOutput(list1) << nl;
+
+
+            // input1.swap(list1);   // This is wrong!
+            list1.swap(input1);   // Correct
+
+            Info<< "after swap:" << nl;
+            Info<< "  input: " << input1.size()
+                << '/' << input1.capacity() << ' '
+                << flatOutput(input1) << nl;
+            Info<< "  list:  " << list1.size() << '/'
+                << list1.capacity() << ' '
+                << flatOutput(list1) << nl;
         }
     }
 
diff --git a/applications/test/DynamicList2/Test-DynamicList2.C b/applications/test/DynamicList2/Test-DynamicList2.C
index c97d6248e1..31a81ab827 100644
--- a/applications/test/DynamicList2/Test-DynamicList2.C
+++ b/applications/test/DynamicList2/Test-DynamicList2.C
@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2021-2022 OpenCFD Ltd.
+    Copyright (C) 2021-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -33,7 +33,6 @@ Description
 #include "IOstreams.H"
 #include "ITstream.H"
 #include "OTstream.H"
-#include "StringStream.H"
 #include "FlatOutput.H"
 #include "ListOps.H"
 #include "labelRange.H"
@@ -144,6 +143,29 @@ int main(int argc, char *argv[])
 
         list1.setCapacity(3);
         printInfo("", list1);
+
+        std::fill_n(std::back_inserter(list1), 10, 5);
+        Info<< "back_inserter to fill some values" << nl;
+        printInfo("", list1);
+
+        // Not very efficient, but just test for capability
+        DynamicList<label, 64> list2;
+
+        list2.resize(5);
+        ListOps::identity(list2);
+
+        Info<< "initial list" << nl;
+        printInfo("", list2);
+
+        labelRange range(10, 5);
+        std::copy(range.begin(), range.end(), std::back_inserter(list2));
+        Info<< "back_inserter to append some values" << nl;
+        printInfo("", list2);
+
+        range.reset(0, 4);
+        std::copy_n(range.begin(), range.size(), std::back_inserter(list2));
+        Info<< "back_inserter to append more values" << nl;
+        printInfo("", list2);
     }
 
     Info<< "\nEnd\n";
diff --git a/applications/test/FixedList/Test-FixedList.C b/applications/test/FixedList/Test-FixedList.C
index e7f4c4e7a8..ae4bbc995c 100644
--- a/applications/test/FixedList/Test-FixedList.C
+++ b/applications/test/FixedList/Test-FixedList.C
@@ -211,22 +211,6 @@ int main(int argc, char *argv[])
             << " hash:" << Hash<FixedList<label, 4>>()(list2) << nl;
 
 
-        // Test deprecated form
-        SLList<label> sllist3;
-        {
-            sllist3.push_back(0);
-            sllist3.push_back(1);
-            sllist3.push_back(2);
-            sllist3.push_back(3);
-        }
-        FixedList<label, 4> list3(sllist3);
-
-        Info<< "list3:" << list3 << nl;
-        // Test deprecated forms
-        list3 = array2;
-        list2 = sllist3;
-
-
         // Using FixedList for content too
         {
             List<FixedList<label, 4>> twolists{list1, list2};
diff --git a/applications/test/HashTable1/Test-HashTable1.C b/applications/test/HashTable1/Test-HashTable1.C
index 811e93fd65..0a1df9bcb5 100644
--- a/applications/test/HashTable1/Test-HashTable1.C
+++ b/applications/test/HashTable1/Test-HashTable1.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2017-2022 OpenCFD Ltd.
+    Copyright (C) 2017-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -31,7 +31,7 @@ License
 #include "DynamicList.H"
 #include "FlatOutput.H"
 #include "IOstreams.H"
-#include "StringStream.H"
+#include "SpanStream.H"
 #include "ListOps.H"
 #include "stringListOps.H"
 
@@ -119,9 +119,9 @@ int main()
         << table1["aaa"] << nl;
 
     {
-        OStringStream os;
+        OCharStream os;
         os  << table1;
-        HashTable<scalar> readTable(IStringStream(os.str())(), 100);
+        HashTable<scalar> readTable(ISpanStream(os.view())());
 
         Info<< "Istream constructor:" << readTable << endl;
     }
diff --git a/applications/test/ICharStream1/Test-ICharStream1.C b/applications/test/ICharStream1/Test-ICharStream1.C
index f4b18a1f43..cf36c3cddd 100644
--- a/applications/test/ICharStream1/Test-ICharStream1.C
+++ b/applications/test/ICharStream1/Test-ICharStream1.C
@@ -37,12 +37,28 @@ Description
 
 using namespace Foam;
 
-Ostream& writeList(Ostream& os, const UList<char>& list)
+Ostream& printString(Ostream& os, const char* first, const char* last)
+{
+    os << '"';
+    for (; first != last; (void)++first)
+    {
+        os << *first;
+    }
+    os << '"';
+
+    return os;
+}
+
+
+Ostream& printView(Ostream& os, const char* first, const char* last)
 {
     char buf[4];
-    os << list.size() << '(';
-    for (const char c : list)
+    os << label(last-first) << '(';
+
+    for (; first != last; (void)++first)
     {
+        const char c = *first;
+
         if (isprint(c))
         {
             os << c;
@@ -67,16 +83,35 @@ Ostream& writeList(Ostream& os, const UList<char>& list)
 }
 
 
+#if __cplusplus >= 201703L
+Ostream& printView(Ostream& os, std::string_view s)
+{
+    return printView(os, s.begin(), s.end());
+}
+#endif
+
+
+Ostream& printView(Ostream& os, stdFoam::span<char> s)
+{
+    return printView(os, s.begin(), s.end());
+}
+
+
+Ostream& printView(Ostream& os, const UList<char>& list)
+{
+    return printView(os, list.begin(), list.end());
+}
+
+
+Ostream& writeList(Ostream& os, const UList<char>& list)
+{
+    return printView(os, list.begin(), list.end());
+}
+
+
 Ostream& toString(Ostream& os, const UList<char>& list)
 {
-    os << '"';
-    for (const char c : list)
-    {
-        os << c;
-    }
-    os << '"';
-
-    return os;
+    return printString(os, list.begin(), list.end());
 }
 
 
@@ -85,6 +120,7 @@ void printInfo(const BufType& buf)
 {
     Info<< nl << "=========================" << endl;
     buf.print(Info);
+    Info<< "addr: " << Foam::name(buf.list().cdata()) << nl;
     toString(Info, buf.list());
     Info<< nl << "=========================" << endl;
 }
@@ -136,14 +172,16 @@ int main(int argc, char *argv[])
 
     Info<< "transfer contents to a List" << endl;
 
-    ICharStream ibuf;
-
     // Reclaim data storage from OCharStream -> ICharStream
-    {
-        List<char> data;
-        obuf.swap(data);
-        ibuf.swap(data);
-    }
+    ICharStream ibuf(std::move(obuf));
+
+    // OLD
+    // ICharStream ibuf;
+    // {
+    //     List<char> data;
+    //     obuf.swap(data);
+    //     ibuf.swap(data);
+    // }
 
     Info<< nl;
     Info<< nl << "input string:";
@@ -194,12 +232,12 @@ int main(int argc, char *argv[])
     printInfo(newvalues);
 
     {
-        iliststream is(std::move(newvalues));
+        icharstream is(std::move(newvalues));
 
         char c = 0;
 
         Info<< nl
-            << "getting values from iliststream of "
+            << "getting values from icharstream of "
             << is.list() << endl;
 
         // Info<< " (" << is.tellg() << " " << is.remaining() << ")";
diff --git a/applications/test/IntRange/Test-IntRange.C b/applications/test/IntRange/Test-IntRange.C
index 533d349bb1..4163ea7b40 100644
--- a/applications/test/IntRange/Test-IntRange.C
+++ b/applications/test/IntRange/Test-IntRange.C
@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2020 OpenCFD Ltd.
+    Copyright (C) 2020-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM, distributed under GPL-3.0-or-later.
@@ -20,7 +20,7 @@ Description
 #include "argList.H"
 #include "labelPair.H"
 #include "IntRange.H"
-#include "StringStream.H"
+#include "SpanStream.H"
 
 using namespace Foam;
 
@@ -75,9 +75,8 @@ int main(int argc, char *argv[])
 
     // Read from stream
     {
-        IStringStream is("(10 100)");
+        ICharStream is("(10 100)");
         intRange range;
-
         is >> range;
 
         Info<< "From stream int32_t: " << range << nl;
diff --git a/applications/test/List/Test-List.C b/applications/test/List/Test-List.C
index 03e77dcfef..ad0461e978 100644
--- a/applications/test/List/Test-List.C
+++ b/applications/test/List/Test-List.C
@@ -40,7 +40,7 @@ See also
 #include "wordRes.H"
 
 #include "IOstreams.H"
-#include "StringStream.H"
+#include "SpanStream.H"
 #include "scalar.H"
 #include "vector.H"
 
@@ -169,22 +169,31 @@ int main(int argc, char *argv[])
             Info<<" " << *iter;
         }
         Info<< nl;
-    }
 
+        Info<< "data:" << Foam::name(ident.cdata())
+            << " size:" << ident.size() << nl;
+
+
+        Info<< "resize_unsafe(10)" << nl;
+        ident.resize_unsafe(10);
+
+        Info<< "data:" << Foam::name(ident.cdata())
+            << " size:" << ident.size() << nl;
+    }
 
     if (false)
     {
-        labelList intlist(IStringStream("(0 1 2)")());
+        labelList intlist(ICharStream("(0 1 2)")());
         Info<<"construct from Istream: " << intlist << endl;
 
-        IStringStream("(3 4 5)")() >> static_cast<labelUList&>(intlist);
+        ICharStream("(3 4 5)")() >> static_cast<labelUList&>(intlist);
         Info<<"is >>: " << intlist << endl;
 
-        IStringStream("(6 7 8)")() >> intlist;
+        ICharStream("(6 7 8)")() >> intlist;
         Info<<"is >>: " << intlist << endl;
     }
 
-    List<vector> list1(IStringStream("1 ((0 1 2))")());
+    List<vector> list1(ICharStream("1 ((0 1 2))")());
     Info<< "list1: " << list1 << endl;
 
     List<vector> list2
diff --git a/applications/test/ListRead1/Test-ListRead1.C b/applications/test/ListRead1/Test-ListRead1.C
index 5c9c4fd91f..d7417235b4 100644
--- a/applications/test/ListRead1/Test-ListRead1.C
+++ b/applications/test/ListRead1/Test-ListRead1.C
@@ -37,7 +37,6 @@ Description
 
 #include "IOstreams.H"
 #include "Fstream.H"
-#include "StringStream.H"
 #include "scalar.H"
 #include "vector.H"
 
diff --git a/applications/test/OCharStream1/Test-OCharStream1.C b/applications/test/OCharStream1/Test-OCharStream1.C
index ccd663d30d..f4039f231b 100644
--- a/applications/test/OCharStream1/Test-OCharStream1.C
+++ b/applications/test/OCharStream1/Test-OCharStream1.C
@@ -37,12 +37,28 @@ Description
 
 using namespace Foam;
 
-Ostream& writeList(Ostream& os, const UList<char>& list)
+Ostream& printString(Ostream& os, const char* first, const char* last)
+{
+    os << '"';
+    for (; first != last; (void)++first)
+    {
+        os << *first;
+    }
+    os << '"';
+
+    return os;
+}
+
+
+Ostream& printView(Ostream& os, const char* first, const char* last)
 {
     char buf[4];
-    os << list.size() << '(';
-    for (const char c : list)
+    os << label(last-first) << '(';
+
+    for (; first != last; (void)++first)
     {
+        const char c = *first;
+
         if (isprint(c))
         {
             os << c;
@@ -67,16 +83,35 @@ Ostream& writeList(Ostream& os, const UList<char>& list)
 }
 
 
+#if __cplusplus >= 201703L
+Ostream& printView(Ostream& os, std::string_view s)
+{
+    return printView(os, s.begin(), s.end());
+}
+#endif
+
+
+Ostream& printView(Ostream& os, stdFoam::span<char> s)
+{
+    return printView(os, s.begin(), s.end());
+}
+
+
+Ostream& printView(Ostream& os, const UList<char>& list)
+{
+    return printView(os, list.begin(), list.end());
+}
+
+
+Ostream& writeList(Ostream& os, const UList<char>& list)
+{
+    return printView(os, list);
+}
+
+
 Ostream& toString(Ostream& os, const UList<char>& list)
 {
-    os << '"';
-    for (const char c : list)
-    {
-        os << c;
-    }
-    os << '"';
-
-    return os;
+    return printString(os, list.begin(), list.end());
 }
 
 
@@ -85,6 +120,7 @@ void printInfo(const BufType& buf)
 {
     Info<< nl << "=========================" << endl;
     buf.print(Info);
+    Info<< "addr: " << Foam::name(buf.list().cdata()) << nl;
     toString(Info, buf.list());
     Info<< nl << "=========================" << endl;
 }
@@ -152,11 +188,6 @@ int main(int argc, char *argv[])
 
     printInfo(obuf);
 
-    obuf.shrink();
-
-    Info<< "after shrink" << nl;
-    printInfo(obuf);
-
     // Add some more
     for (label i=10; i < 15; ++i)
     {
@@ -175,13 +206,16 @@ int main(int argc, char *argv[])
 
     Info<< "transfer contents to a List or ICharStream" << nl;
 
-    ICharStream ibuf;
     // Reclaim data storage from OCharStream -> ICharStream
-    {
-        List<char> data;
-        obuf.swap(data);
-        ibuf.swap(data);
-    }
+    ICharStream ibuf(std::move(obuf));
+
+    // OLD
+    // ICharStream ibuf;
+    // {
+    //     List<char> data;
+    //     obuf.swap(data);
+    //     ibuf.swap(data);
+    // }
 
     Info<<"original:";
     printInfo(obuf);
@@ -253,6 +287,14 @@ int main(int argc, char *argv[])
 
         Info<< "Compact" << nl;
         printInfo(os2);
+
+        Info<< "address: " << Foam::name(os2.list().cdata()) << nl;
+
+        DynamicList<char> chars(os2.release());
+        Info<< "chars: " << chars.size() << '/' << chars.capacity() << nl;
+        Info<< "address: " << Foam::name(chars.cdata()) << nl;
+        Info<< "release" << nl;
+        printInfo(os2);
     }
 
 
diff --git a/applications/test/OCountStream/Test-OCountStream.C b/applications/test/OCountStream/Test-OCountStream.C
index 95028ce9c2..85ffab4e0c 100644
--- a/applications/test/OCountStream/Test-OCountStream.C
+++ b/applications/test/OCountStream/Test-OCountStream.C
@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2017-2020 OpenCFD Ltd.
+    Copyright (C) 2017-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -29,6 +29,7 @@ Description
 \*---------------------------------------------------------------------------*/
 
 #include "OCountStream.H"
+#include "SpanStream.H"
 #include "StringStream.H"
 #include "Fstream.H"
 #include "IOstreams.H"
@@ -63,9 +64,11 @@ int main(int argc, char *argv[])
     #include "setRootCase.H"
 
     OCountStream cnt;
+    OCharStream cstr;
     OStringStream str;
     ocountstream plain;
 
+    generateOutput(cstr);
     generateOutput(str);
     generateOutput(cnt);
     generateOutput(plain);
@@ -73,6 +76,7 @@ int main(int argc, char *argv[])
     cnt.print(Info);
 
     Info<< "counter state: " << (cnt.stdStream().rdstate()) << nl
+        << "via char-stream: " << label(cstr.view().size()) << " chars" << nl
         << "via string-stream: " << str.str().size() << " chars" << nl
         << "via ocountstream: " << plain.count() << " chars" << endl;
 
diff --git a/applications/test/OStringStream/Test-OStringStream.C b/applications/test/OStringStream/Test-OStringStream.C
index afeef3dfb1..b2ef61c5da 100644
--- a/applications/test/OStringStream/Test-OStringStream.C
+++ b/applications/test/OStringStream/Test-OStringStream.C
@@ -28,18 +28,15 @@ Description
 \*---------------------------------------------------------------------------*/
 
 #include "IOstreams.H"
+#include "SpanStream.H"
 #include "StringStream.H"
 
 using namespace Foam;
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-// Main program:
-
-int main(int argc, char *argv[])
+template<class OStreamType>
+void doTest()
 {
-    Info<< "Begin test OStringStream" << endl;
-
-    OStringStream os;
+    OStreamType os;
     os << "output with some values " << 1 << " entry" << endl;
 
     Info<< "contains:" << nl
@@ -59,8 +56,20 @@ int main(int argc, char *argv[])
 
     Info<< "after reset:" << nl
         << os.str() << endl;
+}
 
-    Info<< "End\n" << endl;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// Main program:
+
+int main(int argc, char *argv[])
+{
+    Info<< "Begin test OStringStream" << endl;
+
+    doTest<OStringStream>();
+    // No reset() method:  doTest<OCharStream>();
+
+    Info<< "\nEnd\n" << endl;
 
     return 0;
 }
diff --git a/applications/test/SpanStream1/Test-SpanStream1.C b/applications/test/SpanStream1/Test-SpanStream1.C
index dede85f880..92fb58daa0 100644
--- a/applications/test/SpanStream1/Test-SpanStream1.C
+++ b/applications/test/SpanStream1/Test-SpanStream1.C
@@ -39,12 +39,28 @@ Description
 
 using namespace Foam;
 
-Ostream& writeList(Ostream& os, const UList<char>& list)
+Ostream& printString(Ostream& os, const char* first, const char* last)
+{
+    os << '"';
+    for (; first != last; (void)++first)
+    {
+        os << *first;
+    }
+    os << '"';
+
+    return os;
+}
+
+
+Ostream& printView(Ostream& os, const char* first, const char* last)
 {
     char buf[4];
-    os << list.size() << '(';
-    for (const char c : list)
+    os << label(last-first) << '(';
+
+    for (; first != last; (void)++first)
     {
+        const char c = *first;
+
         if (isprint(c))
         {
             os << c;
@@ -69,29 +85,41 @@ Ostream& writeList(Ostream& os, const UList<char>& list)
 }
 
 
+#if __cplusplus >= 201703L
+Ostream& printView(Ostream& os, std::string_view s)
+{
+    return printView(os, s.begin(), s.end());
+}
+#endif
+
+
+Ostream& printView(Ostream& os, stdFoam::span<char> s)
+{
+    return printView(os, s.begin(), s.end());
+}
+
+
+Ostream& printView(Ostream& os, const UList<char>& list)
+{
+    return printView(os, list.begin(), list.end());
+}
+
+
+Ostream& writeList(Ostream& os, const UList<char>& list)
+{
+    return printView(os, list.begin(), list.end());
+}
+
+
 Ostream& toString(Ostream& os, const UList<char>& list)
 {
-    os << '"';
-    for (const char c : list)
-    {
-        os << c;
-    }
-    os << '"';
-
-    return os;
+    return printString(os, list.begin(), list.end());
 }
 
 
 Ostream& toString(Ostream& os, const std::vector<char>& list)
 {
-    os << '"';
-    for (const char c : list)
-    {
-        os << c;
-    }
-    os << '"';
-
-    return os;
+    return printString(os, list.data(), list.data() + list.size());
 }
 
 
diff --git a/applications/test/UList/Test-UList.C b/applications/test/UList/Test-UList.C
index 9b70627dcf..667e624529 100644
--- a/applications/test/UList/Test-UList.C
+++ b/applications/test/UList/Test-UList.C
@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2017-2019 OpenCFD Ltd.
+    Copyright (C) 2017-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -36,7 +36,7 @@ See also
 
 #include "OSspecific.H"
 #include "IOstreams.H"
-#include "StringStream.H"
+#include "SpanStream.H"
 
 #include "labelList.H"
 #include "ListOps.H"
@@ -95,7 +95,7 @@ int main(int argc, char *argv[])
     {
         Info<<"Read from " << inputSLList << nl;
 
-        IStringStream is(inputSLList);
+        ISpanStream is(inputSLList);
         is >> ulist;
 
 //         Info<<"source: "; print(source);
@@ -107,7 +107,7 @@ int main(int argc, char *argv[])
     {
         Info<<"Read from " << inputCompound << nl;
 
-        IStringStream is(inputCompound);
+        ISpanStream is(inputCompound);
         is >> ulist;
 
 //         Info<<"source: "; print(source);
diff --git a/applications/test/argList/Test-argList.C b/applications/test/argList/Test-argList.C
index fafa778517..008e8421c4 100644
--- a/applications/test/argList/Test-argList.C
+++ b/applications/test/argList/Test-argList.C
@@ -31,7 +31,6 @@ Description
 #include "IOstreams.H"
 #include "MinMax.H"
 #include "Switch.H"
-#include "StringStream.H"
 
 using namespace Foam;
 
diff --git a/applications/test/bitSet1/Test-bitSet1.C b/applications/test/bitSet1/Test-bitSet1.C
index a6dd8e1418..08d5f47a2a 100644
--- a/applications/test/bitSet1/Test-bitSet1.C
+++ b/applications/test/bitSet1/Test-bitSet1.C
@@ -37,7 +37,7 @@ Description
 #include "HashSet.H"
 #include "ListOps.H"
 #include "cpuTime.H"
-#include "StringStream.H"
+#include "SpanStream.H"
 #include "FlatOutput.H"
 #include <vector>
 #include <unordered_set>
@@ -124,7 +124,7 @@ int main(int argc, char *argv[])
 
         Info<< "Test read/write (ASCII)" << nl;
 
-        OStringStream ostr;
+        OCharStream ostr;
 
         undecorated(ostr, set3a);  // like flatOutput
         ostr << bitSet();
@@ -132,7 +132,7 @@ int main(int argc, char *argv[])
         undecorated(ostr, set3a);  // like flatOutput
 
         {
-            IStringStream istr(ostr.str());
+            ISpanStream istr(ostr.view());
             Info<< "parse: " << istr.str() << nl;
 
             bitSet bset1(istr);
diff --git a/applications/test/bitSet2/Test-bitSet2.C b/applications/test/bitSet2/Test-bitSet2.C
index f53f3e831f..fb9bc746a1 100644
--- a/applications/test/bitSet2/Test-bitSet2.C
+++ b/applications/test/bitSet2/Test-bitSet2.C
@@ -36,7 +36,7 @@ Description
 #include "DynamicList.H"
 #include "IOstreams.H"
 #include "ITstream.H"
-#include "StringStream.H"
+#include "SpanStream.H"
 #include "bitSet.H"
 #include "FlatOutput.H"
 
@@ -415,7 +415,7 @@ int main(int argc, char *argv[])
     Info<< "\nassign from indices\n";
     list4.readList
     (
-        IStringStream
+        ICharStream
         (
             "{0 1 2 3 12 13 14 19 20 21}"
         )()
diff --git a/applications/test/charList/Test-charList.C b/applications/test/charList/Test-charList.C
index 34882fc125..32e9811093 100644
--- a/applications/test/charList/Test-charList.C
+++ b/applications/test/charList/Test-charList.C
@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2021 OpenCFD Ltd.
+    Copyright (C) 2021-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -38,7 +38,7 @@ Description
 
 #include "charList.H"
 #include "labelList.H"
-#include "StringStream.H"
+#include "SpanStream.H"
 #include "ListOps.H"
 #include "SubList.H"
 #include "FlatOutput.H"
@@ -61,7 +61,7 @@ int main(int argc, char *argv[])
     // Info<< "Known compound tokens: "
     //     << token::compound::emptyConstructorTablePtr_->sortedToc() << nl;
 
-    OStringStream ostr;
+    OCharStream ostr;
 
     {
         List<char> alphabet(64);
@@ -75,7 +75,8 @@ int main(int argc, char *argv[])
     }
 
     {
-        IStringStream istr(ostr.str());
+        // ICharStream istr(ostr.release());
+        ISpanStream istr(ostr.view());
         List<char> alphabet(istr);
 
         Info<< "re-read: " << alphabet << nl;
@@ -88,6 +89,8 @@ int main(int argc, char *argv[])
         Info<< "blanked: " << alphabet << nl;
     }
 
+    Info<< "\nEnd\n" << nl;
+
     return 0;
 }
 
diff --git a/applications/test/compoundToken1/Test-compoundToken1.C b/applications/test/compoundToken1/Test-compoundToken1.C
index 8eabd24fb1..6a27793aae 100644
--- a/applications/test/compoundToken1/Test-compoundToken1.C
+++ b/applications/test/compoundToken1/Test-compoundToken1.C
@@ -31,7 +31,6 @@ Description
 #include "IOobject.H"
 #include "IOstreams.H"
 #include "IFstream.H"
-#include "StringStream.H"
 #include "cpuTime.H"
 #include "labelList.H"
 #include "DynamicList.H"
@@ -57,7 +56,7 @@ class IFstreamDelayed
 :
     public IFstream
 {
-    virtual bool readCompoundToken(token& tok, const word& type)
+    virtual bool readCompoundToken(token& tok, const word& type) override
     {
         auto& is = *this;
 
diff --git a/applications/test/dictionary2/Test-dictionary2.C b/applications/test/dictionary2/Test-dictionary2.C
index 165bdf0726..da12142e4b 100644
--- a/applications/test/dictionary2/Test-dictionary2.C
+++ b/applications/test/dictionary2/Test-dictionary2.C
@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2017-2021 OpenCFD Ltd.
+    Copyright (C) 2017-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -36,6 +36,7 @@ Description
 #include "IOobject.H"
 #include "IFstream.H"
 #include "dictionary.H"
+#include "SpanStream.H"
 #include "ops.H"
 #include "scalarRange.H"
 #include "stringOps.H"
@@ -348,7 +349,7 @@ int main(int argc, char *argv[])
         Info<< nl << "Test reading good/bad/empty scalar entries" << nl;
         dictionary dict2
         (
-            IStringStream
+            ICharStream
             (
                 "good 3.14159;\n"
                 "negative -3.14159;\n"
@@ -418,7 +419,7 @@ int main(int argc, char *argv[])
 
             dictionary mydict
             (
-                IStringStream
+                ICharStream
                 (
                     "scalar 3.14159;\n"
                     "label 10;\n"
diff --git a/applications/test/dictionary3/Test-dictionary3.C b/applications/test/dictionary3/Test-dictionary3.C
index 11c1835b28..6e27e3430f 100644
--- a/applications/test/dictionary3/Test-dictionary3.C
+++ b/applications/test/dictionary3/Test-dictionary3.C
@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2021 OpenCFD Ltd.
+    Copyright (C) 2021-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -35,7 +35,7 @@ Description
 #include "IOstreams.H"
 #include "dictionary.H"
 #include "vector.H"
-#include "StringStream.H"
+#include "SpanStream.H"
 
 using namespace Foam;
 
@@ -47,7 +47,7 @@ int main(int argc, char *argv[])
     argList::noParallel();
 
     {
-        IStringStream is
+        ICharStream is
         (
             "value   10;"
             "scalar1 $value;"
diff --git a/applications/test/dimensionedType/Test-dimensionedType.C b/applications/test/dimensionedType/Test-dimensionedType.C
index 1d948709d2..20bcf4748c 100644
--- a/applications/test/dimensionedType/Test-dimensionedType.C
+++ b/applications/test/dimensionedType/Test-dimensionedType.C
@@ -29,6 +29,7 @@ License
 #include "dictionary.H"
 #include "primitiveEntry.H"
 #include "dimensionedTypes.H"
+#include "SpanStream.H"
 
 using namespace Foam;
 
@@ -53,7 +54,7 @@ int main(int argc, char *argv[])
 
     {
         string dimString("[Pa m^2 s^-2]");
-        IStringStream is("[Pa m^2 s^-2]");
+        ICharStream is("[Pa m^2 s^-2]");
 
         Pout<< nl;
         Pout<< "dimensionSet construct from (is) with contents "
@@ -70,23 +71,23 @@ int main(int argc, char *argv[])
     {
         Pout<< nl
             << "construct from (is) = "
-            << dimensionedScalar(IStringStream("bla [Pa mm^2 s^-2] 3.0")())
+            << dimensionedScalar(ICharStream("bla [Pa mm^2 s^-2] 3.0")())
             << endl;
         Pout<< "construct from (name,is) = "
             <<  dimensionedScalar
                 (
                     "ABC",
-                    IStringStream("[Pa mm^2 s^-2] 3.0")()
+                    ICharStream("[Pa mm^2 s^-2] 3.0")()
                 ) << endl;
         Pout<< "construct from (name,dims,is) = "
             <<  dimensionedScalar
                 (
                     "ABC",
                     dimLength,
-                    IStringStream("bla [mm] 3.0")()
+                    ICharStream("bla [mm] 3.0")()
                 ) << endl;
         {
-            IStringStream is("bla [mm] 3.0");
+            ICharStream is("bla [mm] 3.0");
             dimensionedScalar ds;
             is >> ds;
             Pout<< "read:" << ds << endl;
diff --git a/applications/test/fileHandler-writing/Make/files b/applications/test/fileHandler-writing/Make/files
new file mode 100644
index 0000000000..f85b2cccec
--- /dev/null
+++ b/applications/test/fileHandler-writing/Make/files
@@ -0,0 +1,3 @@
+Test-fileHandler-writing.C
+
+EXE = $(FOAM_USER_APPBIN)/Test-fileHandler-writing
diff --git a/applications/test/fileHandler-writing/Make/options b/applications/test/fileHandler-writing/Make/options
new file mode 100644
index 0000000000..67583ec122
--- /dev/null
+++ b/applications/test/fileHandler-writing/Make/options
@@ -0,0 +1,18 @@
+EXE_INC = \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude \
+    -I$(LIB_SRC)/TurbulenceModels/turbulenceModels/lnInclude \
+    -I$(LIB_SRC)/TurbulenceModels/incompressible/lnInclude \
+    -I$(LIB_SRC)/transportModels \
+    -I$(LIB_SRC)/transportModels/incompressible/singlePhaseTransportModel
+
+EXE_LIBS = \
+    -lfiniteVolume \
+    -lfvOptions \
+    -lmeshTools \
+    -lsampling \
+    -lturbulenceModels \
+    -lincompressibleTurbulenceModels \
+    -lincompressibleTransportModels \
+    -latmosphericModels
diff --git a/applications/test/fileHandler-writing/Test-fileHandler-writing.C b/applications/test/fileHandler-writing/Test-fileHandler-writing.C
new file mode 100644
index 0000000000..03caeab26d
--- /dev/null
+++ b/applications/test/fileHandler-writing/Test-fileHandler-writing.C
@@ -0,0 +1,169 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2023 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Application
+    Test-fileHandler-writing
+
+Description
+    Simple test of file writing, including timings
+
+\*---------------------------------------------------------------------------*/
+
+#include "argList.H"
+#include "profiling.H"
+#include "clockTime.H"
+
+#include "fileName.H"
+#include "fileOperation.H"
+#include "IOstreams.H"
+#include "OSspecific.H"
+#include "ReadFields.H"
+#include "volFields.H"
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// Main program:
+
+int main(int argc, char *argv[])
+{
+    argList::addNote
+    (
+        "Loads mesh and fields from latest time and writes multiple times"
+    );
+
+    argList::noFunctionObjects();  // Disallow function objects
+    argList::addVerboseOption("additional verbosity");
+    argList::addOption("output", "Begin output iteration (default: 10000)");
+    argList::addOption("count", "Number of writes (default: 1)");
+
+    #include "setRootCase.H"
+    #include "createTime.H"
+
+    const label firstOutput = args.getOrDefault("output", 10000);
+    const label nOutput = args.getOrDefault("count", 1);
+
+    const int verbose = args.verbose();
+
+    // Select latestTime, including 0 and constant
+    {
+        const auto& times = runTime.times();
+        const label timeIndex = (times.size()-1);
+
+        if (timeIndex < 0)
+        {
+            FatalErrorInFunction
+                << "No times!"
+                << exit(FatalError);
+        }
+
+        runTime.setTime(times[timeIndex], timeIndex);
+    }
+
+    // #include "createMesh.H"
+
+    Info << "Create mesh time = " << runTime.timeName() << nl;
+
+    fvMesh mesh
+    (
+        IOobject
+        (
+            polyMesh::defaultRegion,
+            runTime.timeName(),
+            runTime,
+            Foam::IOobject::MUST_READ
+        ),
+        false
+    );
+    mesh.init(true);   // initialise all (lower levels and current)
+    Info<< endl;
+
+
+    // Read objects in time directory
+    IOobjectList objects(mesh, runTime.timeName());
+
+    // List of stored objects to clear after (as required)
+    DynamicList<regIOobject*> storedObjects;
+
+
+    // Read GeometricFields
+    Info<< nl << "Load fields" << nl;
+
+    #undef  ReadFields
+    #define ReadFields(FieldType)                                             \
+    readFields<FieldType>(mesh, objects, predicates::always{}, storedObjects);
+
+    // Read volFields
+    ReadFields(volScalarField);
+    ReadFields(volVectorField);
+    ReadFields(volSphericalTensorField);
+    ReadFields(volSymmTensorField);
+    ReadFields(volTensorField);
+
+    // Set fields to AUTO_WRITE
+    for (regIOobject* io : storedObjects)
+    {
+        io->writeOpt(IOobjectOption::AUTO_WRITE);
+    }
+
+    Info<< nl
+        << "Writing " << nOutput << " times starting at "
+        << firstOutput << nl;
+
+    clockTime timing;
+
+    if (verbose) Info<< "Time:";
+
+    for
+    (
+        label timeIndex = firstOutput, count = 0;
+        count < nOutput;
+        ++timeIndex, ++count
+    )
+    {
+        runTime.setTime(timeIndex, timeIndex);
+        if (verbose) Info<< ' ' << runTime.timeName() << flush;
+        runTime.writeNow();
+    }
+
+    if (verbose) Info<< nl;
+    Info<< nl << "Writing took "
+        << timing.timeIncrement() << "s" << endl;
+
+
+    Info<< nl
+        << "Cleanup newly generated files with" << nl << nl
+        << "    foamListTimes -rm -time "
+        << firstOutput << ":" << nl
+        << "    foamListTimes -processor -rm -time "
+        << firstOutput << ":" << nl;
+
+
+    Info<< "\nEnd\n" << endl;
+    return 0;
+}
+
+
+// ************************************************************************* //
diff --git a/applications/test/mesh/Test-mesh.C b/applications/test/mesh/Test-mesh.C
index 49c64c4b51..478b471713 100644
--- a/applications/test/mesh/Test-mesh.C
+++ b/applications/test/mesh/Test-mesh.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2017 OpenCFD Ltd.
+    Copyright (C) 2017-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -30,6 +30,7 @@ License
 #include "fvMesh.H"
 #include "volFields.H"
 #include "surfaceFields.H"
+#include "SpanStream.H"
 
 using namespace Foam;
 
@@ -76,9 +77,9 @@ int main(int argc, char *argv[])
         PtrList<dictionary> boundaryDicts(pbm.size());
         forAll(pbm, patchi)
         {
-            OStringStream os;
+            OCharStream os;
             os << pbm[patchi];
-            IStringStream is(os.str());
+            ISpanStream is(os.view());
             boundaryDicts.set(patchi, new dictionary(is));
         }
 
diff --git a/applications/test/polyMeshGeom-speed1/Test-polyMeshGeom-speed1.C b/applications/test/polyMeshGeom-speed1/Test-polyMeshGeom-speed1.C
index 4c268797dd..202b1a76d6 100644
--- a/applications/test/polyMeshGeom-speed1/Test-polyMeshGeom-speed1.C
+++ b/applications/test/polyMeshGeom-speed1/Test-polyMeshGeom-speed1.C
@@ -117,8 +117,7 @@ void cell_labels
         nVerts += meshFaces[facei].size();
     }
 
-    // pointLabels.clear();
-    pointLabels.expandStorage();
+    pointLabels.resize(pointLabels.capacity());  // Use full storage
 
     // The first face has no duplicates, can copy in values
     const labelList& firstFace = meshFaces[cFaces[0]];
diff --git a/applications/test/primitives/Test-primitives.C b/applications/test/primitives/Test-primitives.C
index 2ac56c7b25..e0e5d2fe28 100644
--- a/applications/test/primitives/Test-primitives.C
+++ b/applications/test/primitives/Test-primitives.C
@@ -34,7 +34,6 @@ Description
 #include "scalar.H"
 #include "FlatOutput.H"
 #include "SpanStream.H"
-#include "StringStream.H"
 #include "NASCore.H"
 #include "parsing.H"
 #include "Tuple2.H"
@@ -443,6 +442,7 @@ int main(int argc, char *argv[])
             << " read " << sizeof(scalar) << nl;
 
         List<otherType> srcList(15);
+        List<scalar> dstList;  // Read back
 
         forAll(srcList, i)
         {
@@ -452,13 +452,8 @@ int main(int argc, char *argv[])
         OCharStream os(IOstreamOption::BINARY);
         os << srcList;
 
-        DynamicList<char> buf;
-        os.swap(buf);  // Recover written contents
-
-        // Read back
-        List<scalar> dstList;
-
-        ISpanStream is(buf, IOstreamOption::BINARY);
+        // Recover written contents
+        ICharStream is(os.release(), IOstreamOption::BINARY);
         is.setScalarByteSize(sizeof(otherType));
 
         Info<< "Stream scalar-size ("
diff --git a/applications/test/scalarPredicates/Test-scalarPredicates.C b/applications/test/scalarPredicates/Test-scalarPredicates.C
index e2f5459f48..9b6a7dbaad 100644
--- a/applications/test/scalarPredicates/Test-scalarPredicates.C
+++ b/applications/test/scalarPredicates/Test-scalarPredicates.C
@@ -37,7 +37,7 @@ Description
 #include "scalarPredicates.H"
 #include "FlatOutput.H"
 #include "Tuple2.H"
-#include "StringStream.H"
+#include "SpanStream.H"
 #include "ops.H"
 #include "bitSet.H"
 
@@ -164,7 +164,7 @@ int main(int argc, char *argv[])
 
     Info<< nl << "Construct from Istream" << nl;
     {
-        IStringStream is("((less 10) (greater 100) (less -8) (le -9))");
+        ICharStream is("((less 10) (greater 100) (less -8) (le -9))");
         predicates::scalars accept(is);
 
         doTest(values, accept);
diff --git a/applications/test/sha1/Test-SHA1.C b/applications/test/sha1/Test-SHA1.C
index b13ebdee46..b76af9a0b3 100644
--- a/applications/test/sha1/Test-SHA1.C
+++ b/applications/test/sha1/Test-SHA1.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2015 OpenFOAM Foundation
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -32,6 +32,7 @@ Description
 \*---------------------------------------------------------------------------*/
 
 #include "OSHA1stream.H"
+#include "SpanStream.H"
 #include "StringStream.H"
 #include "dictionary.H"
 
@@ -118,7 +119,7 @@ int main(int argc, char * argv[])
     {
         dictionary dict
         (
-            IStringStream
+            ICharStream
             (
                 "parent { Default_Boundary_Region { type zeroGradient; } }"
                 "inlet_1 { value inlet_1; }"
diff --git a/applications/test/span/Test-stdFoam-span.C b/applications/test/span/Test-stdFoam-span.C
index fc6048b7b8..12ceb2171b 100644
--- a/applications/test/span/Test-stdFoam-span.C
+++ b/applications/test/span/Test-stdFoam-span.C
@@ -34,7 +34,6 @@ Description
 #include "argList.H"
 
 #include "IOstreams.H"
-#include "StringStream.H"
 #include "scalar.H"
 #include "vector.H"
 #include "labelRange.H"
diff --git a/applications/test/stringList/Test-stringList.C b/applications/test/stringList/Test-stringList.C
index 23e441a869..4a7f18748a 100644
--- a/applications/test/stringList/Test-stringList.C
+++ b/applications/test/stringList/Test-stringList.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
-    Copyright (C) 2019-2021 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -32,7 +32,7 @@ Description
 #include "ListOps.H"
 #include "FlatOutput.H"
 #include "IOstreams.H"
-#include "StringStream.H"
+#include "SpanStream.H"
 
 using namespace Foam;
 
@@ -55,7 +55,7 @@ int main(int argc, char *argv[])
     };
     labelList matches;
 
-    wordRes matcher1(IStringStream("( okey \"[hy]e+.*\" )")());
+    wordRes matcher1(ICharStream("( okey \"[hy]e+.*\" )")());
 
     Info<< "stringList " << strings << nl;
 
diff --git a/applications/test/string_view1/Make/files b/applications/test/string_view1/Make/files
new file mode 100644
index 0000000000..4d92aada22
--- /dev/null
+++ b/applications/test/string_view1/Make/files
@@ -0,0 +1,3 @@
+Test-string_view1.C
+
+EXE = $(FOAM_USER_APPBIN)/Test-string_view1
diff --git a/applications/test/string_view1/Make/options b/applications/test/string_view1/Make/options
new file mode 100644
index 0000000000..18e6fe47af
--- /dev/null
+++ b/applications/test/string_view1/Make/options
@@ -0,0 +1,2 @@
+/* EXE_INC = */
+/* EXE_LIBS = */
diff --git a/applications/test/string_view1/Test-string_view1.C b/applications/test/string_view1/Test-string_view1.C
new file mode 100644
index 0000000000..155e364165
--- /dev/null
+++ b/applications/test/string_view1/Test-string_view1.C
@@ -0,0 +1,94 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2023 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Description
+    Test some string_view functionality
+
+\*---------------------------------------------------------------------------*/
+
+#include "string.H"
+#include "IOstreams.H"
+#include "List.H"
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// Main program:
+
+int main(int argc, char *argv[])
+{
+    Info<< "Compiled with C++ " << __cplusplus;
+    #if __cplusplus >= 201703L
+    Info<< " - has std::string_view" << nl << nl;
+    #else
+    Info<< " - NO std::string_view" << nl << nl;
+    #endif
+
+    // basics
+    {
+        for
+        (
+            const auto& cstr
+          :
+            {
+                "abcdef"
+            }
+        )
+        {
+            const auto len = strlen(cstr);
+
+            Info<< nl
+                << "input: <" << cstr << '>'
+                << " type: " << typeid(cstr).name() << " len:" << len << nl;
+
+            #if __cplusplus >= 201703L
+            Info<< "    view: " << std::string_view(cstr) << nl;
+            #endif
+
+            Info<< "    span: "
+                << stdFoam::span<const char>(cstr, len) << nl;
+            Info<< "    span: "
+                << stdFoam::span<char>(const_cast<char*>(cstr), len) << nl;
+        }
+    }
+
+    // This should fail to compile:
+    #if 0
+    {
+        labelList values(identity(4));
+
+        Info<< "values: " << values << nl;
+
+        Info<< "    span: "
+            << stdFoam::span<label>(values.data(), values.size()) << nl;
+    }
+    #endif
+
+    Info<< "\nEnd\n" << endl;
+    return 0;
+}
+
+
+// ************************************************************************* //
diff --git a/applications/test/surfaceMeshConvert/Test-surfaceMeshConvert.C b/applications/test/surfaceMeshConvert/Test-surfaceMeshConvert.C
index fe7781ebeb..bf535edde4 100644
--- a/applications/test/surfaceMeshConvert/Test-surfaceMeshConvert.C
+++ b/applications/test/surfaceMeshConvert/Test-surfaceMeshConvert.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2016-2020 OpenCFD Ltd.
+    Copyright (C) 2016-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -66,8 +66,7 @@ Note
 #include "MeshedSurfaces.H"
 #include "ModifiableMeshedSurface.H"
 #include "UnsortedMeshedSurfaces.H"
-
-#include "StringStream.H"
+#include "SpanStream.H"
 
 using namespace Foam;
 
@@ -180,9 +179,9 @@ int main(int argc, char *argv[])
 
         // check: output to ostream, construct from istream
         {
-            OStringStream os;
+            OCharStream os;
             os << surf;
-            IStringStream is(os.str());
+            ISpanStream is(os.view());
 
             // both work:
             triSurface surf2(is);
@@ -245,9 +244,9 @@ int main(int argc, char *argv[])
 
         // check: output to ostream, construct from istream
         {
-            OStringStream os;
+            OCharStream os;
             os << surf;
-            IStringStream is(os.str());
+            ISpanStream is(os.view());
 
             // both work:
             UnsortedMeshedSurface<face> surf2(is);
@@ -309,9 +308,9 @@ int main(int argc, char *argv[])
 
         // check: output to ostream, construct from istream
         {
-            OStringStream os;
+            OCharStream os;
             os << surf;
-            IStringStream is(os.str());
+            ISpanStream is(os.view());
 
             // both work:
             MeshedSurface<face> surf2(is);
@@ -373,9 +372,9 @@ int main(int argc, char *argv[])
 
         // check: output to ostream, construct from istream
         {
-            OStringStream os;
+            OCharStream os;
             os << surf;
-            IStringStream is(os.str());
+            ISpanStream is(os.view());
 
             // both work:
             MeshedSurface<face> surf2(is);
diff --git a/applications/test/token/Test-token.C b/applications/test/token/Test-token.C
index d8f2433186..df2cb36f78 100644
--- a/applications/test/token/Test-token.C
+++ b/applications/test/token/Test-token.C
@@ -31,7 +31,6 @@ Description
 #include "IOobject.H"
 #include "IOstreams.H"
 #include "IFstream.H"
-#include "StringStream.H"
 #include "cpuTime.H"
 #include "labelList.H"
 #include "scalarList.H"
diff --git a/applications/test/tokenize/Test-tokenize.C b/applications/test/tokenize/Test-tokenize.C
index 44a743f0d6..8b6c4ba518 100644
--- a/applications/test/tokenize/Test-tokenize.C
+++ b/applications/test/tokenize/Test-tokenize.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
-    Copyright (C) 2020-2021 OpenCFD Ltd.
+    Copyright (C) 2020-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -34,7 +34,7 @@ Description
 #include "IOobject.H"
 #include "IOstreams.H"
 #include "IFstream.H"
-#include "StringStream.H"
+#include "SpanStream.H"
 #include "cpuTime.H"
 #include "DynamicList.H"
 
@@ -69,7 +69,7 @@ int main(int argc, char *argv[])
                 Info<< "input string: " << rawArg << nl;
             }
 
-            IStringStream is(rawArg);
+            ISpanStream is(rawArg);
 
             DynamicList<token> tokens;
 
diff --git a/applications/utilities/finiteArea/makeFaMesh/faMeshWriteEdgesOBJ.H b/applications/utilities/finiteArea/makeFaMesh/faMeshWriteEdgesOBJ.H
index 20e3a29e86..b942ab792c 100644
--- a/applications/utilities/finiteArea/makeFaMesh/faMeshWriteEdgesOBJ.H
+++ b/applications/utilities/finiteArea/makeFaMesh/faMeshWriteEdgesOBJ.H
@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2021 OpenCFD Ltd.
+    Copyright (C) 2021-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM, distributed under GPL-3.0-or-later.
@@ -33,11 +33,7 @@ Description
 
     OBJstream os(runTime.globalPath()/outputName);
 
-    os.writeQuoted
-    (
-        ("# " + outputName + "\n"),
-        false
-    );
+    os.writeComment(outputName);
 
     os.write(aMesh.patch().edges(), aMesh.patch().localPoints());
 }
diff --git a/applications/utilities/mesh/advanced/modifyMesh/cellSplitter.C b/applications/utilities/mesh/advanced/modifyMesh/cellSplitter.C
index 037e3a18b2..356617bd60 100644
--- a/applications/utilities/mesh/advanced/modifyMesh/cellSplitter.C
+++ b/applications/utilities/mesh/advanced/modifyMesh/cellSplitter.C
@@ -148,7 +148,7 @@ void Foam::cellSplitter::setRefinement
 )
 {
     addedPoints_.clear();
-    addedPoints_.resize(cellToMidPoint.size());
+    addedPoints_.reserve(cellToMidPoint.size());
 
 
     //
@@ -184,7 +184,7 @@ void Foam::cellSplitter::setRefinement
     // Add cells (first one is modified original cell)
     //
 
-    Map<labelList> cellToCells(cellToMidPoint.size());
+    Map<labelList> cellToCells(2*cellToMidPoint.size());
 
     forAllConstIters(cellToMidPoint, iter)
     {
diff --git a/applications/utilities/mesh/conversion/cfx4ToFoam/cfx4ToFoam.C b/applications/utilities/mesh/conversion/cfx4ToFoam/cfx4ToFoam.C
index 140babc1b9..536e7dd8a9 100644
--- a/applications/utilities/mesh/conversion/cfx4ToFoam/cfx4ToFoam.C
+++ b/applications/utilities/mesh/conversion/cfx4ToFoam/cfx4ToFoam.C
@@ -200,7 +200,7 @@ int main(int argc, char *argv[])
         )
         {
             patchMasterBlocks[patchi] = -1;
-            rawPatches[patchi].setSize(0);
+            rawPatches[patchi].clear();
         }
         else
         {
diff --git a/applications/utilities/mesh/conversion/ensightToFoam/ensightMeshReader.C b/applications/utilities/mesh/conversion/ensightToFoam/ensightMeshReader.C
index 39c0f2e7e6..91be645d68 100644
--- a/applications/utilities/mesh/conversion/ensightToFoam/ensightMeshReader.C
+++ b/applications/utilities/mesh/conversion/ensightToFoam/ensightMeshReader.C
@@ -102,7 +102,7 @@ void Foam::fileFormats::ensightMeshReader::readIDs
     foamToElem.resize(sz+nShapes);
     if (doRead)
     {
-        elemToFoam.resize(sz+nShapes);
+        elemToFoam.reserve(elemToFoam.size()+nShapes);
         for (label shapei = 0; shapei < nShapes; shapei++)
         {
             label elemi;
diff --git a/applications/utilities/mesh/conversion/fluent3DMeshToFoam/fluent3DMeshToFoam.L b/applications/utilities/mesh/conversion/fluent3DMeshToFoam/fluent3DMeshToFoam.L
index 3700bc8b87..f46d9c2b86 100644
--- a/applications/utilities/mesh/conversion/fluent3DMeshToFoam/fluent3DMeshToFoam.L
+++ b/applications/utilities/mesh/conversion/fluent3DMeshToFoam/fluent3DMeshToFoam.L
@@ -76,14 +76,14 @@ label nCells = 0;
 
 bool hangingNodes = false;
 
-pointField points(0);
-faceList faces(0);
-labelList owner(0);
-labelList neighbour(0);
+pointField points;
+faceList faces;
+labelList owner;
+labelList neighbour;
 
 // Group type and name
-Map<word> groupType(128);
-Map<word> groupName(128);
+Map<word> groupType;
+Map<word> groupName;
 
 // Point groups
 DynamicList<label> pointGroupZoneID;
@@ -1211,7 +1211,7 @@ int main(int argc, char *argv[])
     {
         meshMod.addPoint(points[pointi], pointi, -1, true);
     }
-    points.setSize(0);
+    points.clear();
 
     // Add all cells
     for (label celli = 0; celli < nCells; celli++)
@@ -1411,9 +1411,9 @@ int main(int argc, char *argv[])
     }
 
     // Reclaim storage
-    faces.setSize(0);
-    owner.setSize(0);
-    neighbour.setSize(0);
+    faces.clear();
+    owner.clear();
+    neighbour.clear();
 
 
     // Modify mesh
diff --git a/applications/utilities/mesh/conversion/ideasUnvToFoam/ideasUnvToFoam.C b/applications/utilities/mesh/conversion/ideasUnvToFoam/ideasUnvToFoam.C
index 1d9f361e9d..125995083d 100644
--- a/applications/utilities/mesh/conversion/ideasUnvToFoam/ideasUnvToFoam.C
+++ b/applications/utilities/mesh/conversion/ideasUnvToFoam/ideasUnvToFoam.C
@@ -1059,7 +1059,7 @@ int main(int argc, char *argv[])
                     }
                 }
 
-                patchFaces.setSize(0); // Assume that this is no patch at all
+                patchFaces.clear();  // Assume that this is no patch at all
 
                 if (cellCorrespondence[faceIndices[0]] >= 0)
                 {
diff --git a/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/DelaunayMesh/DelaunayMeshIO.C b/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/DelaunayMesh/DelaunayMeshIO.C
index 4f73231286..320f442a97 100644
--- a/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/DelaunayMesh/DelaunayMeshIO.C
+++ b/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/DelaunayMesh/DelaunayMeshIO.C
@@ -357,7 +357,7 @@ Foam::DelaunayMesh<Triangulation>::createMesh
     List<DynamicList<face>> patchFaces(1, DynamicList<face>());
     List<DynamicList<label>> patchOwners(1, DynamicList<label>());
 
-    vertexMap.resize(vertexCount());
+    vertexMap.reserve(vertexCount());
     cellMap.setSize(Triangulation::number_of_finite_cells(), -1);
 
     // Calculate pts and a map of point index to location in pts.
diff --git a/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/uniform/uniform.C b/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/uniform/uniform.C
index cd522974fe..779996d500 100644
--- a/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/uniform/uniform.C
+++ b/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/uniform/uniform.C
@@ -71,8 +71,8 @@ bool uniform::sizeLocations
     scalarField& shapeSizes
 ) const
 {
-    shapePts.setSize(0);
-    shapeSizes.setSize(0);
+    shapePts.clear();
+    shapeSizes.clear();
 
     return true;
 }
diff --git a/applications/utilities/mesh/manipulation/checkMesh/checkGeometry.C b/applications/utilities/mesh/manipulation/checkMesh/checkGeometry.C
index 482acaaff3..b8008a71b4 100644
--- a/applications/utilities/mesh/manipulation/checkMesh/checkGeometry.C
+++ b/applications/utilities/mesh/manipulation/checkMesh/checkGeometry.C
@@ -240,13 +240,13 @@ bool Foam::checkWedges
 
         if (setPtr)
         {
-            setPtr->resize(2*nEdgesInError);
+            setPtr->reserve(2*nEdgesInError);
             forAllConstIters(edgesInError, iter)
             {
-                if (iter() >= 0)
+                if (iter.val() >= 0)
                 {
-                    setPtr->insert(iter.key()[0]);
-                    setPtr->insert(iter.key()[1]);
+                    setPtr->insert(iter.key().first());
+                    setPtr->insert(iter.key().second());
                 }
             }
         }
diff --git a/applications/utilities/mesh/manipulation/setSet/setSet.C b/applications/utilities/mesh/manipulation/setSet/setSet.C
index b717e9f152..af462ed6d9 100644
--- a/applications/utilities/mesh/manipulation/setSet/setSet.C
+++ b/applications/utilities/mesh/manipulation/setSet/setSet.C
@@ -375,7 +375,7 @@ bool doCommand
 
                 topoSet& currentSet = currentSetPtr();
                 // Presize it according to current mesh data.
-                currentSet.resize(max(currentSet.size(), typSize));
+                currentSet.reserve(max(currentSet.size(), typSize));
             }
         }
 
diff --git a/src/OpenFOAM/algorithms/dynamicIndexedOctree/dynamicIndexedOctree.C b/src/OpenFOAM/algorithms/dynamicIndexedOctree/dynamicIndexedOctree.C
index f60afd763f..670ff7d845 100644
--- a/src/OpenFOAM/algorithms/dynamicIndexedOctree/dynamicIndexedOctree.C
+++ b/src/OpenFOAM/algorithms/dynamicIndexedOctree/dynamicIndexedOctree.C
@@ -2164,12 +2164,9 @@ Foam::label Foam::dynamicIndexedOctree<Type>::findBox
 
     if (!nodes_.empty())
     {
-        if (!elements.capacity())
-        {
-            // Some arbitrary minimal size estimate (eg, 1/100 are found)
-            label estimatedCapacity(max(256, 2*(shapes_.size() / 100)));
-            elements.resize(estimatedCapacity);
-        }
+        // Some arbitrary minimal size estimate (eg, 1/100 are found)
+        label estimatedCount(max(128, (shapes_.size() / 100)));
+        elements.reserve(estimatedCount);
 
         // start node=0, store results
         findBox(0, searchBox, &elements);
@@ -2223,12 +2220,9 @@ Foam::label Foam::dynamicIndexedOctree<Type>::findSphere
 
     if (!nodes_.empty())
     {
-        if (!elements.capacity())
-        {
-            // Some arbitrary minimal size estimate (eg, 1/100 are found)
-            label estimatedCapacity(max(256, 2*(shapes_.size()/100)));
-            elements.resize(estimatedCapacity);
-        }
+        // Some arbitrary minimal size estimate (eg, 1/100 are found)
+        label estimatedCount(max(128, (shapes_.size() / 100)));
+        elements.reserve(estimatedCount);
 
         // start node=0, store results
         findSphere(0, centre, radiusSqr, &elements);
diff --git a/src/OpenFOAM/algorithms/indexedOctree/indexedOctree.C b/src/OpenFOAM/algorithms/indexedOctree/indexedOctree.C
index b75d9dfbf5..590cea90db 100644
--- a/src/OpenFOAM/algorithms/indexedOctree/indexedOctree.C
+++ b/src/OpenFOAM/algorithms/indexedOctree/indexedOctree.C
@@ -2517,12 +2517,9 @@ Foam::label Foam::indexedOctree<Type>::findBox
 
     if (!nodes_.empty())
     {
-        if (!elements.capacity())
-        {
-            // Some arbitrary minimal size estimate (eg, 1/100 are found)
-            label estimatedCapacity(max(256, 2*(shapes_.size() / 100)));
-            elements.resize(estimatedCapacity);
-        }
+        // Some arbitrary minimal size estimate (eg, 1/100 are found)
+        label estimatedCount(max(128, (shapes_.size() / 100)));
+        elements.reserve(estimatedCount);
 
         // start node=0, store results
         findBox(0, searchBox, &elements);
@@ -2576,12 +2573,9 @@ Foam::label Foam::indexedOctree<Type>::findSphere
 
     if (!nodes_.empty())
     {
-        if (!elements.capacity())
-        {
-            // Some arbitrary minimal size estimate (eg, 1/100 are found)
-            label estimatedCapacity(max(256, 2*(shapes_.size() / 100)));
-            elements.resize(estimatedCapacity);
-        }
+        // Some arbitrary minimal size estimate (eg, 1/100 are found)
+        label estimatedCount(max(128, (shapes_.size() / 100)));
+        elements.reserve(estimatedCount);
 
         // start node=0, store results
         findSphere(0, centre, radiusSqr, &elements);
diff --git a/src/OpenFOAM/containers/Buffers/CircularBuffer.H b/src/OpenFOAM/containers/Buffers/CircularBuffer.H
index 2c19b78444..47de665f71 100644
--- a/src/OpenFOAM/containers/Buffers/CircularBuffer.H
+++ b/src/OpenFOAM/containers/Buffers/CircularBuffer.H
@@ -232,17 +232,16 @@ public:
         //- The contents of the first internal array
         SubList<T> array_one();
 
-        //- The contents of the first internal array
+        //- The contents of the second internal array
         SubList<T> array_two();
 
-        //- The contents of the second internal array
+        //- The contents of the first internal array
         const SubList<T> array_one() const;
 
         //- The contents of the second internal array
         const SubList<T> array_two() const;
 
 
-
     // Access
 
         //- Access the first element (front). Requires !empty().
@@ -352,9 +351,6 @@ public:
 
     // Member Operators
 
-        //- Return the buffer flattened as a single List. Use sparingly!
-        List<T> operator()() const { return this->list(); }
-
         //- Non-const access to an element in the list.
         //  The index is allowed to wrap in both directions
         inline T& operator[](const label i);
@@ -489,47 +485,6 @@ public:
 
         //- Return a const_iterator at end of buffer
         inline const_iterator end() const { return cend(); }
-
-
-    // Housekeeping
-
-        //- Same as contains()
-        bool found(const T& val, label pos = 0) const
-        {
-            return contains(val, pos);
-        }
-
-        //- Access the first element (front). Requires !empty().
-        //FOAM_DEPRECATED_FOR(2022-10, "front()")
-        T& first() { return front(); }
-
-        //- Access the first element (front). Requires !empty().
-        //FOAM_DEPRECATED_FOR(2022-10, "front()")
-        const T& first() const { return front(); }
-
-        //- Access the last element (back). Requires !empty().
-        //FOAM_DEPRECATED_FOR(2022-10, "back()")
-        T& last() { return back(); }
-
-        //- Access the last element (back). Requires !empty().
-        //FOAM_DEPRECATED_FOR(2022-10, "back()")
-        const T& last() const { return back(); }
-
-        //- Copy append an element to the end of the buffer
-        //FOAM_DEPRECATED_FOR(2022-10, "push_back()")
-        void append(const T& val) { this->push_back(val); }
-
-        //- Move append an element to the end of the buffer
-        //FOAM_DEPRECATED_FOR(2022-10, "push_back()")
-        void append(T&& val) { this->push_back(std::move(val)); }
-
-        //- Copy append multiple elements the end of the buffer
-        //FOAM_DEPRECATED_FOR(2022-10, "push_back()")
-        void append(const UList<T>& list) { this->push_back(list); }
-
-        //- Same as push_uniq()
-        FOAM_DEPRECATED_STRICT(2022-10, "push_uniq()")
-        label appendUniq(const T& val) { return this->push_uniq(val); }
 };
 
 
diff --git a/src/OpenFOAM/containers/Buffers/CircularBufferI.H b/src/OpenFOAM/containers/Buffers/CircularBufferI.H
index b7f71671f6..45a1a40d1c 100644
--- a/src/OpenFOAM/containers/Buffers/CircularBufferI.H
+++ b/src/OpenFOAM/containers/Buffers/CircularBufferI.H
@@ -160,6 +160,7 @@ inline Foam::CircularBuffer<T>::CircularBuffer
 template<class T>
 inline Foam::label Foam::CircularBuffer<T>::capacity() const noexcept
 {
+    // or storage_.capacity();
     return storage_.size();
 }
 
diff --git a/src/OpenFOAM/containers/Dictionaries/DictionaryBase/DictionaryBase.H b/src/OpenFOAM/containers/Dictionaries/DictionaryBase/DictionaryBase.H
index 9073637892..26a7de9b7e 100644
--- a/src/OpenFOAM/containers/Dictionaries/DictionaryBase/DictionaryBase.H
+++ b/src/OpenFOAM/containers/Dictionaries/DictionaryBase/DictionaryBase.H
@@ -101,8 +101,11 @@ public:
 
     // Constructors
 
-        //- Construct with given or default (128) table capacity
-        explicit DictionaryBase(const label initialCapacity = 128)
+        //- Default construct: empty without allocation (capacity=0).
+        DictionaryBase() = default;
+
+        //- Construct empty with initial table capacity
+        explicit DictionaryBase(const label initialCapacity)
         :
             hashedTs_(initialCapacity)
         {}
diff --git a/src/OpenFOAM/containers/Dictionaries/PtrDictionary/PtrDictionary.H b/src/OpenFOAM/containers/Dictionaries/PtrDictionary/PtrDictionary.H
index 116fdef855..235f25128b 100644
--- a/src/OpenFOAM/containers/Dictionaries/PtrDictionary/PtrDictionary.H
+++ b/src/OpenFOAM/containers/Dictionaries/PtrDictionary/PtrDictionary.H
@@ -62,8 +62,11 @@ public:
 
     // Constructors
 
-        //- Default construct, or with initial table capacity
-        explicit PtrDictionary(const label initialCapacity = 128)
+        //- Default construct: empty without allocation (capacity=0).
+        PtrDictionary() = default;
+
+        //- Construct empty with initial table capacity
+        explicit PtrDictionary(const label initialCapacity)
         :
             dict_type(initialCapacity)
         {}
diff --git a/src/OpenFOAM/containers/Dictionaries/UDictionary/UDictionary.H b/src/OpenFOAM/containers/Dictionaries/UDictionary/UDictionary.H
index dac3fcb69c..faa7972eed 100644
--- a/src/OpenFOAM/containers/Dictionaries/UDictionary/UDictionary.H
+++ b/src/OpenFOAM/containers/Dictionaries/UDictionary/UDictionary.H
@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -63,8 +64,11 @@ public:
 
     // Constructors
 
-        //- Default construct, or with initial table capacity
-        explicit UDictionary(const label initialCapacity = 128)
+        //- Default construct: empty without allocation (capacity=0).
+        UDictionary() = default;
+
+        //- Construct empty with initial table capacity
+        explicit UDictionary(const label initialCapacity)
         :
             dict_type(initialCapacity)
         {}
diff --git a/src/OpenFOAM/containers/Dictionaries/UPtrDictionary/UPtrDictionary.H b/src/OpenFOAM/containers/Dictionaries/UPtrDictionary/UPtrDictionary.H
index fa5729a2c3..710266c845 100644
--- a/src/OpenFOAM/containers/Dictionaries/UPtrDictionary/UPtrDictionary.H
+++ b/src/OpenFOAM/containers/Dictionaries/UPtrDictionary/UPtrDictionary.H
@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -63,8 +64,11 @@ public:
 
     // Constructors
 
-        //- Default construct, or with initial table capacity
-        explicit UPtrDictionary(const label initialCapacity = 128)
+        //- Default construct: empty without allocation (capacity=0).
+        UPtrDictionary() = default;
+
+        //- Construct empty with initial table capacity
+        explicit UPtrDictionary(const label initialCapacity)
         :
             dict_type(initialCapacity)
         {}
diff --git a/src/OpenFOAM/containers/HashTables/HashOps/HashOps.C b/src/OpenFOAM/containers/HashTables/HashOps/HashOps.C
index ad70f1c660..8a8e07452e 100644
--- a/src/OpenFOAM/containers/HashTables/HashOps/HashOps.C
+++ b/src/OpenFOAM/containers/HashTables/HashOps/HashOps.C
@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -32,11 +32,11 @@ License
 
 Foam::labelHashSet Foam::HashSetOps::used(const bitSet& select)
 {
-    labelHashSet output(0);
+    labelHashSet output;
 
     if (select.any())
     {
-        output.resize(2*select.count());
+        output.reserve(select.count());
 
         for (label i = select.find_first(); i >= 0; i = select.find_next(i))
         {
diff --git a/src/OpenFOAM/containers/HashTables/HashPtrTable/HashPtrTableIO.C b/src/OpenFOAM/containers/HashTables/HashPtrTable/HashPtrTableIO.C
index b69b7e3c6b..66eb572603 100644
--- a/src/OpenFOAM/containers/HashTables/HashPtrTable/HashPtrTableIO.C
+++ b/src/OpenFOAM/containers/HashTables/HashPtrTable/HashPtrTableIO.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2015 OpenFOAM Foundation
-    Copyright (C) 2017-2021 OpenCFD Ltd.
+    Copyright (C) 2017-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -61,10 +61,7 @@ void Foam::HashPtrTable<T, Key, Hash>::readIstream
 
         if (len)
         {
-            if (2*len > this->capacity())
-            {
-                this->resize(2*len);
-            }
+            this->reserve(this->size() + len);
 
             if (delimiter == token::BEGIN_LIST)
             {
@@ -133,6 +130,7 @@ void Foam::HashPtrTable<T, Key, Hash>::read
     const INew& inew
 )
 {
+    this->reserve(this->size() + dict.size());
     for (const entry& e : dict)
     {
         this->set(e.keyword(), inew(e.dict()).ptr());
diff --git a/src/OpenFOAM/containers/HashTables/HashSet/HashSet.C b/src/OpenFOAM/containers/HashTables/HashSet/HashSet.C
index abae7f59a6..ba4f9298b1 100644
--- a/src/OpenFOAM/containers/HashTables/HashSet/HashSet.C
+++ b/src/OpenFOAM/containers/HashTables/HashSet/HashSet.C
@@ -43,15 +43,8 @@ inline Foam::label Foam::HashSet<Key, Hash>::assignMany
     InputIter last
 )
 {
-    if (!this->capacity())
-    {
-        // Zero-sized from a previous transfer()?
-        this->resize(2*nItems);
-    }
-    else
-    {
-        this->clear();
-    }
+    this->clear();
+    this->reserve(nItems);
 
     return insert(first, last);
 }
@@ -104,7 +97,7 @@ Foam::HashSet<Key, Hash>::HashSet
     const HashTable<AnyType, Key, AnyHash>& tbl
 )
 :
-    parent_type(tbl.capacity())
+    parent_type(2*tbl.size())
 {
     for (auto iter = tbl.cbegin(); iter != tbl.cend(); ++iter)
     {
diff --git a/src/OpenFOAM/containers/HashTables/HashSet/HashSet.H b/src/OpenFOAM/containers/HashTables/HashSet/HashSet.H
index b02b18ace4..45bb13f85b 100644
--- a/src/OpenFOAM/containers/HashTables/HashSet/HashSet.H
+++ b/src/OpenFOAM/containers/HashTables/HashSet/HashSet.H
@@ -124,10 +124,10 @@ public:
 
     // Constructors
 
-        //- Default construct with default (128) initial table capacity
-        HashSet() = default;
+        //- Default construct: empty without allocation (capacity=0)
+        HashSet() noexcept = default;
 
-        //- Construct empty with zero table capacity
+        //- Construct empty without allocation (capacity=0)
         explicit HashSet(const Foam::zero) noexcept
         :
             parent_type(Foam::zero{})
diff --git a/src/OpenFOAM/containers/HashTables/HashTable/HashTable.C b/src/OpenFOAM/containers/HashTables/HashTable/HashTable.C
index 1876393b57..f564003f7b 100644
--- a/src/OpenFOAM/containers/HashTables/HashTable/HashTable.C
+++ b/src/OpenFOAM/containers/HashTables/HashTable/HashTable.C
@@ -37,7 +37,7 @@ License
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class T, class Key, class Hash>
-Foam::HashTable<T, Key, Hash>::HashTable(const Foam::zero) noexcept
+Foam::HashTable<T, Key, Hash>::HashTable() noexcept
 :
     HashTableCore(),
     size_(0),
@@ -47,30 +47,23 @@ Foam::HashTable<T, Key, Hash>::HashTable(const Foam::zero) noexcept
 
 
 template<class T, class Key, class Hash>
-Foam::HashTable<T, Key, Hash>::HashTable()
+Foam::HashTable<T, Key, Hash>::HashTable(const Foam::zero) noexcept
 :
-    HashTable<T, Key, Hash>(128)
+    HashTable<T, Key, Hash>()
 {}
 
 
 template<class T, class Key, class Hash>
 Foam::HashTable<T, Key, Hash>::HashTable(const label initialCapacity)
 :
-    HashTableCore(),
-    size_(0),
-    capacity_(0),
-    table_(nullptr)
+    HashTable<T, Key, Hash>()
 {
     if (initialCapacity > 0)
     {
         // Like resize() but no initial content to transfer
         capacity_ = HashTableCore::canonicalSize(initialCapacity);
         table_ = new node_type*[capacity_];
-
-        for (label i=0; i < capacity_; ++i)
-        {
-            table_[i] = nullptr;
-        }
+        std::fill_n(table_, capacity_, static_cast<node_type*>(nullptr));
     }
 }
 
@@ -78,7 +71,7 @@ Foam::HashTable<T, Key, Hash>::HashTable(const label initialCapacity)
 template<class T, class Key, class Hash>
 Foam::HashTable<T, Key, Hash>::HashTable(const HashTable<T, Key, Hash>& ht)
 :
-    HashTable<T, Key, Hash>(ht.capacity_)
+    HashTable<T, Key, Hash>(2*ht.size())
 {
     for (const_iterator iter = ht.cbegin(); iter != ht.cend(); ++iter)
     {
@@ -367,8 +360,7 @@ bool Foam::HashTable<T, Key, Hash>::setEntry
 {
     if (!capacity_)
     {
-        // Same as default sizing
-        resize(128);
+        setCapacity(128);  // Impose an initial capacity
     }
 
     const label index = hashKeyIndex(key);
@@ -393,9 +385,9 @@ bool Foam::HashTable<T, Key, Hash>::setEntry
             new node_type(table_[index], key, std::forward<Args>(args)...);
 
         ++size_;
-        if (0.8*capacity_ < size_)  // Resize after 80% fill factor
+        if (0.8*capacity_ < size_)  // Resize after 0.8 load factor
         {
-            if (capacity_ < maxTableSize) resize(2*capacity_);
+            if (capacity_ < maxTableSize) setCapacity(2*capacity_);
         }
     }
     else if (overwrite)
@@ -445,8 +437,7 @@ void Foam::HashTable<T, Key, Hash>::insert_node(node_type* entry)
 
     if (!capacity_)
     {
-        // Same as default sizing
-        resize(128);
+        setCapacity(128);  // Impose an initial capacity
     }
 
     const label index = hashKeyIndex(entry->key());
@@ -472,7 +463,7 @@ void Foam::HashTable<T, Key, Hash>::insert_node(node_type* entry)
         ++size_;
         if (0.8*capacity_ < size_)  // Resize after 80% fill factor
         {
-            if (capacity_ < maxTableSize) resize(2*capacity_);
+            if (capacity_ < maxTableSize) setCapacity(2*capacity_);
         }
     }
     else
@@ -648,44 +639,43 @@ Foam::label Foam::HashTable<T, Key, Hash>::retain
 
 
 template<class T, class Key, class Hash>
-void Foam::HashTable<T, Key, Hash>::resize(const label requestedCapacity)
+void Foam::HashTable<T, Key, Hash>::setCapacity(label newCapacity)
 {
-    const label newCapacity = HashTableCore::canonicalSize(requestedCapacity);
-    const label oldCapacity = capacity_;
+    newCapacity = HashTableCore::canonicalSize(newCapacity);
 
-    if (newCapacity == oldCapacity)
+    if (newCapacity == capacity_)
     {
         return;
     }
-    else if (!newCapacity)
+
+    if (!size_)
     {
-        // Special treatment for resize(0)
+        // Table is unpopulated - can already remove now
+        capacity_ = 0;
+        delete[] table_;
+        table_ = nullptr;
+    }
+
+    if (!newCapacity)
+    {
+        // Special handling for capacity = 0.
         if (size_)
         {
             WarningInFunction
                 << "HashTable contains " << size_
-                << " elements, cannot resize(0)" << nl;
+                << " elements, cannot set capacity to 0 buckets!" << nl;
         }
-        else
-        {
-            capacity_ = 0;
-            delete[] table_;
-            table_ = nullptr;
-        }
-
         return;
     }
 
     // Swap primary table entries: size_ is left untouched
 
     auto oldTable = table_;
-    capacity_ = newCapacity;
+    const label oldCapacity = capacity_;
 
+    capacity_ = newCapacity;
     table_ = new node_type*[capacity_];
-    for (label i=0; i < capacity_; ++i)
-    {
-        table_[i] = nullptr;
-    }
+    std::fill_n(table_, capacity_, static_cast<node_type*>(nullptr));
 
     if (!oldTable)
     {
@@ -718,6 +708,26 @@ void Foam::HashTable<T, Key, Hash>::resize(const label requestedCapacity)
 }
 
 
+template<class T, class Key, class Hash>
+void Foam::HashTable<T, Key, Hash>::resize(label newCapacity)
+{
+    setCapacity(newCapacity);
+}
+
+
+template<class T, class Key, class Hash>
+void Foam::HashTable<T, Key, Hash>::reserve(label numEntries)
+{
+    if (numEntries > size_)
+    {
+        // From number of entries to estimated capacity
+        // - initial load factor of 0.5
+        numEntries *= 2;
+        if (numEntries > capacity_) setCapacity(numEntries);
+    }
+}
+
+
 template<class T, class Key, class Hash>
 void Foam::HashTable<T, Key, Hash>::clear()
 {
@@ -917,15 +927,8 @@ void Foam::HashTable<T, Key, Hash>::operator=
         return;  // Self-assignment is a no-op
     }
 
-    if (!capacity_)
-    {
-        // Zero-sized from a previous transfer()?
-        resize(rhs.capacity_);
-    }
-    else
-    {
-        clear();
-    }
+    this->clear();
+    this->reserve(rhs.size());
 
     for (const_iterator iter = rhs.cbegin(); iter != rhs.cend(); ++iter)
     {
@@ -940,15 +943,8 @@ void Foam::HashTable<T, Key, Hash>::operator=
     std::initializer_list<std::pair<Key, T>> rhs
 )
 {
-    if (!capacity_)
-    {
-        // Zero-sized from a previous transfer()?
-        resize(2*rhs.size());
-    }
-    else
-    {
-        clear();
-    }
+    this->clear();
+    this->reserve(rhs.size());
 
     for (const auto& keyval : rhs)
     {
diff --git a/src/OpenFOAM/containers/HashTables/HashTable/HashTable.H b/src/OpenFOAM/containers/HashTables/HashTable/HashTable.H
index 3884212de8..07ffb7e2f0 100644
--- a/src/OpenFOAM/containers/HashTables/HashTable/HashTable.H
+++ b/src/OpenFOAM/containers/HashTables/HashTable/HashTable.H
@@ -40,6 +40,12 @@ Description
     Internally the table uses closed addressing into a flat storage space
     with collisions handled by linked-list chaining.
 
+    - The max_load_factor is 0.8, but a load factor 0.5 is generally
+      assumed when initially creating a HashTable (ie, use an capacity
+      of twice the expected number elements).
+    - When inserting into a table without an initial capacity,
+      a default capacity (bucket count) of 128 is used.
+
     The end iterator of all hash-tables has a nullptr to the hash entry.
     Thus avoid separate allocation for each table and use a single one with
     a nullptr. The hash-table iterators always have an entry-pointer as the
@@ -185,10 +191,10 @@ private:
 
     // Private Data
 
-        //- The number of nodes currently stored in table
+        //- The number of elements currently stored in table
         label size_;
 
-        //- Number of nodes allocated in table
+        //- Number of buckets allocated in table
         label capacity_;
 
         //- The table of primary nodes
@@ -228,18 +234,17 @@ public:
 
     // Constructors
 
-        //- Default construct with default (128) initial table capacity
-        HashTable();
+        //- Default construct: empty without allocation (capacity=0)
+        HashTable() noexcept;
 
-        //- Construct empty with zero initial table capacity
+        //- Construct empty without allocation (capacity=0)
         explicit HashTable(const Foam::zero) noexcept;
 
         //- Construct empty with initial table capacity
         explicit HashTable(const label initialCapacity);
 
-        //- Construct from Istream,
-        //- with default or specified initial table capacity.
-        HashTable(Istream& is, const label initialCapacity = 128);
+        //- Construct from Istream
+        HashTable(Istream& is);
 
         //- Copy construct
         HashTable(const this_type& ht);
@@ -258,7 +263,7 @@ public:
 
     // Member Functions
 
-    // Access
+    // Capacity
 
         //- True if the hash table is empty
         bool empty() const noexcept { return !size_; }
@@ -266,9 +271,12 @@ public:
         //- The number of elements in table
         label size() const noexcept { return size_; }
 
-        //- The size of the underlying table
+        //- The size of the underlying table (the number of buckets)
         label capacity() const noexcept { return capacity_; }
 
+
+    // Access
+
         //- Find and return a hashed entry. FatalError if it does not exist.
         inline T& at(const Key& key);
 
@@ -526,16 +534,26 @@ public:
         );
 
 
-        //- Resize the hash table for efficiency
-        void resize(const label requestedCapacity);
-
         //- Remove all entries from table
         void clear();
 
         //- Remove all entries from table and the table itself.
-        //  Equivalent to clear() followed by resize(0)
+        //  Equivalent to clear() followed by setCapacity(0)
         void clearStorage();
 
+        //- Change the hash table capacity (number of buckets).
+        //  Setting a zero capacity will only remove the underlying
+        //  storage if the table is empty.
+        void setCapacity(label newCapacity);
+
+        //- Rehash the hash table with new number of buckets.
+        //- Currently identical to setCapacity()
+        void resize(label newCapacity);
+
+        //- Reserve space for at least the specified number of elements
+        //- (not the number of buckets) and regenerates the hash table.
+        void reserve(label numEntries);
+
         //- Swap contents into this table
         void swap(HashTable<T, Key, Hash>& rhs) noexcept;
 
diff --git a/src/OpenFOAM/containers/HashTables/HashTable/HashTableIO.C b/src/OpenFOAM/containers/HashTables/HashTable/HashTableIO.C
index 3680f25aee..934e4a19ad 100644
--- a/src/OpenFOAM/containers/HashTables/HashTable/HashTableIO.C
+++ b/src/OpenFOAM/containers/HashTables/HashTable/HashTableIO.C
@@ -33,13 +33,9 @@ License
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class T, class Key, class Hash>
-Foam::HashTable<T, Key, Hash>::HashTable
-(
-    Istream& is,
-    const label initialCapacity
-)
+Foam::HashTable<T, Key, Hash>::HashTable(Istream& is)
 :
-    HashTable(initialCapacity)
+    HashTable<T, Key, Hash>()
 {
     operator>>(is, *this);
 }
@@ -170,10 +166,7 @@ Foam::Istream& Foam::HashTable<T, Key, Hash>::readTable
                     << exit(FatalIOError);
             }
 
-            if (2*len > tbl.capacity())
-            {
-                tbl.resize(2*len);
-            }
+            tbl.reserve(tbl.size() + len);
 
             for (label i=0; i<len; ++i)
             {
diff --git a/src/OpenFOAM/containers/HashTables/Map/Map.H b/src/OpenFOAM/containers/HashTables/Map/Map.H
index 4866e954b8..4a318f31ee 100644
--- a/src/OpenFOAM/containers/HashTables/Map/Map.H
+++ b/src/OpenFOAM/containers/HashTables/Map/Map.H
@@ -73,10 +73,10 @@ public:
 
     // Constructors
 
-        //- Default construct with default (128) initial table capacity
-        Map() = default;
+        //- Default construct: empty without allocation (capacity=0)
+        Map() noexcept = default;
 
-        //- Construct empty with zero initial table capacity
+        //- Construct empty without allocation (capacity=0)
         explicit Map(const Foam::zero) noexcept
         :
             parent_type(Foam::zero{})
diff --git a/src/OpenFOAM/containers/HashTables/PtrMap/PtrMap.H b/src/OpenFOAM/containers/HashTables/PtrMap/PtrMap.H
index 3d3d08b532..50360060d9 100644
--- a/src/OpenFOAM/containers/HashTables/PtrMap/PtrMap.H
+++ b/src/OpenFOAM/containers/HashTables/PtrMap/PtrMap.H
@@ -65,10 +65,10 @@ public:
 
     // Constructors
 
-        //- Default construct with default (128) initial table capacity
-        PtrMap() = default;
+        //- Default construct: empty without allocation (capacity=0)
+        PtrMap() noexcept = default;
 
-        //- Construct empty with zero initial table capacity
+        //- Construct empty without allocation (capacity=0)
         explicit PtrMap(const Foam::zero) noexcept
         :
             parent_type(Foam::zero{})
diff --git a/src/OpenFOAM/containers/IndirectLists/IndirectListBase/IndirectListBaseIO.C b/src/OpenFOAM/containers/IndirectLists/IndirectListBase/IndirectListBaseIO.C
index d08bcb4314..acab8cc477 100644
--- a/src/OpenFOAM/containers/IndirectLists/IndirectListBase/IndirectListBaseIO.C
+++ b/src/OpenFOAM/containers/IndirectLists/IndirectListBase/IndirectListBaseIO.C
@@ -69,7 +69,7 @@ Foam::Ostream& Foam::IndirectListBase<T, Addr>::writeList
             os.endRawWrite();
         }
     }
-    else if (len > 1 && is_contiguous<T>::value && list.uniform())
+    else if (is_contiguous<T>::value && len > 1 && list.uniform())
     {
         // Two or more entries, and all entries have identical values.
         os << len << token::BEGIN_BLOCK << list[0] << token::END_BLOCK;
diff --git a/src/OpenFOAM/containers/Lists/DynamicList/DynamicList.H b/src/OpenFOAM/containers/Lists/DynamicList/DynamicList.H
index 691f233e27..719eabff57 100644
--- a/src/OpenFOAM/containers/Lists/DynamicList/DynamicList.H
+++ b/src/OpenFOAM/containers/Lists/DynamicList/DynamicList.H
@@ -152,14 +152,14 @@ public:
         inline explicit DynamicList(const IndirectListBase<T, Addr>& lst);
 
         //- Move construct.
-        inline DynamicList(DynamicList<T, SizeMin>&& lst);
+        inline DynamicList(DynamicList<T, SizeMin>&& list) noexcept;
 
         //- Move construct with different sizing parameters
         template<int AnySizeMin>
-        inline DynamicList(DynamicList<T, AnySizeMin>&& lst);
+        inline DynamicList(DynamicList<T, AnySizeMin>&& list) noexcept;
 
         //- Move construct from List
-        inline DynamicList(List<T>&& lst);
+        inline DynamicList(List<T>&& list) noexcept;
 
         //- Construct from Istream. Size set to size of list read.
         explicit DynamicList(Istream& is);
@@ -167,7 +167,7 @@ public:
 
     // Member Functions
 
-    // Access
+    // Capacity
 
         //- Normal lower capacity limit - the SizeMin template parameter
         static constexpr label min_size() noexcept { return SizeMin; }
@@ -241,20 +241,23 @@ public:
         //- Clear the list and delete storage.
         inline void clearStorage();
 
-        //- Expand the addressable size to fit the allocated capacity.
-        //  Returns the previous addressable size.
-        inline label expandStorage() noexcept;
-
         //- Shrink the allocated space to the number of elements used.
-        inline void shrinkStorage();
+        inline void shrink_to_fit();
 
-        //- Shrink the allocated space to the number of elements used.
-        //  Returns a reference to the DynamicList.
+        //- Shrink the internal bookkeeping of the allocated space to the
+        //- number of addressed elements without affecting allocation.
+        //  \note when empty() it will delete any allocated memory.
+        inline void shrink_unsafe();
+
+        //- Calls shrink_to_fit() and returns a reference to the DynamicList.
         inline DynamicList<T, SizeMin>& shrink();
 
 
     // Edit
 
+        //- Swap with plain List content. Implies shrink_to_fit().
+        inline void swap(List<T>& list);
+
         //- Swap content, independent of sizing parameter
         template<int AnySizeMin>
         inline void swap(DynamicList<T, AnySizeMin>& other) noexcept;
diff --git a/src/OpenFOAM/containers/Lists/DynamicList/DynamicListI.H b/src/OpenFOAM/containers/Lists/DynamicList/DynamicListI.H
index 432adc9dff..178544aa2a 100644
--- a/src/OpenFOAM/containers/Lists/DynamicList/DynamicListI.H
+++ b/src/OpenFOAM/containers/Lists/DynamicList/DynamicListI.H
@@ -260,12 +260,13 @@ inline Foam::DynamicList<T, SizeMin>::DynamicList
 template<class T, int SizeMin>
 inline Foam::DynamicList<T, SizeMin>::DynamicList
 (
-    DynamicList<T, SizeMin>&& lst
-)
+    DynamicList<T, SizeMin>&& list
+) noexcept
 :
-    capacity_(0)
+    List<T>(std::move(static_cast<List<T>&>(list))),
+    capacity_(list.capacity())
 {
-    transfer(lst);
+    list.setCapacity_unsafe(0);  // Same as shrink_unsafe() but noexcept
 }
 
 
@@ -273,22 +274,23 @@ template<class T, int SizeMin>
 template<int AnySizeMin>
 inline Foam::DynamicList<T, SizeMin>::DynamicList
 (
-    DynamicList<T, AnySizeMin>&& lst
-)
+    DynamicList<T, AnySizeMin>&& list
+) noexcept
 :
-    capacity_(0)
+    List<T>(std::move(static_cast<List<T>&>(list))),
+    capacity_(list.capacity())
 {
-    transfer(lst);
+    list.setCapacity_unsafe(0);  // Same as shrink_unsafe() but noexcept
 }
 
 
 template<class T, int SizeMin>
 inline Foam::DynamicList<T, SizeMin>::DynamicList
 (
-    List<T>&& lst
-)
+    List<T>&& list
+) noexcept
 :
-    List<T>(std::move(lst)),
+    List<T>(std::move(list)),
     capacity_(List<T>::size())
 {}
 
@@ -422,41 +424,64 @@ inline void Foam::DynamicList<T, SizeMin>::clearStorage()
 
 
 template<class T, int SizeMin>
-inline Foam::label Foam::DynamicList<T, SizeMin>::expandStorage() noexcept
-{
-    const label currLen = List<T>::size();
-
-    // Address into the entire list
-    List<T>::setAddressableSize(capacity_);
-
-    return currLen;
-}
-
-
-template<class T, int SizeMin>
-inline void Foam::DynamicList<T, SizeMin>::shrinkStorage()
+inline void Foam::DynamicList<T, SizeMin>::shrink_to_fit()
 {
     const label currLen = List<T>::size();
     if (currLen < capacity_)
     {
         // Adjust addressable size to trigger proper resizing
         List<T>::setAddressableSize(currLen+1);
-
         List<T>::resize(currLen);
         capacity_ = List<T>::size();
     }
 }
 
 
+template<class T, int SizeMin>
+inline void Foam::DynamicList<T, SizeMin>::shrink_unsafe()
+{
+    if (List<T>::empty())
+    {
+        // Delete storage if empty
+        List<T>::clear();
+    }
+    capacity_ = List<T>::size();
+}
+
+
 template<class T, int SizeMin>
 inline Foam::DynamicList<T, SizeMin>&
 Foam::DynamicList<T, SizeMin>::shrink()
 {
-    this->shrinkStorage();
+    this->shrink_to_fit();
     return *this;
 }
 
 
+template<class T, int SizeMin>
+inline void
+Foam::DynamicList<T, SizeMin>::swap(List<T>& list)
+{
+    if
+    (
+        static_cast<const List<T>*>(this)
+     == static_cast<const List<T>*>(&list)
+    )
+    {
+        return;  // Self-swap is a no-op
+    }
+
+    // Remove unused storage
+    this->shrink_to_fit();
+
+    // Swap storage and addressable size
+    UList<T>::swap(list);
+
+    // Update capacity
+    capacity_ = List<T>::size();
+}
+
+
 template<class T, int SizeMin>
 template<int AnySizeMin>
 inline void Foam::DynamicList<T, SizeMin>::swap
@@ -485,9 +510,8 @@ template<class T, int SizeMin>
 inline void
 Foam::DynamicList<T, SizeMin>::transfer(List<T>& list)
 {
-    // Take over storage, clear addressing for list
-    capacity_ = list.size();
     List<T>::transfer(list);
+    capacity_ = List<T>::size();
 }
 
 
@@ -508,12 +532,11 @@ Foam::DynamicList<T, SizeMin>::transfer
         return;  // Self-assignment is a no-op
     }
 
-    // Take over storage as-is (without shrink, without using SizeMin)
-    // clear addressing and storage for old lst.
+    // Take over storage as-is (without shrink)
     capacity_ = list.capacity();
 
     List<T>::transfer(static_cast<List<T>&>(list));
-    list.clearStorage();  // Ensure capacity=0
+    list.clearStorage();  // capacity=0 etc.
 }
 
 
@@ -662,7 +685,7 @@ inline void Foam::DynamicList<T, SizeMin>::push_back
 )
 {
     push_back(std::move(static_cast<List<T>&>(list)));
-    list.clearStorage();  // Ensure capacity=0
+    list.clearStorage();  // Deletion, capacity=0 etc.
 }
 
 
diff --git a/src/OpenFOAM/containers/Lists/DynamicList/DynamicListIO.C b/src/OpenFOAM/containers/Lists/DynamicList/DynamicListIO.C
index c4a2dbae33..b47cc12b7a 100644
--- a/src/OpenFOAM/containers/Lists/DynamicList/DynamicListIO.C
+++ b/src/OpenFOAM/containers/Lists/DynamicList/DynamicListIO.C
@@ -222,26 +222,24 @@ Foam::Istream& Foam::DynamicList<T, SizeMin>::readList(Istream& is)
                 );
             }
         }
-        else if (std::is_same<char, T>::value)
+        else if (std::is_same<char, typename std::remove_cv<T>::type>::value)
         {
-            // Special treatment for char data (always binary and contiguous)
-            // (see List<char>::readList)
+            // Special treatment for char data (binary I/O only)
+            const auto oldFmt = is.format(IOstreamOption::BINARY);
 
             if (len)
             {
-                const auto oldFmt = is.format(IOstreamOption::BINARY);
-
                 // read(...) includes surrounding start/end delimiters
                 is.read(list.data_bytes(), list.size_bytes());
 
-                is.format(oldFmt);
-
                 is.fatalCheck
                 (
                     "DynamicList<char>::readList(Istream&) : "
                     "reading binary block"
                 );
             }
+
+            is.format(oldFmt);
         }
         else
         {
@@ -252,9 +250,13 @@ Foam::Istream& Foam::DynamicList<T, SizeMin>::readList(Istream& is)
             {
                 if (delimiter == token::BEGIN_LIST)
                 {
-                    for (label i=0; i<len; ++i)
+                    auto iter = list.begin();
+                    const auto last = list.end();
+
+                    // Contents
+                    for (/*nil*/; (iter != last); (void)++iter)
                     {
-                        is >> list[i];
+                        is >> *iter;
 
                         is.fatalCheck
                         (
diff --git a/src/OpenFOAM/containers/Lists/List/List.C b/src/OpenFOAM/containers/Lists/List/List.C
index c2fa0870ec..9437fd2c43 100644
--- a/src/OpenFOAM/containers/Lists/List/List.C
+++ b/src/OpenFOAM/containers/Lists/List/List.C
@@ -282,12 +282,12 @@ Foam::List<T>::List(std::initializer_list<T> list)
 
 
 template<class T>
-Foam::List<T>::List(List<T>&& list)
+Foam::List<T>::List(List<T>&& list) noexcept
 :
-    UList<T>()
+    UList<T>(list.data(), list.size())
 {
-    // Can use transfer or swap to manage content
-    transfer(list);
+    list.size_ = 0;
+    list.v_ = nullptr;
 }
 
 
@@ -351,12 +351,13 @@ template<class T>
 template<int SizeMin>
 void Foam::List<T>::transfer(DynamicList<T, SizeMin>& list)
 {
-    // Shrink the allocated space to the number of elements used
-    list.shrink();
-    transfer(static_cast<List<T>&>(list));
+    // Remove existing contents before anything else.
+    clear();
 
-    // Ensure DynamicList has proper capacity=0 too
-    list.clearStorage();
+    // Shrink the allocated space to the number of elements used
+    list.shrink_to_fit();
+    transfer(static_cast<List<T>&>(list));
+    list.clearStorage();  // Deletion, capacity=0 etc.
 }
 
 
diff --git a/src/OpenFOAM/containers/Lists/List/List.H b/src/OpenFOAM/containers/Lists/List/List.H
index ec0283589c..c0b6f767b4 100644
--- a/src/OpenFOAM/containers/Lists/List/List.H
+++ b/src/OpenFOAM/containers/Lists/List/List.H
@@ -115,9 +115,6 @@ class List
 
     // Methods as per DynamicList to simplify code maintenance
 
-        //- Stub method for internal naming as per DynamicList
-        label capacity() const noexcept { return UList<T>::size(); }
-
         //- Stub method for internal naming as per DynamicList
         void setCapacity_nocopy(const label len) { resize_nocopy(len); }
 
@@ -190,7 +187,7 @@ public:
         List(std::initializer_list<T> list);
 
         //- Move construct from List
-        List(List<T>&& list);
+        List(List<T>&& list) noexcept;
 
         //- Move construct from DynamicList
         template<int SizeMin>
@@ -230,6 +227,13 @@ public:
         //  Otherwise the contents will be uninitialized.
         inline void resize_nocopy(const label len);
 
+        //- Change the addressed list size directly without affecting
+        //- any memory management (advanced usage).
+        //
+        //  It is left to the caller to avoid \em unsafe lengthening beyond
+        //  the allocated memory region.
+        inline void resize_unsafe(const label len) noexcept;
+
         //- Alias for resize()
         void setSize(const label n) { this->resize(n); }
 
@@ -289,7 +293,7 @@ public:
     // Member Operators
 
         //- Assignment to UList operator. Takes linear time
-        void operator=(const UList<T>& a);
+        void operator=(const UList<T>& list);
 
         //- Assignment operator. Takes linear time
         void operator=(const List<T>& list);
@@ -410,11 +414,6 @@ public:
 
 // * * * * * * * * * * * * Template Specializations  * * * * * * * * * * * * //
 
-//- Specialized list reading for character lists which always uses
-//- binary format.
-template<>
-Istream& List<char>::readList(Istream& is);
-
 //- Hashing for List data
 template<class T>
 struct Hash<List<T>> : List<T>::hasher {};
diff --git a/src/OpenFOAM/containers/Lists/List/ListI.H b/src/OpenFOAM/containers/Lists/List/ListI.H
index 621ecd19d6..6bab28191b 100644
--- a/src/OpenFOAM/containers/Lists/List/ListI.H
+++ b/src/OpenFOAM/containers/Lists/List/ListI.H
@@ -185,6 +185,13 @@ inline void Foam::List<T>::resize_nocopy(const label len)
 }
 
 
+template<class T>
+inline void Foam::List<T>::resize_unsafe(const label len) noexcept
+{
+    UList<T>::setAddressableSize(len);
+}
+
+
 template<class T>
 inline T& Foam::List<T>::newElmt(const label i)
 {
diff --git a/src/OpenFOAM/containers/Lists/List/ListIO.C b/src/OpenFOAM/containers/Lists/List/ListIO.C
index 654cdb46f6..06786f8f2a 100644
--- a/src/OpenFOAM/containers/Lists/List/ListIO.C
+++ b/src/OpenFOAM/containers/Lists/List/ListIO.C
@@ -222,6 +222,25 @@ Foam::Istream& Foam::List<T>::readList(Istream& is)
                 );
             }
         }
+        else if (std::is_same<char, typename std::remove_cv<T>::type>::value)
+        {
+            // Special treatment for char data (binary I/O only)
+            const auto oldFmt = is.format(IOstreamOption::BINARY);
+
+            if (len)
+            {
+                // read(...) includes surrounding start/end delimiters
+                is.read(list.data_bytes(), list.size_bytes());
+
+                is.fatalCheck
+                (
+                    "List<char>::readList(Istream&) : "
+                    "reading binary block"
+                );
+            }
+
+            is.format(oldFmt);
+        }
         else
         {
             // Begin of contents marker
@@ -231,9 +250,13 @@ Foam::Istream& Foam::List<T>::readList(Istream& is)
             {
                 if (delimiter == token::BEGIN_LIST)
                 {
-                    for (label i=0; i<len; ++i)
+                    auto iter = list.begin();
+                    const auto last = list.end();
+
+                    // Contents
+                    for (/*nil*/; (iter != last); (void)++iter)
                     {
-                        is >> list[i];
+                        is >> *iter;
 
                         is.fatalCheck
                         (
diff --git a/src/OpenFOAM/containers/Lists/List/SubList.H b/src/OpenFOAM/containers/Lists/List/SubList.H
index f1c6aa2b38..e34f27fcd0 100644
--- a/src/OpenFOAM/containers/Lists/List/SubList.H
+++ b/src/OpenFOAM/containers/Lists/List/SubList.H
@@ -83,7 +83,7 @@ public:
         SubList() noexcept = default;
 
         //- Copy construct, shallow copy
-        SubList(const SubList&) noexcept = default;
+        SubList(const SubList<T>&) noexcept = default;
 
 
     // Constructors
@@ -93,21 +93,21 @@ public:
 
         //- Construct from FixedList, the entire size
         template<unsigned N>
-        inline explicit SubList(const FixedList<T, N>& list);
+        inline explicit SubList(const FixedList<T, N>& list) noexcept;
 
         //- Construct from UList and sub-list size, start at 0
         inline SubList
         (
             const UList<T>& list,
-            const label subSize
+            const label len
         );
 
         //- Construct from UList, sub-list size and start index
         inline SubList
         (
             const UList<T>& list,
-            const label subSize,
-            const label startIndex
+            const label len,
+            const label start
         );
 
         //- Construct from UList and a (start,size) range.
@@ -119,8 +119,8 @@ public:
             const labelRange& range
         );
 
-        //- Construct from UList and a (start,size) range, but bypassing
-        //- run-time range checking.
+        //- Construct from UList and a (start,size) range,
+        //- but bypassing run-time range checking.
         inline SubList
         (
             const labelRange& range,
@@ -140,15 +140,15 @@ public:
         inline UList<T>& reset
         (
             const UList<T>& list,
-            const label subSize
+            const label len
         );
 
         //- Reset to use UList with sub-list size and start index
         inline UList<T>& reset
         (
             const UList<T>& list,
-            const label subSize,
-            const label startIndex
+            const label len,
+            const label start
         );
 
         //- Reset to use UList with a (start,size) range.
diff --git a/src/OpenFOAM/containers/Lists/List/SubListI.H b/src/OpenFOAM/containers/Lists/List/SubListI.H
index 389e9e85f8..3b15f4c9e1 100644
--- a/src/OpenFOAM/containers/Lists/List/SubListI.H
+++ b/src/OpenFOAM/containers/Lists/List/SubListI.H
@@ -54,9 +54,9 @@ template<unsigned N>
 inline Foam::SubList<T>::SubList
 (
     const FixedList<T, N>& list
-)
+) noexcept
 :
-    UList<T>(const_cast<T*>(list.cdata()), static_cast<label>(N))
+    UList<T>(const_cast<T*>(list.cdata()), list.size())
 {}
 
 
@@ -64,13 +64,13 @@ template<class T>
 inline Foam::SubList<T>::SubList
 (
     const UList<T>& list,
-    const label subSize
+    const label len
 )
 :
-    UList<T>(const_cast<T*>(list.cdata()), subSize)
+    UList<T>(const_cast<T*>(list.cdata()), len)
 {
     #ifdef FULLDEBUG
-    list.checkSize(subSize);
+    list.checkSize(len);
     #endif
 }
 
@@ -79,14 +79,14 @@ template<class T>
 inline Foam::SubList<T>::SubList
 (
     const UList<T>& list,
-    const label subSize,
-    const label startIndex
+    const label len,
+    const label start
 )
 :
-    UList<T>(const_cast<T*>(list.cdata() + startIndex), subSize)
+    UList<T>(const_cast<T*>(list.cdata() + start), len)
 {
     #ifdef FULLDEBUG
-    list.checkRange(startIndex, subSize);
+    list.checkRange(start, len);
     #endif
 }
 
@@ -144,14 +144,14 @@ template<class T>
 inline Foam::UList<T>& Foam::SubList<T>::reset
 (
     const UList<T>& list,
-    const label subSize
+    const label len
 )
 {
     #ifdef FULLDEBUG
-    list.checkSize(subSize);
+    list.checkSize(len);
     #endif
 
-    UList<T>::shallowCopy(const_cast<T*>(list.cdata()), subSize);
+    UList<T>::shallowCopy(const_cast<T*>(list.cdata()), len);
     return *this;
 }
 
@@ -160,18 +160,18 @@ template<class T>
 inline Foam::UList<T>& Foam::SubList<T>::reset
 (
     const UList<T>& list,
-    const label subSize,
-    const label startIndex
+    const label len,
+    const label start
 )
 {
     #ifdef FULLDEBUG
-    list.checkRange(startIndex, subSize);
+    list.checkRange(start, len);
     #endif
 
     UList<T>::shallowCopy
     (
-        const_cast<T*>(list.cdata() + startIndex),
-        subSize
+        const_cast<T*>(list.cdata() + start),
+        len
     );
     return *this;
 }
diff --git a/src/OpenFOAM/containers/Lists/List/UList.H b/src/OpenFOAM/containers/Lists/List/UList.H
index 1d70c02703..b7ed2f27d3 100644
--- a/src/OpenFOAM/containers/Lists/List/UList.H
+++ b/src/OpenFOAM/containers/Lists/List/UList.H
@@ -482,9 +482,12 @@ public:
         //- True if List is empty (ie, size() is zero)
         bool empty() const noexcept { return !size_; }
 
-        //- The number of elements in the List
+        //- The number of elements in the container
         label size() const noexcept { return size_; }
 
+        //- Size of the underlying storage.
+        label capacity() const noexcept { return size_; }
+
         //- The size of the largest possible UList
         static constexpr label max_size() noexcept { return labelMax; }
 
@@ -497,22 +500,22 @@ public:
         //- Equality operation on ULists of the same type.
         //  Returns true when the ULists are element-wise equal
         //  (using UList::value_type::operator==).  Takes linear time
-        bool operator==(const UList<T>& a) const;
+        bool operator==(const UList<T>& list) const;
 
         //- The opposite of the equality operation. Takes linear time
-        bool operator!=(const UList<T>& a) const;
+        bool operator!=(const UList<T>& list) const;
 
         //- Compare two ULists lexicographically. Takes linear time
         bool operator<(const UList<T>& list) const;
 
         //- Compare two ULists lexicographically. Takes linear time
-        bool operator>(const UList<T>& a) const;
+        bool operator>(const UList<T>& list) const;
 
         //- Return true if !(a > b). Takes linear time
-        bool operator<=(const UList<T>& a) const;
+        bool operator<=(const UList<T>& list) const;
 
         //- Return true if !(a < b). Takes linear time
-        bool operator>=(const UList<T>& a) const;
+        bool operator>=(const UList<T>& list) const;
 
 
     // Reading/writing
@@ -640,19 +643,10 @@ public:
 
 // * * * * * * * * * * * * Template Specializations  * * * * * * * * * * * * //
 
-//- Specialized list reading for character lists which always uses
-//- binary format.
-template<>
-Istream& UList<char>::readList(Istream& is);
-
-//- Character list writeEntry - always uses binary format.
+//- Character list writeEntry
 template<>
 void UList<char>::writeEntry(Ostream& os) const;
 
-//- Character list writeList - always uses binary format.
-template<>
-Ostream& UList<char>::writeList(Ostream& os, const label /*unused*/) const;
-
 //- Character list assign zero - avoids Foam::zero casting ambiguities
 template<>
 void UList<char>::operator=(const Foam::zero);
diff --git a/src/OpenFOAM/containers/Lists/List/UListIO.C b/src/OpenFOAM/containers/Lists/List/UListIO.C
index 93ff35f190..9a70a186aa 100644
--- a/src/OpenFOAM/containers/Lists/List/UListIO.C
+++ b/src/OpenFOAM/containers/Lists/List/UListIO.C
@@ -46,15 +46,20 @@ void Foam::UList<T>::writeEntry(Ostream& os) const
     {
         os << *this;
     }
-    else if (os.format() == IOstreamOption::ASCII)
+    else if
+    (
+        os.format() == IOstreamOption::BINARY
+     || std::is_same<char, typename std::remove_cv<T>::type>::value
+    )
     {
-        // Zero-sized ASCII - Write size and delimiters
-        os  << 0 << token::BEGIN_LIST << token::END_LIST;
+        // Zero-sized binary - Write size only
+        // NB: special treatment for char data (binary I/O only)
+        os << label(0);
     }
     else
     {
-        // Zero-sized binary - Write size only
-        os  << 0;
+        // Zero-sized ASCII - Write size and delimiters
+        os << label(0) << token::BEGIN_LIST << token::END_LIST;
     }
 }
 
@@ -96,7 +101,22 @@ Foam::Ostream& Foam::UList<T>::writeList
             os.write(list.cdata_bytes(), list.size_bytes());
         }
     }
-    else if (len > 1 && is_contiguous<T>::value && list.uniform())
+    else if (std::is_same<char, typename std::remove_cv<T>::type>::value)
+    {
+        // Special treatment for char data (binary I/O only)
+
+        const auto oldFmt = os.format(IOstreamOption::BINARY);
+        os << nl << len << nl;
+
+        if (len)
+        {
+            // write(...) includes surrounding start/end delimiters
+            os.write(list.cdata_bytes(), list.size_bytes());
+        }
+
+        os.format(oldFmt);
+    }
+    else if (is_contiguous<T>::value && len > 1 && list.uniform())
     {
         // Two or more entries, and all entries have identical values.
         os  << len << token::BEGIN_BLOCK << list[0] << token::END_BLOCK;
@@ -120,11 +140,18 @@ Foam::Ostream& Foam::UList<T>::writeList
         // Size and start delimiter
         os << len << token::BEGIN_LIST;
 
+        auto iter = list.cbegin();
+        const auto last = list.cend();
+
         // Contents
-        for (label i=0; i < len; ++i)
+        if (iter != last)
         {
-            if (i) os << token::SPACE;
-            os << list[i];
+            os << *iter;
+
+            for (++iter; (iter != last); (void)++iter)
+            {
+                os << token::SPACE << *iter;
+            }
         }
 
         // End delimiter
@@ -135,16 +162,19 @@ Foam::Ostream& Foam::UList<T>::writeList
         // Multi-line output
 
         // Size and start delimiter
-        os << nl << len << nl << token::BEGIN_LIST << nl;
+        os << nl << len << nl << token::BEGIN_LIST;
+
+        auto iter = list.cbegin();
+        const auto last = list.cend();
 
         // Contents
-        for (label i=0; i < len; ++i)
+        for (/*nil*/; (iter != last); (void)++iter)
         {
-            os << list[i] << nl;
+            os << nl << *iter;
         }
 
         // End delimiter
-        os << token::END_LIST << nl;
+        os << nl << token::END_LIST << nl;
     }
 
     os.check(FUNCTION_NAME);
@@ -224,6 +254,25 @@ Foam::Istream& Foam::UList<T>::readList(Istream& is)
                 );
             }
         }
+        else if (std::is_same<char, typename std::remove_cv<T>::type>::value)
+        {
+            // Special treatment for char data (binary I/O only)
+            const auto oldFmt = is.format(IOstreamOption::BINARY);
+
+            if (len)
+            {
+                // read(...) includes surrounding start/end delimiters
+                is.read(list.data_bytes(), list.size_bytes());
+
+                is.fatalCheck
+                (
+                    "UList<char>::readList(Istream&) : "
+                    "reading binary block"
+                );
+            }
+
+            is.format(oldFmt);
+        }
         else
         {
             // Begin of contents marker
diff --git a/src/OpenFOAM/containers/PtrLists/PtrDynList/PtrDynList.H b/src/OpenFOAM/containers/PtrLists/PtrDynList/PtrDynList.H
index 365a2f4249..09f44c928a 100644
--- a/src/OpenFOAM/containers/PtrLists/PtrDynList/PtrDynList.H
+++ b/src/OpenFOAM/containers/PtrLists/PtrDynList/PtrDynList.H
@@ -85,8 +85,12 @@ public:
         //- Move construct
         inline PtrDynList(PtrDynList<T, SizeMin>&& list);
 
+        //- Move construct with different sizing parameters
+        template<int AnySizeMin>
+        inline PtrDynList(PtrDynList<T, AnySizeMin>&& list);
+
         //- Move construct from PtrList
-        inline PtrDynList(PtrList<T>&& list);
+        inline PtrDynList(PtrList<T>&& list) noexcept;
 
         //- Take ownership of pointers in the list, set old pointers to null.
         inline explicit PtrDynList(UList<T*>& list);
@@ -121,12 +125,16 @@ public:
         //- Clear the list and delete storage.
         inline void clearStorage();
 
-        //- Expand the addressable size to fit the allocated capacity.
-        //  Returns the previous addressable size.
-        inline label expandStorage() noexcept;
-
         //- Shrink the allocated space to the number of elements used.
-        inline void shrink();
+        inline void shrink_to_fit();
+
+        //- Shrink the internal bookkeeping of the allocated space to the
+        //- number of addressed elements without affecting allocation.
+        //  \note when empty() it will delete any allocated memory.
+        inline void shrink_unsafe();
+
+        //- Calls shrink_to_fit()
+        void shrink() { shrink_to_fit(); }
 
 
     // Edit
@@ -136,9 +144,12 @@ public:
         //  \return the number of non-null entries
         inline label squeezeNull();
 
+        //- Swap with plain PtrList content. Implies shrink_to_fit().
+        inline void swap(PtrList<T>& list);
+
         //- Swap content, independent of sizing parameter
         template<int AnySizeMin>
-        inline void swap(PtrDynList<T, AnySizeMin>& other);
+        inline void swap(PtrDynList<T, AnySizeMin>& other) noexcept;
 
         //- Transfer contents of the argument PtrList into this.
         inline void transfer(PtrList<T>& list);
diff --git a/src/OpenFOAM/containers/PtrLists/PtrDynList/PtrDynListI.H b/src/OpenFOAM/containers/PtrLists/PtrDynList/PtrDynListI.H
index a94cf0a4c5..ba4f0ad11b 100644
--- a/src/OpenFOAM/containers/PtrLists/PtrDynList/PtrDynListI.H
+++ b/src/OpenFOAM/containers/PtrLists/PtrDynList/PtrDynListI.H
@@ -67,9 +67,29 @@ inline Foam::PtrDynList<T, SizeMin>::PtrDynList
 )
 :
     PtrList<T>(std::move(list)),
-    capacity_(list.capacity_)
+    capacity_(list.capacity())
 {
-    list.clearStorage();
+    // FUTURE:
+    // list.setCapacity_unsafe(0);  // Same as shrink_unsafe() but noexcept
+
+    list.clearStorage();  // capacity=0 etc.
+}
+
+
+template<class T, int SizeMin>
+template<int AnySizeMin>
+inline Foam::PtrDynList<T, SizeMin>::PtrDynList
+(
+    PtrDynList<T, AnySizeMin>&& list
+)
+:
+    PtrList<T>(std::move(list)),
+    capacity_(list.capacity())
+{
+    // FUTURE:
+    // list.setCapacity_unsafe(0);  // Same as shrink_unsafe() but noexcept
+
+    list.clearStorage();  // capacity=0 etc.
 }
 
 
@@ -77,7 +97,7 @@ template<class T, int SizeMin>
 inline Foam::PtrDynList<T, SizeMin>::PtrDynList
 (
     PtrList<T>&& list
-)
+) noexcept
 :
     PtrList<T>(std::move(list)),
     capacity_(PtrList<T>::size())
@@ -177,32 +197,31 @@ inline void Foam::PtrDynList<T, SizeMin>::clearStorage()
 
 
 template<class T, int SizeMin>
-inline Foam::label Foam::PtrDynList<T, SizeMin>::expandStorage() noexcept
-{
-    const label currLen = PtrList<T>::size();
-
-    // Allow addressing into the entire list
-    PtrList<T>::setAddressableSize(capacity_);
-
-    return currLen;
-}
-
-
-template<class T, int SizeMin>
-inline void Foam::PtrDynList<T, SizeMin>::shrink()
+inline void Foam::PtrDynList<T, SizeMin>::shrink_to_fit()
 {
     const label currLen = PtrList<T>::size();
     if (currLen < capacity_)
     {
         // Adjust addressable size to trigger proper resizing
         PtrList<T>::setAddressableSize(currLen+1);
-
         PtrList<T>::resize(currLen);
         capacity_ = PtrList<T>::size();
     }
 }
 
 
+template<class T, int SizeMin>
+inline void Foam::PtrDynList<T, SizeMin>::shrink_unsafe()
+{
+    if (PtrList<T>::empty())
+    {
+        // Delete empty list
+        PtrList<T>::clear();
+    }
+    capacity_ = PtrList<T>::size();
+}
+
+
 template<class T, int SizeMin>
 inline Foam::label Foam::PtrDynList<T, SizeMin>::squeezeNull()
 {
@@ -212,12 +231,35 @@ inline Foam::label Foam::PtrDynList<T, SizeMin>::squeezeNull()
 }
 
 
+template<class T, int SizeMin>
+inline void Foam::PtrDynList<T, SizeMin>::swap(PtrList<T>& list)
+{
+    if
+    (
+        static_cast<const PtrList<T>*>(this)
+     == static_cast<const PtrList<T>*>(&list)
+    )
+    {
+        return;  // Self-swap is a no-op
+    }
+
+    // Remove unused storage
+    this->shrink_to_fit();
+
+    // Swap storage and addressable size
+    UPtrList<T>::swap(list);
+
+    // Update capacity
+    capacity_ = PtrList<T>::size();
+}
+
+
 template<class T, int SizeMin>
 template<int AnySizeMin>
 inline void Foam::PtrDynList<T, SizeMin>::swap
 (
     PtrDynList<T, AnySizeMin>& other
-)
+) noexcept
 {
     if
     (
@@ -248,9 +290,8 @@ inline void Foam::PtrDynList<T, SizeMin>::transfer(PtrList<T>& list)
         return;  // Self assignment is a no-op
     }
 
-    // Take over storage, clear addressing for list
-    capacity_ = list.size();
     PtrList<T>::transfer(list);
+    capacity_ = PtrList<T>::size();
 }
 
 
@@ -270,10 +311,11 @@ inline void Foam::PtrDynList<T, SizeMin>::transfer
         return;  // Self assignment is a no-op
     }
 
-    // Take over storage as-is (without shrink, without using SizeMin)
+    // Take over storage as-is (without shrink)
     capacity_ = list.capacity();
-    PtrList<T>::transfer(list);
-    list.clearStorage();  // Ensure capacity=0
+
+    PtrList<T>::transfer(static_cast<PtrList<T>&>(list));
+    list.clearStorage();  // capacity=0 etc.
 }
 
 
@@ -496,7 +538,7 @@ template<class T, int SizeMin>
 inline void Foam::PtrDynList<T, SizeMin>::reorder(const labelUList& oldToNew)
 {
     // Shrinking first is a bit annoying, but saves needing a special version.
-    shrink();
+    this->shrink_to_fit();
     PtrList<T>::reorder(oldToNew);
 }
 
diff --git a/src/OpenFOAM/containers/PtrLists/PtrList/PtrList.H b/src/OpenFOAM/containers/PtrLists/PtrList/PtrList.H
index 5cd1ee389a..72c8389278 100644
--- a/src/OpenFOAM/containers/PtrLists/PtrList/PtrList.H
+++ b/src/OpenFOAM/containers/PtrLists/PtrList/PtrList.H
@@ -93,7 +93,7 @@ public:
         inline PtrList(const PtrList<T>& list);
 
         //- Move construct
-        inline PtrList(PtrList<T>&& list);
+        inline PtrList(PtrList<T>&& list) noexcept;
 
         //- Take ownership of pointers in the list, set old pointers to null.
         inline explicit PtrList(UList<T*>& list);
diff --git a/src/OpenFOAM/containers/PtrLists/PtrList/PtrListI.H b/src/OpenFOAM/containers/PtrLists/PtrList/PtrListI.H
index ea982933c5..7db0496d3b 100644
--- a/src/OpenFOAM/containers/PtrLists/PtrList/PtrListI.H
+++ b/src/OpenFOAM/containers/PtrLists/PtrList/PtrListI.H
@@ -54,7 +54,7 @@ inline Foam::PtrList<T>::PtrList(const PtrList<T>& list)
 
 
 template<class T>
-inline Foam::PtrList<T>::PtrList(PtrList<T>&& list)
+inline Foam::PtrList<T>::PtrList(PtrList<T>&& list) noexcept
 :
     UPtrList<T>(std::move(list))
 {}
diff --git a/src/OpenFOAM/containers/PtrLists/PtrListDetail/PtrListDetail.H b/src/OpenFOAM/containers/PtrLists/PtrListDetail/PtrListDetail.H
index 72a2ef7dcd..faed8ae374 100644
--- a/src/OpenFOAM/containers/PtrLists/PtrListDetail/PtrListDetail.H
+++ b/src/OpenFOAM/containers/PtrLists/PtrListDetail/PtrListDetail.H
@@ -81,7 +81,7 @@ public:
         inline PtrListDetail(const PtrListDetail<T>& list);
 
         //- Move construct
-        inline PtrListDetail(PtrListDetail<T>&& list);
+        inline PtrListDetail(PtrListDetail<T>&& list) noexcept;
 
         //- Copy or move (reuse) construct as specified
         inline PtrListDetail(PtrListDetail<T>& list, bool reuse);
diff --git a/src/OpenFOAM/containers/PtrLists/PtrListDetail/PtrListDetailI.H b/src/OpenFOAM/containers/PtrLists/PtrListDetail/PtrListDetailI.H
index 45fd7b7502..07595570f4 100644
--- a/src/OpenFOAM/containers/PtrLists/PtrListDetail/PtrListDetailI.H
+++ b/src/OpenFOAM/containers/PtrLists/PtrListDetail/PtrListDetailI.H
@@ -57,7 +57,7 @@ inline Foam::Detail::PtrListDetail<T>::PtrListDetail
     const PtrListDetail<T>& list
 )
 :
-    List<T*>(list)
+    List<T*>(static_cast<const List<T*>&>(list))
 {}
 
 
@@ -65,9 +65,9 @@ template<class T>
 inline Foam::Detail::PtrListDetail<T>::PtrListDetail
 (
     PtrListDetail<T>&& list
-)
+) noexcept
 :
-    List<T*>(std::move(list))
+    List<T*>(std::move(static_cast<List<T*>&>(list)))
 {}
 
 
@@ -78,7 +78,7 @@ inline Foam::Detail::PtrListDetail<T>::PtrListDetail
     bool reuse
 )
 :
-    List<T*>(list, reuse)
+    List<T*>(static_cast<List<T*>&>(list), reuse)
 {}
 
 
diff --git a/src/OpenFOAM/containers/PtrLists/UPtrList/UPtrList.H b/src/OpenFOAM/containers/PtrLists/UPtrList/UPtrList.H
index a25a52fa10..3b180f3616 100644
--- a/src/OpenFOAM/containers/PtrLists/UPtrList/UPtrList.H
+++ b/src/OpenFOAM/containers/PtrLists/UPtrList/UPtrList.H
@@ -124,7 +124,7 @@ protected:
     // Constructors
 
         //- Low-level move construct
-        inline explicit UPtrList(Detail::PtrListDetail<T>&& ptrs);
+        inline explicit UPtrList(Detail::PtrListDetail<T>&& ptrs) noexcept;
 
 
 public:
@@ -216,7 +216,7 @@ public:
     // Constructors
 
         //- Default construct
-        inline constexpr UPtrList() noexcept;
+        constexpr UPtrList() noexcept = default;
 
         //- Construct with specified size and set all entries to \c nullptr
         inline explicit UPtrList(const label len);
@@ -225,7 +225,7 @@ public:
         inline UPtrList(const UPtrList<T>& list);
 
         //- Move construct
-        inline UPtrList(UPtrList<T>&& list);
+        inline UPtrList(UPtrList<T>&& list) noexcept;
 
         //- Construct as shallow copy or re-use as specified
         inline UPtrList(UPtrList<T>& list, bool reuse);
@@ -254,6 +254,9 @@ public:
         //- The number of entries in the list
         inline label size() const noexcept;
 
+        //- Size of the underlying storage.
+        inline label capacity() const noexcept;
+
         //- The number of non-null entries in the list
         inline label count() const noexcept;
 
@@ -322,7 +325,7 @@ public:
         inline void push_back(UPtrList<T>&& other);
 
         //- Swap content
-        inline void swap(UPtrList<T>& list);
+        inline void swap(UPtrList<T>& list) noexcept;
 
         //- Transfer contents into this list and annul the argument
         inline void transfer(UPtrList<T>& list);
diff --git a/src/OpenFOAM/containers/PtrLists/UPtrList/UPtrListI.H b/src/OpenFOAM/containers/PtrLists/UPtrList/UPtrListI.H
index 37cc87a16e..c7763cf9aa 100644
--- a/src/OpenFOAM/containers/PtrLists/UPtrList/UPtrListI.H
+++ b/src/OpenFOAM/containers/PtrLists/UPtrList/UPtrListI.H
@@ -44,13 +44,6 @@ inline Foam::label Foam::UPtrList<T>::find_next(label pos) const
 
 // * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * //
 
-template<class T>
-inline constexpr Foam::UPtrList<T>::UPtrList() noexcept
-:
-    ptrs_()
-{}
-
-
 template<class T>
 inline Foam::UPtrList<T>::UPtrList(const label len)
 :
@@ -59,7 +52,7 @@ inline Foam::UPtrList<T>::UPtrList(const label len)
 
 
 template<class T>
-inline Foam::UPtrList<T>::UPtrList(Detail::PtrListDetail<T>&& ptrs)
+inline Foam::UPtrList<T>::UPtrList(Detail::PtrListDetail<T>&& ptrs) noexcept
 :
     ptrs_(std::move(ptrs))
 {}
@@ -73,7 +66,7 @@ inline Foam::UPtrList<T>::UPtrList(const UPtrList<T>& list)
 
 
 template<class T>
-inline Foam::UPtrList<T>::UPtrList(UPtrList<T>&& list)
+inline Foam::UPtrList<T>::UPtrList(UPtrList<T>&& list) noexcept
 :
     ptrs_(std::move(list.ptrs_))
 {}
@@ -123,6 +116,13 @@ inline Foam::label Foam::UPtrList<T>::size() const noexcept
 }
 
 
+template<class T>
+inline Foam::label Foam::UPtrList<T>::capacity() const noexcept
+{
+    return ptrs_.capacity();
+}
+
+
 template<class T>
 inline Foam::label Foam::UPtrList<T>::count() const noexcept
 {
@@ -213,7 +213,7 @@ inline void Foam::UPtrList<T>::free()
 
 
 template<class T>
-inline void Foam::UPtrList<T>::swap(UPtrList<T>& list)
+inline void Foam::UPtrList<T>::swap(UPtrList<T>& list) noexcept
 {
     ptrs_.swap(list.ptrs_);
 }
diff --git a/src/OpenFOAM/db/IOobject/IOobject.H b/src/OpenFOAM/db/IOobject/IOobject.H
index 7ff2b2a724..d73bade5c0 100644
--- a/src/OpenFOAM/db/IOobject/IOobject.H
+++ b/src/OpenFOAM/db/IOobject/IOobject.H
@@ -307,6 +307,15 @@ public:
             const word& name
         );
 
+        //- Create scope:name1:name2 or scope_name1_name2 string
+        //  An empty scope is ignored.
+        static inline word scopedName
+        (
+            const std::string& scope,
+            const word& name1,
+            const word& name2
+        );
+
         //- Return the IOobject, but also consider an alternative file name.
         //
         //  \param io The expected IOobject to use
@@ -341,7 +350,7 @@ public:
     // Constructors
 
         //- Construct from name, instance, registry, io options
-        //  (default: NO_READ, NO_WRITE, register, non-global)
+        //  (default: NO_READ, NO_WRITE, REGISTER, non-global)
         IOobject
         (
             const word& name,
@@ -351,7 +360,7 @@ public:
         );
 
         //- Construct from name, instance, local, registry, io options
-        //  (default: NO_READ, NO_WRITE, register, non-global)
+        //  (default: NO_READ, NO_WRITE, REGISTER, non-global)
         IOobject
         (
             const word& name,
@@ -362,7 +371,7 @@ public:
         );
 
         //- Construct from path, registry, io options.
-        //  (default: NO_READ, NO_WRITE, register, non-global)
+        //  (default: NO_READ, NO_WRITE, REGISTER, non-global)
         //
         //  Uses fileNameComponents() to split path into components.
         //  A path that starts with a '/' is regarded as a file system path.
diff --git a/src/OpenFOAM/db/IOobject/IOobjectI.H b/src/OpenFOAM/db/IOobject/IOobjectI.H
index eed345e0d2..f0d0c114b6 100644
--- a/src/OpenFOAM/db/IOobject/IOobjectI.H
+++ b/src/OpenFOAM/db/IOobject/IOobjectI.H
@@ -54,7 +54,40 @@ inline Foam::word Foam::IOobject::scopedName
         return name;
     }
 
-    return scope + (IOobject::scopeSeparator + name);
+    word output;
+    output.reserve(scope.size() + name.size() + 1);
+
+    output += scope;
+    output += IOobject::scopeSeparator;
+    output += name;
+    return output;
+}
+
+
+inline Foam::word Foam::IOobject::scopedName
+(
+    const std::string& scope,
+    const word& name1,
+    const word& name2
+)
+{
+    if (scope.empty())
+    {
+        return IOobject::scopedName(name1, name2);
+    }
+
+    word output;
+    output.reserve(scope.size() + name1.size() + name2.size() + 2);
+
+    output += scope;
+    output += IOobject::scopeSeparator;
+    output += name1;
+    if (!name2.empty())
+    {
+        output += IOobject::scopeSeparator;
+        output += name2;
+    }
+    return output;
 }
 
 
diff --git a/src/OpenFOAM/db/IOobjectList/IOobjectList.H b/src/OpenFOAM/db/IOobjectList/IOobjectList.H
index 427f8513fd..2c993f1fb0 100644
--- a/src/OpenFOAM/db/IOobjectList/IOobjectList.H
+++ b/src/OpenFOAM/db/IOobjectList/IOobjectList.H
@@ -168,13 +168,13 @@ public:
 
     // Constructors
 
-        //- Default construct (empty) with default (128) table capacity
-        IOobjectList() = default;
+        //- Default construct: empty without allocation (capacity=0).
+        IOobjectList() noexcept = default;
 
-        //- Construct with zero table capacity
+        //- Construct empty without allocation (capacity=0)
         inline explicit IOobjectList(const Foam::zero) noexcept;
 
-        //- Construct given initial table capacity
+        //- Construct empty with initial table capacity
         inline explicit IOobjectList(const label initialCapacity);
 
         //- Copy construct
diff --git a/src/OpenFOAM/db/IOobjects/decomposedBlockData/decomposedBlockData.C b/src/OpenFOAM/db/IOobjects/decomposedBlockData/decomposedBlockData.C
index 2076d0fde3..4139ecca42 100644
--- a/src/OpenFOAM/db/IOobjects/decomposedBlockData/decomposedBlockData.C
+++ b/src/OpenFOAM/db/IOobjects/decomposedBlockData/decomposedBlockData.C
@@ -103,6 +103,76 @@ Foam::decomposedBlockData::decomposedBlockData
 
 // * * * * * * * * * * * * * * * Members Functions * * * * * * * * * * * * * //
 
+std::streamoff Foam::decomposedBlockData::writeBlockEntry
+(
+    OSstream& os,
+    const label blocki,
+    const char* str,
+    const size_t len
+)
+{
+    // Offset to the beginning of this output
+    // This should generally be OK for non-compressed streams
+    // (eg, std::ofstream)
+
+    std::streamoff blockOffset = os.stdStream().tellp();
+
+    const word procName("processor" + Foam::name(blocki));
+
+    // Write as commented content
+    // ----------------
+    // // processorN
+    // NCHARS
+    // (...)
+    // ----------------
+    {
+        os << nl << "// " << procName << nl;
+
+        if (str && len > 0)
+        {
+            // Special treatment for char data (binary I/O only)
+            const auto oldFmt = os.format(IOstreamOption::BINARY);
+
+            os << label(len) << nl;
+            os.write(str, len);
+            os << nl;
+
+            os.format(oldFmt);
+        }
+        else
+        {
+            os << label(0) << nl;
+        }
+    }
+
+    // Write as primitiveEntry
+    // {
+    //     // Like writeKeyword()
+    //     os << nl << procName << nl;
+    //
+    //     if (str && len > 0)
+    //     {
+    //         // Special treatment for char data (binary I/O only)
+    //         const auto oldFmt = os.format(IOstreamOption::BINARY);
+    //
+    //         os << label(len) << nl;
+    //         os.write(str, len);
+    //         os << nl;
+    //
+    //         os.format(oldFmt);
+    //     }
+    //     else
+    //     {
+    //         os << label(0) << nl;
+    //     }
+    //
+    //     os.endEntry();
+    // }
+
+    return blockOffset;
+}
+
+
 bool Foam::decomposedBlockData::readBlockEntry
 (
     Istream& is,
@@ -149,7 +219,7 @@ bool Foam::decomposedBlockData::readBlockEntry
 bool Foam::decomposedBlockData::skipBlockEntry(Istream& is)
 {
     // As per readBlockEntry but seeks instead of reading.
-    // Internals like charList::readList
+    // Internals like charList::readList - ie, always binary
 
     // Handle any of these:
     // 0.  NCHARS (...)
@@ -184,19 +254,17 @@ bool Foam::decomposedBlockData::skipBlockEntry(Istream& is)
 
         const label len = tok.labelToken();
 
-        // Binary, always contiguous
+        // Special treatment for char data (binary I/O only)
+        const auto oldFmt = is.format(IOstreamOption::BINARY);
 
         if (len)
         {
-            const auto oldFmt = is.format(IOstreamOption::BINARY);
-
             // read(...) includes surrounding start/end delimiters.
 
-            // Note: nullptr to seek instead of reading
+            // Note: nullptr to ignore instead of reading
             is.read(nullptr, std::streamsize(len));
-
-            is.format(oldFmt);
         }
+        is.format(oldFmt);
 
         handled = true;
     }
@@ -288,52 +356,6 @@ bool Foam::decomposedBlockData::hasBlock(Istream& is, const label blockNumber)
 }
 
 
-std::streamoff Foam::decomposedBlockData::writeBlockEntry
-(
-    OSstream& os,
-    const label blocki,
-    const UList<char>& charData
-)
-{
-    // Offset to the beginning of this output
-
-    std::streamoff blockOffset = os.stdStream().tellp();
-
-    const word procName("processor" + Foam::name(blocki));
-
-    // Write as commented content
-    {
-        os  << nl << "// " << procName << nl;
-        charData.writeList(os) << nl;
-    }
-    // Write as primitiveEntry
-    // {
-    //     os << nl << procName << nl;
-    //     charData.writeList(os);
-    //     os.endEntry();
-    // }
-
-    return blockOffset;
-}
-
-
-std::streamoff Foam::decomposedBlockData::writeBlockEntry
-(
-    OSstream& os,
-    const label blocki,
-    const std::string& content
-)
-{
-    UList<char> charData
-    (
-        const_cast<char*>(content.data()),
-        label(content.size())
-    );
-
-    return decomposedBlockData::writeBlockEntry(os, blocki, charData);
-}
-
-
 std::streamoff Foam::decomposedBlockData::writeBlockEntry
 (
     OSstream& os,
diff --git a/src/OpenFOAM/db/IOobjects/decomposedBlockData/decomposedBlockData.H b/src/OpenFOAM/db/IOobjects/decomposedBlockData/decomposedBlockData.H
index 133b640901..213e6bcb8c 100644
--- a/src/OpenFOAM/db/IOobjects/decomposedBlockData/decomposedBlockData.H
+++ b/src/OpenFOAM/db/IOobjects/decomposedBlockData/decomposedBlockData.H
@@ -261,16 +261,31 @@ public:
         (
             OSstream& os,
             const label blocki,
-            const UList<char>& charData
+            const char* str,
+            const size_t len
         );
 
+        //- Helper: write block of (binary) character data
+        static std::streamoff writeBlockEntry
+        (
+            OSstream& os,
+            const label blocki,
+            const UList<char>& s
+        )
+        {
+            return writeBlockEntry(os, blocki, s.cdata(), s.size_bytes());
+        }
+
         //- Helper: write block of (binary) character content
         static std::streamoff writeBlockEntry
         (
             OSstream& os,
             const label blocki,
-            const std::string& content
-        );
+            const std::string& s
+        )
+        {
+            return writeBlockEntry(os, blocki, s.data(), s.size());
+        }
 
         //- Helper: write block of (binary) character data
         //  \return -1 on error
diff --git a/src/OpenFOAM/db/IOstreams/Fstreams/IFstream.H b/src/OpenFOAM/db/IOstreams/Fstreams/IFstream.H
index 457c850a62..c6ea419a75 100644
--- a/src/OpenFOAM/db/IOstreams/Fstreams/IFstream.H
+++ b/src/OpenFOAM/db/IOstreams/Fstreams/IFstream.H
@@ -105,20 +105,20 @@ public:
     // STL stream
 
         //- Access to underlying std::istream
-        virtual std::istream& stdStream();
+        virtual std::istream& stdStream() override;
 
         //- Const access to underlying std::istream
-        virtual const std::istream& stdStream() const;
+        virtual const std::istream& stdStream() const override;
 
         //- Rewind the stream so that it may be read again.
         //  Includes special handling for compressed streams.
-        virtual void rewind();
+        virtual void rewind() override;
 
 
     // Print
 
         //- Print stream description
-        virtual void print(Ostream& os) const;
+        virtual void print(Ostream& os) const override;
 
 
     // Member Operators
diff --git a/src/OpenFOAM/db/IOstreams/Fstreams/OFstream.H b/src/OpenFOAM/db/IOstreams/Fstreams/OFstream.H
index 488c878471..ca0819ff43 100644
--- a/src/OpenFOAM/db/IOstreams/Fstreams/OFstream.H
+++ b/src/OpenFOAM/db/IOstreams/Fstreams/OFstream.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2017-2022 OpenCFD Ltd.
+    Copyright (C) 2017-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -130,11 +130,11 @@ public:
 
     // STL stream
 
-        //- Access to underlying std::ostream
-        virtual std::ostream& stdStream();
-
         //- Const access to underlying std::ostream
-        virtual const std::ostream& stdStream() const;
+        virtual const std::ostream& stdStream() const override;
+
+        //- Access to underlying std::ostream
+        virtual std::ostream& stdStream() override;
 
         //- Rewind the stream so that it may be written again.
         //- Reopens the file (truncation)
@@ -144,7 +144,7 @@ public:
     // Print
 
         //- Print stream description
-        void print(Ostream& os) const;
+        void print(Ostream& os) const override;
 
 
     // Additional constructors and methods
diff --git a/src/OpenFOAM/db/IOstreams/IOstreams/Ostream.C b/src/OpenFOAM/db/IOstreams/IOstreams/Ostream.C
index 1f65035883..c09ee532ad 100644
--- a/src/OpenFOAM/db/IOstreams/IOstreams/Ostream.C
+++ b/src/OpenFOAM/db/IOstreams/IOstreams/Ostream.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2016-2019 OpenCFD Ltd.
+    Copyright (C) 2016-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -48,16 +48,26 @@ void Foam::Ostream::decrIndent()
 }
 
 
+Foam::Ostream& Foam::Ostream::writeQuoted
+(
+    const std::string& str,
+    const bool quoted
+)
+{
+    return writeQuoted(str.data(), str.size(), quoted);
+}
+
+
 Foam::Ostream& Foam::Ostream::write(const keyType& kw)
 {
-    return writeQuoted(kw, kw.isPattern());
+    return writeQuoted(kw.data(), kw.size(), kw.isPattern());
 }
 
 
 Foam::Ostream& Foam::Ostream::writeKeyword(const keyType& kw)
 {
     indent();
-    writeQuoted(kw, kw.isPattern());
+    writeQuoted(kw.data(), kw.size(), kw.isPattern());
 
     if (indentSize_ <= 1)
     {
@@ -86,7 +96,7 @@ Foam::Ostream& Foam::Ostream::writeKeyword(const keyType& kw)
 
 Foam::Ostream& Foam::Ostream::beginBlock(const keyType& kw)
 {
-    indent(); writeQuoted(kw, kw.isPattern()); write('\n');
+    indent(); writeQuoted(kw.data(), kw.size(), kw.isPattern()); write('\n');
     beginBlock();
 
     return *this;
diff --git a/src/OpenFOAM/db/IOstreams/IOstreams/Ostream.H b/src/OpenFOAM/db/IOstreams/IOstreams/Ostream.H
index d55ec85388..a8ec427a6a 100644
--- a/src/OpenFOAM/db/IOstreams/IOstreams/Ostream.H
+++ b/src/OpenFOAM/db/IOstreams/IOstreams/Ostream.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2016-2022 OpenCFD Ltd.
+    Copyright (C) 2016-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -41,6 +41,7 @@ SourceFiles
 
 #include "IOstream.H"
 #include "keyType.H"
+#include "stdFoam.H"  // For span etc.
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -118,28 +119,35 @@ public:
             //- Write character
             virtual Ostream& write(const char c) = 0;
 
+            //- Write character/string content, with/without surrounding quotes
+            virtual Ostream& writeQuoted
+            (
+                const char* str,
+                std::streamsize len,
+                const bool quoted=true
+            ) = 0;
+
+            //- Write string content, with/without surrounding quotes
+            virtual Ostream& writeQuoted
+            (
+                const std::string& str,
+                const bool quoted=true
+            );
+
             //- Write character string
             virtual Ostream& write(const char* str) = 0;
 
-            //- Write word
+            //- Write word (unquoted)
             virtual Ostream& write(const word& str) = 0;
 
+            //- Write string content (usually quoted)
+            virtual Ostream& write(const std::string& str) = 0;
+
             //- Write keyType
             //  A plain word is written unquoted.
             //  A regular expression is written as a quoted string.
             virtual Ostream& write(const keyType& kw);
 
-            //- Write string
-            virtual Ostream& write(const string& str) = 0;
-
-            //- Write std::string surrounded by quotes.
-            //  Optional write without quotes.
-            virtual Ostream& writeQuoted
-            (
-                const std::string& str,
-                const bool quoted=true
-            ) = 0;
-
             //- Write int32_t
             virtual Ostream& write(const int32_t val) = 0;
 
@@ -317,9 +325,38 @@ public:
 };
 
 
-// --------------------------------------------------------------------
-// ------ Manipulators (not taking arguments)
-// --------------------------------------------------------------------
+// * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * //
+
+#if __cplusplus >= 201703L
+//- Write operator for std::string_view
+inline Ostream& operator<<(Ostream& os, std::string_view s)
+{
+    os.writeQuoted(s.data(), s.size(), true);  // quoted
+    os.check("Foam::operator<<(Ostream&, std::string_view)");
+    return os;
+}
+#endif
+
+//- Write operator for character span. Output like string data
+inline Ostream& operator<<(Ostream& os, stdFoam::span<char> s)
+{
+    os.writeQuoted(s.data(), s.size(), true);  // quoted
+    os.check("Foam::operator<<(Ostream&, stdFoam::span<char>)");
+    return os;
+}
+
+//- Write operator for const character span. Output like string data
+inline Ostream& operator<<(Ostream& os, stdFoam::span<const char> s)
+{
+    os.writeQuoted(s.data(), s.size(), true);  // quoted
+    os.check("Foam::operator<<(Ostream&, stdFoam::span<const char>)");
+    return os;
+}
+
+
+/*---------------------------------------------------------------------------*\
+                       Manipulators (without arguments)
+\*---------------------------------------------------------------------------*/
 
 //- An Ostream manipulator
 typedef Ostream& (*OstreamManip)(Ostream&);
diff --git a/src/OpenFOAM/db/IOstreams/Pstreams/UIPstream.H b/src/OpenFOAM/db/IOstreams/Pstreams/UIPstream.H
index 9a61d58f7f..3e70872c34 100644
--- a/src/OpenFOAM/db/IOstreams/Pstreams/UIPstream.H
+++ b/src/OpenFOAM/db/IOstreams/Pstreams/UIPstream.H
@@ -149,77 +149,71 @@ public:
 
     // Member Functions
 
-        // Inquiry
+    // Stream State Functions
 
-            //- Return flags of output stream
-            virtual ios_base::fmtflags flags() const
-            {
-                return ios_base::fmtflags(0);
-            }
+        //- Return stream flags
+        virtual ios_base::fmtflags flags() const override
+        {
+            return ios_base::fmtflags(0);
+        }
 
-
-        // Read Functions
-
-            //- Return next token from stream
-            Istream& read(token& t);
-
-            //- Read a character
-            Istream& read(char& c);
-
-            //- Read a word
-            Istream& read(word& str);
-
-            // Read a string
-            Istream& read(string& str);
-
-            //- Read a label
-            Istream& read(label& val);
-
-            //- Read a float
-            Istream& read(float& val);
-
-            //- Read a double
-            Istream& read(double& val);
-
-            //- Read binary block with 8-byte alignment.
-            //- Reading into a null pointer behaves like a forward seek of
-            //- count characters.
-            Istream& read(char* data, std::streamsize count);
-
-            //- Low-level raw binary read.
-            //- Reading into a null pointer behaves like a forward seek of
-            //- count characters.
-            Istream& readRaw(char* data, std::streamsize count);
-
-            //- Start of low-level raw binary read
-            bool beginRawRead();
-
-            //- End of low-level raw binary read
-            bool endRawRead()
-            {
-                return true;
-            }
-
-
-    // Positioning
-
-        //- Rewind the receive stream position so that it may be read again
-        virtual void rewind();
-
-
-    // Edit
-
-        //- Set flags of stream
-        virtual ios_base::fmtflags flags(const ios_base::fmtflags)
+        //- Set flags of stream flags
+        virtual ios_base::fmtflags flags(const ios_base::fmtflags) override
         {
             return ios_base::fmtflags(0);
         }
 
 
+    // Read Functions
+
+        //- Return next token from stream
+        virtual Istream& read(token&) override;
+
+        //- Read a character
+        virtual Istream& read(char& c) override;
+
+        //- Read a word
+        virtual Istream& read(word& str) override;
+
+        // Read a string
+        virtual Istream& read(string& str) override;
+
+        //- Read a label
+        virtual Istream& read(label& val) override;
+
+        //- Read a float
+        virtual Istream& read(float& val) override;
+
+        //- Read a double
+        virtual Istream& read(double& val) override;
+
+        //- Read binary block with 8-byte alignment.
+        //- Reading into a null pointer behaves like a forward seek of
+        //- count characters.
+        virtual Istream& read(char* data, std::streamsize count) override;
+
+        //- Low-level raw binary read.
+        //- Reading into a null pointer behaves like a forward seek of
+        //- count characters.
+        virtual Istream& readRaw(char* data, std::streamsize count) override;
+
+        //- Start of low-level raw binary read
+        virtual bool beginRawRead() override;
+
+        //- End of low-level raw binary read
+        virtual bool endRawRead() override { return true; }
+
+
+    // Positioning
+
+        //- Rewind the receive stream position so that it may be read again
+        virtual void rewind() override;
+
+
     // Print
 
         //- Print stream description to Ostream
-        void print(Ostream& os) const;
+        void print(Ostream& os) const override;
 };
 
 
diff --git a/src/OpenFOAM/db/IOstreams/Pstreams/UIPstreamBase.C b/src/OpenFOAM/db/IOstreams/Pstreams/UIPstreamBase.C
index abb58f29a2..714ce38c8f 100644
--- a/src/OpenFOAM/db/IOstreams/Pstreams/UIPstreamBase.C
+++ b/src/OpenFOAM/db/IOstreams/Pstreams/UIPstreamBase.C
@@ -137,7 +137,7 @@ inline void Foam::UIPstreamBase::readFromBuffer
 
 inline Foam::Istream& Foam::UIPstreamBase::readString(std::string& str)
 {
-    // Use std::string::assign() to copy content, including '\0'.
+    // Use std::string::assign() to copy content, including embedded nul chars.
     // Stripping (when desired) is the responsibility of the sending side.
 
     size_t len;
diff --git a/src/OpenFOAM/db/IOstreams/Pstreams/UOPstream.H b/src/OpenFOAM/db/IOstreams/Pstreams/UOPstream.H
index 02f6f85037..274e8aaedb 100644
--- a/src/OpenFOAM/db/IOstreams/Pstreams/UOPstream.H
+++ b/src/OpenFOAM/db/IOstreams/Pstreams/UOPstream.H
@@ -83,8 +83,10 @@ class UOPstreamBase
         //- Add a single char to the send buffer. No alignment needed
         inline void putChar(const char c);
 
-        //- Write string length and string content.
-        //  The content includes the trailing nul char.
+        //- Write string length and content, including embedded nul chars.
+        inline void putString(const char* str, const size_t len);
+
+        //- Write string length and content, including embedded nul chars.
         inline void putString(const std::string& str);
 
 
@@ -142,124 +144,135 @@ public:
 
     // Member Functions
 
-        // Inquiry
+    // Inquiry
 
-            //- Return flags of output stream
-            virtual ios_base::fmtflags flags() const
-            {
-                return ios_base::fmtflags(0);
-            }
+        //- Return flags of output stream
+        virtual ios_base::fmtflags flags() const override
+        {
+            return ios_base::fmtflags(0);
+        }
 
 
-        // Write Functions
+    // Write Functions
 
-            //- Write token to stream or otherwise handle it.
-            //  \return false if the token type was not handled by this method
-            virtual bool write(const token& tok);
+        //- Inherit write methods from Ostream
+        using Ostream::writeQuoted;
 
-            //- Write single character. Whitespace is suppressed.
-            virtual Ostream& write(const char c);
+        //- Write token to stream or otherwise handle it.
+        //  \return false if the token type was not handled by this method
+        virtual bool write(const token& tok) override;
 
-            //- Write the word-characters of a character string.
-            //  Sends as a single char, or as word.
-            virtual Ostream& write(const char* str);
+        //- Write single character. Whitespace is suppressed.
+        virtual Ostream& write(const char c) override;
 
-            //- Write word
-            virtual Ostream& write(const word& str);
+        //- Write character/string content, with/without surrounding quotes
+        virtual Ostream& writeQuoted
+        (
+            const char* str,
+            std::streamsize len,
+            const bool quoted=true
+        ) override;
 
-            //- Write string
-            virtual Ostream& write(const string& str);
+        //- Write the word-characters of a character string.
+        //  Sends as a single char, or as word.
+        virtual Ostream& write(const char* str) override;
 
-            //- Write std::string surrounded by quotes.
-            //  Optional write without quotes.
-            virtual Ostream& writeQuoted
-            (
-                const std::string& str,
-                const bool quoted=true
-            );
+        //- Write word
+        virtual Ostream& write(const word& str) override;
 
-            //- Write int32_t as a label
-            virtual Ostream& write(const int32_t val);
+        //- Write string
+        virtual Ostream& write(const std::string& str) override;
 
-            //- Write int64_t as a label
-            virtual Ostream& write(const int64_t val);
+        //- Write int32_t as a label
+        virtual Ostream& write(const int32_t val) override;
 
-            //- Write float
-            virtual Ostream& write(const float val);
+        //- Write int64_t as a label
+        virtual Ostream& write(const int64_t val) override;
 
-            //- Write double
-            virtual Ostream& write(const double val);
+        //- Write float
+        virtual Ostream& write(const float val) override;
 
-            //- Write binary block with 8-byte alignment.
-            virtual Ostream& write(const char* data, std::streamsize count);
+        //- Write double
+        virtual Ostream& write(const double val) override;
 
-            //- Low-level raw binary output.
-            virtual Ostream& writeRaw(const char* data, std::streamsize count);
+        //- Write binary block with 8-byte alignment.
+        virtual Ostream& write
+        (
+            const char* data,
+            std::streamsize count
+        ) override;
 
-            //- Begin marker for low-level raw binary output.
-            //  The count indicates the number of bytes for subsequent
-            //  writeRaw calls.
-            virtual bool beginRawWrite(std::streamsize count);
+        //- Low-level raw binary output.
+        virtual Ostream& writeRaw
+        (
+            const char* data,
+            std::streamsize count
+        ) override;
 
-            //- End marker for low-level raw binary output.
-            virtual bool endRawWrite()
-            {
-                return true;
-            }
+        //- Begin marker for low-level raw binary output.
+        //  The count indicates the number of bytes for subsequent
+        //  writeRaw calls.
+        virtual bool beginRawWrite(std::streamsize count) override;
 
-            //- Add indentation characters
-            virtual void indent()
-            {}
+        //- End marker for low-level raw binary output.
+        virtual bool endRawWrite() override
+        {
+            return true;
+        }
+
+        //- Add indentation characters
+        virtual void indent() override
+        {}
 
 
-        // Stream state functions
+    // Stream state functions
 
-            //- Flush stream
-            virtual void flush()
-            {}
+        //- Flush stream
+        virtual void flush() override
+        {}
 
-            //- Add newline and flush stream
-            virtual void endl()
-            {}
+        //- Add newline and flush stream
+        virtual void endl() override
+        {}
 
-            //- Get the current padding character
-            //  \return previous padding character
-            virtual char fill() const
-            {
-                return 0;
-            }
+        //- Get the current padding character
+        //  \return previous padding character
+        virtual char fill() const override
+        {
+            return 0;
+        }
 
-            //- Set padding character for formatted field up to field width
-            virtual char fill(const char)
-            {
-                return 0;
-            }
+        //- Set padding character for formatted field up to field width
+        virtual char fill(const char) override
+        {
+            return 0;
+        }
 
-            //- Get width of output field
-            virtual int width() const
-            {
-                return 0;
-            }
+        //- Get width of output field
+        virtual int width() const override
+        {
+            return 0;
+        }
 
-            //- Set width of output field
-            //  \return previous width
-            virtual int width(const int)
-            {
-                 return 0;
-            }
+        //- Set width of output field
+        //  \return previous width
+        virtual int width(const int) override
+        {
+             return 0;
+        }
 
-            //- Get precision of output field
-            virtual int precision() const
-            {
-                 return 0;
-            }
+        //- Get precision of output field
+        virtual int precision() const override
+        {
+             return 0;
+        }
 
-            //- Set precision of output field
-            //  \return old precision
-            virtual int precision(const int)
-            {
-                 return 0;
-            }
+        //- Set precision of output field
+        //  \return old precision
+        virtual int precision(const int) override
+        {
+             return 0;
+        }
 
 
     // Positioning
@@ -271,7 +284,7 @@ public:
     // Edit
 
         //- Set flags of stream
-        virtual ios_base::fmtflags flags(const ios_base::fmtflags)
+        virtual ios_base::fmtflags flags(const ios_base::fmtflags) override
         {
             return ios_base::fmtflags(0);
         }
@@ -280,7 +293,7 @@ public:
     // Print
 
         //- Print stream description to Ostream
-        void print(Ostream& os) const;
+        void print(Ostream& os) const override;
 };
 
 
diff --git a/src/OpenFOAM/db/IOstreams/Pstreams/UOPstreamBase.C b/src/OpenFOAM/db/IOstreams/Pstreams/UOPstreamBase.C
index fca288d555..5fa812f21e 100644
--- a/src/OpenFOAM/db/IOstreams/Pstreams/UOPstreamBase.C
+++ b/src/OpenFOAM/db/IOstreams/Pstreams/UOPstreamBase.C
@@ -121,11 +121,20 @@ inline void Foam::UOPstreamBase::putChar(const char c)
 }
 
 
+inline void Foam::UOPstreamBase::putString
+(
+    const char* str,
+    const size_t len
+)
+{
+    writeToBuffer(len);
+    writeToBuffer(str, len, 1);  // no-op when len == 0
+}
+
+
 inline void Foam::UOPstreamBase::putString(const std::string& str)
 {
-    const size_t len = str.size();
-    writeToBuffer(len);
-    writeToBuffer(str.data(), len, 1);  // no-op when len == 0
+    putString(str.data(), str.size());
 }
 
 
@@ -253,6 +262,27 @@ Foam::Ostream& Foam::UOPstreamBase::write(const char c)
 }
 
 
+Foam::Ostream& Foam::UOPstreamBase::writeQuoted
+(
+    const char* str,
+    std::streamsize len,
+    const bool quoted
+)
+{
+    if (quoted)
+    {
+        putChar(token::tokenType::STRING);
+    }
+    else
+    {
+        putChar(token::tokenType::WORD);
+    }
+    putString(str, len);
+
+    return *this;
+}
+
+
 Foam::Ostream& Foam::UOPstreamBase::write(const char* str)
 {
     const word nonWhiteChars(string::validate<word>(str));
@@ -279,7 +309,7 @@ Foam::Ostream& Foam::UOPstreamBase::write(const word& str)
 }
 
 
-Foam::Ostream& Foam::UOPstreamBase::write(const string& str)
+Foam::Ostream& Foam::UOPstreamBase::write(const std::string& str)
 {
     putChar(token::tokenType::STRING);
     putString(str);
@@ -288,26 +318,6 @@ Foam::Ostream& Foam::UOPstreamBase::write(const string& str)
 }
 
 
-Foam::Ostream& Foam::UOPstreamBase::writeQuoted
-(
-    const std::string& str,
-    const bool quoted
-)
-{
-    if (quoted)
-    {
-        putChar(token::tokenType::STRING);
-    }
-    else
-    {
-        putChar(token::tokenType::WORD);
-    }
-    putString(str);
-
-    return *this;
-}
-
-
 Foam::Ostream& Foam::UOPstreamBase::write(const int32_t val)
 {
     putChar(token::tokenType::LABEL);
diff --git a/src/OpenFOAM/db/IOstreams/Sstreams/ISstream.H b/src/OpenFOAM/db/IOstreams/Sstreams/ISstream.H
index f1d9a6d615..89f232b401 100644
--- a/src/OpenFOAM/db/IOstreams/Sstreams/ISstream.H
+++ b/src/OpenFOAM/db/IOstreams/Sstreams/ISstream.H
@@ -126,7 +126,7 @@ public:
 
         //- The name of the input serial stream.
         //- (eg, the name of the Fstream file name)
-        virtual const fileName& name() const { return name_; }
+        virtual const fileName& name() const override { return name_; }
 
         //- The name of the input serial stream, for modification.
         virtual fileName& name() { return name_; }
@@ -144,13 +144,13 @@ public:
     // Stream State
 
         //- Return flags of output stream
-        virtual ios_base::fmtflags flags() const
+        virtual ios_base::fmtflags flags() const override
         {
             return is_.flags();
         }
 
         //- Set stream flags
-        virtual ios_base::fmtflags flags(const ios_base::fmtflags f)
+        virtual ios_base::fmtflags flags(const ios_base::fmtflags f) override
         {
             return is_.flags(f);
         }
@@ -181,74 +181,81 @@ public:
         );
 
 
-        // Read Functions
+    // Serial-stream functions
 
-            //- Raw, low-level get character function.
-            inline ISstream& get(char& c);
+        //- Raw, low-level get character function.
+        inline ISstream& get(char& c);
 
-            //- Raw, low-level peek function.
-            //  Does not remove the character from the stream.
-            //  Returns the next character in the stream or EOF if the
-            //  end of file is read.
-            inline int peek();
+        //- Raw, low-level peek function.
+        //  Does not remove the character from the stream.
+        //  Returns the next character in the stream or EOF if the
+        //  end of file is read.
+        inline int peek();
 
-            //- Raw, low-level getline (until delimiter) into a string.
-            inline ISstream& getLine(std::string& str, char delim = '\n');
+        //- Raw, low-level getline (until delimiter) into a string.
+        inline ISstream& getLine(std::string& str, char delim = '\n');
 
-            //- Low-level discard until delimiter
-            //  \return the number of characters extracted
-            inline std::streamsize getLine(std::nullptr_t, char delim = '\n');
+        //- Low-level discard until delimiter
+        //  \return the number of characters extracted
+        inline std::streamsize getLine(std::nullptr_t, char delim = '\n');
 
-            //- Raw, low-level putback character function.
-            inline ISstream& putback(const char c);
-
-            //- Return next token from stream
-            virtual Istream& read(token& t);
-
-            //- Read a character
-            virtual Istream& read(char& c);
-
-            //- Read a word
-            virtual Istream& read(word& str);
-
-            //- Read a string (including enclosing double-quotes).
-            //  Backslashes are retained, except when escaping double-quotes
-            //  and an embedded newline character.
-            virtual Istream& read(string& str);
-
-            //- Read a label
-            virtual Istream& read(label& val);
-
-            //- Read a float
-            virtual Istream& read(float& val);
-
-            //- Read a double
-            virtual Istream& read(double& val);
-
-            //- Read binary block (with any possible block delimiters).
-            //- Reading into a null pointer behaves like a forward seek of
-            //- count characters.
-            virtual Istream& read(char* data, std::streamsize count);
-
-            //- Low-level raw binary read (without possible block delimiters).
-            //- Reading into a null pointer behaves like a forward seek of
-            //- count characters.
-            virtual Istream& readRaw(char* data, std::streamsize count);
-
-            //- Start of low-level raw binary read
-            virtual bool beginRawRead();
-
-            //- End of low-level raw binary read
-            virtual bool endRawRead();
-
-            //- Rewind the stream so that it may be read again
-            virtual void rewind();
+        //- Raw, low-level putback character function.
+        inline ISstream& putback(const char c);
 
 
-        // Print
+    // Read Functions
 
-            //- Print stream description to Ostream
-            virtual void print(Ostream& os) const;
+        //- Return next token from stream
+        virtual Istream& read(token& t) override;
+
+        //- Read a character
+        virtual Istream& read(char& c) override;
+
+        //- Read a word
+        virtual Istream& read(word& str) override;
+
+        //- Read a string (including enclosing double-quotes).
+        //  Backslashes are retained, except when escaping double-quotes
+        //  and an embedded newline character.
+        virtual Istream& read(string& str) override;
+
+        //- Read a label
+        virtual Istream& read(label& val) override;
+
+        //- Read a float
+        virtual Istream& read(float& val) override;
+
+        //- Read a double
+        virtual Istream& read(double& val) override;
+
+        //- Read binary block (with any possible block delimiters).
+        //- Reading into a null pointer behaves like a forward seek of
+        //- count characters.
+        virtual Istream& read(char* data, std::streamsize count) override;
+
+        //- Low-level raw binary read (without possible block delimiters).
+        //- Reading into a null pointer behaves like a forward seek of
+        //- count characters.
+        virtual Istream& readRaw
+        (
+            char* data,
+            std::streamsize count
+        ) override;
+
+        //- Start of low-level raw binary read
+        virtual bool beginRawRead() override;
+
+        //- End of low-level raw binary read
+        virtual bool endRawRead() override;
+
+        //- Rewind the stream so that it may be read again
+        virtual void rewind() override;
+
+
+    // Print
+
+        //- Print stream description to Ostream
+        virtual void print(Ostream& os) const override;
 };
 
 
diff --git a/src/OpenFOAM/db/IOstreams/Sstreams/OSstream.C b/src/OpenFOAM/db/IOstreams/Sstreams/OSstream.C
index fd7baf3e9d..e0907ad5a9 100644
--- a/src/OpenFOAM/db/IOstreams/Sstreams/OSstream.C
+++ b/src/OpenFOAM/db/IOstreams/Sstreams/OSstream.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2017-2022 OpenCFD Ltd.
+    Copyright (C) 2017-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -29,7 +29,7 @@ License
 #include "error.H"
 #include "token.H"
 #include "OSstream.H"
-#include "stringOps.H"
+#include <algorithm>
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
@@ -89,70 +89,67 @@ bool Foam::OSstream::write(const token& tok)
 Foam::Ostream& Foam::OSstream::write(const char c)
 {
     os_ << c;
-    if (c == token::NL)
-    {
-        ++lineNumber_;
-    }
     syncState();
-    return *this;
-}
 
-
-Foam::Ostream& Foam::OSstream::write(const char* str)
-{
-    lineNumber_ += stringOps::count(str, token::NL);
-    os_ << str;
-    syncState();
-    return *this;
-}
-
-
-Foam::Ostream& Foam::OSstream::write(const word& str)
-{
-    os_ << str;
-    syncState();
+    // Advance line number on newline
+    if (c == token::NL) ++lineNumber_;
     return *this;
 }
 
 
 Foam::Ostream& Foam::OSstream::writeQuoted
 (
-    const std::string& str,
+    const char* str,
+    std::streamsize len,
     const bool quoted
 )
 {
+    if (!str || len <= 0) return *this;
+
+    const char* last = (str + len);
+
     if (!quoted)
     {
-        // Output unquoted, only advance line number on newline
-        lineNumber_ += stringOps::count(str, token::NL);
-        os_ << str;
-
+        #if __cplusplus >= 201703L
+        os_ << std::string_view(str, len);
+        #else
+        for (const char* iter = str; iter != last; ++iter)
+        {
+            os_ << *iter;
+        }
+        #endif
         syncState();
+
+        // Unquoted, only advance line number on newline
+        lineNumber_ += std::count(str, last, '\n');
         return *this;
     }
 
 
     // Output with surrounding quotes and backslash escaping
+    // - functionality like std::quoted (from <iomanip>), while also
+    //   counting the newlines.
+
     os_ << token::DQUOTE;
 
     unsigned backslash = 0;
-    for (auto iter = str.cbegin(); iter != str.cend(); ++iter)
+    for (auto iter = str; iter != last; ++iter)
     {
         const char c = *iter;
 
         if (c == '\\')
         {
             ++backslash;
-            continue; // only output after escaped character is known
+            continue;       // Delay output until escaped character is known
         }
         else if (c == token::NL)
         {
-            ++lineNumber_;
-            ++backslash;    // backslash escape for newline
+            ++backslash;    // Add backslash escape for newline
+            ++lineNumber_;  // Advance line number on newline
         }
         else if (c == token::DQUOTE)
         {
-            ++backslash;    // backslash escape for quote
+            ++backslash;    // Add backslash escape for quote
         }
 
         // output all pending backslashes
@@ -174,9 +171,34 @@ Foam::Ostream& Foam::OSstream::writeQuoted
 }
 
 
-Foam::Ostream& Foam::OSstream::write(const string& str)
+Foam::Ostream& Foam::OSstream::write(const char* str)
 {
-    return writeQuoted(str, true);
+    if (!str) return *this;
+
+    const char* last = (str + strlen(str));
+
+    os_ << str;
+    syncState();
+
+    // Advance line number on newline
+    lineNumber_ += std::count(str, last, '\n');
+    return *this;
+}
+
+
+Foam::Ostream& Foam::OSstream::write(const word& str)
+{
+    // Unquoted, and no newlines expected.
+    os_ << str;
+    syncState();
+
+    return *this;
+}
+
+
+Foam::Ostream& Foam::OSstream::write(const std::string& str)
+{
+    return writeQuoted(str.data(), str.size(), true);
 }
 
 
diff --git a/src/OpenFOAM/db/IOstreams/Sstreams/OSstream.H b/src/OpenFOAM/db/IOstreams/Sstreams/OSstream.H
index 23318a7646..70dcd99bba 100644
--- a/src/OpenFOAM/db/IOstreams/Sstreams/OSstream.H
+++ b/src/OpenFOAM/db/IOstreams/Sstreams/OSstream.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2014 OpenFOAM Foundation
-    Copyright (C) 2017-2022 OpenCFD Ltd.
+    Copyright (C) 2017-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -117,7 +117,7 @@ public:
 
         //- Get the name of the output serial stream.
         //- (eg, the name of the Fstream file name)
-        virtual const fileName& name() const { return name_; }
+        virtual const fileName& name() const override { return name_; }
 
 
     // STL stream
@@ -132,13 +132,13 @@ public:
     // Stream State
 
         //- Get stream flags
-        virtual ios_base::fmtflags flags() const
+        virtual ios_base::fmtflags flags() const override
         {
             return os_.flags();
         }
 
         //- Set stream flags
-        virtual ios_base::fmtflags flags(const ios_base::fmtflags f)
+        virtual ios_base::fmtflags flags(const ios_base::fmtflags f) override
         {
             return os_.flags(f);
         }
@@ -152,101 +152,108 @@ public:
 
     // Write Functions
 
-            //- Write token to stream or otherwise handle it.
-            //  \return false if the token type was not handled by this method
-            virtual bool write(const token& tok);
+        //- Inherit write methods from Ostream
+        using Ostream::writeQuoted;
 
-            //- Write character
-            virtual Ostream& write(const char c);
+        //- Write token to stream or otherwise handle it.
+        //  \return false if the token type was not handled by this method
+        virtual bool write(const token& tok) override;
 
-            //- Write character string
-            virtual Ostream& write(const char* str);
+        //- Write character
+        virtual Ostream& write(const char c) override;
 
-            //- Write word
-            virtual Ostream& write(const word& str);
+        //- Write character/string content, with/without surrounding quotes
+        virtual Ostream& writeQuoted
+        (
+            const char* str,
+            std::streamsize len,
+            const bool quoted=true
+        ) override;
 
-            //- Write string (quoted)
-            //  In the rare case that the string contains a final trailing
-            //  backslash, it will be dropped to the appearance of an escaped
-            //  double-quote.
-            virtual Ostream& write(const string& str);
+        //- Write character string
+        virtual Ostream& write(const char* str) override;
 
-            //- Write std::string surrounded by quotes.
-            //  Optional write without quotes.
-            virtual Ostream& writeQuoted
-            (
-                const std::string& str,
-                const bool quoted=true
-            );
+        //- Write word
+        virtual Ostream& write(const word& str) override;
 
-            //- Write int32_t
-            virtual Ostream& write(const int32_t val);
+        //- Write string (quoted)
+        //  In the rare case that the string contains a final trailing
+        //  backslash, it will be dropped to the appearance of an escaped
+        //  double-quote.
+        virtual Ostream& write(const std::string& str) override;
 
-            //- Write int64_t
-            virtual Ostream& write(const int64_t val);
+        //- Write int32_t
+        virtual Ostream& write(const int32_t val) override;
 
-            //- Write float
-            virtual Ostream& write(const float val);
+        //- Write int64_t
+        virtual Ostream& write(const int64_t val) override;
 
-            //- Write double
-            virtual Ostream& write(const double val);
+        //- Write float
+        virtual Ostream& write(const float val) override;
 
-            //- Write binary block
-            virtual Ostream& write(const char* data, std::streamsize count);
+        //- Write double
+        virtual Ostream& write(const double val) override;
 
-            //- Low-level raw binary output
-            virtual Ostream& writeRaw
-            (
-                const char* data,
-                std::streamsize count
-            );
+        //- Write binary block
+        virtual Ostream& write
+        (
+            const char* data,
+            std::streamsize count
+        ) override;
 
-            //- Begin marker for low-level raw binary output.
-            //  The count indicates the number of bytes for subsequent
-            //  writeRaw calls.
-            virtual bool beginRawWrite(std::streamsize count);
+        //- Low-level raw binary output
+        virtual Ostream& writeRaw
+        (
+            const char* data,
+            std::streamsize count
+        ) override;
 
-            //- End marker for low-level raw binary output.
-            virtual bool endRawWrite();
+        //- Begin marker for low-level raw binary output.
+        //  The count indicates the number of bytes for subsequent
+        //  writeRaw calls.
+        virtual bool beginRawWrite(std::streamsize count) override;
 
-            //- Add indentation characters
-            virtual void indent();
+        //- End marker for low-level raw binary output.
+        virtual bool endRawWrite() override;
+
+        //- Add indentation characters
+        virtual void indent() override;
 
 
-        // Stream state functions
+    // Stream state functions
 
-            //- Flush stream
-            virtual void flush();
+        //- Flush stream
+        virtual void flush() override;
 
-            //- Add newline and flush stream
-            virtual void endl();
+        //- Add newline and flush stream
+        virtual void endl() override;
 
-            //- Get the current padding character
-            virtual char fill() const;
+        //- Get the current padding character
+        virtual char fill() const override;
 
-            //- Set padding character for formatted field up to field width
-            //  \return previous padding character
-            virtual char fill(const char fillch);
+        //- Set padding character for formatted field up to field width
+        //  \return previous padding character
+        virtual char fill(const char fillch) override;
 
-            //- Get width of output field
-            virtual int width() const;
+        //- Get width of output field
+        virtual int width() const override;
 
-            //- Set width of output field
-            //  \return previous width
-            virtual int width(const int w);
+        //- Set width of output field
+        //  \return previous width
+        virtual int width(const int w) override;
 
-            //- Get precision of output field
-            virtual int precision() const;
+        //- Get precision of output field
+        virtual int precision() const override;
 
-            //- Set precision of output field
-            //  \return old precision
-            virtual int precision(const int p);
+        //- Set precision of output field
+        //  \return old precision
+        virtual int precision(const int p) override;
 
 
-        // Print
+    // Print
 
-            //- Print stream description to Ostream
-            virtual void print(Ostream& os) const;
+        //- Print stream description to Ostream
+        virtual void print(Ostream& os) const override;
 };
 
 
diff --git a/src/OpenFOAM/db/IOstreams/Sstreams/prefixOSstream.C b/src/OpenFOAM/db/IOstreams/Sstreams/prefixOSstream.C
index f2c3567bce..c768677d69 100644
--- a/src/OpenFOAM/db/IOstreams/Sstreams/prefixOSstream.C
+++ b/src/OpenFOAM/db/IOstreams/Sstreams/prefixOSstream.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2014 OpenFOAM Foundation
-    Copyright (C) 2020-2022 OpenCFD Ltd.
+    Copyright (C) 2020-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -77,11 +77,21 @@ Foam::Ostream& Foam::prefixOSstream::write(const char c)
     checkWritePrefix();
     OSstream::write(c);
 
-    if (c == token::NL)
-    {
-        printPrefix_ = true;
-    }
+    // Reset prefix state on newline
+    if (c == token::NL) printPrefix_ = true;
+    return *this;
+}
 
+
+Foam::Ostream& Foam::prefixOSstream::writeQuoted
+(
+    const char* str,
+    std::streamsize len,
+    const bool quoted
+)
+{
+    checkWritePrefix();
+    OSstream::writeQuoted(str, len, quoted);
     return *this;
 }
 
@@ -92,8 +102,9 @@ Foam::Ostream& Foam::prefixOSstream::write(const char* str)
     OSstream::write(str);
 
     const size_t len = strlen(str);
-    if (len && str[len-1] == token::NL)
+    if (len > 0 && str[len-1] == token::NL)
     {
+        // Reset prefix state on newline
         printPrefix_ = true;
     }
 
@@ -103,26 +114,15 @@ Foam::Ostream& Foam::prefixOSstream::write(const char* str)
 
 Foam::Ostream& Foam::prefixOSstream::write(const word& val)
 {
+    // Unquoted, and no newlines expected.
     checkWritePrefix();
     return OSstream::write(val);
 }
 
 
-Foam::Ostream& Foam::prefixOSstream::write(const string& val)
+Foam::Ostream& Foam::prefixOSstream::write(const std::string& str)
 {
-    checkWritePrefix();
-    return OSstream::write(val);
-}
-
-
-Foam::Ostream& Foam::prefixOSstream::writeQuoted
-(
-    const std::string& val,
-    const bool quoted
-)
-{
-    checkWritePrefix();
-    return OSstream::writeQuoted(val, quoted);
+    return writeQuoted(str.data(), str.size(), true);
 }
 
 
diff --git a/src/OpenFOAM/db/IOstreams/Sstreams/prefixOSstream.H b/src/OpenFOAM/db/IOstreams/Sstreams/prefixOSstream.H
index 089c5c168c..ad95d44d12 100644
--- a/src/OpenFOAM/db/IOstreams/Sstreams/prefixOSstream.H
+++ b/src/OpenFOAM/db/IOstreams/Sstreams/prefixOSstream.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2014 OpenFOAM Foundation
-    Copyright (C) 2020-2022 OpenCFD Ltd.
+    Copyright (C) 2020-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -65,6 +65,7 @@ class prefixOSstream
 
     // Private Member Functions
 
+        //- Emit pending prefix before any output
         inline void checkWritePrefix();
 
 
@@ -83,70 +84,67 @@ public:
 
     // Member Functions
 
-        // Enquiry
+    // Enquiry
 
-            //- Return the stream prefix
-            const string& prefix() const noexcept
-            {
-                return prefix_;
-            }
+        //- Return the stream prefix
+        const string& prefix() const noexcept { return prefix_; }
 
-            //- Return non-const access to the stream prefix
-            string& prefix() noexcept
-            {
-                return prefix_;
-            }
+        //- Return non-const access to the stream prefix
+        string& prefix() noexcept { return prefix_; }
 
 
-        // Write Functions
+    // Write Functions
 
-            //- Write token to stream or otherwise handle it.
-            //  \return false if the token type was not handled by this method
-            virtual bool write(const token& tok);
+        //- Inherit write methods from OSstream
+        using OSstream::writeQuoted;
 
-            //- Write character
-            virtual Ostream& write(const char c);
+        //- Write token to stream or otherwise handle it.
+        //  \return false if the token type was not handled by this method
+        virtual bool write(const token& tok) override;
 
-            //- Write character string
-            virtual Ostream& write(const char* str);
+        //- Write character
+        virtual Ostream& write(const char c) override;
 
-            //- Write word
-            virtual Ostream& write(const word& val);
+        //- Write character/string content, with/without surrounding quotes
+        virtual Ostream& writeQuoted
+        (
+            const char* str,
+            std::streamsize len,
+            const bool quoted=true
+        ) override;
 
-            //- Write string
-            virtual Ostream& write(const string& val);
+        //- Write character string
+        virtual Ostream& write(const char* str) override;
 
-            //- Write std::string surrounded by quotes.
-            //  Optional write without quotes.
-            virtual Ostream& writeQuoted
-            (
-                const std::string& val,
-                const bool quoted=true
-            );
+        //- Write word
+        virtual Ostream& write(const word& val) override;
 
-            //- Write int32_t
-            virtual Ostream& write(const int32_t val);
+        //- Write string
+        virtual Ostream& write(const std::string& val) override;
 
-            //- Write int64_t
-            virtual Ostream& write(const int64_t val);
+        //- Write int32_t
+        virtual Ostream& write(const int32_t val) override;
 
-            //- Write float
-            virtual Ostream& write(const float val);
+        //- Write int64_t
+        virtual Ostream& write(const int64_t val) override;
 
-            //- Write double
-            virtual Ostream& write(const double val);
+        //- Write float
+        virtual Ostream& write(const float val) override;
 
-            //- Write binary block
-            virtual Ostream& write(const char* buf, std::streamsize count);
+        //- Write double
+        virtual Ostream& write(const double val) override;
 
-            //- Add indentation characters
-            virtual void indent();
+        //- Write binary block
+        virtual Ostream& write(const char* buf, std::streamsize count) override;
+
+        //- Add indentation characters
+        virtual void indent() override;
 
 
     // Print
 
         //- Print stream description to Ostream
-        virtual void print(Ostream& os) const;
+        virtual void print(Ostream& os) const override;
 };
 
 
diff --git a/src/OpenFOAM/db/IOstreams/StringStreams/StringStream.H b/src/OpenFOAM/db/IOstreams/StringStreams/StringStream.H
index 3a0286347e..66d766562f 100644
--- a/src/OpenFOAM/db/IOstreams/StringStreams/StringStream.H
+++ b/src/OpenFOAM/db/IOstreams/StringStreams/StringStream.H
@@ -166,7 +166,7 @@ public:
         }
 
         //- Print stream description to Ostream
-        virtual void print(Ostream& os) const;
+        virtual void print(Ostream& os) const override;
 
 
     // Member Operators
@@ -263,7 +263,7 @@ public:
         }
 
         //- Print stream description to Ostream
-        virtual void print(Ostream& os) const;
+        virtual void print(Ostream& os) const override;
 
 
     // Older style, without stream option (including 2012 release)
diff --git a/src/OpenFOAM/db/IOstreams/Tstreams/ITstream.H b/src/OpenFOAM/db/IOstreams/Tstreams/ITstream.H
index 3dc3f9096a..b940e4bfc6 100644
--- a/src/OpenFOAM/db/IOstreams/Tstreams/ITstream.H
+++ b/src/OpenFOAM/db/IOstreams/Tstreams/ITstream.H
@@ -223,7 +223,7 @@ public:
     // Characteristics
 
         //- The name of the input token stream.
-        virtual const fileName& name() const { return name_; }
+        virtual const fileName& name() const override { return name_; }
 
         //- The name of the input token stream, for modification.
         virtual fileName& name() { return name_; }
@@ -371,13 +371,13 @@ public:
     // Stream State Functions
 
         //- Get stream flags - always 0
-        virtual ios_base::fmtflags flags() const
+        virtual ios_base::fmtflags flags() const override
         {
             return ios_base::fmtflags(0);
         }
 
         //- Set flags of stream - ignored
-        ios_base::fmtflags flags(const ios_base::fmtflags)
+        ios_base::fmtflags flags(const ios_base::fmtflags) override
         {
             return ios_base::fmtflags(0);
         }
@@ -386,47 +386,47 @@ public:
     // Read Functions
 
         //- Return next token from stream
-        virtual Istream& read(token& tok);
+        virtual Istream& read(token& tok) override;
 
         //- Read a character : triggers not implemented error
-        virtual Istream& read(char&);
+        virtual Istream& read(char&) override;
 
         //- Read a word : triggers not implemented error
-        virtual Istream& read(word&);
+        virtual Istream& read(word&) override;
 
         //- Read a string (including enclosing double-quotes) :
         //- triggers not implemented error
-        virtual Istream& read(string&);
+        virtual Istream& read(string&) override;
 
         //- Read a label : triggers not implemented error
-        virtual Istream& read(label&);
+        virtual Istream& read(label&) override;
 
         //- Read a float : triggers not implemented error
-        virtual Istream& read(float&);
+        virtual Istream& read(float&) override;
 
         //- Read a double : triggers not implemented error
-        virtual Istream& read(double&);
+        virtual Istream& read(double&) override;
 
         //- Read binary block : triggers not implemented error
-        virtual Istream& read(char* data, std::streamsize);
+        virtual Istream& read(char* data, std::streamsize) override;
 
         //- Low-level raw binary read : triggers not implemented error
-        virtual Istream& readRaw(char* data, std::streamsize count);
+        virtual Istream& readRaw(char* data, std::streamsize count) override;
 
         //- Start of low-level raw binary read : no-op
-        virtual bool beginRawRead() { return false; }
+        virtual bool beginRawRead() override { return false; }
 
         //- End of low-level raw binary read : no-op
-        virtual bool endRawRead() { return false; }
+        virtual bool endRawRead() override { return false; }
 
         //- Rewind the stream so that it may be read again. Same as seek(0)
-        virtual void rewind();
+        virtual void rewind() override;
 
 
     // Output
 
         //- Print stream description to Ostream
-        void print(Ostream& os) const;
+        void print(Ostream& os) const override;
 
         //- Concatenate tokens into a space-separated std::string.
         //- The resulting string may contain quote characters.
diff --git a/src/OpenFOAM/db/IOstreams/Tstreams/OTstream.C b/src/OpenFOAM/db/IOstreams/Tstreams/OTstream.C
index 67d1703d7a..1843509c05 100644
--- a/src/OpenFOAM/db/IOstreams/Tstreams/OTstream.C
+++ b/src/OpenFOAM/db/IOstreams/Tstreams/OTstream.C
@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2019-2022 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -55,9 +55,31 @@ Foam::Ostream& Foam::OTstream::write(const char c)
 }
 
 
+Foam::Ostream& Foam::OTstream::writeQuoted
+(
+    const char* str,
+    std::streamsize len,
+    const bool quoted
+)
+{
+    if (quoted)
+    {
+        // tokenType::STRING
+        tokens().emplace_back() = string(str, len);
+    }
+    else if (len > 0)
+    {
+        // tokenType::WORD
+        tokens().emplace_back() = word(str, len, false);  // No stripping
+    }
+
+    return *this;
+}
+
+
 Foam::Ostream& Foam::OTstream::write(const char* str)
 {
-    const word nonWhiteChars(string::validate<word>(str));
+    word nonWhiteChars(string::validate<word>(str));
 
     if (nonWhiteChars.size() == 1)
     {
@@ -67,7 +89,7 @@ Foam::Ostream& Foam::OTstream::write(const char* str)
     else if (nonWhiteChars.size())
     {
         // As a word
-        write(nonWhiteChars);
+        tokens().emplace_back() = std::move(nonWhiteChars);  // Move assign
     }
 
     return *this;
@@ -76,34 +98,17 @@ Foam::Ostream& Foam::OTstream::write(const char* str)
 
 Foam::Ostream& Foam::OTstream::write(const word& str)
 {
-    tokens().push_back(token(str)); // tokenType::WORD
+    // tokenType::WORD
+    tokens().emplace_back() = str;  // Copy assign
 
     return *this;
 }
 
 
-Foam::Ostream& Foam::OTstream::write(const string& str)
+Foam::Ostream& Foam::OTstream::write(const std::string& str)
 {
-    tokens().push_back(token(str)); // tokenType::STRING
-
-    return *this;
-}
-
-
-Foam::Ostream& Foam::OTstream::writeQuoted
-(
-    const std::string& str,
-    const bool quoted
-)
-{
-    if (quoted)
-    {
-        tokens().push_back(token(string(str))); // tokenType::STRING
-    }
-    else if (!str.empty())
-    {
-        tokens().push_back(token(word(str, false))); // tokenType::WORD
-    }
+    // tokenType::STRING
+    tokens().emplace_back() = Foam::string(str);  // Move assign
 
     return *this;
 }
diff --git a/src/OpenFOAM/db/IOstreams/Tstreams/OTstream.H b/src/OpenFOAM/db/IOstreams/Tstreams/OTstream.H
index bd6076c043..f50d30308e 100644
--- a/src/OpenFOAM/db/IOstreams/Tstreams/OTstream.H
+++ b/src/OpenFOAM/db/IOstreams/Tstreams/OTstream.H
@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2019-2022 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -115,122 +115,133 @@ public:
 
     // Write
 
+        //- Inherit write methods from Ostream
+        using Ostream::writeQuoted;
+
         //- Write token to stream or otherwise handle it.
         //  \return false if the token type was not handled by this method
-        virtual bool write(const token& tok);
+        virtual bool write(const token& tok) override;
 
         //- Write single character. Whitespace is suppressed.
-        virtual Ostream& write(const char c);
+        virtual Ostream& write(const char c) override;
+
+        //- Write character/string content, with/without surrounding quotes
+        virtual Ostream& writeQuoted
+        (
+            const char* str,
+            std::streamsize len,
+            const bool quoted=true
+        ) override;
 
         //- Write the word-characters of a character string.
         //  Sends as a single char, or as word.
-        virtual Ostream& write(const char* str);
+        virtual Ostream& write(const char* str) override;
 
         //- Write word
-        virtual Ostream& write(const word& str);
+        virtual Ostream& write(const word& str) override;
 
         //- Write string
-        virtual Ostream& write(const string& str);
-
-        //- Write std::string surrounded by quotes.
-        //  Optional write without quotes.
-        virtual Ostream& writeQuoted
-        (
-            const std::string& str,
-            const bool quoted=true
-        );
+        virtual Ostream& write(const std::string& str) override;
 
         //- Write int32_t as a label
-        virtual Ostream& write(const int32_t val);
+        virtual Ostream& write(const int32_t val) override;
 
         //- Write int64_t as a label
-        virtual Ostream& write(const int64_t val);
+        virtual Ostream& write(const int64_t val) override;
 
         //- Write float
-        virtual Ostream& write(const float val);
+        virtual Ostream& write(const float val) override;
 
         //- Write double
-        virtual Ostream& write(const double val);
+        virtual Ostream& write(const double val) override;
 
         //- Write binary block with 8-byte alignment.
-        virtual Ostream& write(const char* data, std::streamsize count);
+        virtual Ostream& write
+        (
+            const char* data,
+            std::streamsize count
+        ) override;
 
         //- Low-level raw binary output.
-        virtual Ostream& writeRaw(const char* data, std::streamsize count);
+        virtual Ostream& writeRaw
+        (
+            const char* data,
+            std::streamsize count
+        ) override;
 
         //- Begin marker for low-level raw binary output.
         //  The count indicates the number of bytes for subsequent
         //  writeRaw calls.
-        virtual bool beginRawWrite(std::streamsize count);
+        virtual bool beginRawWrite(std::streamsize count) override;
 
         //- End marker for low-level raw binary output.
-        virtual bool endRawWrite()
+        virtual bool endRawWrite() override
         {
             return true;
         }
 
         //- Add indentation characters
-        virtual void indent()
+        virtual void indent() override
         {}
 
 
     // Stream State Functions
 
         //- Get flags of output stream
-        virtual ios_base::fmtflags flags() const
+        virtual ios_base::fmtflags flags() const override
         {
             return ios_base::fmtflags(0);
         }
 
         //- Set flags of stream - ignored
-        std::ios_base::fmtflags flags(const ios_base::fmtflags)
+        std::ios_base::fmtflags flags(const ios_base::fmtflags) override
         {
             return ios_base::fmtflags(0);
         }
 
         //- Flush stream
-        virtual void flush()
+        virtual void flush() override
         {}
 
         //- Add newline and flush stream
-        virtual void endl()
+        virtual void endl() override
         {}
 
         //- Get the current padding character
         //  \return previous padding character
-        virtual char fill() const
+        virtual char fill() const override
         {
             return 0;
         }
 
         //- Set padding character for formatted field up to field width
-        virtual char fill(const char)
+        virtual char fill(const char) override
         {
             return 0;
         }
 
         //- Get width of output field
-        virtual int width() const
+        virtual int width() const override
         {
             return 0;
         }
 
         //- Set width of output field
         //  \return previous width
-        virtual int width(const int)
+        virtual int width(const int) override
         {
              return 0;
         }
 
         //- Get precision of output field
-        virtual int precision() const
+        virtual int precision() const override
         {
              return 0;
         }
 
         //- Set precision of output field
         //  \return old precision
-        virtual int precision(const int)
+        virtual int precision(const int) override
         {
              return 0;
         }
@@ -253,7 +264,7 @@ public:
         }
 
         //- Print stream description to Ostream
-        void print(Ostream& os) const;
+        void print(Ostream& os) const override;
 
 
     // Additional constructors and methods (as per v2012 and earlier)
diff --git a/src/OpenFOAM/db/IOstreams/dummy/dummyISstream.H b/src/OpenFOAM/db/IOstreams/dummy/dummyISstream.H
index 0af74bc015..6b50f50c6b 100644
--- a/src/OpenFOAM/db/IOstreams/dummy/dummyISstream.H
+++ b/src/OpenFOAM/db/IOstreams/dummy/dummyISstream.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2017 OpenFOAM Foundation
-    Copyright (C) 2019-2022 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -71,98 +71,101 @@ public:
 
     // Member Functions
 
-        // Read Functions
+    // Stream-state
 
-            //- Return next token from stream
-            virtual Istream& read(token&)
-            {
-                NotImplemented;
-                return *this;
-            }
+        //- Return flags of stream
+        virtual ios_base::fmtflags flags() const override
+        {
+            return ios_base::fmtflags(0);
+        }
 
-            //- Read a character
-            virtual Istream& read(char&)
-            {
-                NotImplemented;
-                return *this;
-            }
+        //- Set flags of stream
+        virtual ios_base::fmtflags flags(const ios_base::fmtflags) override
+        {
+            return ios_base::fmtflags(0);
+        }
 
-            //- Read a word
-            virtual Istream& read(word&)
-            {
-                NotImplemented;
-                return *this;
-            }
 
-            // Read a string (including enclosing double-quotes)
-            virtual Istream& read(string&)
-            {
-                NotImplemented;
-                return *this;
-            }
+    // Read Functions
 
-            //- Read a label
-            virtual Istream& read(label&)
-            {
-                NotImplemented;
-                return *this;
-            }
+        //- Return next token from stream
+        virtual Istream& read(token&) override
+        {
+            NotImplemented;
+            return *this;
+        }
 
-            //- Read a float
-            virtual Istream& read(float&)
-            {
-                NotImplemented;
-                return *this;
-            }
+        //- Read a character
+        virtual Istream& read(char&) override
+        {
+            NotImplemented;
+            return *this;
+        }
 
-            //- Read a double
-            virtual Istream& read(double&)
-            {
-                NotImplemented;
-                return *this;
-            }
+        //- Read a word
+        virtual Istream& read(word&) override
+        {
+            NotImplemented;
+            return *this;
+        }
 
-            //- Read binary block
-            virtual Istream& read(char*, std::streamsize)
-            {
-                NotImplemented;
-                return *this;
-            }
+        // Read a string (including enclosing double-quotes)
+        virtual Istream& read(string&) override
+        {
+            NotImplemented;
+            return *this;
+        }
 
-            //- Low-level raw binary read
-            virtual Istream& readRaw(char*, std::streamsize)
-            {
-                NotImplemented;
-                return *this;
-            }
+        //- Read a label
+        virtual Istream& read(label&) override
+        {
+            NotImplemented;
+            return *this;
+        }
 
-            //- Start of low-level raw binary read
-            virtual bool beginRawRead()
-            {
-                return false;
-            }
+        //- Read a float
+        virtual Istream& read(float&) override
+        {
+            NotImplemented;
+            return *this;
+        }
 
-            //- End of low-level raw binary read
-            virtual bool endRawRead()
-            {
-                return false;
-            }
+        //- Read a double
+        virtual Istream& read(double&) override
+        {
+            NotImplemented;
+            return *this;
+        }
 
-            //- Rewind the stream so that it may be read again
-            virtual void rewind()
-            {}
+        //- Read binary block
+        virtual Istream& read(char*, std::streamsize) override
+        {
+            NotImplemented;
+            return *this;
+        }
 
-            //- Return flags of stream
-            virtual ios_base::fmtflags flags() const
-            {
-                return ios_base::fmtflags(0);
-            }
+        //- Low-level raw binary read
+        virtual Istream& readRaw(char*, std::streamsize) override
+        {
+            NotImplemented;
+            return *this;
+        }
 
-            //- Set flags of stream
-            virtual ios_base::fmtflags flags(const ios_base::fmtflags)
-            {
-                return ios_base::fmtflags(0);
-            }
+        //- Start of low-level raw binary read
+        virtual bool beginRawRead() override
+        {
+            return false;
+        }
+
+        //- End of low-level raw binary read
+        virtual bool endRawRead() override
+        {
+            return false;
+        }
+
+        //- Rewind the stream so that it may be read again
+        virtual void rewind() override
+        {}
 };
 
 
diff --git a/src/OpenFOAM/db/IOstreams/hashes/OSHA1stream.H b/src/OpenFOAM/db/IOstreams/hashes/OSHA1stream.H
index bf13b73805..69491d2b90 100644
--- a/src/OpenFOAM/db/IOstreams/hashes/OSHA1stream.H
+++ b/src/OpenFOAM/db/IOstreams/hashes/OSHA1stream.H
@@ -191,9 +191,9 @@ public:
 
         //- Add (unquoted) string contents.
         //  Ensures that SHA1 of C-string or C++-string content are identical.
-        virtual Ostream& write(const string& str)
+        virtual Ostream& write(const std::string& str) override
         {
-            return writeQuoted(str, false); // Unquoted!
+            return writeQuoted(str, false);  // Unquoted!
         }
 
 
diff --git a/src/OpenFOAM/db/IOstreams/memory/ICharStream.H b/src/OpenFOAM/db/IOstreams/memory/ICharStream.H
index 5100551dfb..c242b9d08d 100644
--- a/src/OpenFOAM/db/IOstreams/memory/ICharStream.H
+++ b/src/OpenFOAM/db/IOstreams/memory/ICharStream.H
@@ -53,6 +53,7 @@ namespace Foam
 // Forward Declarations
 class icharstream;
 class ICharStream;
+class OCharStream;
 
 // Older names (prior to 2023-08)
 typedef ICharStream IListStream;
@@ -93,14 +94,6 @@ public:
             reset(buffer, nbytes);
         }
 
-        // //- Construct (deep copy) from span character content
-        // explicit icharstream(stdFoam::span<char> s)
-        // :
-        //     icharstream()
-        // {
-        //     reset(buffer, nbytes);
-        // }
-
         //- Move construct from List
         icharstream(List<char>&& buffer)
         :
@@ -143,7 +136,28 @@ public:
         //- Span of the input characters (is modifiable!)
         UList<char> list() const
         {
-            return buffer_type::span_list();
+            return UList<char>
+            (
+                buffer_type::data_bytes(),
+                label(buffer_type::size_bytes())
+            );
+        }
+
+        //- A string_view (c++17) or span view (older c++) of buffer contents
+        auto view() const -> decltype(buffer_type::view())
+        {
+            return buffer_type::view();
+        }
+
+        //- For istringstream compatibility, return the buffer as string copy.
+        //  Use sparingly - it creates a full copy!!
+        std::string str() const
+        {
+            return std::string
+            (
+                buffer_type::data_bytes(),
+                buffer_type::size_bytes()
+            );
         }
 
         //- Rewind the stream, clearing any old errors
@@ -153,21 +167,21 @@ public:
             stream_type::clear();  // Clear old errors
         }
 
-        //- Reset content (copy)
+        //- Reset stream content (copy), reset positions
         void reset(const char* buffer, size_t nbytes)
         {
             buffer_type::reset(buffer, nbytes);
             stream_type::clear();  // Clear old errors
         }
 
-        //- Transfer list contents to List buffer
+        //- Exchange stream content and parameter contents, reset positions
         void swap(List<char>& other)
         {
             buffer_type::swap(other);
             stream_type::clear();  // Clear old errors
         }
 
-        //- Transfer list contents to a DynamicList buffer
+        //- Exchange stream content and parameter contents, reset positions
         template<int SizeMin>
         void swap(DynamicList<char,SizeMin>& other)
         {
@@ -175,11 +189,18 @@ public:
             stream_type::clear();  // Clear old errors
         }
 
+        //- Reset stream and return contents as a List
+        DynamicList<char> release()
+        {
+            DynamicList<char> chars(buffer_type::release());
+            stream_type::clear();  // Clear old errors
+            return chars;
+        }
+
         //- Some information about the input buffer position/capacity
         void debug_info(Ostream& os) const
         {
-            os  << "get="
-                << input_pos() << '/' << capacity();
+            os  << "get=" << input_pos() << '/' << capacity();
         }
 };
 
@@ -252,7 +273,7 @@ public:
         //- Move construct from List
         explicit ICharStream
         (
-            ::Foam::List<char>&& buffer,  // Fully qualify (issue #1521)
+            List<char>&& buffer,
             IOstreamOption streamOpt = IOstreamOption()
         )
         :
@@ -296,11 +317,17 @@ public:
         //- Span of the input characters (is modifiable!)
         UList<char> list() const { return stream_.list(); }
 
-        //- Rewind the stream, clearing any old errors
-        virtual void rewind()
+        //- A string_view (c++17) or span view (older c++) of buffer contents
+        auto view() const -> decltype(stream_.view())
         {
-            stream_.rewind();
-            syncState();
+            return stream_.view();
+        }
+
+        //- For IStringStream compatibility, return the buffer as string copy.
+        //  Use sparingly - it creates a full copy!!
+        auto str() const -> decltype(stream_.str())
+        {
+            return stream_.str();
         }
 
         //- Reset content (copy)
@@ -310,14 +337,14 @@ public:
             syncState();
         }
 
-        //- Transfer list contents to List buffer
+        //- Exchange stream content and parameter contents, reset positions
         void swap(List<char>& other)
         {
             stream_.swap(other);
             syncState();
         }
 
-        //- Transfer list contents to a DynamicList buffer
+        //- Exchange stream content and parameter contents, reset positions
         template<int SizeMin>
         void swap(DynamicList<char,SizeMin>& other)
         {
@@ -325,8 +352,23 @@ public:
             syncState();
         }
 
+        //- Reset stream and return contents as a List
+        DynamicList<char> release()
+        {
+            DynamicList<char> chars(stream_.release());
+            syncState();
+            return chars;
+        }
+
+        //- Rewind the stream, clearing any old errors
+        virtual void rewind() override
+        {
+            stream_.rewind();
+            syncState();
+        }
+
         //- Print stream description to Ostream
-        virtual void print(Ostream& os) const;
+        virtual void print(Ostream& os) const override;
 
 
     // Member Operators
diff --git a/src/OpenFOAM/db/IOstreams/memory/ISpanStream.H b/src/OpenFOAM/db/IOstreams/memory/ISpanStream.H
index 5ff1e69531..f2debfeb69 100644
--- a/src/OpenFOAM/db/IOstreams/memory/ISpanStream.H
+++ b/src/OpenFOAM/db/IOstreams/memory/ISpanStream.H
@@ -64,9 +64,9 @@ See Also
 #ifndef Foam_ISpanStream_H
 #define Foam_ISpanStream_H
 
+#include "memoryStreamBuffer.H"
 #include "UList.H"
 #include "ISstream.H"
-#include "memoryStreamBuffer.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -117,12 +117,28 @@ public:
             stream_type(static_cast<buffer_type*>(this))
         {}
 
-        // //- Construct (shallow copy) from span character content
-        // ispanstream(stdFoam::span<char> s)
-        // :
-        //     buffer_type(const_cast<char*>(s.data()), s.size()),
-        //     stream_type(static_cast<buffer_type*>(this))
-        // {}
+        #if __cplusplus >= 201703L
+        //- Construct (shallow copy) from std::string_view content
+        explicit ispanstream(std::string_view s)
+        {
+            buffer_type(const_cast<char*>(s.data()), s.size()),
+            stream_type(static_cast<buffer_type*>(this))
+        }
+        #endif
+
+        //- Construct (shallow copy) from span character content
+        explicit ispanstream(stdFoam::span<char> s)
+        :
+            buffer_type(const_cast<char*>(s.data()), s.size()),
+            stream_type(static_cast<buffer_type*>(this))
+        {}
+
+        //- Construct (shallow copy) from span character content
+        explicit ispanstream(stdFoam::span<const char> s)
+        :
+            buffer_type(const_cast<char*>(s.data()), s.size()),
+            stream_type(static_cast<buffer_type*>(this))
+        {}
 
 
     // Member Functions
@@ -149,7 +165,28 @@ public:
         //- Span of the input characters (is modifiable!)
         UList<char> list() const
         {
-            return buffer_type::span_list();
+            return UList<char>
+            (
+                buffer_type::data_bytes(),
+                label(buffer_type::size_bytes())
+            );
+        }
+
+        //- A string_view (c++17) or span view (older c++) of buffer contents
+        auto view() const -> decltype(buffer_type::view())
+        {
+            return buffer_type::view();
+        }
+
+        //- For istringstream compatibility, return the buffer as string copy.
+        //  Use sparingly - it creates a full copy!!
+        std::string str() const
+        {
+            return std::string
+            (
+                buffer_type::data_bytes(),
+                buffer_type::size_bytes()
+            );
         }
 
         //- Rewind the stream, clearing any old errors
@@ -259,17 +296,6 @@ public:
             reset(buffer);
         }
 
-        //- Construct using data area from a List and number of bytes
-        ISpanStream
-        (
-            const ::Foam::UList<char>& buffer,
-            size_t nbytes,
-            IOstreamOption streamOpt = IOstreamOption()
-        )
-        :
-            ISpanStream(buffer.cdata(), nbytes, streamOpt)
-        {}
-
         //- Construct using data area from a List and its inherent storage size
         //  Uses addressed size, thus no special treatment for a DynamicList
         explicit ISpanStream
@@ -281,6 +307,38 @@ public:
             ISpanStream(buffer.cdata(), buffer.size(), streamOpt)
         {}
 
+        #if __cplusplus >= 201703L
+        //- Construct (shallow copy) from std::string_view content
+        explicit ISpanStream
+        (
+            std::string_view s,
+            IOstreamOption streamOpt = IOstreamOption()
+        )
+        :
+            ISpanStream(s.data(), s.size(), streamOpt)
+        {}
+        #endif
+
+        //- Construct (shallow copy) from span character content
+        explicit ISpanStream
+        (
+            stdFoam::span<const char> s,
+            IOstreamOption streamOpt = IOstreamOption()
+        )
+        :
+            ISpanStream(s.data(), s.size(), streamOpt)
+        {}
+
+        //- Construct (shallow copy) from span character content
+        explicit ISpanStream
+        (
+            stdFoam::span<char> s,
+            IOstreamOption streamOpt = IOstreamOption()
+        )
+        :
+            ISpanStream(s.data(), s.size(), streamOpt)
+        {}
+
 
     // Member Functions
 
@@ -300,10 +358,22 @@ public:
         //- Same as (capacity() - input_pos())
         std::streamsize remaining() const { return stream_.remaining(); }
 
-
         //- Span of the current input characters (is modifiable!)
         UList<char> list() const { return stream_.list(); }
 
+        //- A string_view (c++17) or span view (older c++) of buffer contents
+        auto view() const -> decltype(stream_.view())
+        {
+            return stream_.view();
+        }
+
+        //- For IStringStream compatibility, return the buffer as string copy.
+        //  Use sparingly - it creates a full copy!!
+        auto str() const -> decltype(stream_.str())
+        {
+            return stream_.str();
+        }
+
         //- Reset input area, position to buffer start and clear errors
         void reset(const char* buffer, size_t nbytes)
         {
@@ -318,15 +388,38 @@ public:
             syncState();
         }
 
+        #if __cplusplus >= 201703L
+        //- Reset input area to use data from a std::string_view
+        void reset(std::string_view s)
+        {
+            stream_.reset(s.data(), s.size());
+            syncState();
+        }
+        #endif
+
+        //- Reset input area to use data from span character content
+        void reset(stdFoam::span<char> s)
+        {
+            stream_.reset(s.data(), s.size());
+            syncState();
+        }
+
+        //- Reset input area to use data from span character content
+        void reset(stdFoam::span<const char> s)
+        {
+            stream_.reset(s.data(), s.size());
+            syncState();
+        }
+
         //- Rewind the stream, clearing any old errors
-        virtual void rewind()
+        virtual void rewind() override
         {
             stream_.rewind();
             syncState();
         }
 
         //- Print stream description to Ostream
-        virtual void print(Ostream& os) const;
+        virtual void print(Ostream& os) const override;
 
 
     // Member Operators
diff --git a/src/OpenFOAM/db/IOstreams/memory/OCharStream.H b/src/OpenFOAM/db/IOstreams/memory/OCharStream.H
index fe086a5e3c..9b45472eae 100644
--- a/src/OpenFOAM/db/IOstreams/memory/OCharStream.H
+++ b/src/OpenFOAM/db/IOstreams/memory/OCharStream.H
@@ -124,12 +124,6 @@ public:
             buffer_type::reserve(n);
         }
 
-        //- Span of the current output characters (is modifiable!)
-        UList<char> list() const
-        {
-            return buffer_type::span_list();
-        }
-
         //- Rewind the stream, clearing any old errors
         void rewind()
         {
@@ -137,14 +131,41 @@ public:
             stream_type::clear();  // Clear old errors
         }
 
-        //- Transfer list contents to List buffer
+        //- Span of the current output characters (is modifiable!)
+        UList<char> list() const
+        {
+            return UList<char>
+            (
+                buffer_type::data_bytes(),
+                label(buffer_type::size_bytes())
+            );
+        }
+
+        //- A string_view (c++17) or span view (older c++) of buffer contents
+        auto view() const -> decltype(buffer_type::view())
+        {
+            return buffer_type::view();
+        }
+
+        //- For ostringstream compatibility, return the buffer as string copy.
+        //  Use sparingly - it creates a full copy!!
+        std::string str() const
+        {
+            return std::string
+            (
+                buffer_type::data_bytes(),
+                buffer_type::size_bytes()
+            );
+        }
+
+        //- Exchange stream content and parameter contents, reset positions
         void swap(List<char>& other)
         {
             buffer_type::swap(other);
             stream_type::clear();  // Clear old errors
         }
 
-        //- Transfer list contents to a DynamicList buffer
+        //- Exchange stream content and parameter contents, reset positions
         template<int SizeMin>
         void swap(DynamicList<char,SizeMin>& other)
         {
@@ -152,11 +173,18 @@ public:
             stream_type::clear();  // Clear old errors
         }
 
+        //- Reset buffer and return contents
+        DynamicList<char> release()
+        {
+            DynamicList<char> chars(buffer_type::release());
+            stream_type::clear();  // Clear old errors
+            return chars;
+        }
+
         //- Some information about the output buffer position/capacity
         void debug_info(Ostream& os) const
         {
-            os  << "put="
-                << output_pos() << '/' << capacity();
+            os  << "put=" << output_pos() << '/' << capacity();
         }
 };
 
@@ -214,19 +242,7 @@ public:
             OSstream(stream_, "output", streamOpt.format(), streamOpt.version())
         {}
 
-        //- Construct with initial reserved number of bytes
-        explicit OCharStream
-        (
-            size_t nbytes,
-            IOstreamOption streamOpt = IOstreamOption()
-        )
-        :
-            OCharStream(streamOpt)
-        {
-            stream_.reserve(nbytes);
-        }
-
-        //- Move construct from a List
+        //- Move construct from a List of initial storage
         explicit OCharStream
         (
             ::Foam::List<char>&& buffer,
@@ -238,7 +254,8 @@ public:
             stream_.swap(buffer);
         }
 
-        //- Move construct from a DynamicList (uses entire capacity)
+        //- Move construct from a DynamicList of initial storage
+        //- (uses entire capacity)
         template<int SizeMin>
         explicit OCharStream
         (
@@ -272,21 +289,27 @@ public:
         //- Span of the current output characters (is modifiable!)
         UList<char> list() const { return stream_.list(); }
 
-        //- Rewind the stream, clearing any old errors
-        virtual void rewind()
+        //- A string_view (c++17) or span view (older c++) of buffer contents
+        auto view() const -> decltype(stream_.view())
         {
-            stream_.rewind();
-            syncState();
+            return stream_.view();
         }
 
-        //- Transfer list contents to List buffer
+        //- For OStringStream compatibility, return the buffer as string copy.
+        //  Use sparingly - it creates a full copy!!
+        auto str() const -> decltype(stream_.str())
+        {
+            return stream_.str();
+        }
+
+        //- Exchange stream content and parameter contents, reset positions
         void swap(List<char>& other)
         {
             stream_.swap(other);
             syncState();
         }
 
-        //- Transfer list contents to a DynamicList buffer
+        //- Exchange stream content and parameter contents, reset positions
         template<int SizeMin>
         void swap(DynamicList<char,SizeMin>& other)
         {
@@ -294,8 +317,23 @@ public:
             syncState();
         }
 
+        //- Reset buffer and return contents
+        DynamicList<char> release()
+        {
+            DynamicList<char> chars(stream_.release());
+            syncState();
+            return chars;
+        }
+
+        //- Rewind the stream, clearing any old errors
+        virtual void rewind()
+        {
+            stream_.rewind();
+            syncState();
+        }
+
         //- Print stream description to Ostream
-        virtual void print(Ostream& os) const;
+        virtual void print(Ostream& os) const override;
 
 
     // Houskeeping
diff --git a/src/OpenFOAM/db/IOstreams/memory/OCountStream.H b/src/OpenFOAM/db/IOstreams/memory/OCountStream.H
index 0e57bcb77f..1618dd51da 100644
--- a/src/OpenFOAM/db/IOstreams/memory/OCountStream.H
+++ b/src/OpenFOAM/db/IOstreams/memory/OCountStream.H
@@ -255,7 +255,7 @@ public:
         }
 
         //- Print stream description to Ostream
-        virtual void print(Ostream& os) const;
+        virtual void print(Ostream& os) const override;
 };
 
 
diff --git a/src/OpenFOAM/db/IOstreams/memory/OSpanStream.H b/src/OpenFOAM/db/IOstreams/memory/OSpanStream.H
index c1ce9935a5..1903c5a6b6 100644
--- a/src/OpenFOAM/db/IOstreams/memory/OSpanStream.H
+++ b/src/OpenFOAM/db/IOstreams/memory/OSpanStream.H
@@ -132,13 +132,6 @@ public:
             stream_type(static_cast<buffer_type*>(this))
         {}
 
-        // //- Construct (shallow copy) from span character content
-        // ospanstream(stdFoam::span<char> s)
-        // :
-        //     buffer_type(const_cast<char*>(s.data()), s.size()),
-        //     stream_type(static_cast<buffer_type*>(this))
-        // {}
-
 
     // Member Functions
 
@@ -157,7 +150,28 @@ public:
         //- Span of the current output characters (is modifiable!)
         UList<char> list() const
         {
-            return buffer_type::span_list();
+            return UList<char>
+            (
+                buffer_type::data_bytes(),
+                label(buffer_type::size_bytes())
+            );
+        }
+
+        //- A string_view (c++17) or span view (older c++) of buffer contents
+        auto view() const -> decltype(buffer_type::view())
+        {
+            return buffer_type::view();
+        }
+
+        //- For ostringstream compatibility, return the buffer as string copy.
+        //  Use sparingly - it creates a full copy!!
+        std::string str() const
+        {
+            return std::string
+            (
+                buffer_type::data_bytes(),
+                buffer_type::size_bytes()
+            );
         }
 
         //- Rewind the stream, clearing any old errors
@@ -222,7 +236,6 @@ protected:
                          Class OSpanStream Declaration
 \*---------------------------------------------------------------------------*/
 
-//- An OSstream attached to an unallocated external buffer
 class OSpanStream
 :
     public Detail::OSpanStreamAllocator,
@@ -269,17 +282,6 @@ public:
             stream_.reset(buffer, nbytes);
         }
 
-        //- Construct using data area from a List and number of bytes
-        OSpanStream
-        (
-            ::Foam::UList<char>& buffer,
-            size_t nbytes,
-            IOstreamOption streamOpt = IOstreamOption()
-        )
-        :
-            OSpanStream(buffer.data(), nbytes, streamOpt)
-        {}
-
         //- Construct using data area from a List and its inherent storage size
         explicit OSpanStream
         (
@@ -321,6 +323,19 @@ public:
         //- Span of the current output characters (is modifiable!)
         UList<char> list() const { return stream_.list(); }
 
+        //- A string_view (c++17) or span view (older c++) of buffer contents
+        auto view() const -> decltype(stream_.view())
+        {
+            return stream_.view();
+        }
+
+        //- For OStringStream compatibility, return buffer as string copy.
+        //  Use sparingly - it creates a full copy!!
+        auto str() const -> decltype(stream_.str())
+        {
+            return stream_.str();
+        }
+
         //- Reset the put area
         void reset(char* buffer, size_t nbytes)
         {
@@ -343,7 +358,7 @@ public:
         }
 
         //- Print stream description to Ostream
-        virtual void print(Ostream& os) const;
+        virtual void print(Ostream& os) const override;
 };
 
 
diff --git a/src/OpenFOAM/db/IOstreams/memory/memoryStreamBuffer.H b/src/OpenFOAM/db/IOstreams/memory/memoryStreamBuffer.H
index be8b31aef9..8de6992f87 100644
--- a/src/OpenFOAM/db/IOstreams/memory/memoryStreamBuffer.H
+++ b/src/OpenFOAM/db/IOstreams/memory/memoryStreamBuffer.H
@@ -36,10 +36,9 @@ Description
 #define Foam_memoryStreamBuffer_H
 
 #include "stdFoam.H"  // For span
-#include "UList.H"
+#include "DynamicList.H"
 
 #include <memory>
-#include <sstream>    // Possibly want stringstream too...
 #include <type_traits>
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -208,17 +207,23 @@ public:
             return (gptr() < egptr()) ? (egptr() - gptr()) : 0;
         }
 
-        //- Span of the input characters (is modifiable!)
-        UList<char> span_list() const
-        {
-            return UList<char>(eback(), (egptr() - eback()));
-        }
+        //- The span data (start of input characters)
+        char* data_bytes() const { return eback(); }
 
-        // //- The span of input characters (is modifiable!)
-        // stdFoam::span<char> span() const
-        // {
-        //     return stdFoam::span<char>(eback(), (egptr() - eback()));
-        // }
+        //- The span size (number of input characters)
+        std::streamsize size_bytes() const { return (egptr() - eback()); }
+
+        #if __cplusplus >= 201703L
+        std::string_view view() const
+        {
+            return std::string_view(data_bytes(), size_bytes());
+        }
+        #else
+        stdFoam::span<const char> view() const
+        {
+            return stdFoam::span<const char>(data_bytes(), size_bytes());
+        }
+        #endif
 
         //- Some information about the input buffer position/capacity
         void info(Ostream& os) const
@@ -273,7 +278,7 @@ public:
         template<int SizeMin>
         in_dynamic(::Foam::DynamicList<char,SizeMin>&& buffer)
         {
-            storage_.transfer(buffer);
+            storage_.transfer(buffer);  // Implies shrink_to_fit
             sync_gbuffer();
         }
 
@@ -302,24 +307,29 @@ public:
             sync_gbuffer();
         }
 
-        //- Transfer list contents to List buffer
-        void swap(::Foam::List<char>& other)
+        //- Exchange buffer content and parameter contents, reset positions
+        void swap(List<char>& other)
         {
-            storage_.swap(other);  // Swap contents
+            other.swap(storage_);  // Swap contents
             sync_gbuffer();
         }
 
-        //- Transfer list contents to a DynamicList buffer
+        //- Exchange buffer content and parameter contents, reset positions
         template<int SizeMin>
         void swap(DynamicList<char,SizeMin>& other)
         {
-            List<char> tmp(std::move(storage_));
-
-            other.shrink();             // Use addressed length only
-            storage_.transfer(other);
-            other.transfer(tmp);
+            // NB: not storage_.swap(other)! - incorrect slicing
+            other.swap(storage_);  // Swap contents: implies shrink_to_fit
             sync_gbuffer();
         }
+
+        //- Reset buffer and return contents
+        DynamicList<char> release()
+        {
+            DynamicList<char> chars(std::move(storage_));
+            sync_gbuffer();
+            return chars;
+        }
 };
 
 
@@ -387,17 +397,23 @@ public:
         //- The put buffer capacity
         std::streamsize span_capacity() const { return (epptr() - pbase()); }
 
-        //- Span of the output characters (is modifiable!)
-        UList<char> span_list() const
-        {
-            return UList<char>(pbase(), (pptr() - pbase()));
-        }
+        //- The span data (start of output characters)
+        char* data_bytes() const { return pbase(); }
 
-        //- The span of output characters (is modifiable!)
-        // stdFoam::span<char> span() const
-        // {
-        //     return stdFoam::span<char>(pbase(), (pptr() - pbase()));
-        // }
+        //- The span size (size of output buffer)
+        std::streamsize size_bytes() const { return (pptr() - pbase()); }
+
+        #if __cplusplus >= 201703L
+        std::string_view view() const
+        {
+            return std::string_view(data_bytes(), size_bytes());
+        }
+        #else
+        stdFoam::span<const char> view() const
+        {
+            return stdFoam::span<const char>(data_bytes(), size_bytes());
+        }
+        #endif
 
         //- Some information about the output buffer position/capacity
         void info(Ostream& os) const
@@ -532,38 +548,48 @@ public:
         }
 
         //- Shrink storage to addressed storage
-        inline void shrink()
+        void shrink()
         {
-            const auto cur = span_tellp();   // Addressed length
+            const auto cur = span_tellp();  // Addressed length
 
             storage_.resize(cur);
             sync_pbuffer();
             pbump(cur);
         }
 
-        //- Transfer list contents to List buffer
-        inline void swap(List<char>& other)
+        //- Exchange buffer content and parameter contents, reset positions
+        void swap(List<char>& other)
         {
-            const auto cur = span_tellp(); // Addressed length
-
-            storage_.swap(other);       // Swap contents
-            other.resize(cur);          // Adjust to addressed length
+            const auto cur = span_tellp();  // Output length
+            other.swap(storage_);
+            other.resize(cur);              // Truncate to output length
             sync_pbuffer();
         }
 
-        //- Transfer list contents to a DynamicList buffer
+        //- Exchange buffer content and parameter contents, reset positions
         template<int SizeMin>
-        inline void swap(DynamicList<char,SizeMin>& other)
+        void swap(DynamicList<char,SizeMin>& other)
         {
-            const auto cur = span_tellp();   // Addressed length
-            List<char> tmp(std::move(storage_));
+            const auto cur = span_tellp();  // Output length
 
-            other.resize(other.capacity());  // Use entire space
-            storage_.transfer(other);
-            other.transfer(tmp);
-            other.resize(cur);          // Adjust to addressed length
+            other.resize(other.capacity()); // Use entire space
+            other.swap(storage_);  // NB: not storage_.swap(other)
+            other.resize(cur);              // Restrict to output length
             sync_pbuffer();
         }
+
+        //- Reset buffer and return contents as a DynamicList.
+        //- The list size corresponds to the region of output.
+        DynamicList<char> release()
+        {
+            const auto cur = span_tellp();  // Output length
+            DynamicList<char> chars(std::move(storage_));
+            chars.resize(cur);              // Restrict to output length
+
+            if (chars.empty()) chars.clearStorage();  // Can destroy now
+            sync_pbuffer();
+            return chars;
+        }
 };
 
 
diff --git a/src/OpenFOAM/expressions/exprDriver/exprDriverFunctions.C b/src/OpenFOAM/expressions/exprDriver/exprDriverFunctions.C
index 0df7706169..f1d0096a15 100644
--- a/src/OpenFOAM/expressions/exprDriver/exprDriverFunctions.C
+++ b/src/OpenFOAM/expressions/exprDriver/exprDriverFunctions.C
@@ -43,6 +43,7 @@ static wordHashSet getAcceptableFunctionKeys
 )
 {
     wordHashSet acceptKeys(0);
+    wordHashSet rejectKeys(0);
 
     if (!dictPtr)
     {
@@ -51,8 +52,8 @@ static wordHashSet getAcceptableFunctionKeys
 
     const dictionary& dict = *dictPtr;
 
-    acceptKeys.resize(2*dict.size());
-    wordHashSet rejectKeys(2*dict.size());
+    acceptKeys.reserve(dict.size());
+    rejectKeys.reserve(dict.size());
 
     for (const entry& dEntry : dict)
     {
diff --git a/src/OpenFOAM/fields/Fields/DynamicField/DynamicField.H b/src/OpenFOAM/fields/Fields/DynamicField/DynamicField.H
index 1135129a03..7debed435b 100644
--- a/src/OpenFOAM/fields/Fields/DynamicField/DynamicField.H
+++ b/src/OpenFOAM/fields/Fields/DynamicField/DynamicField.H
@@ -134,18 +134,18 @@ public:
         inline explicit DynamicField(const IndirectListBase<T, Addr>& list);
 
         //- Move construct from List contents
-        inline explicit DynamicField(List<T>&& content);
+        inline explicit DynamicField(List<T>&& content) noexcept;
 
         //- Move construct from dynamic Field contents
-        inline DynamicField(DynamicField<T, SizeMin>&& content);
+        inline DynamicField(DynamicField<T, SizeMin>&& content) noexcept;
 
         //- Move construct with different sizing parameters
         template<int AnySizeMin>
-        inline DynamicField(DynamicField<T, AnySizeMin>&& content);
+        inline DynamicField(DynamicField<T, AnySizeMin>&& content) noexcept;
 
         //- Move construct from DynamicList
         template<int AnySizeMin>
-        inline DynamicField(DynamicList<T, AnySizeMin>&& list);
+        inline DynamicField(DynamicList<T, AnySizeMin>&& content) noexcept;
 
         //- Construct by 1 to 1 mapping from the given field
         inline DynamicField
@@ -178,7 +178,7 @@ public:
 
     // Member Functions
 
-    // Sizing
+    // Capacity
 
         //- Normal lower capacity limit - the SizeMin template parameter
         static constexpr label min_size() noexcept { return SizeMin; }
@@ -190,6 +190,9 @@ public:
         //  \note Only meaningful for contiguous data
         inline std::streamsize capacity_bytes() const noexcept;
 
+
+    // Sizing
+
         //- Alter the size of the underlying storage.
         //  The addressed size will be truncated if needed to fit, but will
         //  remain otherwise untouched.
@@ -246,20 +249,23 @@ public:
         //- Clear the list and delete storage.
         inline void clearStorage();
 
-        //- Expand the addressable size to fit the allocated capacity.
-        //  Returns the previous addressable size.
-        inline label expandStorage() noexcept;
-
         //- Shrink the allocated space to the number of elements used.
-        inline void shrinkStorage();
+        inline void shrink_to_fit();
 
-        //- Shrink the allocated space to the number of elements used.
-        //  Returns a reference to the DynamicField.
+        //- Shrink the internal bookkeeping of the allocated space to the
+        //- number of addressed elements without affecting allocation.
+        //  \note when empty() it will delete any allocated memory.
+        inline void shrink_unsafe();
+
+        //- Calls shrink_to_fit() and returns a reference to the DynamicField.
         inline DynamicField<T, SizeMin>& shrink();
 
 
     // Edit
 
+        //- Swap with plain List content. Implies shrink_to_fit().
+        inline void swap(List<T>& list);
+
         //- Swap content, independent of sizing parameter
         template<int AnySizeMin>
         inline void swap(DynamicField<T, AnySizeMin>& other);
diff --git a/src/OpenFOAM/fields/Fields/DynamicField/DynamicFieldI.H b/src/OpenFOAM/fields/Fields/DynamicField/DynamicFieldI.H
index 426edd4f05..453c602450 100644
--- a/src/OpenFOAM/fields/Fields/DynamicField/DynamicFieldI.H
+++ b/src/OpenFOAM/fields/Fields/DynamicField/DynamicFieldI.H
@@ -220,7 +220,7 @@ template<class T, int SizeMin>
 inline Foam::DynamicField<T, SizeMin>::DynamicField
 (
     List<T>&& content
-)
+) noexcept
 :
     Field<T>(std::move(content)),
     capacity_(Field<T>::size())
@@ -231,13 +231,13 @@ template<class T, int SizeMin>
 template<int AnySizeMin>
 inline Foam::DynamicField<T, SizeMin>::DynamicField
 (
-    DynamicList<T, AnySizeMin>&& list
-)
+    DynamicList<T, AnySizeMin>&& content
+) noexcept
 :
-    Field<T>(),
-    capacity_(0)
+    Field<T>(std::move(static_cast<List<T>&>(content))),
+    capacity_(content.capacity())
 {
-    transfer(list);
+    content.setCapacity_unsafe(0);  // Same as shrink_unsafe() but noexcept
 }
 
 
@@ -245,12 +245,12 @@ template<class T, int SizeMin>
 inline Foam::DynamicField<T, SizeMin>::DynamicField
 (
     DynamicField<T, SizeMin>&& content
-)
+) noexcept
 :
-    Field<T>(),
-    capacity_(0)
+    Field<T>(std::move(static_cast<List<T>&>(content))),
+    capacity_(content.capacity())
 {
-    transfer(content);
+    content.setCapacity_unsafe(0);  // Same as shrink_unsafe() but noexcept
 }
 
 
@@ -259,12 +259,12 @@ template<int AnySizeMin>
 inline Foam::DynamicField<T, SizeMin>::DynamicField
 (
     DynamicField<T, AnySizeMin>&& content
-)
+) noexcept
 :
-    Field<T>(),
-    capacity_(0)
+    Field<T>(std::move(static_cast<List<T>&>(content))),
+    capacity_(content.capacity())
 {
-    transfer(content);
+    content.setCapacity_unsafe(0);  // Same as shrink_unsafe() but noexcept
 }
 
 
@@ -438,19 +438,7 @@ inline void Foam::DynamicField<T, SizeMin>::clearStorage()
 
 
 template<class T, int SizeMin>
-inline Foam::label Foam::DynamicField<T, SizeMin>::expandStorage() noexcept
-{
-    const label currLen = List<T>::size();
-
-    // Allow addressing into the entire list
-    List<T>::setAddressableSize(capacity_);
-
-    return currLen;
-}
-
-
-template<class T, int SizeMin>
-inline void Foam::DynamicField<T, SizeMin>::shrinkStorage()
+inline void Foam::DynamicField<T, SizeMin>::shrink_to_fit()
 {
     const label currLen = List<T>::size();
 
@@ -458,22 +446,57 @@ inline void Foam::DynamicField<T, SizeMin>::shrinkStorage()
     {
         // Adjust addressable size to trigger proper resizing
         List<T>::setAddressableSize(currLen+1);
-
         List<T>::resize(currLen);
         capacity_ = List<T>::size();
     }
 }
 
 
+template<class T, int SizeMin>
+inline void Foam::DynamicField<T, SizeMin>::shrink_unsafe()
+{
+    if (List<T>::empty())
+    {
+        // Delete storage if empty
+        List<T>::clear();
+    }
+    capacity_ = List<T>::size();
+}
+
+
 template<class T, int SizeMin>
 inline Foam::DynamicField<T, SizeMin>&
 Foam::DynamicField<T, SizeMin>::shrink()
 {
-    this->shrinkStorage();
+    this->shrink_to_fit();
     return *this;
 }
 
 
+template<class T, int SizeMin>
+inline void
+Foam::DynamicField<T, SizeMin>::swap(List<T>& list)
+{
+    if
+    (
+        static_cast<const List<T>*>(this)
+     == static_cast<const List<T>*>(&list)
+    )
+    {
+        return;  // Self-swap is a no-op
+    }
+
+    // Remove unused storage
+    this->shrink_to_fit();
+
+    // Swap storage and addressable size
+    UList<T>::swap(list);
+
+    // Update capacity
+    capacity_ = List<T>::size();
+}
+
+
 template<class T, int SizeMin>
 template<int AnySizeMin>
 inline void Foam::DynamicField<T, SizeMin>::swap
@@ -529,9 +552,8 @@ inline void Foam::DynamicField<T, SizeMin>::swap
 template<class T, int SizeMin>
 inline void Foam::DynamicField<T, SizeMin>::transfer(List<T>& list)
 {
-    // Take over storage, clear addressing for list
-    capacity_ = list.size();
     Field<T>::transfer(list);
+    capacity_ = Field<T>::size();
 }
 
 
@@ -551,12 +573,10 @@ inline void Foam::DynamicField<T, SizeMin>::transfer
         return;  // Self-assignment is a no-op
     }
 
-    // Take over storage as-is (without shrink, without using SizeMin)
-    // clear addressing and storage for old list.
+    // Take over storage as-is (without shrink)
     capacity_ = list.capacity();
-
     Field<T>::transfer(static_cast<List<T>&>(list));
-    list.clearStorage();  // Ensure capacity=0
+    list.clearStorage();  // capacity=0 etc.
 }
 
 
@@ -576,12 +596,10 @@ inline void Foam::DynamicField<T, SizeMin>::transfer
         return;  // Self-assignment is a no-op
     }
 
-    // Take over storage as-is (without shrink, without using SizeMin)
-    // clear addressing and storage for old list.
+    // Take over storage as-is (without shrink)
     capacity_ = list.capacity();
-
     Field<T>::transfer(static_cast<List<T>&>(list));
-    list.clearStorage();  // Ensure capacity=0
+    list.clearStorage();  // capacity=0 etc.
 }
 
 
@@ -818,10 +836,10 @@ inline Foam::Istream& Foam::DynamicField<T, SizeMin>::readList
     // The logic should be the same and this avoids duplicate code
 
     DynamicList<T, SizeMin> list;
-    (*this).swap(list);
+    this->swap(list);
 
     list.readList(is);
-    (*this).swap(list);
+    this->swap(list);
 
     return is;
 }
diff --git a/src/OpenFOAM/fields/Fields/Field/Field.H b/src/OpenFOAM/fields/Fields/Field/Field.H
index 0f5d81237f..9a2d17c7a4 100644
--- a/src/OpenFOAM/fields/Fields/Field/Field.H
+++ b/src/OpenFOAM/fields/Fields/Field/Field.H
@@ -162,10 +162,10 @@ public:
         inline explicit Field(const IndirectListBase<Type, Addr>& list);
 
         //- Move construct from Field
-        inline Field(Field<Type>&& fld);
+        inline Field(Field<Type>&& fld) noexcept;
 
         //- Move construct from List
-        inline Field(List<Type>&& list);
+        inline Field(List<Type>&& list) noexcept;
 
         //- Move construct from DynamicList
         template<int SizeMin>
diff --git a/src/OpenFOAM/fields/Fields/Field/FieldI.H b/src/OpenFOAM/fields/Fields/Field/FieldI.H
index f2f4b5d7d4..a5c37b841b 100644
--- a/src/OpenFOAM/fields/Fields/Field/FieldI.H
+++ b/src/OpenFOAM/fields/Fields/Field/FieldI.H
@@ -108,21 +108,17 @@ inline Foam::Field<Type>::Field(const IndirectListBase<Type, Addr>& list)
 
 
 template<class Type>
-inline Foam::Field<Type>::Field(Field<Type>&& fld)
+inline Foam::Field<Type>::Field(Field<Type>&& fld) noexcept
 :
-    List<Type>()
-{
-    List<Type>::transfer(fld);
-}
+    List<Type>(std::move(static_cast<List<Type>&>(fld)))
+{}
 
 
 template<class Type>
-inline Foam::Field<Type>::Field(List<Type>&& list)
+inline Foam::Field<Type>::Field(List<Type>&& list) noexcept
 :
-    List<Type>()
-{
-    List<Type>::transfer(list);
-}
+    List<Type>(std::move(list))
+{}
 
 
 template<class Type>
diff --git a/src/OpenFOAM/fields/Fields/Field/SubField.H b/src/OpenFOAM/fields/Fields/Field/SubField.H
index 5634a9736d..48cc8530ff 100644
--- a/src/OpenFOAM/fields/Fields/Field/SubField.H
+++ b/src/OpenFOAM/fields/Fields/Field/SubField.H
@@ -37,8 +37,8 @@ SourceFiles
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef SubField_H
-#define SubField_H
+#ifndef Foam_SubField_H
+#define Foam_SubField_H
 
 #include "Field.H"
 #include "SubList.H"
@@ -79,27 +79,27 @@ public:
         SubField() noexcept = default;
 
         //- Copy construct (shallow copy)
-        inline SubField(const SubField<Type>& sfield);
+        inline SubField(const SubField<Type>& fld);
 
         //- Copy construct from SubList
         inline SubField(const SubList<Type>& list);
 
         //- Construct from UList, the entire size
-        inline explicit SubField(const UList<Type>& list);
+        inline explicit SubField(const UList<Type>& list) noexcept;
 
         //- Construct from UList with a given sub-list size, start at 0
         inline SubField
         (
             const UList<Type>& list,
-            const label subSize
+            const label len
         );
 
-        //- Construct from UList with a given size and start index
+        //- Construct from UList, sub-list size and start index
         inline SubField
         (
             const UList<Type>& list,
-            const label subSize,
-            const label startIndex
+            const label len,
+            const label start
         );
 
         //- Construct from UList and a (start,size) range.
@@ -111,8 +111,8 @@ public:
             const labelRange& range
         );
 
-        //- Construct from UList and a (start,size) range, but bypassing
-        //- run-time range checking.
+        //- Construct from UList and a (start,size) range,
+        //- but bypassing run-time range checking.
         inline SubField
         (
             const labelRange& range,
diff --git a/src/OpenFOAM/fields/Fields/Field/SubFieldI.H b/src/OpenFOAM/fields/Fields/Field/SubFieldI.H
index 184f4b8650..738096e039 100644
--- a/src/OpenFOAM/fields/Fields/Field/SubFieldI.H
+++ b/src/OpenFOAM/fields/Fields/Field/SubFieldI.H
@@ -40,10 +40,10 @@ inline const Foam::SubField<Type>& Foam::SubField<Type>::null()
 template<class Type>
 inline Foam::SubField<Type>::SubField
 (
-    const SubField<Type>& sfield
+    const SubField<Type>& fld
 )
 :
-    SubList<Type>(sfield)
+    SubList<Type>(fld)
 {}
 
 
@@ -61,7 +61,7 @@ template<class Type>
 inline Foam::SubField<Type>::SubField
 (
     const UList<Type>& list
-)
+) noexcept
 :
     SubList<Type>(list)
 {}
@@ -71,10 +71,10 @@ template<class Type>
 inline Foam::SubField<Type>::SubField
 (
     const UList<Type>& list,
-    const label subSize
+    const label len
 )
 :
-    SubList<Type>(list, subSize)
+    SubList<Type>(list, len)
 {}
 
 
@@ -82,11 +82,11 @@ template<class Type>
 inline Foam::SubField<Type>::SubField
 (
     const UList<Type>& list,
-    const label subSize,
-    const label startIndex
+    const label len,
+    const label start
 )
 :
-    SubList<Type>(list, subSize, startIndex)
+    SubList<Type>(list, len, start)
 {}
 
 
diff --git a/src/OpenFOAM/global/debug/simpleObjectRegistry.H b/src/OpenFOAM/global/debug/simpleObjectRegistry.H
index 9d559194c6..6c899866bb 100644
--- a/src/OpenFOAM/global/debug/simpleObjectRegistry.H
+++ b/src/OpenFOAM/global/debug/simpleObjectRegistry.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2012-2016 OpenFOAM Foundation
-    Copyright (C) 2019-2021 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -35,8 +35,8 @@ SourceFiles
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef simpleObjectRegistry_H
-#define simpleObjectRegistry_H
+#ifndef Foam_simpleObjectRegistry_H
+#define Foam_simpleObjectRegistry_H
 
 #include "Dictionary.H"
 #include "simpleRegIOobject.H"
@@ -87,10 +87,13 @@ public:
 
     // Constructors
 
-        //- Construct with given or default (128) table capacity
-        explicit simpleObjectRegistry(const label size = 128)
+        //- Default construct: empty without allocation (capacity=0).
+        simpleObjectRegistry() = default;
+
+        //- Construct empty with initial table capacity
+        explicit simpleObjectRegistry(const label initialCapacity)
         :
-            Dictionary<simpleObjectRegistryEntry>(size)
+            Dictionary<simpleObjectRegistryEntry>(initialCapacity)
         {}
 
 
diff --git a/src/OpenFOAM/matrices/Matrix/MatrixIO.C b/src/OpenFOAM/matrices/Matrix/MatrixIO.C
index 164880fdcc..e2fd604558 100644
--- a/src/OpenFOAM/matrices/Matrix/MatrixIO.C
+++ b/src/OpenFOAM/matrices/Matrix/MatrixIO.C
@@ -84,7 +84,6 @@ bool Foam::Matrix<Form, Type>::readMatrix(Istream& is)
 
                 is.fatalCheck("readMatrix : reading the binary block");
             }
-
         }
         else
         {
@@ -95,16 +94,16 @@ bool Foam::Matrix<Form, Type>::readMatrix(Istream& is)
             {
                 if (listDelimiter == token::BEGIN_LIST)
                 {
-                    label idx = 0;
+                    auto iter = this->begin();
 
                     // Loop over rows
                     for (label i = 0; i < mRows_; ++i)
                     {
                         listDelimiter = is.readBeginList("MatrixRow");
 
-                        for (label j = 0; j < nCols_; ++j)
+                        for (label j = 0; j < nCols_; ++j, (void)++iter)
                         {
-                            is >> v_[idx++];
+                            is >> *iter;
                             is.fatalCheck("readMatrix : reading entry");
                         }
 
@@ -113,12 +112,12 @@ bool Foam::Matrix<Form, Type>::readMatrix(Istream& is)
                 }
                 else  // BEGIN_BLOCK
                 {
-                    Type element;
-                    is >> element;
+                    Type elem;
+                    is >> elem;
 
                     is.fatalCheck("readMatrix : reading the single entry");
 
-                    std::fill_n(begin(), size(), element);
+                    std::fill_n(begin(), size(), elem);
                 }
             }
 
@@ -163,7 +162,7 @@ Foam::Ostream& Foam::Matrix<Form, Type>::writeMatrix
             os.write(mat.cdata_bytes(), mat.size_bytes());
         }
     }
-    else if (len > 1 && is_contiguous<Type>::value && mat.uniform())
+    else if (is_contiguous<Type>::value && len > 1 && mat.uniform())
     {
         // Two or more entries, and all entries have identical values.
         os  << token::BEGIN_BLOCK << *iter << token::END_BLOCK;
@@ -186,11 +185,10 @@ Foam::Ostream& Foam::Matrix<Form, Type>::writeMatrix
             os  << token::BEGIN_LIST;
 
             // Write row
-            for (label j = 0; j < mat.nCols(); ++j)
+            for (label j = 0; j < mat.nCols(); ++j, (void)++iter)
             {
                 if (j) os << token::SPACE;
                 os << *iter;
-                ++iter;
             }
 
             // End row
@@ -218,11 +216,10 @@ Foam::Ostream& Foam::Matrix<Form, Type>::writeMatrix
             os  << nl << token::BEGIN_LIST;
 
             // Write row
-            for (label j = 0; j < mat.nCols(); ++j)
+            for (label j = 0; j < mat.nCols(); ++j, (void)++iter)
             {
                 if (j) os << token::SPACE;
                 os << *iter;
-                ++iter;
             }
 
             // End row
@@ -246,10 +243,9 @@ Foam::Ostream& Foam::Matrix<Form, Type>::writeMatrix
             os  << nl << token::BEGIN_LIST;
 
             // Write row
-            for (label j = 0; j < mat.nCols(); ++j)
+            for (label j = 0; j < mat.nCols(); ++j, (void)++iter)
             {
                 os << nl << *iter;
-                ++iter;
             }
 
             // End row
diff --git a/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGAgglomerations/GAMGAgglomeration/GAMGAgglomerateLduAddressing.C b/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGAgglomerations/GAMGAgglomeration/GAMGAgglomerateLduAddressing.C
index 255c6a4389..f8314ce489 100644
--- a/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGAgglomerations/GAMGAgglomeration/GAMGAgglomerateLduAddressing.C
+++ b/src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGAgglomerations/GAMGAgglomeration/GAMGAgglomerateLduAddressing.C
@@ -245,10 +245,10 @@ void Foam::GAMGAgglomeration::agglomerateLduAddressing
 
 
     // Clear the temporary storage for the coarse cell data
-    cCellnFaces.setSize(0);
-    cCellFaces.setSize(0);
-    initCoarseNeighb.setSize(0);
-    coarseFaceMap.setSize(0);
+    cCellnFaces.clear();
+    cCellFaces.clear();
+    initCoarseNeighb.clear();
+    coarseFaceMap.clear();
 
 
     // Create coarse-level interfaces
diff --git a/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalPoints.C b/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalPoints.C
index de0b3210c7..25ce60d1c8 100644
--- a/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalPoints.C
+++ b/src/OpenFOAM/meshes/polyMesh/globalMeshData/globalPoints.C
@@ -768,7 +768,7 @@ void Foam::globalPoints::remove
 
     // Save old ones.
     Map<label> oldMeshToProcPoint(std::move(meshToProcPoint_));
-    meshToProcPoint_.resize(oldMeshToProcPoint.size());
+    meshToProcPoint_.reserve(oldMeshToProcPoint.size());
     DynamicList<labelPairList> oldProcPoints(std::move(procPoints_));
     procPoints_.setCapacity(oldProcPoints.size());
 
@@ -867,7 +867,7 @@ void Foam::globalPoints::remove
     }
 
     procPoints_.shrink();
-    meshToProcPoint_.resize(2*procPoints_.size());
+    meshToProcPoint_.reserve(procPoints_.size());
 }
 
 
diff --git a/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapDistribute/mapDistributeBase.C b/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapDistribute/mapDistributeBase.C
index 6fc781028b..b8efeb9be7 100644
--- a/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapDistribute/mapDistributeBase.C
+++ b/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapDistribute/mapDistributeBase.C
@@ -413,7 +413,7 @@ void Foam::mapDistributeBase::calcCompactAddressing
         compactMap[proci].clear();
         if (proci != myRank)
         {
-            compactMap[proci].resize(2*nNonLocal[proci]);
+            compactMap[proci].reserve(nNonLocal[proci]);
         }
     }
 
@@ -464,7 +464,7 @@ void Foam::mapDistributeBase::calcCompactAddressing
         compactMap[proci].clear();
         if (proci != myRank)
         {
-            compactMap[proci].resize(2*nNonLocal[proci]);
+            compactMap[proci].reserve(nNonLocal[proci]);
         }
     }
 
diff --git a/src/OpenFOAM/meshes/polyMesh/polyBoundaryMesh/polyBoundaryMesh.C b/src/OpenFOAM/meshes/polyMesh/polyBoundaryMesh/polyBoundaryMesh.C
index 21f4a2506c..29ffe6f3f1 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyBoundaryMesh/polyBoundaryMesh.C
+++ b/src/OpenFOAM/meshes/polyMesh/polyBoundaryMesh/polyBoundaryMesh.C
@@ -742,7 +742,7 @@ Foam::labelList Foam::polyBoundaryMesh::indices
     // Only check groups if requested and they exist
     if (useGroups && this->hasGroupIDs())
     {
-        ids.resize(2*this->size());
+        ids.reserve(this->size());
 
         const auto& groupLookup = groupPatchIDs();
         forAllConstIters(groupLookup, iter)
@@ -787,7 +787,7 @@ Foam::labelList Foam::polyBoundaryMesh::indices
     // Only check groups if requested and they exist
     if (useGroups && this->hasGroupIDs())
     {
-        ids.resize(2*this->size());
+        ids.reserve(this->size());
 
         const auto& groupLookup = groupPatchIDs();
         forAllConstIters(groupLookup, iter)
@@ -958,7 +958,7 @@ Foam::labelHashSet Foam::polyBoundaryMesh::patchSet
 
     const label len = patches.size();
 
-    ids.resize(2*len);
+    ids.reserve(len);
 
     // Only check groups if requested and they exist
     const bool checkGroups = (useGroups && this->hasGroupIDs());
diff --git a/src/OpenFOAM/meshes/polyMesh/polyMeshCheck/polyMeshCheck.C b/src/OpenFOAM/meshes/polyMesh/polyMeshCheck/polyMeshCheck.C
index 255335aafa..da62393871 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyMeshCheck/polyMeshCheck.C
+++ b/src/OpenFOAM/meshes/polyMesh/polyMeshCheck/polyMeshCheck.C
@@ -373,11 +373,11 @@ bool Foam::polyMesh::checkEdgeAlignment
 
         if (setPtr)
         {
-            setPtr->resize(2*edgesInError.size());
+            setPtr->reserve(2*edgesInError.size());
             forAllConstIters(edgesInError, iter)
             {
-                setPtr->insert(iter.key()[0]);
-                setPtr->insert(iter.key()[1]);
+                setPtr->insert(iter.key().first());
+                setPtr->insert(iter.key().second());
             }
         }
 
diff --git a/src/OpenFOAM/meshes/polyMesh/polyMeshClear.C b/src/OpenFOAM/meshes/polyMesh/polyMeshClear.C
index 75703ddaeb..a7d76831b7 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyMeshClear.C
+++ b/src/OpenFOAM/meshes/polyMesh/polyMeshClear.C
@@ -208,10 +208,10 @@ void Foam::polyMesh::clearPrimitives()
 {
     resetMotion();
 
-    points_.setSize(0);
-    faces_.setSize(0);
-    owner_.setSize(0);
-    neighbour_.setSize(0);
+    points_.clear();
+    faces_.clear();
+    owner_.clear();
+    neighbour_.clear();
 
     clearedPrimitives_ = true;
 }
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.C b/src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.C
index c850d08db2..0419af3041 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.C
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.C
@@ -324,10 +324,10 @@ void Foam::coupledPolyPatch::calcTransformTensors
     if (Cf.size() == 0)
     {
         // Dummy geometry. Assume non-separated, parallel.
-        separation_.setSize(0);
+        separation_.clear();
         forwardT_.clear();
         reverseT_.clear();
-        collocated_.setSize(0);
+        collocated_.clear();
     }
     else
     {
@@ -352,7 +352,7 @@ void Foam::coupledPolyPatch::calcTransformTensors
 
             // Assume per-face differing transformation, correct later
 
-            separation_.setSize(0);
+            separation_.clear();
 
             forwardT_.setSize(Cf.size());
             reverseT_.setSize(Cf.size());
@@ -390,8 +390,8 @@ void Foam::coupledPolyPatch::calcTransformTensors
         {
             // Translational or (unknown and normals aligned)
 
-            forwardT_.setSize(0);
-            reverseT_.setSize(0);
+            forwardT_.clear();
+            reverseT_.clear();
 
             separation_ = Cr - Cf;
 
@@ -443,7 +443,7 @@ void Foam::coupledPolyPatch::calcTransformTensors
                             << ". Assuming zero separation." << endl;
                     }
 
-                    separation_.setSize(0);
+                    separation_.clear();
                     collocated_ = boolList(1, true);
                 }
                 else
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicPolyPatch.C b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicPolyPatch.C
index b2e912e00f..f42eb85f15 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicPolyPatch.C
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicPolyPatch.C
@@ -294,7 +294,7 @@ void Foam::cyclicPolyPatch::calcTransforms
 
             const_cast<tensorField&>(forwardT()) = tensorField(1, revT.T());
             const_cast<tensorField&>(reverseT()) = tensorField(1, revT);
-            const_cast<vectorField&>(separation()).setSize(0);
+            const_cast<vectorField&>(separation()).clear();
             const_cast<boolList&>(collocated()) = boolList(1, false);
         }
         else
diff --git a/src/OpenFOAM/meshes/polyMesh/syncTools/syncToolsTemplates.C b/src/OpenFOAM/meshes/polyMesh/syncTools/syncToolsTemplates.C
index 7afd9d8969..dbd296f421 100644
--- a/src/OpenFOAM/meshes/polyMesh/syncTools/syncToolsTemplates.C
+++ b/src/OpenFOAM/meshes/polyMesh/syncTools/syncToolsTemplates.C
@@ -104,7 +104,7 @@ void Foam::syncTools::syncPointMap
         // global shared index per local index
         const labelList& sharedPtAddr = pd.sharedPointAddr();
 
-        sharedPointValues.resize(sharedPtAddr.size());
+        sharedPointValues.reserve(sharedPtAddr.size());
 
         // Fill my entries in the shared points
         forAll(sharedPtLabels, i)
diff --git a/src/OpenFOAM/meshes/polyMesh/zones/ZoneMesh/ZoneMesh.C b/src/OpenFOAM/meshes/polyMesh/zones/ZoneMesh/ZoneMesh.C
index 63e3747836..ed35f4a341 100644
--- a/src/OpenFOAM/meshes/polyMesh/zones/ZoneMesh/ZoneMesh.C
+++ b/src/OpenFOAM/meshes/polyMesh/zones/ZoneMesh/ZoneMesh.C
@@ -384,7 +384,7 @@ Foam::labelList Foam::ZoneMesh<ZoneType, MeshType>::indices
 
     if (checkGroups)
     {
-        ids.resize(2*this->size());
+        ids.reserve(this->size());
     }
 
     if (matcher.isPattern())
@@ -459,7 +459,7 @@ Foam::labelList Foam::ZoneMesh<ZoneType, MeshType>::indices
     // Only check groups if requested and they exist
     if (useGroups && this->hasGroupIDs())
     {
-        ids.resize(2*this->size());
+        ids.reserve(this->size());
 
         const auto& groupLookup = groupZoneIDs();
         forAllConstIters(groupLookup, iter)
@@ -505,7 +505,7 @@ Foam::labelList Foam::ZoneMesh<ZoneType, MeshType>::indices
     // Only check groups if requested and they exist
     if (useGroups && this->hasGroupIDs())
     {
-        ids.resize(2*this->size());
+        ids.reserve(this->size());
 
         const auto& groupLookup = groupZoneIDs();
         forAllConstIters(groupLookup, iter)
diff --git a/src/OpenFOAM/meshes/primitiveMesh/PrimitivePatch/PrimitivePatchBdryPoints.C b/src/OpenFOAM/meshes/primitiveMesh/PrimitivePatch/PrimitivePatchBdryPoints.C
index 17190d0a1e..b5fdf6d8d1 100644
--- a/src/OpenFOAM/meshes/primitiveMesh/PrimitivePatch/PrimitivePatchBdryPoints.C
+++ b/src/OpenFOAM/meshes/primitiveMesh/PrimitivePatch/PrimitivePatchBdryPoints.C
@@ -51,7 +51,7 @@ Foam::PrimitivePatch<FaceList, PointField>::calcBdryPoints() const
             << "Calculating boundary points from existing addressing"
             << nl;
 
-        bp.resize(4*nBoundaryEdges());
+        bp.reserve(2*nBoundaryEdges());
 
         for (const edge& e : boundaryEdges())
         {
@@ -103,7 +103,7 @@ Foam::PrimitivePatch<FaceList, PointField>::calcBdryPoints() const
             }
         }
 
-        bp.resize(4*edgeCount);
+        bp.reserve(2*edgeCount);
 
         forAllConstIters(knownEdges, iter)
         {
diff --git a/src/OpenFOAM/meshes/primitiveMesh/primitiveMeshCheck/primitiveMeshCheck.C b/src/OpenFOAM/meshes/primitiveMesh/primitiveMeshCheck/primitiveMeshCheck.C
index c45ad6ca4b..24b36c89e7 100644
--- a/src/OpenFOAM/meshes/primitiveMesh/primitiveMeshCheck/primitiveMeshCheck.C
+++ b/src/OpenFOAM/meshes/primitiveMesh/primitiveMeshCheck/primitiveMeshCheck.C
@@ -1512,7 +1512,7 @@ bool Foam::primitiveMesh::checkFaceFaces
     label nBaffleFaces = 0;
     label nErrorDuplicate = 0;
     label nErrorOrder = 0;
-    Map<label> nCommonPoints(128);
+    Map<label> nCommonPoints;
 
     for (label facei = 0; facei < nFaces(); facei++)
     {
diff --git a/src/OpenFOAM/parallel/processorTopology/processorTopologyNew.H b/src/OpenFOAM/parallel/processorTopology/processorTopologyNew.H
index 17384f3532..aa25fea0f8 100644
--- a/src/OpenFOAM/parallel/processorTopology/processorTopologyNew.H
+++ b/src/OpenFOAM/parallel/processorTopology/processorTopologyNew.H
@@ -95,7 +95,7 @@ Foam::processorTopology Foam::processorTopology::New
         // - assumes single connections between processors
 
         auto& patchMap = topo.procPatchMap_;
-        patchMap.resize(2*numProcPatches);
+        patchMap.reserve(numProcPatches);
 
         forAll(patches, patchi)
         {
diff --git a/src/OpenFOAM/primitives/chars/lists/charList.C b/src/OpenFOAM/primitives/chars/lists/charList.C
index 05ff1c4de7..312802f13a 100644
--- a/src/OpenFOAM/primitives/chars/lists/charList.C
+++ b/src/OpenFOAM/primitives/chars/lists/charList.C
@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2021-2023 OpenCFD Ltd.
+    Copyright (C) 2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -26,9 +26,6 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "charList.H"
-#include "Istream.H"
-#include "Ostream.H"
-#include "token.H"
 #include "addToRunTimeSelectionTable.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@@ -40,74 +37,4 @@ namespace Foam
 }
 
 
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-template<>
-Istream& List<char>::readList(Istream& is)
-{
-    List<char>& list = *this;
-
-    is.fatalCheck(FUNCTION_NAME);
-
-    token tok(is);
-
-    is.fatalCheck("List<char>::readList(Istream&) : reading first token");
-
-    if (tok.isCompound())
-    {
-        // Compound: simply transfer contents
-
-        list.clear();  // Clear old contents
-        list.transfer
-        (
-            tok.transferCompoundToken<List<char>>(is)
-        );
-    }
-    else if (tok.isLabel())
-    {
-        // Label: could be int(..) or just a plain '0'
-
-        const label len = tok.labelToken();
-
-        // Resize to length required
-        list.resize_nocopy(len);
-
-        // Binary, always contiguous
-
-        if (len)
-        {
-            const auto oldFmt = is.format(IOstreamOption::BINARY);
-
-            // read(...) includes surrounding start/end delimiters
-            is.read(list.data(), std::streamsize(len));
-
-            is.format(oldFmt);
-
-            is.fatalCheck
-            (
-                "List<char>::readList(Istream&) : "
-                "reading binary block"
-            );
-        }
-    }
-    else
-    {
-        list.clear();  // Clear old contents
-
-        FatalIOErrorInFunction(is)
-            << "incorrect first token, expected <int>, found "
-            << tok.info() << nl
-            << exit(FatalIOError);
-    }
-
-    return is;
-}
-
-
-} // End namespace Foam
-
-
 // ************************************************************************* //
diff --git a/src/OpenFOAM/primitives/chars/lists/charUList.C b/src/OpenFOAM/primitives/chars/lists/charUList.C
index 5c1a0b7b4d..354d4bc073 100644
--- a/src/OpenFOAM/primitives/chars/lists/charUList.C
+++ b/src/OpenFOAM/primitives/chars/lists/charUList.C
@@ -30,38 +30,6 @@ License
 #include "Ostream.H"
 #include "token.H"
 
-// * * * * * * * * * * * * * * * Local Functions * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-static Ostream& writeChars
-(
-    Ostream& os,
-    const char* chars,
-    std::streamsize count
-)
-{
-    // Contents are binary and contiguous
-    os << nl << label(count) << nl;
-
-    if (count)
-    {
-        const auto oldFmt = os.format(IOstreamOption::BINARY);
-
-        // write(...) includes surrounding start/end delimiters
-        os.write(chars, count);
-
-        os.format(oldFmt);
-    }
-
-    os.check(FUNCTION_NAME);
-    return os;
-}
-
-} // End namespace Foam
-
-
 // * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
 
 namespace Foam
@@ -70,13 +38,12 @@ namespace Foam
 template<>
 void UList<char>::writeEntry(Ostream& os) const
 {
-    const std::streamsize count(this->size());
-
     os  << word("List<char>");
 
-    if (count)
+    if (this->size())
     {
-        writeChars(os, this->cdata(), count);
+        // Non-zero size: write as binary, so has leading newline separator.
+        os << *this;
     }
     else
     {
@@ -93,99 +60,6 @@ void UList<char>::writeEntry(Ostream& os) const
 namespace Foam
 {
 
-template<>
-Ostream& UList<char>::writeList
-(
-    Ostream& os,
-    const label /* shortLen (unused) */
-) const
-{
-    return writeChars(os, this->cdata(), std::streamsize(this->size()));
-}
-
-
-template<>
-Istream& UList<char>::readList(Istream& is)
-{
-    UList<char>& list = *this;
-
-    // The target list length - must match with sizes read
-    const label len = list.size();
-
-    is.fatalCheck(FUNCTION_NAME);
-
-    token tok(is);
-
-    is.fatalCheck("UList<char>::readList(Istream&) : reading first token");
-
-    if (tok.isCompound())
-    {
-        // Compound: simply transfer contents
-
-        List<char> elems;
-        elems.transfer
-        (
-            tok.transferCompoundToken<List<char>>(is)
-        );
-
-        const label inputLen = elems.size();
-
-        // List lengths must match
-        if (inputLen != len)
-        {
-            FatalIOErrorInFunction(is)
-                << "incorrect length for UList. Read "
-                << inputLen << " expected " << len
-                << exit(FatalIOError);
-        }
-
-        this->deepCopy(elems);
-    }
-    if (tok.isLabel())
-    {
-        // Label: could be int(..) or just a plain '0'
-
-        const label inputLen = tok.labelToken();
-
-        // List lengths must match
-        if (inputLen != len)
-        {
-            FatalIOErrorInFunction(is)
-                << "incorrect length for UList. Read "
-                << inputLen << " expected " << len
-                << exit(FatalIOError);
-        }
-
-        // Binary, always contiguous
-
-        if (len)
-        {
-            const auto oldFmt = is.format(IOstreamOption::BINARY);
-
-            // read(...) includes surrounding start/end delimiters
-            is.read(list.data(), std::streamsize(len));
-
-            is.format(oldFmt);
-
-            is.fatalCheck
-            (
-                "UList<char>::readList(Istream&) : "
-                "reading binary block"
-            );
-        }
-    }
-    else
-    {
-        FatalIOErrorInFunction(is)
-            << "incorrect first token, expected <int>, found "
-            << tok.info() << nl
-            << exit(FatalIOError);
-    }
-
-    return is;
-}
-
-
 template<>
 void UList<char>::operator=(const Foam::zero)
 {
diff --git a/src/OpenFOAM/primitives/strings/lists/hashedWordList.C b/src/OpenFOAM/primitives/strings/lists/hashedWordList.C
index f8737e5857..bd5e9217bb 100644
--- a/src/OpenFOAM/primitives/strings/lists/hashedWordList.C
+++ b/src/OpenFOAM/primitives/strings/lists/hashedWordList.C
@@ -35,7 +35,7 @@ void Foam::hashedWordList::rehash() const
     const label len = list.size();
 
     lookup_.clear();
-    lookup_.resize(2*len);
+    lookup_.reserve(len);
 
     for (label i = 0; i < len; ++i)
     {
@@ -50,7 +50,7 @@ void Foam::hashedWordList::uniq()
     const label len = list.size();
 
     lookup_.clear();
-    lookup_.resize(2*len);
+    lookup_.reserve(len);
 
     label count = 0;
 
diff --git a/src/OpenFOAM/primitives/strings/string/string.H b/src/OpenFOAM/primitives/strings/string/string.H
index f90c9c225a..878028e6b8 100644
--- a/src/OpenFOAM/primitives/strings/string/string.H
+++ b/src/OpenFOAM/primitives/strings/string/string.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2016-2022 OpenCFD Ltd.
+    Copyright (C) 2016-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -197,6 +197,21 @@ public:
 
     // Static Member Functions
 
+        //- Avoid masking the normal std::string length() method
+        using std::string::length;
+
+        //- Length of the character sequence (with nullptr protection)
+        static inline std::string::size_type length(const char* s)
+        {
+            return (s ? strlen(s) : 0);
+        }
+
+        //- The length of the string
+        static inline std::string::size_type length(const std::string& s)
+        {
+            return s.size();
+        }
+
         //- Does the string contain valid characters only?
         template<class StringType>
         static inline bool valid(const std::string& str);
diff --git a/src/OpenFOAM/primitives/strings/string/stringI.H b/src/OpenFOAM/primitives/strings/string/stringI.H
index 3f89a95198..aca1a202c5 100644
--- a/src/OpenFOAM/primitives/strings/string/stringI.H
+++ b/src/OpenFOAM/primitives/strings/string/stringI.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2015 OpenFOAM Foundation
-    Copyright (C) 2017-2022 OpenCFD Ltd.
+    Copyright (C) 2017-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -150,7 +150,7 @@ inline Foam::string::string(const size_type len, const char c)
 {}
 
 
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
 
 template<class StringType>
 inline bool Foam::string::valid(const std::string& str)
@@ -219,6 +219,8 @@ inline StringType Foam::string::validate(const std::string& str)
 }
 
 
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
 inline bool Foam::string::match(const std::string& text) const
 {
     return !compare(text);  // Always compare as literal string
diff --git a/src/OpenFOAM/primitives/strings/string/stringIO.C b/src/OpenFOAM/primitives/strings/string/stringIO.C
index c89aedc8d3..346ebce3e5 100644
--- a/src/OpenFOAM/primitives/strings/string/stringIO.C
+++ b/src/OpenFOAM/primitives/strings/string/stringIO.C
@@ -74,7 +74,7 @@ Foam::Istream& Foam::operator>>(Istream& is, string& val)
 
 Foam::Ostream& Foam::operator<<(Ostream& os, const string& val)
 {
-    os.write(val);
+    os.write(static_cast<const std::string&>(val));
     os.check(FUNCTION_NAME);
     return os;
 }
@@ -82,7 +82,7 @@ Foam::Ostream& Foam::operator<<(Ostream& os, const string& val)
 
 Foam::Ostream& Foam::operator<<(Ostream& os, const std::string& val)
 {
-    os.write(string(val));
+    os.write(val);
     os.check(FUNCTION_NAME);
     return os;
 }
diff --git a/src/OpenFOAM/primitives/strings/stringOps/stringOps.C b/src/OpenFOAM/primitives/strings/stringOps/stringOps.C
index 5413326a10..4ef6719911 100644
--- a/src/OpenFOAM/primitives/strings/stringOps/stringOps.C
+++ b/src/OpenFOAM/primitives/strings/stringOps/stringOps.C
@@ -690,6 +690,14 @@ static void expandString
 
 // * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
 
+std::string::size_type Foam::stringOps::count(const char* s, const char c)
+{
+    // or: size_t len = Foam::string::length(s);
+    size_t len = (s ? strlen(s) : 0);
+    return len ? std::count(s, (s + len), c) : 0;
+}
+
+
 std::string::size_type Foam::stringOps::count
 (
     const std::string& s,
@@ -700,13 +708,6 @@ std::string::size_type Foam::stringOps::count
 }
 
 
-std::string::size_type Foam::stringOps::count(const char* s, const char c)
-{
-    size_t len = (s ? strlen(s) : 0);
-    return len ? std::count(s, (s + len), c) : 0;
-}
-
-
 Foam::string Foam::stringOps::expand
 (
     const std::string& s,
diff --git a/src/OpenFOAM/primitives/strings/stringOps/stringOps.H b/src/OpenFOAM/primitives/strings/stringOps/stringOps.H
index 28fb6fb4d2..11807754ba 100644
--- a/src/OpenFOAM/primitives/strings/stringOps/stringOps.H
+++ b/src/OpenFOAM/primitives/strings/stringOps/stringOps.H
@@ -63,13 +63,13 @@ template<class T1, class T2> class Tuple2;
 
 namespace stringOps
 {
-    //- Count the number of occurrences of the specified character
-    std::string::size_type count(const std::string& s, const char c);
-
     //- Count the number of occurrences of the specified character
     //  Correctly handles nullptr.
     std::string::size_type count(const char* s, const char c);
 
+    //- Count the number of occurrences of the specified character
+    std::string::size_type count(const std::string& s, const char c);
+
     //- Return true if text matches one of the regular expressions.
     inline bool match(const UList<wordRe>& patterns, const std::string& text)
     {
diff --git a/src/conversion/polyDualMesh/polyDualMesh.C b/src/conversion/polyDualMesh/polyDualMesh.C
index 89b89bb7f7..f60f0106d7 100644
--- a/src/conversion/polyDualMesh/polyDualMesh.C
+++ b/src/conversion/polyDualMesh/polyDualMesh.C
@@ -1229,20 +1229,20 @@ void Foam::polyDualMesh::calcDual
     // Create cells.
     cellList dualCells(mesh.nPoints());
 
-    forAll(dualCells, celli)
-    {
-        dualCells[celli].setSize(0);
-    }
+    // unnecessary...
+    // forAll(dualCells, celli)
+    // {
+    //     dualCells[celli].clear();
+    // }
 
     forAll(dualOwner, facei)
     {
         label celli = dualOwner[facei];
 
-        labelList& cFaces = dualCells[celli];
-
-        label sz = cFaces.size();
-        cFaces.setSize(sz+1);
-        cFaces[sz] = facei;
+        if (celli != -1)
+        {
+            dualCells[celli].push_back(facei);
+        }
     }
     forAll(dualNeighbour, facei)
     {
@@ -1250,11 +1250,7 @@ void Foam::polyDualMesh::calcDual
 
         if (celli != -1)
         {
-            labelList& cFaces = dualCells[celli];
-
-            label sz = cFaces.size();
-            cFaces.setSize(sz+1);
-            cFaces[sz] = facei;
+            dualCells[celli].push_back(facei);
         }
     }
 
diff --git a/src/dynamicFvMesh/dynamicRefineFvMesh/dynamicRefineFvMesh.C b/src/dynamicFvMesh/dynamicRefineFvMesh/dynamicRefineFvMesh.C
index b32abd951f..ff8f00d5e5 100644
--- a/src/dynamicFvMesh/dynamicRefineFvMesh/dynamicRefineFvMesh.C
+++ b/src/dynamicFvMesh/dynamicRefineFvMesh/dynamicRefineFvMesh.C
@@ -184,7 +184,7 @@ void Foam::dynamicRefineFvMesh::readDict()
     auto fluxVelocities = refineDict.get<List<Pair<word>>>("correctFluxes");
 
     // Rework into hashtable.
-    correctFluxes_.resize(fluxVelocities.size());
+    correctFluxes_.reserve(fluxVelocities.size());
     for (const auto& pr : fluxVelocities)
     {
         correctFluxes_.insert(pr.first(), pr.second());
diff --git a/src/dynamicMesh/meshCut/meshModifiers/boundaryCutter/boundaryCutter.C b/src/dynamicMesh/meshCut/meshModifiers/boundaryCutter/boundaryCutter.C
index 8d27e71951..a58517cec3 100644
--- a/src/dynamicMesh/meshCut/meshModifiers/boundaryCutter/boundaryCutter.C
+++ b/src/dynamicMesh/meshCut/meshModifiers/boundaryCutter/boundaryCutter.C
@@ -408,7 +408,7 @@ void Foam::boundaryCutter::setRefinement
     edgeAddedPoints_.clear();
 
     faceAddedPoint_.clear();
-    faceAddedPoint_.resize(faceToFeaturePoint.size());
+    faceAddedPoint_.reserve(faceToFeaturePoint.size());
 
 
     //
@@ -813,7 +813,7 @@ void Foam::boundaryCutter::setRefinement
 
     // Convert edge to points storage from edge labels (not preserved)
     // to point labels
-    edgeAddedPoints_.resize(edgeToCuts.size());
+    edgeAddedPoints_.reserve(edgeToAddedPoints.size());
 
     forAllConstIters(edgeToAddedPoints, iter)
     {
@@ -832,7 +832,7 @@ void Foam::boundaryCutter::updateMesh(const mapPolyMesh& morphMap)
 
     {
         // Create copy since we're deleting entries.
-        Map<label> newAddedPoints(faceAddedPoint_.size());
+        Map<label> newAddedPoints(faceAddedPoint_.capacity());
 
         forAllConstIters(faceAddedPoint_, iter)
         {
@@ -860,7 +860,7 @@ void Foam::boundaryCutter::updateMesh(const mapPolyMesh& morphMap)
 
     {
         // Create copy since we're deleting entries
-        EdgeMap<labelList> newEdgeAddedPoints(edgeAddedPoints_.size());
+        EdgeMap<labelList> newEdgeAddedPoints(edgeAddedPoints_.capacity());
 
         forAllConstIters(edgeAddedPoints_, iter)
         {
diff --git a/src/dynamicMesh/meshCut/meshModifiers/meshCutAndRemove/meshCutAndRemove.C b/src/dynamicMesh/meshCut/meshModifiers/meshCutAndRemove/meshCutAndRemove.C
index 239ec27dbd..0468de2e5c 100644
--- a/src/dynamicMesh/meshCut/meshModifiers/meshCutAndRemove/meshCutAndRemove.C
+++ b/src/dynamicMesh/meshCut/meshModifiers/meshCutAndRemove/meshCutAndRemove.C
@@ -583,10 +583,10 @@ void Foam::meshCutAndRemove::setRefinement
 {
     // Clear and size maps here since mesh size will change.
     addedFaces_.clear();
-    addedFaces_.resize(cuts.nLoops());
+    addedFaces_.reserve(cuts.nLoops());
 
     addedPoints_.clear();
-    addedPoints_.resize(cuts.nLoops());
+    addedPoints_.reserve(cuts.nLoops());
 
     if (cuts.nLoops() == 0)
     {
diff --git a/src/dynamicMesh/meshCut/meshModifiers/meshCutter/meshCutter.C b/src/dynamicMesh/meshCut/meshModifiers/meshCutter/meshCutter.C
index d79b6c5918..37a800ab39 100644
--- a/src/dynamicMesh/meshCut/meshModifiers/meshCutter/meshCutter.C
+++ b/src/dynamicMesh/meshCut/meshModifiers/meshCutter/meshCutter.C
@@ -526,13 +526,13 @@ void Foam::meshCutter::setRefinement
 {
     // Clear and size maps here since mesh size will change.
     addedCells_.clear();
-    addedCells_.resize(cuts.nLoops());
+    addedCells_.reserve(cuts.nLoops());
 
     addedFaces_.clear();
-    addedFaces_.resize(cuts.nLoops());
+    addedFaces_.reserve(cuts.nLoops());
 
     addedPoints_.clear();
-    addedPoints_.resize(cuts.nLoops());
+    addedPoints_.reserve(cuts.nLoops());
 
     if (!returnReduceOr(cuts.nLoops()))
     {
diff --git a/src/dynamicMesh/polyMeshAdder/faceCoupleInfo.C b/src/dynamicMesh/polyMeshAdder/faceCoupleInfo.C
index 7b4bc566a7..bbe666c31f 100644
--- a/src/dynamicMesh/polyMeshAdder/faceCoupleInfo.C
+++ b/src/dynamicMesh/polyMeshAdder/faceCoupleInfo.C
@@ -514,7 +514,7 @@ void Foam::faceCoupleInfo::setCutEdgeToPoints(const labelList& cutToMasterEdges)
     const edgeList& cutEdges = cutFaces().edges();
 
     // Size extra big so searching is faster
-    cutEdgeToPoints_.resize
+    cutEdgeToPoints_.reserve
     (
         masterPatch().nEdges()
       + slavePatch().nEdges()
@@ -1254,7 +1254,7 @@ Foam::label Foam::faceCoupleInfo::matchEdgeFaces
 
     // For every unassigned cutFacei the possible list of master faces.
     candidates.clear();
-    candidates.resize(cutFaces().size());
+    candidates.reserve(cutFaces().size());
 
     label nChanged = 0;
 
diff --git a/src/dynamicMesh/polyMeshFilter/polyMeshFilter.C b/src/dynamicMesh/polyMeshFilter/polyMeshFilter.C
index 3d8a01bcb5..c63e3c0ca7 100644
--- a/src/dynamicMesh/polyMeshFilter/polyMeshFilter.C
+++ b/src/dynamicMesh/polyMeshFilter/polyMeshFilter.C
@@ -1006,7 +1006,7 @@ Foam::label Foam::polyMeshFilter::filterEdges
     label nOuterIterations = 0;
 
     minEdgeLen_.resize(mesh_.nEdges(), minLen());
-    faceFilterFactor_.resize(0);
+    faceFilterFactor_.clear();
 
     labelList pointErrorCount(mesh_.nPoints(), Zero);
 
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/addPatchCellLayer.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/addPatchCellLayer.C
index f0441afd67..c369d7246e 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/addPatchCellLayer.C
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/addPatchCellLayer.C
@@ -1884,7 +1884,7 @@ void Foam::addPatchCellLayer::setRefinement
     // For now just keep it connected to the original.
     {
         // Work space
-        Map<label> minPointValue(128);
+        Map<label> minPointValue;
         faceList oldBoundaryFaces(mesh_.nBoundaryFaces());
 
         while (true)
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/edgeCollapser.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/edgeCollapser.C
index 2e1b557c42..46df773fe2 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/edgeCollapser.C
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/edgeCollapser.C
@@ -1316,7 +1316,7 @@ bool Foam::edgeCollapser::setRefinement
         }
 
         // 2. Size
-        collapseStrings.resize(2*nPerIndex.size());
+        collapseStrings.reserve(nPerIndex.size());
         forAllConstIters(nPerIndex, iter)
         {
             collapseStrings.insert(iter.key(), DynamicList<label>(iter.val()));
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef8/hexRef8.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef8/hexRef8.C
index ad16095498..ce5548367c 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef8/hexRef8.C
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef8/hexRef8.C
@@ -4163,7 +4163,7 @@ void Foam::hexRef8::storeData
 )
 {
     savedPointLevel_.clear();
-    savedPointLevel_.resize(2*pointsToStore.size());
+    savedPointLevel_.reserve(pointsToStore.size());
     forAll(pointsToStore, i)
     {
         label pointi = pointsToStore[i];
@@ -4171,7 +4171,7 @@ void Foam::hexRef8::storeData
     }
 
     savedCellLevel_.clear();
-    savedCellLevel_.resize(2*cellsToStore.size());
+    savedCellLevel_.reserve(cellsToStore.size());
     forAll(cellsToStore, i)
     {
         label celli = cellsToStore[i];
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/removePoints.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/removePoints.C
index c2d9bf584a..9dbed92810 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/removePoints.C
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/removePoints.C
@@ -319,8 +319,8 @@ void Foam::removePoints::setRefinement
     // Size undo storage
     if (undoable_)
     {
-        savedPoints_.setSize(nDeleted);
-        pointToSaved.resize(2*nDeleted);
+        savedPoints_.resize(nDeleted);
+        pointToSaved.reserve(nDeleted);
     }
 
 
diff --git a/src/fileFormats/ensight/file/ensightFile.C b/src/fileFormats/ensight/file/ensightFile.C
index 19e9eb0b46..5d4ff28479 100644
--- a/src/fileFormats/ensight/file/ensightFile.C
+++ b/src/fileFormats/ensight/file/ensightFile.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2015 OpenFOAM Foundation
-    Copyright (C) 2016-2022 OpenCFD Ltd.
+    Copyright (C) 2016-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -147,13 +147,16 @@ float Foam::ensightFile::undefValue(float value) noexcept
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-Foam::Ostream& Foam::ensightFile::writeString(const char* str)
+Foam::Ostream& Foam::ensightFile::writeString(const char* str, size_t len)
 {
-    // Output 80 chars, but allocate for trailing nul character
-    // to avoid -Wstringop-truncation warnings/errors.
+    // Output 79 chars (ASCII) or 80 chars (BINARY)
+    char buf[80];
+    if (len > 80) len = 80;
 
-    char buf[80+1];
-    strncpy(buf, str, 80); // max 80 chars or padded with nul if smaller
+    // TBD: truncate at newline? (shouldn't really occur anyhow)
+
+    std::copy_n(str, len, buf);
+    std::fill_n(buf + len, (len - 80), '\0');  // Pad trailing with nul
 
     if (format() == IOstreamOption::BINARY)
     {
@@ -161,7 +164,7 @@ Foam::Ostream& Foam::ensightFile::writeString(const char* str)
     }
     else
     {
-        buf[79] = 0;  // max 79 in ASCII, ensure it is indeed nul-terminated
+        buf[79] = 0;  // Max 79 in ASCII
         stdStream() << buf;
         syncState();
     }
@@ -170,27 +173,33 @@ Foam::Ostream& Foam::ensightFile::writeString(const char* str)
 }
 
 
+Foam::Ostream& Foam::ensightFile::writeString(const char* str)
+{
+    return writeString(str, strlen(str));
+}
+
+
 Foam::Ostream& Foam::ensightFile::writeString(const std::string& str)
 {
-    return writeString(str.c_str());
+    return writeString(str.data(), str.size());
 }
 
 
 Foam::Ostream& Foam::ensightFile::write(const char* str)
 {
-    return writeString(str);
+    return writeString(str, strlen(str));
 }
 
 
 Foam::Ostream& Foam::ensightFile::write(const word& str)
 {
-    return writeString(str);
+    return writeString(str.data(), str.size());
 }
 
 
-Foam::Ostream& Foam::ensightFile::write(const string& str)
+Foam::Ostream& Foam::ensightFile::write(const std::string& str)
 {
-    return writeString(str);
+    return writeString(str.data(), str.size());
 }
 
 
diff --git a/src/fileFormats/ensight/file/ensightFile.H b/src/fileFormats/ensight/file/ensightFile.H
index b35dd97558..e472f25720 100644
--- a/src/fileFormats/ensight/file/ensightFile.H
+++ b/src/fileFormats/ensight/file/ensightFile.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2015 OpenFOAM Foundation
-    Copyright (C) 2016-2022 OpenCFD Ltd.
+    Copyright (C) 2016-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -145,13 +145,12 @@ public:
 
     // Output
 
-        //- Write element keyword with trailing newline,
-        //- optionally with undef and the value for undefined
-        virtual Ostream& writeKeyword(const keyType& key);
-
         //- Write "C Binary" string for binary files (eg, geometry/measured)
         Ostream& writeBinaryHeader();
 
+        //- Write character/string content as "%79s" or as binary (max 80 chars)
+        Ostream& writeString(const char* str, size_t len);
+
         //- Write C-string as "%79s" or as binary (max 80 chars)
         Ostream& writeString(const char* str);
 
@@ -162,46 +161,50 @@ public:
         Ostream& writeUndef();
 
 
+        //- Write element keyword with trailing newline,
+        //- optionally with undef and the value for undefined
+        virtual Ostream& writeKeyword(const keyType& key) override;
+
         //- Writing token does not make sense
-        virtual bool write(const token&)
+        virtual bool write(const token&) override
         {
             NotImplemented;
             return false;
         }
 
         //- Writing single character does not make sense
-        virtual Ostream& write(const char)
+        virtual Ostream& write(const char) override
         {
             NotImplemented;
             return *this;
         }
 
         //- Binary write
-        virtual Ostream& write(const char* buf, std::streamsize count);
+        virtual Ostream& write(const char* buf, std::streamsize count) override;
 
         //- Write C-string, uses writeString()
-        virtual Ostream& write(const char* str);
+        virtual Ostream& write(const char* str) override;
 
         //- Write word, uses writeString()
-        virtual Ostream& write(const word& str);
+        virtual Ostream& write(const word& str) override;
 
         //- Write string, uses writeString()
-        virtual Ostream& write(const string& str);
+        virtual Ostream& write(const std::string& str) override;
 
         //- Write integer as "%10d" or as binary
-        virtual Ostream& write(const int32_t val);
+        virtual Ostream& write(const int32_t val) override;
 
         //- Write integer as "%10d" or as binary
-        virtual Ostream& write(const int64_t val);
+        virtual Ostream& write(const int64_t val) override;
 
         //- Write integer with specified width or as binary
         Ostream& write(const label value, const label fieldWidth);
 
         //- Write floating-point as "%12.5e" or as binary
-        virtual Ostream& write(const float val);
+        virtual Ostream& write(const float val) override;
 
         //- Write floating-point as "%12.5e" or as binary (narrowed to float)
-        virtual Ostream& write(const double val);
+        virtual Ostream& write(const double val) override;
 
         //- Add carriage return to ascii stream
         void newline();
diff --git a/src/fileFormats/ensight/read/ensightReadFile.H b/src/fileFormats/ensight/read/ensightReadFile.H
index 6982ae9072..f11cead56e 100644
--- a/src/fileFormats/ensight/read/ensightReadFile.H
+++ b/src/fileFormats/ensight/read/ensightReadFile.H
@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2016-2022 OpenCFD Ltd.
+    Copyright (C) 2016-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -96,22 +96,22 @@ public:
         using Istream::read;
 
         //- Binary read
-        virtual Istream& read(char* buf, std::streamsize count);
+        virtual Istream& read(char* buf, std::streamsize count) override;
 
         //- Read string as "%80s" or as binary
-        virtual Istream& read(string& value);
+        virtual Istream& read(string& value) override;
 
         //- Read integer as "%10d" or as binary
-        virtual Istream& read(label& value);
+        virtual Istream& read(label& value) override;
 
         //- Read floating-point as "%12.5e" or as binary
-        virtual Istream& read(float& value);
+        virtual Istream& read(float& value) override;
 
         //- Read floating-point as "%12.5e" or as a binary (narrowed) float
-        virtual Istream& read(double& value);
+        virtual Istream& read(double& value) override;
 
-        //- Read element keyword
-        virtual Istream& readKeyword(string& key);
+        //- Read element keyword. Currently the same as read(string)
+        Istream& readKeyword(string& key);
 
         //- Read "C Binary" for binary files (eg, geometry/measured)
         Istream& readBinaryHeader();
diff --git a/src/fileFormats/obj/OBJstream.C b/src/fileFormats/obj/OBJstream.C
index c998c6a0ab..2a94fbca71 100644
--- a/src/fileFormats/obj/OBJstream.C
+++ b/src/fileFormats/obj/OBJstream.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2012-2016 OpenFOAM Foundation
-    Copyright (C) 2020-2022 OpenCFD Ltd.
+    Copyright (C) 2020-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -40,7 +40,7 @@ namespace Foam
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-void Foam::OBJstream::writeAndCheck(const char c)
+inline void Foam::OBJstream::vertex_state(const char c)
 {
     if (c == '\n')
     {
@@ -54,8 +54,6 @@ void Foam::OBJstream::writeAndCheck(const char c)
             ++nVertices_;
         }
     }
-
-    OFstream::write(c);
 }
 
 
@@ -77,16 +75,51 @@ Foam::OBJstream::OBJstream
 
 Foam::Ostream& Foam::OBJstream::write(const char c)
 {
-    writeAndCheck(c);
+    OFstream::write(c);
+    vertex_state(c);
+    return *this;
+}
+
+
+Foam::Ostream& Foam::OBJstream::writeQuoted
+(
+    const char* str,
+    std::streamsize len,
+    const bool quoted
+)
+{
+    OFstream::writeQuoted(str, len, quoted);
+
+    // NOTE:
+    // Since vertex_state() handling only tracks newline followed by
+    // an initial 'v' (vertex) character, it probably should not be possible
+    // to triggered from within a quoted string.
+
+    if (str && len >= 0)
+    {
+        if (quoted) vertex_state(0);  // Begin quote: reset state
+
+        const char* last = (str + len);
+
+        // std::for_each
+        for (const char* iter = str; iter != last; ++iter)
+        {
+            vertex_state(*iter);
+        }
+
+        if (quoted) vertex_state(0);  // End quote
+    }
+
     return *this;
 }
 
 
 Foam::Ostream& Foam::OBJstream::write(const char* str)
 {
+    OFstream::write(str);
     for (const char* iter = str; *iter; ++iter)
     {
-        writeAndCheck(*iter);
+        vertex_state(*iter);
     }
     return *this;
 }
@@ -94,68 +127,54 @@ Foam::Ostream& Foam::OBJstream::write(const char* str)
 
 Foam::Ostream& Foam::OBJstream::write(const word& str)
 {
-    return writeQuoted(str, false);
+    return writeQuoted(str.data(), str.size(), false);
 }
 
 
-Foam::Ostream& Foam::OBJstream::write(const string& str)
+Foam::Ostream& Foam::OBJstream::write(const std::string& str)
 {
-    return writeQuoted(str, true);
+    return writeQuoted(str.data(), str.size(), true);
 }
 
 
-Foam::Ostream& Foam::OBJstream::writeQuoted
-(
-    const std::string& str,
-    const bool quoted
-)
+Foam::Ostream& Foam::OBJstream::writeComment(const std::string& str)
 {
-    if (!quoted)
+    if (!startOfLine_)
     {
-        // Output unquoted, only advance line number on newline
-        for (auto iter = str.cbegin(); iter != str.cend(); ++iter)
-        {
-            writeAndCheck(*iter);
-        }
+        OFstream::write('\n');
+        startOfLine_ = true;
+    }
+
+    if (str.empty())
+    {
+        OFstream::write("#\n");
+        startOfLine_ = true;
         return *this;
     }
 
-    // Output with surrounding quotes and backslash escaping
-    OFstream::write(static_cast<char>(token::DQUOTE));
+    const char* iter = str.data();
+    const char* last = (str.data() + str.size());
 
-    unsigned backslash = 0;
-    for (auto iter = str.cbegin(); iter != str.cend(); ++iter)
+    // std::for_each
+    for (; iter != last; ++iter)
     {
         const char c = *iter;
 
-        if (c == '\\')
+        if (startOfLine_)
         {
-            ++backslash;
-            continue; // only output after escaped character is known
-        }
-        else if (c == token::NL)
-        {
-            ++lineNumber_;
-            ++backslash;    // backslash escape for newline
-        }
-        else if (c == token::DQUOTE)
-        {
-            ++backslash;    // backslash escape for quote
+            OFstream::write("# ");
+            startOfLine_ = false;
         }
 
-        // output all pending backslashes
-        while (backslash)
-        {
-            OFstream::write('\\');
-            --backslash;
-        }
-
-        writeAndCheck(c);
+        startOfLine_ = (c == '\n');
+        OFstream::write(c);
     }
 
-    // silently drop any trailing backslashes
-    // they would otherwise appear like an escaped end-quote
-    OFstream::write(static_cast<char>(token::DQUOTE));
+    if (!startOfLine_)
+    {
+        OFstream::write('\n');
+        startOfLine_ = true;
+    }
 
     return *this;
 }
diff --git a/src/fileFormats/obj/OBJstream.H b/src/fileFormats/obj/OBJstream.H
index 7ab96b146a..f391c415e2 100644
--- a/src/fileFormats/obj/OBJstream.H
+++ b/src/fileFormats/obj/OBJstream.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2012-2015 OpenFOAM Foundation
-    Copyright (C) 2017-2022 OpenCFD Ltd.
+    Copyright (C) 2017-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -70,7 +70,9 @@ class OBJstream
 
     // Private Member Functions
 
-        void writeAndCheck(const char c);
+        //- State engine to count number of vertices.
+        //- Triggered on newline and 'v' (vertex).
+        inline void vertex_state(const char c);
 
 public:
 
@@ -105,104 +107,107 @@ public:
 
     // Member Functions
 
+    // Access
+
         //- Return the number of vertices written
-        label nVertices() const noexcept
-        {
-            return nVertices_;
-        }
+        label nVertices() const noexcept { return nVertices_; }
 
 
-        // Ostream implementation
+    // Write Functions
 
-            //- Inherit write from Ostream
-            using Ostream::write;
+        //- Inherit write methods from OFstream
+        using OFstream::write;
+        using OFstream::writeQuoted;
 
-            //- Write character
-            virtual Ostream& write(const char c);
+        //- Write character
+        virtual Ostream& write(const char c) override;
 
-            //- Write character string
-            virtual Ostream& write(const char* str);
+        //- Write character/string content, with/without surrounding quotes
+        virtual Ostream& writeQuoted
+        (
+            const char* str,
+            std::streamsize len,
+            const bool quoted=true
+        ) override;
 
-            //- Write word
-            virtual Ostream& write(const word& str);
+        //- Write character string
+        virtual Ostream& write(const char* str) override;
 
-            //- Write string
-            virtual Ostream& write(const string& str);
+        //- Write word
+        virtual Ostream& write(const word& str) override;
 
-            //- Write std::string surrounded by quotes.
-            //  Optional write without quotes.
-            virtual Ostream& writeQuoted
-            (
-                const std::string& str,
-                const bool quoted=true
-            );
+        //- Write string
+        virtual Ostream& write(const std::string& str) override;
 
 
-        // Direct write functionality
+    // Direct write functionality
 
-            //- Write point
-            Ostream& write(const point& p);
+        //- Write comment (with '# ' prefix)
+        Ostream& writeComment(const std::string& str);
 
-            //- Write point and vector normal ('vn')
-            Ostream& write(const point& p, const vector& n);
+        //- Write point (vertex)
+        Ostream& write(const point& p);
 
-            //- Write multiple points
-            Ostream& write(const UList<point>& points);
+        //- Write point and vector normal ('vn')
+        Ostream& write(const point& p, const vector& n);
 
-            //- Write edge as points with line
-            Ostream& write(const edge& e, const UList<point>& points);
+        //- Write multiple points
+        Ostream& write(const UList<point>& points);
 
-            //- Write line
-            Ostream& write(const linePointRef& ln);
+        //- Write edge as points with line
+        Ostream& write(const edge& e, const UList<point>& points);
 
-            //- Write line with points and vector normals ('vn')
-            Ostream& write
-            (
-                const linePointRef& ln,
-                const vector& n0,
-                const vector& n1
-            );
+        //- Write line
+        Ostream& write(const linePointRef& ln);
 
-            //- Write line joining two points
-            Ostream& writeLine(const point& p0, const point& p1);
+        //- Write line with points and vector normals ('vn')
+        Ostream& write
+        (
+            const linePointRef& ln,
+            const vector& n0,
+            const vector& n1
+        );
 
-            //- Write triangle as points with lines/filled-polygon
-            Ostream& write(const triPointRef& f, const bool lines = true);
+        //- Write line joining two points
+        Ostream& writeLine(const point& p0, const point& p1);
 
-            //- Write face loop points with lines/filled-polygon
-            Ostream& writeFace
-            (
-                const UList<point>& points,
-                const bool lines = true
-            );
+        //- Write triangle as points with lines/filled-polygon
+        Ostream& write(const triPointRef& f, const bool lines = true);
 
-            //- Write face as points with lines/filled-polygon
-            Ostream& write
-            (
-                const face& f,
-                const UList<point>& points,
-                const bool lines = true
-            );
+        //- Write face loop points with lines/filled-polygon
+        Ostream& writeFace
+        (
+            const UList<point>& points,
+            const bool lines = true
+        );
 
-            //- Write patch faces as points with lines/filled-polygon
-            Ostream& write
-            (
-                const UList<face>& faces,
-                const pointField& points,
-                const bool lines = true
-            );
+        //- Write face as points with lines/filled-polygon
+        Ostream& write
+        (
+            const face& f,
+            const UList<point>& points,
+            const bool lines = true
+        );
 
-            //- Write edges as points with lines.
-            //  Optionally eliminate unused points.
-            Ostream& write
-            (
-                const UList<edge>& edges,
-                const UList<point>& points,
-                const bool compact = false
-            );
+        //- Write patch faces as points with lines/filled-polygon
+        Ostream& write
+        (
+            const UList<face>& faces,
+            const pointField& points,
+            const bool lines = true
+        );
 
-            //- Write tree-bounding box with lines/filled-polygons
-            Ostream& write(const treeBoundBox& bb, const bool lines = true);
+        //- Write edges as points with lines.
+        //  Optionally eliminate unused points.
+        Ostream& write
+        (
+            const UList<edge>& edges,
+            const UList<point>& points,
+            const bool compact = false
+        );
+
+        //- Write tree-bounding box with lines/filled-polygons
+        Ostream& write(const treeBoundBox& bb, const bool lines = true);
 };
 
 
diff --git a/src/finiteArea/faMesh/faBoundaryMesh/faBoundaryMesh.C b/src/finiteArea/faMesh/faBoundaryMesh/faBoundaryMesh.C
index 8717ef5af3..2417132a1e 100644
--- a/src/finiteArea/faMesh/faBoundaryMesh/faBoundaryMesh.C
+++ b/src/finiteArea/faMesh/faBoundaryMesh/faBoundaryMesh.C
@@ -490,7 +490,7 @@ Foam::labelList Foam::faBoundaryMesh::indices
     {
         if (checkGroups)
         {
-            ids.resize(2*this->size());
+            ids.reserve(this->size());
 
             const auto& groupLookup = groupPatchIDs();
             forAllConstIters(groupLookup, iter)
@@ -559,7 +559,7 @@ Foam::labelList Foam::faBoundaryMesh::indices
     // Only check groups if requested and they exist
     if (useGroups && this->hasGroupIDs())
     {
-        ids.resize(2*this->size());
+        ids.reserve(this->size());
 
         const auto& groupLookup = groupPatchIDs();
         forAllConstIters(groupLookup, iter)
@@ -604,7 +604,7 @@ Foam::labelList Foam::faBoundaryMesh::indices
     // Only check groups if requested and they exist
     if (useGroups && this->hasGroupIDs())
     {
-        ids.resize(2*this->size());
+        ids.reserve(this->size());
 
         const auto& groupLookup = groupPatchIDs();
         forAllConstIters(groupLookup, iter)
diff --git a/src/finiteVolume/fvMesh/extendedStencil/cellToCell/globalIndexStencils/CECCellToCellStencil.C b/src/finiteVolume/fvMesh/extendedStencil/cellToCell/globalIndexStencils/CECCellToCellStencil.C
index 496abb1ddb..4e6698efb7 100644
--- a/src/finiteVolume/fvMesh/extendedStencil/cellToCell/globalIndexStencils/CECCellToCellStencil.C
+++ b/src/finiteVolume/fvMesh/extendedStencil/cellToCell/globalIndexStencils/CECCellToCellStencil.C
@@ -39,7 +39,7 @@ void Foam::CECCellToCellStencil::calcEdgeBoundaryData
     EdgeMap<labelList>& neiGlobal
 ) const
 {
-    neiGlobal.resize(2*boundaryEdges.size());
+    neiGlobal.reserve(boundaryEdges.size());
 
     labelHashSet edgeGlobals;
 
diff --git a/src/finiteVolume/fvMesh/extendedStencil/cellToCell/globalIndexStencils/CPCCellToCellStencil.C b/src/finiteVolume/fvMesh/extendedStencil/cellToCell/globalIndexStencils/CPCCellToCellStencil.C
index d62d13c4fd..c39ac159b6 100644
--- a/src/finiteVolume/fvMesh/extendedStencil/cellToCell/globalIndexStencils/CPCCellToCellStencil.C
+++ b/src/finiteVolume/fvMesh/extendedStencil/cellToCell/globalIndexStencils/CPCCellToCellStencil.C
@@ -38,7 +38,7 @@ void Foam::CPCCellToCellStencil::calcPointBoundaryData
     Map<labelList>& neiGlobal
 ) const
 {
-    neiGlobal.resize(2*boundaryPoints.size());
+    neiGlobal.reserve(boundaryPoints.size());
 
     labelHashSet pointGlobals;
 
diff --git a/src/finiteVolume/fvMesh/extendedStencil/cellToFace/globalIndexStencils/FECCellToFaceStencil.C b/src/finiteVolume/fvMesh/extendedStencil/cellToFace/globalIndexStencils/FECCellToFaceStencil.C
index afc9845ac3..63ed3f7840 100644
--- a/src/finiteVolume/fvMesh/extendedStencil/cellToFace/globalIndexStencils/FECCellToFaceStencil.C
+++ b/src/finiteVolume/fvMesh/extendedStencil/cellToFace/globalIndexStencils/FECCellToFaceStencil.C
@@ -40,7 +40,7 @@ void Foam::FECCellToFaceStencil::calcEdgeBoundaryData
     EdgeMap<labelList>& neiGlobal
 ) const
 {
-    neiGlobal.resize(2*boundaryEdges.size());
+    neiGlobal.reserve(boundaryEdges.size());
 
     labelHashSet edgeGlobals;
 
diff --git a/src/finiteVolume/fvMesh/wallDist/wallDistAddressing/wallDistAddressing.C b/src/finiteVolume/fvMesh/wallDist/wallDistAddressing/wallDistAddressing.C
index c6639c2857..e7f21e66b2 100644
--- a/src/finiteVolume/fvMesh/wallDist/wallDistAddressing/wallDistAddressing.C
+++ b/src/finiteVolume/fvMesh/wallDist/wallDistAddressing/wallDistAddressing.C
@@ -222,7 +222,7 @@ void Foam::wallDistAddressing::correct(volScalarField& y)
     Map<label> cellToWallFace;
     if (correctWalls_)
     {
-        cellToWallFace.resize(2*nWalls);
+        cellToWallFace.reserve(nWalls);
         correctBoundaryFaceCells
         (
             patchSet,
diff --git a/src/finiteVolume/fvMesh/zoneDistribute/zoneStencils/zoneCPCStencil.C b/src/finiteVolume/fvMesh/zoneDistribute/zoneStencils/zoneCPCStencil.C
index c32751b733..8f6ae13f09 100644
--- a/src/finiteVolume/fvMesh/zoneDistribute/zoneStencils/zoneCPCStencil.C
+++ b/src/finiteVolume/fvMesh/zoneDistribute/zoneStencils/zoneCPCStencil.C
@@ -91,7 +91,7 @@ void Foam::zoneCPCStencil::calcPointBoundaryData
     Map<labelList>& neiGlobal
 ) const
 {
-    neiGlobal.resize(2*boundaryPoints.size());
+    neiGlobal.reserve(boundaryPoints.size());
 
     labelHashSet pointGlobals;
 
diff --git a/src/functionObjects/field/nearWallFields/nearWallFields.C b/src/functionObjects/field/nearWallFields/nearWallFields.C
index 5aeaf99c93..45c0a87c13 100644
--- a/src/functionObjects/field/nearWallFields/nearWallFields.C
+++ b/src/functionObjects/field/nearWallFields/nearWallFields.C
@@ -284,8 +284,8 @@ bool Foam::functionObjects::nearWallFields::read(const dictionary& dict)
     // Generate fields with mappedField boundary condition
 
     // Convert field to map
-    fieldMap_.resize(2*fieldSet_.size());
-    reverseFieldMap_.resize(2*fieldSet_.size());
+    fieldMap_.reserve(fieldSet_.size());
+    reverseFieldMap_.reserve(fieldSet_.size());
     forAll(fieldSet_, seti)
     {
         const word& fldName = fieldSet_[seti].first();
diff --git a/src/fvAgglomerationMethods/MGridGenGamgAgglomeration/MGridGenGAMGAgglomeration.C b/src/fvAgglomerationMethods/MGridGenGamgAgglomeration/MGridGenGAMGAgglomeration.C
index 83f7c096e8..aaf99f953e 100644
--- a/src/fvAgglomerationMethods/MGridGenGamgAgglomeration/MGridGenGAMGAgglomeration.C
+++ b/src/fvAgglomerationMethods/MGridGenGamgAgglomeration/MGridGenGAMGAgglomeration.C
@@ -147,7 +147,7 @@ void Foam::MGridGenGAMGAgglomeration::detectSharedFaces
     const labelUList& upper = addr.upperAddr();
 
     sharedFaces.clear();
-    sharedFaces.resize(addr.lowerAddr().size()/100);
+    sharedFaces.reserve(addr.lowerAddr().size()/100);
 
     // Detect any faces inbetween same value
     forAll(lower, facei)
diff --git a/src/fvAgglomerationMethods/pairPatchAgglomeration/pairPatchAgglomeration.C b/src/fvAgglomerationMethods/pairPatchAgglomeration/pairPatchAgglomeration.C
index 8bc9ed667e..16314968ad 100644
--- a/src/fvAgglomerationMethods/pairPatchAgglomeration/pairPatchAgglomeration.C
+++ b/src/fvAgglomerationMethods/pairPatchAgglomeration/pairPatchAgglomeration.C
@@ -175,7 +175,7 @@ void Foam::pairPatchAgglomeration::setEdgeWeights
 
     // Clean old weights
     facePairWeight_.clear();
-    facePairWeight_.resize(coarsePatch.nEdges());
+    facePairWeight_.reserve(coarsePatch.nEdges());
 
     for (label i = 0; i < coarsePatch.nInternalEdges(); i++)
     {
diff --git a/src/fvOptions/sources/general/semiImplicitSource/SemiImplicitSource.C b/src/fvOptions/sources/general/semiImplicitSource/SemiImplicitSource.C
index 1011eb1823..c8830ae3d7 100644
--- a/src/fvOptions/sources/general/semiImplicitSource/SemiImplicitSource.C
+++ b/src/fvOptions/sources/general/semiImplicitSource/SemiImplicitSource.C
@@ -63,18 +63,18 @@ void Foam::fv::SemiImplicitSource<Type>::setFieldCoeffs
 
     Su_.clear();
     Sp_.clear();
-    Su_.resize(2*count);
-    Sp_.resize(2*count);
+    Su_.reserve(count);
+    Sp_.reserve(count);
 
     driverSu_.clear();
     driverSp_.clear();
-    driverSu_.resize(2*count);
-    driverSp_.resize(2*count);
+    driverSu_.reserve(count);
+    driverSp_.reserve(count);
 
     valueExprSu_.clear();
     valueExprSp_.clear();
-    valueExprSu_.resize(2*count);
-    valueExprSp_.resize(2*count);
+    valueExprSu_.reserve(count);
+    valueExprSp_.reserve(count);
 
     fv::option::resetApplied();
 
diff --git a/src/lagrangian/basic/InteractionLists/InteractionLists.C b/src/lagrangian/basic/InteractionLists/InteractionLists.C
index 28609e9891..8bbd96b67b 100644
--- a/src/lagrangian/basic/InteractionLists/InteractionLists.C
+++ b/src/lagrangian/basic/InteractionLists/InteractionLists.C
@@ -445,7 +445,7 @@ void Foam::InteractionLists<ParticleType>::buildInteractionLists()
     // At this point, wallFaceBbsToExchange does not need to be
     // maintained or distributed as it is not longer needed.
 
-    wallFaceBbsToExchange.setSize(0);
+    wallFaceBbsToExchange.clear();
 
     wallFaceMap().reverseDistribute
     (
@@ -615,9 +615,9 @@ void Foam::InteractionLists<ParticleType>::findExtendedProcBbsInRange
     List<label>& extendedProcBbsOrigProc
 )
 {
-    extendedProcBbsInRange.setSize(0);
-    extendedProcBbsTransformIndex.setSize(0);
-    extendedProcBbsOrigProc.setSize(0);
+    extendedProcBbsInRange.clear();
+    extendedProcBbsTransformIndex.clear();
+    extendedProcBbsOrigProc.clear();
 
     DynamicList<treeBoundBox> tmpExtendedProcBbsInRange;
     DynamicList<label> tmpExtendedProcBbsTransformIndex;
diff --git a/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
index 1c0268b575..91e697ed6e 100644
--- a/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
+++ b/src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
@@ -234,7 +234,7 @@ void Foam::cyclicAMIPolyPatch::calcTransforms
 
             const_cast<tensorField&>(forwardT()) = tensorField(1, revT.T());
             const_cast<tensorField&>(reverseT()) = tensorField(1, revT);
-            const_cast<vectorField&>(separation()).setSize(0);
+            const_cast<vectorField&>(separation()).clear();
             const_cast<boolList&>(collocated()) = boolList(1, false);
 
             break;
@@ -269,7 +269,7 @@ void Foam::cyclicAMIPolyPatch::calcTransforms
 
             const_cast<tensorField&>(forwardT()).clear();
             const_cast<tensorField&>(reverseT()).clear();
-            const_cast<vectorField&>(separation()).setSize(0);
+            const_cast<vectorField&>(separation()).clear();
             const_cast<boolList&>(collocated()) = boolList(1, true);
 
             break;
diff --git a/src/meshTools/polyTopoChange/polyTopoChange.C b/src/meshTools/polyTopoChange/polyTopoChange.C
index 60b0cc76a9..3756807f04 100644
--- a/src/meshTools/polyTopoChange/polyTopoChange.C
+++ b/src/meshTools/polyTopoChange/polyTopoChange.C
@@ -2890,7 +2890,7 @@ void Foam::polyTopoChange::removeFace
             << abort(FatalError);
     }
 
-    faces_[facei].setSize(0);
+    faces_[facei].clear();
     region_[facei] = -1;
     faceOwner_[facei] = -1;
     faceNeighbour_[facei] = -1;
diff --git a/src/meshTools/regionSplit/localPointRegion.C b/src/meshTools/regionSplit/localPointRegion.C
index 02d2e8aea3..c4dd9b2eef 100644
--- a/src/meshTools/regionSplit/localPointRegion.C
+++ b/src/meshTools/regionSplit/localPointRegion.C
@@ -684,7 +684,7 @@ Foam::List<Foam::labelPair> Foam::localPointRegion::findDuplicateFacePairs
 void Foam::localPointRegion::updateMesh(const mapPolyMesh& map)
 {
     {
-        Map<label> newMap(meshFaceMap_.size());
+        Map<label> newMap(2*meshFaceMap_.size());
 
         forAllConstIters(meshFaceMap_, iter)
         {
@@ -698,7 +698,7 @@ void Foam::localPointRegion::updateMesh(const mapPolyMesh& map)
         meshFaceMap_.transfer(newMap);
     }
     {
-        Map<label> newMap(meshPointMap_.size());
+        Map<label> newMap(2*meshPointMap_.size());
 
         forAllConstIters(meshPointMap_, iter)
         {
diff --git a/src/meshTools/regionSplit/regionSplit.C b/src/meshTools/regionSplit/regionSplit.C
index 20ca5ece34..9e02486ed5 100644
--- a/src/meshTools/regionSplit/regionSplit.C
+++ b/src/meshTools/regionSplit/regionSplit.C
@@ -721,17 +721,16 @@ Foam::regionSplit::reduceRegionsImpl
     labelListList sendNonLocal(Pstream::nProcs());
 
     {
-        List<labelHashSet> nonLocal(Pstream::nProcs(), labelHashSet(0));
+        List<labelHashSet> nonLocal(Pstream::nProcs());
 
         // Use estimate of sizing for non-local regions
+        label estimatedCount((nLocalRegions-nCompact)/Pstream::nProcs());
+
         forAll(nonLocal, proci)
         {
             if (proci != Pstream::myProcNo())
             {
-                nonLocal[proci].resize
-                (
-                    2*((nLocalRegions-nCompact)/Pstream::nProcs())
-                );
+                nonLocal[proci].reserve(estimatedCount);
             }
         }
 
diff --git a/src/meshTools/searchableSurfaces/triSurfaceMesh/triSurfaceMesh.C b/src/meshTools/searchableSurfaces/triSurfaceMesh/triSurfaceMesh.C
index 0cc6121635..a834769306 100644
--- a/src/meshTools/searchableSurfaces/triSurfaceMesh/triSurfaceMesh.C
+++ b/src/meshTools/searchableSurfaces/triSurfaceMesh/triSurfaceMesh.C
@@ -117,7 +117,7 @@ bool Foam::triSurfaceMesh::isSurfaceClosed() const
     // Every edge should be used by two faces exactly.
     // To prevent doing work twice per edge only look at edges to higher
     // point
-    EdgeMap<label> facesPerEdge(128);
+    EdgeMap<label> facesPerEdge;
     forAll(pointFaces, pointi)
     {
         const labelList& pFaces = pointFaces[pointi];
diff --git a/src/meshTools/topoSet/topoSets/cellSet.C b/src/meshTools/topoSet/topoSets/cellSet.C
index 4e2ca99bc3..7df945566e 100644
--- a/src/meshTools/topoSet/topoSets/cellSet.C
+++ b/src/meshTools/topoSet/topoSets/cellSet.C
@@ -220,7 +220,7 @@ void Foam::cellSet::distribute(const mapDistributePolyMesh& map)
     // Update labelHashSet
 
     labels.clear();
-    labels.resize(2*n);
+    labels.reserve(n);
 
     for (label i=0; i < len; ++i)
     {
diff --git a/src/meshTools/topoSet/topoSets/cellZoneSet.C b/src/meshTools/topoSet/topoSets/cellZoneSet.C
index 6e9876439a..28ab5ac500 100644
--- a/src/meshTools/topoSet/topoSets/cellZoneSet.C
+++ b/src/meshTools/topoSet/topoSets/cellZoneSet.C
@@ -50,7 +50,7 @@ void Foam::cellZoneSet::updateSet()
     inplaceReorder(order, addressing_);
 
     cellSet::clearStorage();
-    cellSet::resize(2*addressing_.size());
+    cellSet::reserve(addressing_.size());
     cellSet::set(addressing_);
 }
 
diff --git a/src/meshTools/topoSet/topoSets/faceSet.C b/src/meshTools/topoSet/topoSets/faceSet.C
index 053ee10527..1a87e4f9b7 100644
--- a/src/meshTools/topoSet/topoSets/faceSet.C
+++ b/src/meshTools/topoSet/topoSets/faceSet.C
@@ -199,7 +199,7 @@ void Foam::faceSet::distribute(const mapDistributePolyMesh& map)
     // Update labelHashSet
 
     labels.clear();
-    labels.resize(2*n);
+    labels.reserve(n);
 
     for (label i=0; i < len; ++i)
     {
diff --git a/src/meshTools/topoSet/topoSets/faceZoneSet.C b/src/meshTools/topoSet/topoSets/faceZoneSet.C
index 5ea533e8f8..41177225c1 100644
--- a/src/meshTools/topoSet/topoSets/faceZoneSet.C
+++ b/src/meshTools/topoSet/topoSets/faceZoneSet.C
@@ -55,7 +55,7 @@ void Foam::faceZoneSet::updateSet()
     flipMap_ = boolUIndList(flipMap_, order)();
 
     faceSet::clearStorage();
-    faceSet::resize(2*addressing_.size());
+    faceSet::reserve(addressing_.size());
     faceSet::set(addressing_);
 }
 
diff --git a/src/meshTools/topoSet/topoSets/pointSet.C b/src/meshTools/topoSet/topoSets/pointSet.C
index 68e3b87e44..6c4bc3a862 100644
--- a/src/meshTools/topoSet/topoSets/pointSet.C
+++ b/src/meshTools/topoSet/topoSets/pointSet.C
@@ -201,7 +201,7 @@ void Foam::pointSet::distribute(const mapDistributePolyMesh& map)
     // Update labelHashSet
 
     labels.clear();
-    labels.resize(2*n);
+    labels.reserve(n);
 
     for (label i=0; i < len; ++i)
     {
diff --git a/src/meshTools/topoSet/topoSets/pointZoneSet.C b/src/meshTools/topoSet/topoSets/pointZoneSet.C
index c5392867e3..cd0e151d61 100644
--- a/src/meshTools/topoSet/topoSets/pointZoneSet.C
+++ b/src/meshTools/topoSet/topoSets/pointZoneSet.C
@@ -51,7 +51,7 @@ void Foam::pointZoneSet::updateSet()
     inplaceReorder(order, addressing_);
 
     pointSet::clearStorage();
-    pointSet::resize(2*addressing_.size());
+    pointSet::reserve(addressing_.size());
     pointSet::set(addressing_);
 }
 
diff --git a/src/meshTools/topoSet/topoSets/topoSet.C b/src/meshTools/topoSet/topoSets/topoSet.C
index 31e47c8981..f83680e0e8 100644
--- a/src/meshTools/topoSet/topoSets/topoSet.C
+++ b/src/meshTools/topoSet/topoSets/topoSet.C
@@ -534,7 +534,7 @@ void Foam::topoSet::invert(const label maxLen)
     );
 
     clear();  // Maybe don't trust the previous move operation
-    resize(2*max(64, (maxLen - original.size())));
+    reserve(max(64, (maxLen - original.size())));
 
     for (label id=0; id < maxLen; ++id)
     {
diff --git a/src/meshTools/triSurface/faceTriangulation/faceTriangulation.C b/src/meshTools/triSurface/faceTriangulation/faceTriangulation.C
index aab6832a25..8c60d43050 100644
--- a/src/meshTools/triSurface/faceTriangulation/faceTriangulation.C
+++ b/src/meshTools/triSurface/faceTriangulation/faceTriangulation.C
@@ -618,7 +618,7 @@ Foam::faceTriangulation::faceTriangulation
 
     if (!valid)
     {
-        setSize(0);
+        clear();
     }
 }
 
@@ -639,7 +639,7 @@ Foam::faceTriangulation::faceTriangulation
 
     if (!valid)
     {
-        setSize(0);
+        clear();
     }
 }
 
diff --git a/src/overset/cellCellStencil/inverseDistance/inverseDistanceCellCellStencil.C b/src/overset/cellCellStencil/inverseDistance/inverseDistanceCellCellStencil.C
index 17b92e868d..a0fa676559 100644
--- a/src/overset/cellCellStencil/inverseDistance/inverseDistanceCellCellStencil.C
+++ b/src/overset/cellCellStencil/inverseDistance/inverseDistanceCellCellStencil.C
@@ -801,7 +801,7 @@ void Foam::cellCellStencils::inverseDistance::markDonors
 //    {
 //        if (proci != Pstream::myProcNo())
 //        {
-//            nonLocal[proci].resize(2*nOriginating[proci]);
+//            nonLocal[proci].reserve(nOriginating[proci]);
 //        }
 //    }
 //
diff --git a/src/parallel/decompose/faDecompose/faMeshDecomposition.C b/src/parallel/decompose/faDecompose/faMeshDecomposition.C
index 49518eb545..a3775f461b 100644
--- a/src/parallel/decompose/faDecompose/faMeshDecomposition.C
+++ b/src/parallel/decompose/faDecompose/faMeshDecomposition.C
@@ -275,7 +275,7 @@ void Foam::faMeshDecomposition::decomposeMesh()
             ioAddr.rename("faceProcAddressing");
             labelIOList fvFaceProcAddressing(ioAddr);
 
-            fvFaceProcAddressingHash.resize(2*fvFaceProcAddressing.size());
+            fvFaceProcAddressingHash.reserve(fvFaceProcAddressing.size());
 
             forAll(fvFaceProcAddressing, facei)
             {
@@ -355,7 +355,7 @@ void Foam::faMeshDecomposition::decomposeMesh()
 
         Map<label>& curMap = procMeshEdgesMap_[procI];
         curMap.clear();
-        curMap.resize(2*procEdges.size());
+        curMap.reserve(procEdges.size());
 
         forAll(procEdges, edgeI)
         {
diff --git a/src/sampling/surface/cutting/cuttingSurfaceBaseTemplates.C b/src/sampling/surface/cutting/cuttingSurfaceBaseTemplates.C
index 9438c64eed..ad3bca9c5a 100644
--- a/src/sampling/surface/cutting/cuttingSurfaceBaseTemplates.C
+++ b/src/sampling/surface/cutting/cuttingSurfaceBaseTemplates.C
@@ -67,10 +67,10 @@ void Foam::cuttingSurfaceBase::walkCellCuts
     DynamicList<label> localFaceLoop(16);
 
     // Local scratch space for edge to pointId
-    EdgeMap<label> localEdges(128);
+    EdgeMap<label> localEdges;
 
     // Local scratch space for edge to faceId
-    EdgeMap<edge>  localFaces(128);
+    EdgeMap<edge>  localFaces;
 
     // Avoid duplicates for cuts exactly through a mesh point.
     // No other way to distinguish them, since there is no single edge
diff --git a/src/sampling/surface/isoSurface/isoSurfaceTopo.C b/src/sampling/surface/isoSurface/isoSurfaceTopo.C
index 9e04a21863..8bade733be 100644
--- a/src/sampling/surface/isoSurface/isoSurfaceTopo.C
+++ b/src/sampling/surface/isoSurface/isoSurfaceTopo.C
@@ -206,7 +206,7 @@ Foam::isoSurfaceTopo::tetCutAddressing::tetCutAddressing
     if (useSnap)
     {
         // Some, but not all, cells may have point snapping
-        snapVertsLookup_.resize(4*nCutCells);
+        snapVertsLookup_.reserve(2*nCutCells);
     }
     if (debugCutTetsOn_)
     {
@@ -1390,7 +1390,7 @@ Foam::isoSurfaceTopo::isoSurfaceTopo
             const labelList& mp = s.meshPoints();
             const edgeList& surfEdges = s.edges();
             const labelListList& edgeFaces = s.edgeFaces();
-            openEdgeIds.resize(2*s.size());
+            openEdgeIds.reserve(s.size());
 
             forAll(edgeFaces, edgei)
             {
diff --git a/src/thermophysicalModels/radiation/radiationModels/viewFactor/viewFactor.C b/src/thermophysicalModels/radiation/radiationModels/viewFactor/viewFactor.C
index 86f3432a72..cf5d732806 100644
--- a/src/thermophysicalModels/radiation/radiationModels/viewFactor/viewFactor.C
+++ b/src/thermophysicalModels/radiation/radiationModels/viewFactor/viewFactor.C
@@ -252,11 +252,9 @@ void Foam::radiation::viewFactor::initialise()
 
         DebugInFunction<< "Number of procBound : " <<  nbri << endl;
 
-        PtrList<const lduPrimitiveProcessorInterface> primitiveInterfaces;
-
-        primitiveInterfaces.setSize(nbri);
-        internalCoeffs_.setSize(0);
-        boundaryCoeffs_.setSize(nbri);
+        PtrList<const lduPrimitiveProcessorInterface> primitiveInterfaces(nbri);
+        internalCoeffs_.clear();
+        boundaryCoeffs_.resize_null(nbri);
 
         nbri = 0;
 
@@ -368,8 +366,7 @@ void Foam::radiation::viewFactor::initialise()
             );
         }
 
-        lduInterfacePtrsList allInterfaces;
-        allInterfaces.setSize(primitiveInterfaces.size());
+        lduInterfacePtrsList allInterfaces(primitiveInterfaces.size());
 
         forAll(primitiveInterfaces, i)
         {