From 15f7260884b708aa813c427f9fafa69c6f7866ad Mon Sep 17 00:00:00 2001
From: Mark Olesen <Mark.Olesen@esi-group.com>
Date: Thu, 1 Mar 2018 14:12:51 +0100
Subject: [PATCH] ENH: cleanup of ListOps, ListListOps. Adjustments to List,
 PackedList.

- relocated ListAppendEqOp and ListUniqueEqOp to ListOps::appendEqOp
  and ListOps::UniqueEqOp, respectively for better code isolation and
  documentation of purpose.

- relocated setValues to ListOps::setValue() with many more
  alternative selectors possible

- relocated createWithValues to ListOps::createWithValue
  for better code isolation. The default initialization value is itself
  now a default parameter, which allow for less typing.

  Negative indices in the locations to set are now silently ignored,
  which makes it possible to use an oldToNew mapping that includes
  negative indices.

- additional ListOps::createWithValue taking a single position to set,
  available both in copy assign and move assign versions.
  Since a negative index is ignored, it is possible to combine with
  the output of List::find() etc.

STYLE: changes for PackedList

- code simplication in the PackedList iterators, including dropping
  the unused operator() on iterators, which is not available in plain
  list versions either.

- improved sizing for PackedBoolList creation from a labelUList.

ENH: additional List constructors, for handling single element list.

- can assist in reducing constructor ambiguity, but can also helps
  memory optimization when creating a single element list.
  For example,

    labelListList labels(one(), identity(mesh.nFaces()));
---
 applications/test/List/Test-List.C            | 188 ++++++++-
 .../test/PackedList1/Test-PackedList1.C       |   6 +-
 .../test/PackedList2/Test-PackedList2.C       |  10 +-
 .../test/PackedList4/Test-PackedList4.C       |  18 +-
 .../manipulation/checkMesh/checkGeometry.C    |   4 +-
 .../moveDynamicMesh/moveDynamicMesh.C         |   2 +-
 .../parLagrangianRedistributor.C              |   8 +-
 ...agrangianRedistributorRedistributeFields.C |   2 +-
 .../redistributePar/redistributePar.C         |   2 +-
 src/OpenFOAM/containers/Lists/List/List.C     |  86 ++--
 src/OpenFOAM/containers/Lists/List/List.H     |  50 +--
 src/OpenFOAM/containers/Lists/List/ListI.H    |   2 +-
 .../Lists/ListListOps/ListListOps.C           | 124 +++---
 .../Lists/ListListOps/ListListOps.H           |  43 +-
 .../containers/Lists/ListOps/ListOps.H        | 310 ++++++++++++--
 .../Lists/ListOps/ListOpsTemplates.C          | 382 ++++++++++++++----
 .../Lists/PackedList/PackedBoolListI.H        |   4 +-
 .../containers/Lists/PackedList/PackedList.H  |  35 +-
 .../containers/Lists/PackedList/PackedListI.H | 118 +++---
 src/OpenFOAM/containers/Lists/UList/UList.H   |   4 +-
 src/OpenFOAM/containers/Lists/UList/UListI.H  |   4 +-
 src/OpenFOAM/meshes/meshShapes/edge/edge.H    |   4 +-
 src/OpenFOAM/meshes/meshShapes/face/face.H    |   7 +-
 .../meshShapes/labelledTri/labelledTri.H      |   7 +-
 .../meshes/meshShapes/triFace/triFace.H       |  13 +-
 .../mapDistribute/mapDistributePolyMesh.C     |  32 +-
 .../snappyHexMeshDriver/snappyRefineDriver.C  |   6 +-
 .../AMIInterpolation/AMIInterpolation.C       |   6 +-
 .../distributedTriSurfaceMesh.C               |   8 +-
 src/sampling/surface/isoSurface/isoSurface.C  |   8 +-
 .../surface/isoSurface/isoSurfaceCell.C       |   8 +-
 31 files changed, 1017 insertions(+), 484 deletions(-)

diff --git a/applications/test/List/Test-List.C b/applications/test/List/Test-List.C
index 1628b6f9ed..9ed62a26f9 100644
--- a/applications/test/List/Test-List.C
+++ b/applications/test/List/Test-List.C
@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  | Copyright (C) 2017 OpenCFD Ltd.
+     \\/     M anipulation  | Copyright (C) 2017-2018 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -97,11 +97,14 @@ void printMyString(const UList<string>& lst)
 int main(int argc, char *argv[])
 {
     argList::noParallel();
+    argList::noFunctionObjects();
+
     argList::addOption("reList", "reList");
     argList::addOption("wordList", "wordList");
     argList::addOption("stringList", "stringList");
     argList::addOption("float", "xx");
-    argList::addBoolOption("transform", "Test List::createList functionality");
+    argList::addBoolOption("create", "Test ListOps::create functionality");
+    argList::addBoolOption("ListList", "Test list of list functionality");
     argList::addBoolOption("flag");
 
     #include "setRootCase.H"
@@ -332,11 +335,11 @@ int main(int argc, char *argv[])
         List<scalar> sident(range.begin(), range.end());
         Info<<"range-list (scalar)=" << sident << nl;
 
-        // Sub-ranges also work
-        List<scalar> sident2(range(3), range(10));
-        Info<<"range-list (scalar)=" << sident2 << nl;
+//        // Sub-ranges also work
+//        List<scalar> sident2(range.at(3), range.at(10));
+//        Info<<"subrange-list (scalar)=" << sident2 << nl;
 
-        // VERY BAD IDEA: List<scalar> sident3(range(10), range(3));
+        // VERY BAD IDEA: List<scalar> sident3(range.at(10), range.at(3));
 
         // This doesn't work, and don't know what it should do anyhow
         // List<vector> vident(range.begin(), range.end());
@@ -362,15 +365,15 @@ int main(int argc, char *argv[])
         Info<<"-flag:" << args["flag"] << endl;
     }
 
-    if (args.found("transform"))
+    if (args.found("create"))
     {
-        Info<< nl << "Test List::createList functionality" << nl;
+        Info<< nl << "Test ListOps::create functionality" << nl;
 
         const auto labels = identity(15);
         Info<< "labels: " << flatOutput(labels) << endl;
 
         {
-            auto scalars = List<scalar>::createList
+            auto scalars = ListOps::create<scalar>
             (
                 labels,
                 [](const label& val){ return scalar(1.5*val); }
@@ -379,7 +382,7 @@ int main(int argc, char *argv[])
         }
 
         {
-            auto vectors = List<vector>::createList
+            auto vectors = ListOps::create<vector>
             (
                 labels,
                 [](const label& val){ return vector(1.2*val, -1.2*val, 0); }
@@ -388,7 +391,7 @@ int main(int argc, char *argv[])
         }
 
         {
-            auto longs = List<long>::createList
+            auto longs = ListOps::create<long>
             (
                 labels,
                 [](const label& val){ return val; }
@@ -396,7 +399,7 @@ int main(int argc, char *argv[])
             Info<< "longs: " << flatOutput(longs) << endl;
         }
         {
-            auto negs = List<label>::createList
+            auto negs = ListOps::create<label>
             (
                 labels,
                 std::negate<label>()
@@ -405,7 +408,7 @@ int main(int argc, char *argv[])
         }
 
         {
-            auto scalars = List<scalar>::createList
+            auto scalars = ListOps::create<scalar>
             (
                 labelRange::null.cbegin(),
                 labelRange::identity(15).cend(),
@@ -417,9 +420,9 @@ int main(int argc, char *argv[])
         #if WM_LABEL_SIZE == 32
         {
             List<int64_t> input(10);
-            std::iota(input.begin(), input.end(), 0);
+            std::iota(input.begin(), input.end(), 50);
 
-            auto output = List<label>::createList
+            auto output = ListOps::create<label>
             (
                 input,
                 toLabel<int64_t>()
@@ -429,9 +432,9 @@ int main(int argc, char *argv[])
         #elif WM_LABEL_SIZE == 64
         {
             List<int32_t> input(10);
-            std::iota(input.begin(), input.end(), 0);
+            std::iota(input.begin(), input.end(), 50);
 
-            auto output = List<label>::createList
+            auto output = ListOps::create<label>
             (
                 input,
                 toLabel<int32_t>()
@@ -439,6 +442,157 @@ int main(int argc, char *argv[])
             Info<< "label (from int32): " << flatOutput(output) << endl;
         }
         #endif
+
+
+        labelHashSet locations{ -15, 5, 10, 15, 25, 35 };
+        Info<< nl << "Test for createWithValue with locations :"
+            << flatOutput(locations.sortedToc()) << nl;
+
+        {
+            auto output = ListOps::createWithValue<label>
+            (
+                30,
+                locations.toc(),  // Any order
+                100,
+                -1  // default value
+            );
+            Info<< "with labelUList: " << flatOutput(output)
+                << " selector: " << flatOutput(locations.sortedToc()) << nl;
+        }
+
+        {
+            auto output = ListOps::createWithValue<label>
+            (
+                30,
+                locations,
+                100,
+                -1  // default value
+            );
+            Info<< "with labelHashSet: " << flatOutput(output)
+                << " selector: " << flatOutput(locations) << nl;
+        }
+
+        {
+            PackedBoolList select(locations.toc());
+            auto output = ListOps::createWithValue<label>
+            (
+                30,
+                select,
+                100,
+                -1  // default value
+            );
+            Info<< "with PackedBoolList: " << flatOutput(output)
+                << " selector: " << flatOutput(select.used()) << nl;
+        }
+
+        {
+            // Fairly really inconvenient way to set true/false
+            labelList toc(locations.sortedToc());
+
+            List<bool> select = ListOps::createWithValue<bool>
+            (
+                toc.last() + 1,
+                toc,
+                true,
+                false  // default value
+            );
+
+            auto output = ListOps::createWithValue<label>
+            (
+                30,
+                select,
+                100,
+                -1  // default value
+            );
+            Info<< "with boolList: " << flatOutput(output)
+                << " selector: " << flatOutput(select) << nl;
+        }
+
+        // Repeat with a shorter selector
+        locations = { -15, 5, 10 };
+
+        {
+            auto output = ListOps::createWithValue<label>
+            (
+                30,
+                locations,
+                100,
+                -1  // default value
+            );
+            Info<< "with labelHashSet: " << flatOutput(output)
+                << " selector: " << flatOutput(locations) << nl;
+        }
+
+        {
+            PackedBoolList select(locations.toc());
+            auto output = ListOps::createWithValue<label>
+            (
+                30,
+                select,
+                100,
+                -1  // default value
+            );
+            Info<< "with PackedBoolList: " << flatOutput(output)
+                << " selector: " << flatOutput(select.used()) << nl;
+        }
+
+        {
+            // Fairly really inconvenient way to set true/false
+            labelList toc(locations.sortedToc());
+
+            List<bool> select = ListOps::createWithValue<bool>
+            (
+                toc.last() + 1,
+                toc,
+                true,
+                false  // default value
+            );
+
+            auto output = ListOps::createWithValue<label>
+            (
+                30,
+                select,
+                100,
+                -1  // default value
+            );
+            Info<< "with boolList: " << flatOutput(output)
+                << " selector: " << flatOutput(select) << nl;
+        }
+    }
+
+    if (args.found("ListList"))
+    {
+        {
+            labelListList listlist(5, identity(5));
+            Info<<"list-list with length/val:" << listlist << nl;
+        }
+
+        {
+            labelListList listlist(one(), identity(5));
+            Info<<"list-list 1/val:" << listlist << nl;
+        }
+
+        {
+            labelList content = identity(5);
+
+            labelListList listlist(one(), content);
+            Info<<"list-list 1/copy val:" << listlist
+                <<" - from " << content << nl;
+        }
+
+        {
+            labelList content = identity(5);
+
+            labelListList listlist(one(), std::move(content));
+            Info<<"list-list 1/move val:" << listlist
+                <<" - from " << content << nl;
+        }
+
+        {
+            labelListList listlist(one(), Zero);
+            Info<<"list-list 1/move val:" << listlist
+                << nl;
+        }
     }
 
     if (args.readIfPresent<scalar>("float", xxx))
diff --git a/applications/test/PackedList1/Test-PackedList1.C b/applications/test/PackedList1/Test-PackedList1.C
index f39599fa6c..a963800e38 100644
--- a/applications/test/PackedList1/Test-PackedList1.C
+++ b/applications/test/PackedList1/Test-PackedList1.C
@@ -251,13 +251,13 @@ int main(int argc, char *argv[])
     Info<< "begin():";
     iter.printInfo(Info) << "\n";
 
-    Info<< "iterator:" << iter() << "\n";
-    iter() = 5;
+    Info<< "iterator:" << *iter << "\n";
+    *iter = 5;
     iter.printInfo(Info);
     list1.printInfo(Info, true);
 
     iter = list1[31];
-    Info<< "iterator:" << iter() << "\n";
+    Info<< "iterator:" << *iter << "\n";
     iter.printInfo(Info);
 
 
diff --git a/applications/test/PackedList2/Test-PackedList2.C b/applications/test/PackedList2/Test-PackedList2.C
index 51ddcdaec7..090b64d973 100644
--- a/applications/test/PackedList2/Test-PackedList2.C
+++ b/applications/test/PackedList2/Test-PackedList2.C
@@ -229,7 +229,7 @@ int main(int argc, char *argv[])
     sum = 0;
     for (label iter = 0; iter < nIters; ++iter)
     {
-        forAllIter(PackedBoolList, packed, it)
+        forAllIters(packed, it)
         {
             sum += it;
         }
@@ -244,9 +244,9 @@ int main(int argc, char *argv[])
     sum = 0;
     for (label iter = 0; iter < nIters; ++iter)
     {
-        forAllConstIter(PackedBoolList, packed, cit)
+        forAllConstIters(packed, cit)
         {
-            sum += cit();
+            sum += *cit;
         }
     }
     std::cout
@@ -370,9 +370,9 @@ int main(int argc, char *argv[])
     // Write packed
     for (label iter = 0; iter < nIters; ++iter)
     {
-        forAllIter(PackedBoolList, packed, it)
+        forAllIters(packed, it)
         {
-            it() = 1;
+            *it = 1;
         }
     }
     Info<< "Writing packed using iterator:" << timer.cpuTimeIncrement()
diff --git a/applications/test/PackedList4/Test-PackedList4.C b/applications/test/PackedList4/Test-PackedList4.C
index cb94feb1b9..5d6dea3216 100644
--- a/applications/test/PackedList4/Test-PackedList4.C
+++ b/applications/test/PackedList4/Test-PackedList4.C
@@ -29,9 +29,12 @@ Description
 
 #include "uLabel.H"
 #include "boolList.H"
+#include "DynamicList.H"
 #include "IOstreams.H"
 #include "PackedBoolList.H"
+#include "ITstream.H"
 #include "StringStream.H"
+#include "FlatOutput.H"
 
 using namespace Foam;
 
@@ -135,8 +138,9 @@ int main(int argc, char *argv[])
 
     PackedBoolList list4
     (
-        IStringStream
+        ITstream
         (
+            "input",
             "(1 n 1 n 1 n 1 1 off 0 0 f f 0 y yes y true y false on t)"
         )()
     );
@@ -199,6 +203,18 @@ int main(int argc, char *argv[])
 
     list4.writeEntry("PackedBoolList", Info);
 
+    // Construct from labelUList, labelUIndList
+    {
+        DynamicList<label> indices({10, 50, 300});
+
+        Info<< "set: " << flatOutput(indices) << endl;
+
+        PackedBoolList bools1(indices);
+
+        Info<< "used: " << bools1.size() << " "
+            << flatOutput(bools1.used()) << endl;
+    }
+
     return 0;
 }
 
diff --git a/applications/utilities/mesh/manipulation/checkMesh/checkGeometry.C b/applications/utilities/mesh/manipulation/checkMesh/checkGeometry.C
index 12986a67c9..e34823f188 100644
--- a/applications/utilities/mesh/manipulation/checkMesh/checkGeometry.C
+++ b/applications/utilities/mesh/manipulation/checkMesh/checkGeometry.C
@@ -1007,7 +1007,7 @@ Foam::label Foam::checkGeometry
                         globalFaces().gather
                         (
                             UPstream::worldComm,
-                            labelList::createList
+                            ListOps::create<label>
                             (
                                 UPstream::procID(UPstream::worldComm),
                                 toLabel<int>()  // int -> label
@@ -1061,7 +1061,7 @@ Foam::label Foam::checkGeometry
                         globalFaces().gather
                         (
                             UPstream::worldComm,
-                            labelList::createList
+                            ListOps::create<label>
                             (
                                 UPstream::procID(UPstream::worldComm),
                                 toLabel<int>()  // int -> label
diff --git a/applications/utilities/mesh/manipulation/moveDynamicMesh/moveDynamicMesh.C b/applications/utilities/mesh/manipulation/moveDynamicMesh/moveDynamicMesh.C
index f9961f0242..eadf3831f9 100644
--- a/applications/utilities/mesh/manipulation/moveDynamicMesh/moveDynamicMesh.C
+++ b/applications/utilities/mesh/manipulation/moveDynamicMesh/moveDynamicMesh.C
@@ -84,7 +84,7 @@ void writeWeights
     globalFaces().gather
     (
         UPstream::worldComm,
-        labelList::createList
+        ListOps::create<label>
         (
             UPstream::procID(UPstream::worldComm),
             toLabel<int>()  // int -> label
diff --git a/applications/utilities/parallelProcessing/redistributePar/parLagrangianRedistributor.C b/applications/utilities/parallelProcessing/redistributePar/parLagrangianRedistributor.C
index 9407439476..b55b14d9e3 100644
--- a/applications/utilities/parallelProcessing/redistributePar/parLagrangianRedistributor.C
+++ b/applications/utilities/parallelProcessing/redistributePar/parLagrangianRedistributor.C
@@ -81,7 +81,7 @@ void Foam::parLagrangianRedistributor::findClouds
     }
 
     // Synchronise cloud names
-    Pstream::combineGather(cloudNames, ListUniqueEqOp<word>());
+    Pstream::combineGather(cloudNames, ListOps::uniqueEqOp<word>());
     Pstream::combineScatter(cloudNames);
 
     objectNames.setSize(cloudNames.size());
@@ -117,10 +117,10 @@ void Foam::parLagrangianRedistributor::findClouds
     }
 
     // Synchronise objectNames
-    forAll(objectNames, cloudI)
+    forAll(objectNames, i)
     {
-        Pstream::combineGather(objectNames[cloudI], ListUniqueEqOp<word>());
-        Pstream::combineScatter(objectNames[cloudI]);
+        Pstream::combineGather(objectNames[i], ListOps::uniqueEqOp<word>());
+        Pstream::combineScatter(objectNames[i]);
     }
 }
 
diff --git a/applications/utilities/parallelProcessing/redistributePar/parLagrangianRedistributorRedistributeFields.C b/applications/utilities/parallelProcessing/redistributePar/parLagrangianRedistributorRedistributeFields.C
index 2e34a71a60..2506db2e60 100644
--- a/applications/utilities/parallelProcessing/redistributePar/parLagrangianRedistributorRedistributeFields.C
+++ b/applications/utilities/parallelProcessing/redistributePar/parLagrangianRedistributorRedistributeFields.C
@@ -44,7 +44,7 @@ Foam::wordList Foam::parLagrangianRedistributor::filterObjects
 
     // Parallel synchronise
     wordList fieldNames(objects.names(fieldClassName));
-    Pstream::combineGather(fieldNames, ListUniqueEqOp<word>());
+    Pstream::combineGather(fieldNames, ListOps::uniqueEqOp<word>());
     Pstream::combineScatter(fieldNames);
 
     if (!selectedFields.empty())
diff --git a/applications/utilities/parallelProcessing/redistributePar/redistributePar.C b/applications/utilities/parallelProcessing/redistributePar/redistributePar.C
index b082a260de..10c3ea80c5 100644
--- a/applications/utilities/parallelProcessing/redistributePar/redistributePar.C
+++ b/applications/utilities/parallelProcessing/redistributePar/redistributePar.C
@@ -2357,7 +2357,7 @@ int main(int argc, char *argv[])
     bool nfs = true;
     {
         List<fileName> roots(1, args.rootPath());
-        combineReduce(roots, ListUniqueEqOp<fileName>());
+        combineReduce(roots, ListOps::uniqueEqOp<fileName>());
         nfs = (roots.size() == 1);
     }
 
diff --git a/src/OpenFOAM/containers/Lists/List/List.C b/src/OpenFOAM/containers/Lists/List/List.C
index ea2c300524..d1660e0b4f 100644
--- a/src/OpenFOAM/containers/Lists/List/List.C
+++ b/src/OpenFOAM/containers/Lists/List/List.C
@@ -35,65 +35,6 @@ License
 
 #include <utility>
 
-// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
-
-template<class T>
-template<class T2, class UnaryOperation>
-Foam::List<T> Foam::List<T>::createList
-(
-    const UList<T2>& input,
-    const UnaryOperation& op
-)
-{
-    const label len = input.size();
-
-    List<T> output(len);
-
-    if (len)
-    {
-        List_ACCESS(T, output, out);
-        List_CONST_ACCESS(T2, input, in);
-
-        for (label i = 0; i < len; ++i)
-        {
-            out[i] = op(in[i]);
-        }
-    }
-
-    return output;
-}
-
-
-template<class T>
-template<class InputIterator, class UnaryOperation>
-Foam::List<T> Foam::List<T>::createList
-(
-    InputIterator begIter,
-    InputIterator endIter,
-    const UnaryOperation& op
-)
-{
-    const label len = std::distance(begIter, endIter);
-
-    List<T> output(len);
-
-    if (len)
-    {
-        List_ACCESS(T, output, out);
-
-        InputIterator iter = begIter;
-
-        for (label i = 0; i < len; ++i)
-        {
-            out[i] = op(*iter);
-            ++iter;
-        }
-    }
-
-    return output;
-}
-
-
 // * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * //
 
 template<class T>
@@ -162,6 +103,33 @@ Foam::List<T>::List(const label len, const zero)
 }
 
 
+template<class T>
+Foam::List<T>::List(const one, const T& val)
+:
+    UList<T>(new T[1], 1)
+{
+    this->v_[0] = val;
+}
+
+
+template<class T>
+Foam::List<T>::List(const one, T&& val)
+:
+    UList<T>(new T[1], 1)
+{
+    this->v_[0] = std::move(val);
+}
+
+
+template<class T>
+Foam::List<T>::List(const one, const zero)
+:
+    UList<T>(new T[1], 1)
+{
+    this->v_[0] = Zero;
+}
+
+
 template<class T>
 Foam::List<T>::List(const UList<T>& a)
 :
diff --git a/src/OpenFOAM/containers/Lists/List/List.H b/src/OpenFOAM/containers/Lists/List/List.H
index 73280d2492..d974d58e1c 100644
--- a/src/OpenFOAM/containers/Lists/List/List.H
+++ b/src/OpenFOAM/containers/Lists/List/List.H
@@ -42,6 +42,7 @@ SourceFiles
 
 #include "UList.H"
 #include "autoPtr.H"
+#include "one.H"
 #include "Xfer.H"
 #include "SLListFwd.H"
 
@@ -112,49 +113,11 @@ public:
         //- Return a null List
         inline static const List<T>& null();
 
-        //- Create from a list of a dissimilar type.
-        //  Eg, convert a list of ints to floats, vectors etc.
-        //  For example,
-        //  \code
-        //  auto vectors = List<vector>::createList
-        //  (
-        //      ints,
-        //      [](const int& val){ return vector(1.5*val, 0, 0); }
-        //  );
-        //
-        //  auto neg = labelList::createList
-        //  (
-        //      ints,
-        //      std::negate<label>()
-        //  );
-        //  auto labels = labelList::createList
-        //  (
-        //      ints,
-        //      toLabel<int>()
-        //  );
-        //  \endcode
-        template<class T2, class UnaryOperation>
-        static List<T> createList
-        (
-            const UList<T2>& input,
-            const UnaryOperation& op
-        );
-
-        //- Create from an iterator range (uses std::distance for the size).
-        //  The unary operation can be used to convert to other types.
-        template<class InputIterator, class UnaryOperation>
-        static List<T> createList
-        (
-            InputIterator begIter,
-            InputIterator endIter,
-            const UnaryOperation& op
-        );
-
 
     // Constructors
 
         //- Null constructor
-        inline List();
+        inline constexpr List() noexcept;
 
         //- Construct with given size
         explicit List(const label len);
@@ -165,6 +128,15 @@ public:
         //- Construct with given size initializing all elements to zero
         List(const label len, const zero);
 
+        //- Construct with length=1, copying the value as the only content
+        List(const one, const T& val);
+
+        //- Construct with length=1, moving the value as the only content
+        List(const one, T&& val);
+
+        //- Construct with length=1, initializing content to zero
+        List(const one, const zero);
+
         //- Copy construct from list
         List(const List<T>& a);
 
diff --git a/src/OpenFOAM/containers/Lists/List/ListI.H b/src/OpenFOAM/containers/Lists/List/ListI.H
index eb6eab8bd5..742500554d 100644
--- a/src/OpenFOAM/containers/Lists/List/ListI.H
+++ b/src/OpenFOAM/containers/Lists/List/ListI.H
@@ -88,7 +88,7 @@ inline Foam::List<T>::List
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class T>
-inline Foam::List<T>::List()
+inline constexpr Foam::List<T>::List() noexcept
 {}
 
 
diff --git a/src/OpenFOAM/containers/Lists/ListListOps/ListListOps.C b/src/OpenFOAM/containers/Lists/ListListOps/ListListOps.C
index 55c5eb9ce4..fdfb42f3c8 100644
--- a/src/OpenFOAM/containers/Lists/ListListOps/ListListOps.C
+++ b/src/OpenFOAM/containers/Lists/ListListOps/ListListOps.C
@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
-     \\/     M anipulation  |
+     \\/     M anipulation  | Copyright (C) 2018 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -23,93 +23,109 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
+template<class T, class AccessOp>
+Foam::labelList Foam::ListListOps::subSizes
+(
+    const UList<T>& lists,
+    AccessOp aop
+)
 {
+    labelList output(lists.size());
+    auto out = output.begin();
 
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-template<class AccessType, class T, class AccessOp>
-AccessType ListListOps::combine(const List<T>& lst, AccessOp aop)
-{
-    label sum = 0;
-
-    forAll(lst, lstI)
+    for (const T& sub : lists)
     {
-        sum += aop(lst[lstI]).size();
+        *out = aop(sub).size();
+        ++out;
     }
 
-    AccessType result(sum);
-
-    label globalElemI = 0;
-
-    forAll(lst, lstI)
-    {
-        const T& sub = lst[lstI];
-
-        forAll(aop(sub), elemI)
-        {
-            result[globalElemI++] = aop(sub)[elemI];
-        }
-    }
-    return result;
+    return output;
 }
 
 
 template<class T, class AccessOp>
-labelList ListListOps::subSizes(const List<T>& lst, AccessOp aop)
+Foam::label Foam::ListListOps::sumSizes
+(
+    const UList<T>& lists,
+    AccessOp aop
+)
 {
-    labelList sizes(lst.size());
+    label len = 0;
 
-    forAll(lst, lstI)
+    for (const T& sub : lists)
     {
-        sizes[lstI] = aop(lst[lstI]).size();
+        len += aop(sub).size();
     }
-    return sizes;
+
+    return len;
+}
+
+
+template<class AccessType, class T, class AccessOp>
+AccessType Foam::ListListOps::combine
+(
+    const UList<T>& lists,
+    AccessOp aop
+)
+{
+    label len = 0;
+
+    for (const T& sub : lists)
+    {
+        len += aop(sub).size();
+    }
+
+    AccessType output(len);
+    auto out = output.begin();
+
+    for (const T& sub : lists)
+    {
+        for (const auto& item : aop(sub))
+        {
+            *out = item;
+            ++out;
+        }
+    }
+
+    return output;
 }
 
 
 template<class AccessType, class T, class AccessOp, class OffsetOp>
-AccessType ListListOps::combineOffset
+AccessType Foam::ListListOps::combineOffset
 (
-    const List<T>& lst,
-    const labelList& sizes,
+    const UList<T>& lists,
+    const labelUList& offsets,
     AccessOp aop,
     OffsetOp oop
 )
 {
-    label sum = 0;
+    label len = 0;
 
-    forAll(lst, lstI)
+    for (const T& sub : lists)
     {
-        sum += aop(lst[lstI]).size();
+        len += aop(sub).size();
     }
 
-    AccessType result(sum);
-
-    label globalElemI = 0;
+    AccessType output(len);
+    auto out = output.begin();
+    auto off = offsets.begin();
 
     label offset = 0;
-
-    forAll(lst, lstI)
+    for (const T& sub : lists)
     {
-        const T& sub = lst[lstI];
-
-        forAll(aop(sub), elemI)
+        for (const auto& item : aop(sub))
         {
-            result[globalElemI++] = oop(aop(sub)[elemI], offset);
+            *out = oop(item, offset);
+            ++out;
         }
 
-        offset += sizes[lstI];
+        offset += *off;
+        ++off;
     }
-    return result;
+
+    return output;
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-
 // ************************************************************************* //
diff --git a/src/OpenFOAM/containers/Lists/ListListOps/ListListOps.H b/src/OpenFOAM/containers/Lists/ListListOps/ListListOps.H
index ab9dfd4e49..4d5616621a 100644
--- a/src/OpenFOAM/containers/Lists/ListListOps/ListListOps.H
+++ b/src/OpenFOAM/containers/Lists/ListListOps/ListListOps.H
@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
+     \\/     M anipulation  | Copyright (C) 2018 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -93,12 +93,10 @@ SourceFiles
 namespace Foam
 {
 
-// Dummy access operator for ListListOps::combine()
+//- Dummy access operator for ListListOps::combine()
 template<class T>
-class accessOp
+struct accessOp
 {
-public:
-
     const T& operator()(const T& x) const
     {
         return x;
@@ -106,54 +104,57 @@ public:
 };
 
 
-// Offset operator for ListListOps::combineOffset()
+//- Offset operator for ListListOps::combineOffset()
 template<class T>
-class offsetOp
+struct offsetOp
 {
-public:
-
     T operator()(const T& x, const label offset) const
     {
         return x + offset;
     }
 };
 
+
 /*---------------------------------------------------------------------------*\
-                           Class ListListOps Declaration
+                       Namespace ListListOps Declaration
 \*---------------------------------------------------------------------------*/
 
 namespace ListListOps
 {
-
-    //- Combines sublists into one big list
-    template<class AccessType, class T, class AccessOp>
-    AccessType combine(const List<T>&, AccessOp aop = accessOp<T>());
-
-    //- Gets sizes of sublists
+    //- Return the sizes of the sub-lists
     template<class T, class AccessOp>
-    labelList subSizes(const List<T>&, AccessOp aop = accessOp<T>());
+    labelList subSizes(const UList<T>& lists, AccessOp aop = accessOp<T>());
+
+    //- The total size of all sub-lists
+    template<class T, class AccessOp>
+    label sumSizes(const UList<T>& lists, AccessOp aop = accessOp<T>());
+
+    //- Combines sub-lists into a single list
+    template<class AccessType, class T, class AccessOp>
+    AccessType combine(const UList<T>& lists, AccessOp aop = accessOp<T>());
 
     //- Like combine but also offsets sublists based on passed sizes
     template<class AccessType, class T, class AccessOp, class OffsetOp>
     AccessType combineOffset
     (
-        const List<T>&,
-        const labelList& sizes,
+        const UList<T>& lists,
+        const labelUList& offsets,
         AccessOp aop,
         OffsetOp oop = offsetOp<T>()
     );
-};
+
+} // End namespace ListListOps
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #ifdef NoRepository
     #include "ListListOps.C"
 #endif
 
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #endif
diff --git a/src/OpenFOAM/containers/Lists/ListOps/ListOps.H b/src/OpenFOAM/containers/Lists/ListOps/ListOps.H
index 4f65d10523..54033086d2 100644
--- a/src/OpenFOAM/containers/Lists/ListOps/ListOps.H
+++ b/src/OpenFOAM/containers/Lists/ListOps/ListOps.H
@@ -27,6 +27,12 @@ InNamspace
 Description
     Various functions to operate on Lists.
 
+Namespace
+    Foam::ListOps
+
+Description
+    Various utility functions to work on Lists.
+
 SourceFiles
     ListOps.C
     ListOpsTemplates.C
@@ -38,6 +44,8 @@ SourceFiles
 
 #include "FlatOutput.H"
 #include "labelList.H"
+#include "HashSet.H"
+#include "PackedBoolList.H"
 #include "ops.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -260,25 +268,6 @@ labelList findIndices
     label start=0
 );
 
-//- Opposite of findIndices: set values at indices to given value
-template<class ListType>
-void setValues
-(
-    ListType& input,
-    const labelUList& indices,
-    typename ListType::const_reference val
-);
-
-//- Opposite of findIndices: set values at indices to given value
-template<class ListType>
-ListType createWithValues
-(
-    const label len,
-    typename ListType::const_reference initValue,
-    const labelUList& indices,
-    typename ListType::const_reference setValue
-);
-
 //- Find index of max element (and larger than given element).
 //  return -1 if not found. Linear search.
 template<class ListType>
@@ -325,24 +314,6 @@ label findLower
 );
 
 
-//- Helper class for list to append y onto the end of x
-template<class T>
-class ListAppendEqOp
-{
-public:
-    void operator()(List<T>& x, const List<T>& y) const;
-};
-
-
-//- Helper class for list to append unique elements of y onto the end of x
-template<class T>
-class ListUniqueEqOp
-{
-public:
-    void operator()(List<T>& x, const List<T>& y) const;
-};
-
-
 //- Reverse a list. First element becomes last element etc.
 template<class ListType>
 ListType reverseList(const ListType& input);
@@ -364,6 +335,271 @@ template<template<typename> class ListType, class DataType>
 void inplaceRotateList(ListType<DataType>& list, label n);
 
 
+/*---------------------------------------------------------------------------*\
+                         Namespace ListOps Declaration
+\*---------------------------------------------------------------------------*/
+
+namespace ListOps
+{
+
+//- List helper to append y elements onto the end of x
+template<class T>
+struct appendEqOp
+{
+    void operator()(List<T>& x, const List<T>& y) const;
+};
+
+//- List helper to append y unique elements onto the end of x
+template<class T>
+struct uniqueEqOp
+{
+    void operator()(List<T>& x, const List<T>& y) const;
+};
+
+
+//- Set various locations of the list with a specified value.
+//
+//  \param list the list to modify
+//  \param locations where to apply the specified value
+//       An out-of-range index is silently ignored.
+//  \param val the value to set at the specified locations
+template<class T>
+void setValue
+(
+    UList<T>& list,
+    const labelUList& locations,
+    const T& val
+);
+
+
+//- Set various locations of the list with a specified value.
+//
+//  \param list the list to modify
+//  \param locations where to apply the specified value
+//       An out-of-range index is silently ignored.
+//  \param val the value to set at the specified locations
+template<class T>
+void setValue
+(
+    UList<T>& list,
+    const labelHashSet& locations,
+    const T& val
+);
+
+
+//- Set various locations of the list with a specified value.
+//
+//  \param list the list to modify
+//  \param locations where to apply the specified value
+//       An out-of-range index is silently ignored.
+//  \param val the value to set at the specified locations
+template<class T>
+void setValue
+(
+    UList<T>& list,
+    const UList<bool>& locations,
+    const T& val
+);
+
+
+//- Set various locations of the list with a specified value.
+//
+//  \param list the list to modify
+//  \param locations where to apply the specified value
+//       An out-of-range index is silently ignored.
+//  \param val the value to set at the specified locations
+template<class T>
+void setValue
+(
+    UList<T>& list,
+    const PackedBoolList& locations,
+    const T& val
+);
+
+
+//- Create a List from a List of a dissimilar type, using the entire list.
+//  For example, convert a list of ints to floats, vectors etc.
+//
+//  \param input the list input values.
+//  \param op the unary conversion operator, which can be used to convert
+//      to other types.
+//
+//  \code
+//  auto neg = ListOps::create<label>
+//  (
+//      ints,
+//      std::negate<label>()
+//  );
+//
+//  auto labels = ListOps::create<label>
+//  (
+//      ints,
+//      toLabel<int>()
+//  );
+//
+//  auto vectors = ListOps::create<vector>
+//  (
+//      ints,
+//      [](const int& val){ return vector(1.5*val, 0, 0); }
+//  );
+//
+//  \endcode
+template<class T, class T2, class UnaryOperation>
+List<T> create
+(
+    const UList<T2>& input,
+    const UnaryOperation& op
+);
+
+
+//- Create a List from an iterator range [first,last) of a dissimilar type.
+//  Uses std::distance for the size.
+//
+//  \param first the begin of the iterator range
+//  \param last the end of the iterator range
+//  \param op the unary conversion operator, which can be used to convert
+//      to other types.
+template<class T, class InputIterator, class UnaryOperation>
+List<T> create
+(
+    InputIterator first,
+    InputIterator last,
+    const UnaryOperation& op
+);
+
+
+//- Create a List filled with default values and various locations with
+//- another specified value.
+//
+//  \param len the length of the list
+//  \param locations where to apply the specified value
+//       An out-of-range index is silently ignored.
+//  \param val the value to set at the specified locations
+//  \param deflt the initialization default value
+template<class T>
+List<T> createWithValue
+(
+    const label len,
+    const labelUList& locations,
+    const T& val,
+    const T& deflt = T()
+);
+
+
+//- Create a List filled with default values and various locations with
+//- another specified value.
+//
+//  \param len the length of the list
+//  \param locations where to apply the specified value
+//       An out-of-range index is silently ignored.
+//  \param val the value to set at the specified locations
+//  \param deflt the initialization default value
+template<class T>
+List<T> createWithValue
+(
+    const label len,
+    const labelHashSet& locations,
+    const T& val,
+    const T& deflt = T()
+);
+
+
+//- Create a List filled with default values and various locations with
+//- another specified value.
+//
+//  \param len the length of the list
+//  \param locations where to apply the specified value
+//       An out-of-range index is silently ignored.
+//  \param val the value to set at the specified locations
+//  \param deflt the initialization default value
+template<class T>
+List<T> createWithValue
+(
+    const label len,
+    const UList<bool>& locations,
+    const T& val,
+    const T& deflt = T()
+);
+
+
+//- Create a List filled with default values and various locations with
+//- another specified value.
+//
+//  \param len the length of the list
+//  \param locations where to apply the specified value
+//       An out-of-range index is silently ignored.
+//  \param val the value to set at the specified locations
+//  \param deflt the initialization default value
+template<class T>
+List<T> createWithValue
+(
+    const label len,
+    const PackedBoolList& locations,
+    const T& val,
+    const T& deflt = T()
+);
+
+
+//- Create a List filled with default values and one specified value,
+//- which is copy assigned at the specified index
+//
+//  \param len the length of the list
+//  \param index where to apply the specified value.
+//       An out-of-range index is silently ignored.
+//  \param val the value to copy assign at the specified index
+//  \param deflt the initialization default value
+template<class T>
+List<T> createWithValue
+(
+    const label len,
+    const label index,
+    const T& val,
+    const T& deflt = T()
+);
+
+
+//- Create a List filled with default values and one specified value,
+//- which is move assigned at the specified index
+//
+//  \param len the length of the list
+//  \param index where to apply the specified value.
+//       An out-of-range index is silently ignored.
+//  \param val the value to move assign at the specified index
+//  \param deflt the initialization default value
+//
+//  For example,
+//  \code
+//  // Gather all unique points on master
+//
+//  List<pointField> gatheredPoints(Pstream::nProcs());
+//  gatheredPoints[Pstream::myProcNo()] = pointField
+//  (
+//      mesh.points(),
+//      uniqueMeshPoints
+//  );
+//  ...
+//
+//  // Or else
+//  auto gatheredPoints = ListOps::createWithValue<pointField>
+//  (
+//      Pstream::nProcs(),
+//      Pstream::myProcNo(),
+//      pointField(mesh.points(), uniqueMeshPoints)
+//  );
+//  ...
+//
+//  \endcode
+template<class T>
+List<T> createWithValue
+(
+    const label len,
+    const label index,
+    T&& val,
+    const T& deflt = T()
+);
+
+} // End namespace ListOps
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam
diff --git a/src/OpenFOAM/containers/Lists/ListOps/ListOpsTemplates.C b/src/OpenFOAM/containers/Lists/ListOps/ListOpsTemplates.C
index 0315a2465d..80702424a4 100644
--- a/src/OpenFOAM/containers/Lists/ListOps/ListOpsTemplates.C
+++ b/src/OpenFOAM/containers/Lists/ListOps/ListOpsTemplates.C
@@ -23,7 +23,9 @@ License
 
 \*---------------------------------------------------------------------------*/
 
+#include <utility>
 #include "ListOps.H"
+#include "ListLoopM.H"
 
 // * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
 
@@ -558,36 +560,6 @@ Foam::labelList Foam::findIndices
 }
 
 
-template<class ListType>
-void Foam::setValues
-(
-    ListType& input,
-    const labelUList& indices,
-    typename ListType::const_reference val
-)
-{
-    for (const label idx : indices)
-    {
-        input[idx] = val;
-    }
-}
-
-
-template<class ListType>
-ListType Foam::createWithValues
-(
-    const label len,
-    const typename ListType::const_reference initValue,
-    const labelUList& indices,
-    typename ListType::const_reference setValue
-)
-{
-    ListType list(len, initValue);
-    setValues(list, indices, setValue);
-    return list;
-}
-
-
 template<class ListType>
 Foam::label Foam::findMax(const ListType& input, const label start)
 {
@@ -736,51 +708,6 @@ Foam::label Foam::findLower
 }
 
 
-template<class T>
-void Foam::ListAppendEqOp<T>::operator()(List<T>& x, const List<T>& y) const
-{
-    if (y.size())
-    {
-        label len = x.size();
-        if (len)
-        {
-            x.setSize(len + y.size());
-            for (const T& val : y)
-            {
-                x[len++] = val;
-            }
-        }
-        else
-        {
-            x = y;
-        }
-    }
-}
-
-
-template<class T>
-void Foam::ListUniqueEqOp<T>::operator()(List<T>& x, const List<T>& y) const
-{
-    if (y.size())
-    {
-        if (x.size())
-        {
-            for (const T& val : y)
-            {
-                if (!x.found(val))
-                {
-                    x.append(val);
-                }
-            }
-        }
-        else
-        {
-            x = y;
-        }
-    }
-}
-
-
 template<class ListType>
 ListType Foam::reverseList(const ListType& input)
 {
@@ -859,4 +786,309 @@ void Foam::inplaceRotateList(ListType<DataType>& input, label n)
 }
 
 
+// * * * * * * * * * * * * * * * * * ListOps * * * * * * * * * * * * * * * * //
+
+template<class T>
+void Foam::ListOps::appendEqOp<T>::operator()
+(
+    List<T>& x,
+    const List<T>& y
+) const
+{
+    if (y.size())
+    {
+        label len = x.size();
+        if (len)
+        {
+            x.resize(len + y.size());
+            for (const T& val : y)
+            {
+                x[len++] = val;
+            }
+        }
+        else
+        {
+            x = y;
+        }
+    }
+}
+
+
+template<class T>
+void Foam::ListOps::uniqueEqOp<T>::operator()
+(
+    List<T>& x,
+    const List<T>& y
+) const
+{
+    if (y.size())
+    {
+        if (x.size())
+        {
+            for (const T& val : y)
+            {
+                if (!x.found(val))
+                {
+                    x.append(val);
+                }
+            }
+        }
+        else
+        {
+            x = y;
+        }
+    }
+}
+
+
+template<class T>
+void Foam::ListOps::setValue
+(
+    UList<T>& list,
+    const labelUList& locations,
+    const T& val
+)
+{
+    const label len = list.size();
+
+    for (const label index : locations)
+    {
+        // Range-checked
+        if (index >= 0 && index < len)
+        {
+            list[index] = val;
+        }
+    }
+}
+
+
+template<class T>
+void Foam::ListOps::setValue
+(
+    UList<T>& list,
+    const labelHashSet& locations,
+    const T& val
+)
+{
+    const label len = list.size();
+
+    for (const label index : locations)
+    {
+        // Range-checked
+        if (index >= 0 && index < len)
+        {
+            list[index] = val;
+        }
+    }
+}
+
+
+template<class T>
+void Foam::ListOps::setValue
+(
+    UList<T>& list,
+    const UList<bool>& locations,
+    const T& val
+)
+{
+    const label len = list.size();
+    const label count = locations.size();
+    const label end = min(count, len);
+
+    // The efficiency is modest
+    for (label index = 0; index < end; ++index)
+    {
+         if (locations[index])
+         {
+             list[index] = val;
+         }
+    }
+}
+
+
+template<class T>
+void Foam::ListOps::setValue
+(
+    UList<T>& list,
+    const PackedBoolList& locations,
+    const T& val
+)
+{
+    // Need improvements in PackedBoolList for more efficiency
+
+    const label len = list.size();
+    const label count = locations.count();
+
+    for (label index = 0, used = 0; index < len && used < count; ++index)
+    {
+        if (locations[index])
+        {
+            list[index] = val;
+            ++used;
+        }
+    }
+}
+
+
+template<class T, class T2, class UnaryOperation>
+Foam::List<T> Foam::ListOps::create
+(
+    const UList<T2>& input,
+    const UnaryOperation& op
+)
+{
+    const label len = input.size();
+
+    List<T> output(len);
+
+    if (len)
+    {
+        List_ACCESS(T, output, out);
+        List_CONST_ACCESS(T2, input, in);
+
+        for (label i = 0; i < len; ++i)
+        {
+            out[i] = op(in[i]);
+        }
+    }
+
+    return output;
+}
+
+
+template<class T, class InputIterator, class UnaryOperation>
+Foam::List<T> Foam::ListOps::create
+(
+    InputIterator first,
+    InputIterator last,
+    const UnaryOperation& op
+)
+{
+    const label len = std::distance(first, last);
+
+    List<T> output(len);
+
+    if (len)
+    {
+        List_ACCESS(T, output, out);
+
+        InputIterator in = first;
+
+        for (label i = 0; i < len; ++i)
+        {
+            out[i] = op(*in);
+            ++in;
+        }
+    }
+
+    return output;
+}
+
+
+template<class T>
+Foam::List<T> Foam::ListOps::createWithValue
+(
+    const label len,
+    const labelUList& locations,
+    const T& val,
+    const T& deflt
+)
+{
+    List<T> list(len, deflt);
+    ListOps::setValue(list, locations, val);
+
+    return list;
+}
+
+
+template<class T>
+Foam::List<T> Foam::ListOps::createWithValue
+(
+    const label len,
+    const labelHashSet& locations,
+    const T& val,
+    const T& deflt
+)
+{
+    List<T> list(len, deflt);
+    ListOps::setValue(list, locations, val);
+
+    return list;
+}
+
+
+template<class T>
+Foam::List<T> Foam::ListOps::createWithValue
+(
+    const label len,
+    const UList<bool>& locations,
+    const T& val,
+    const T& deflt
+)
+{
+    List<T> list(len, deflt);
+    ListOps::setValue(list, locations, val);
+
+    return list;
+}
+
+
+template<class T>
+Foam::List<T> Foam::ListOps::createWithValue
+(
+    const label len,
+    const PackedBoolList& locations,
+    const T& val,
+    const T& deflt
+)
+{
+    List<T> list(len, deflt);
+    ListOps::setValue(list, locations, val);
+
+    return list;
+}
+
+
+template<class T>
+Foam::List<T> Foam::ListOps::createWithValue
+(
+    const label len,
+    const label index,
+    const T& val,
+    const T& deflt
+)
+{
+    List<T> list(len, deflt);
+
+    // Range-checked
+    if (index >= 0 && index < len)
+    {
+        list[index] = val;
+    }
+
+    return list;
+}
+
+
+template<class T>
+Foam::List<T> Foam::ListOps::createWithValue
+(
+    const label len,
+    const label index,
+    T&& val,
+    const T& deflt
+)
+{
+    List<T> list(len, deflt);
+
+    // Range-checked
+    if (index >= 0 && index < len)
+    {
+        list[index] = std::move(val);
+    }
+
+    return list;
+}
+
+
 // ************************************************************************* //
diff --git a/src/OpenFOAM/containers/Lists/PackedList/PackedBoolListI.H b/src/OpenFOAM/containers/Lists/PackedList/PackedBoolListI.H
index c89acf0bc3..bd596dbf2b 100644
--- a/src/OpenFOAM/containers/Lists/PackedList/PackedBoolListI.H
+++ b/src/OpenFOAM/containers/Lists/PackedList/PackedBoolListI.H
@@ -88,13 +88,13 @@ inline Foam::PackedBoolList::PackedBoolList(const UList<bool>& lst)
 
 inline Foam::PackedBoolList::PackedBoolList(const labelUList& indices)
 :
-    PackedBoolList(indices.size(), indices)
+    PackedBoolList((indices.size() ? indices.last() : 0), indices)
 {}
 
 
 inline Foam::PackedBoolList::PackedBoolList(const labelUIndList& indices)
 :
-    PackedBoolList(indices.size(), indices)
+    PackedBoolList((indices.size() ? indices.last() : 0), indices)
 {}
 
 
diff --git a/src/OpenFOAM/containers/Lists/PackedList/PackedList.H b/src/OpenFOAM/containers/Lists/PackedList/PackedList.H
index 8ffd02e704..56167ad0c8 100644
--- a/src/OpenFOAM/containers/Lists/PackedList/PackedList.H
+++ b/src/OpenFOAM/containers/Lists/PackedList/PackedList.H
@@ -384,7 +384,7 @@ public:
         void writeEntry(const word& keyword, Ostream& os) const;
 
 
-      // Member operators
+      // Member Operators
 
         //- Append a value at the end of the list
         inline PackedList<nBits>& append(const unsigned int val);
@@ -438,22 +438,32 @@ public:
                 label index_;
 
 
+            // Constructors
+
+                //- Construct null - an end iterator
+                inline iteratorBase();
+
+                //- Construct from base list and position index
+                inline iteratorBase(const PackedList* lst, const label i);
+
+
             // Protected Member Functions
 
+                //- Limit index to the list size - avoid going past end()
+                //  Eg, iter = iterator(list, Inf)
+                inline void bound();
+
                 //- Get value as unsigned, no range-checking
                 inline unsigned int get() const;
 
                 //- Set value, returning true if changed, no range-checking
                 inline bool set(unsigned int val);
 
+                //- Move backward through list
+                inline void prev();
 
-            // Constructors
-
-                //- Construct null
-                inline iteratorBase();
-
-                //- Construct from base list and position index
-                inline iteratorBase(const PackedList* lst, const label i);
+                //- Move forward through list
+                inline void next();
 
 
         public:
@@ -534,15 +544,9 @@ public:
                 //- Return value
                 inline unsigned int operator*() const;
 
-                //- Return value
-                inline unsigned int operator()() const;
-
                 //- Return iteratorBase for assigning values
                 inline iteratorBase& operator*();
 
-                //- Return iteratorBase for assigning values
-                inline iteratorBase& operator()();
-
                 inline iterator& operator++();
                 inline iterator operator++(int);
 
@@ -595,9 +599,6 @@ public:
                 //- Return referenced value directly
                 inline unsigned int operator*() const;
 
-                //- Return referenced value directly
-                inline unsigned int operator()() const;
-
                 inline const_iterator& operator++();
                 inline const_iterator operator++(int);
 
diff --git a/src/OpenFOAM/containers/Lists/PackedList/PackedListI.H b/src/OpenFOAM/containers/Lists/PackedList/PackedListI.H
index b4efd00711..9696290f92 100644
--- a/src/OpenFOAM/containers/Lists/PackedList/PackedListI.H
+++ b/src/OpenFOAM/containers/Lists/PackedList/PackedListI.H
@@ -294,8 +294,31 @@ inline Foam::PackedList<nBits>::iteratorBase::iteratorBase
 
 
 template<unsigned nBits>
-inline unsigned int
-Foam::PackedList<nBits>::iteratorBase::get() const
+inline void Foam::PackedList<nBits>::iteratorBase::bound()
+{
+    if (list_ && index_ > list_->size_)
+    {
+        index_ = list_->size_;
+    }
+}
+
+
+template<unsigned nBits>
+inline void Foam::PackedList<nBits>::iteratorBase::prev()
+{
+    --index_;
+}
+
+
+template<unsigned nBits>
+inline void Foam::PackedList<nBits>::iteratorBase::next()
+{
+    ++index_;
+}
+
+
+template<unsigned nBits>
+inline unsigned int Foam::PackedList<nBits>::iteratorBase::get() const
 {
     const unsigned int seg = index_ / packing();
     const unsigned int off = index_ % packing();
@@ -306,8 +329,7 @@ Foam::PackedList<nBits>::iteratorBase::get() const
 
 
 template<unsigned nBits>
-inline bool
-Foam::PackedList<nBits>::iteratorBase::set(const unsigned int val)
+inline bool Foam::PackedList<nBits>::iteratorBase::set(const unsigned int val)
 {
     const unsigned int seg = index_ / packing();
     const unsigned int off = index_ % packing();
@@ -346,7 +368,7 @@ inline bool Foam::PackedList<nBits>::iteratorBase::operator==
     const iteratorBase& iter
 ) const
 {
-    return this->get() == iter.get();
+    return this->get() == iter.get(); // Compare values
 }
 
 
@@ -356,7 +378,7 @@ inline bool Foam::PackedList<nBits>::iteratorBase::operator!=
     const iteratorBase& iter
 ) const
 {
-    return this->get() != iter.get();
+    return this->get() != iter.get(); // Compare values
 }
 
 
@@ -366,8 +388,7 @@ inline void Foam::PackedList<nBits>::iteratorBase::operator=
     const iteratorBase& iter
 )
 {
-    const unsigned int val = iter.get();
-    this->set(val);
+    this->set(iter.get()); // Set values
 }
 
 
@@ -423,12 +444,7 @@ inline Foam::PackedList<nBits>::iterator::iterator
 :
     iteratorBase(iter)
 {
-    // Avoid going past end()
-    // eg, iter = iterator(list, Inf)
-    if (this->index_ > this->list_->size_)
-    {
-        this->index_ = this->list_->size_;
-    }
+    this->bound();
 }
 
 
@@ -440,12 +456,7 @@ inline Foam::PackedList<nBits>::const_iterator::const_iterator
 :
     iteratorBase(iter)
 {
-    // Avoid going past end()
-    // eg, iter = iterator(list, Inf)
-    if (this->index_ > this->list_->size_)
-    {
-        this->index_ = this->list_->size_;
-    }
+    this->bound();
 }
 
 
@@ -487,7 +498,7 @@ inline bool Foam::PackedList<nBits>::iterator::operator==
     const iteratorBase& iter
 ) const
 {
-    return this->index_ == iter.index_;
+    return this->index_ == iter.index_; // Compare positions
 }
 
 
@@ -497,7 +508,7 @@ inline bool Foam::PackedList<nBits>::iterator::operator!=
     const iteratorBase& iter
 ) const
 {
-    return this->index_ != iter.index_;
+    return this->index_ != iter.index_; // Compare positions
 }
 
 
@@ -507,7 +518,7 @@ inline bool Foam::PackedList<nBits>::const_iterator::operator==
     const iteratorBase& iter
 ) const
 {
-    return this->index_ == iter.index_;
+    return this->index_ == iter.index_; // Compare positions
 }
 
 
@@ -517,7 +528,7 @@ inline bool Foam::PackedList<nBits>::const_iterator::operator!=
     const iteratorBase& iter
 ) const
 {
-    return this->index_ != iter.index_;
+    return this->index_ != iter.index_; // Compare positions
 }
 
 
@@ -530,12 +541,7 @@ inline void Foam::PackedList<nBits>::iterator::operator=
     this->list_  = iter.list_;
     this->index_ = iter.index_;
 
-    // Avoid going past end()
-    // eg, iter = iterator(list, Inf)
-    if (this->index_ > this->list_->size_)
-    {
-        this->index_ = this->list_->size_;
-    }
+    this->bound();
 }
 
 
@@ -548,14 +554,7 @@ inline void Foam::PackedList<nBits>::const_iterator::operator=
     this->list_  = iter.list_;
     this->index_ = iter.index_;
 
-    // Avoid going past end()
-    // eg, iter = iterator(list, Inf)
-    if (this->index_ > this->list_->size_)
-    {
-        this->index_ = this->list_->size_;
-    }
-
-    return *this;
+    this->bound();
 }
 
 
@@ -563,7 +562,7 @@ template<unsigned nBits>
 inline typename Foam::PackedList<nBits>::iterator&
 Foam::PackedList<nBits>::iterator::operator++()
 {
-    ++this->index_;
+    this->next();
     return *this;
 }
 
@@ -572,7 +571,7 @@ template<unsigned nBits>
 inline typename Foam::PackedList<nBits>::const_iterator&
 Foam::PackedList<nBits>::const_iterator::operator++()
 {
-    ++this->index_;
+    this->next();
     return *this;
 }
 
@@ -581,8 +580,8 @@ template<unsigned nBits>
 inline typename Foam::PackedList<nBits>::iterator
 Foam::PackedList<nBits>::iterator::operator++(int)
 {
-    iterator old = *this;
-    ++this->index_;
+    iterator old(*this);
+    this->next();
     return old;
 }
 
@@ -591,8 +590,8 @@ template<unsigned nBits>
 inline typename Foam::PackedList<nBits>::const_iterator
 Foam::PackedList<nBits>::const_iterator::operator++(int)
 {
-    const_iterator old = *this;
-    ++this->index_;
+    const_iterator old(*this);
+    this->next();
     return old;
 }
 
@@ -601,7 +600,7 @@ template<unsigned nBits>
 inline typename Foam::PackedList<nBits>::iterator&
 Foam::PackedList<nBits>::iterator::operator--()
 {
-    --this->index_;
+    this->prev();
     return *this;
 }
 
@@ -610,7 +609,7 @@ template<unsigned nBits>
 inline typename Foam::PackedList<nBits>::const_iterator&
 Foam::PackedList<nBits>::const_iterator::operator--()
 {
-    --this->index_;
+    this->prev();
     return *this;
 }
 
@@ -619,8 +618,8 @@ template<unsigned nBits>
 inline typename Foam::PackedList<nBits>::iterator
 Foam::PackedList<nBits>::iterator::operator--(int)
 {
-    iterator old = *this;
-    --this->index_;
+    iterator old(*this);
+    this->prev();
     return old;
 }
 
@@ -629,8 +628,8 @@ template<unsigned nBits>
 inline typename Foam::PackedList<nBits>::const_iterator
 Foam::PackedList<nBits>::const_iterator::operator--(int)
 {
-    const_iterator old = *this;
-    --this->index_;
+    const_iterator old(*this);
+    this->prev();
     return old;
 }
 
@@ -643,14 +642,6 @@ Foam::PackedList<nBits>::iterator::operator*()
 }
 
 
-template<unsigned nBits>
-inline typename Foam::PackedList<nBits>::iteratorBase&
-Foam::PackedList<nBits>::iterator::operator()()
-{
-    return static_cast<iteratorBase&>(*this);
-}
-
-
 template<unsigned nBits>
 inline unsigned int
 Foam::PackedList<nBits>::const_iterator::operator*() const
@@ -659,14 +650,6 @@ Foam::PackedList<nBits>::const_iterator::operator*() const
 }
 
 
-template<unsigned nBits>
-inline unsigned int
-Foam::PackedList<nBits>::const_iterator::operator()() const
-{
-    return this->get();
-}
-
-
 template<unsigned nBits>
 inline typename Foam::PackedList<nBits>::iterator
 Foam::PackedList<nBits>::begin()
@@ -785,7 +768,6 @@ inline void Foam::PackedList<nBits>::resize
                 }
             }
 
-
             // Mask off the (new) final partial segment
             {
                 const unsigned int off = size_ % packing();
@@ -913,7 +895,7 @@ inline void Foam::PackedList<nBits>::clearStorage()
 template<unsigned nBits>
 inline void Foam::PackedList<nBits>::shrink()
 {
-    // Any uneed space allocated?
+    // Any unneeded space allocated?
     const label len = packedLength();
     if (len < StorageList::size())
     {
diff --git a/src/OpenFOAM/containers/Lists/UList/UList.H b/src/OpenFOAM/containers/Lists/UList/UList.H
index 30c6a9110e..2d31afac2c 100644
--- a/src/OpenFOAM/containers/Lists/UList/UList.H
+++ b/src/OpenFOAM/containers/Lists/UList/UList.H
@@ -213,10 +213,10 @@ public:
     // Constructors
 
         //- Null constructor
-        inline UList();
+        inline constexpr UList() noexcept;
 
         //- Construct from components
-        inline UList(T* __restrict__ v, label size);
+        inline UList(T* __restrict__ v, label size) noexcept;
 
 
     // Member Functions
diff --git a/src/OpenFOAM/containers/Lists/UList/UListI.H b/src/OpenFOAM/containers/Lists/UList/UListI.H
index af07e69719..bd41d2ae55 100644
--- a/src/OpenFOAM/containers/Lists/UList/UListI.H
+++ b/src/OpenFOAM/containers/Lists/UList/UListI.H
@@ -30,7 +30,7 @@ License
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class T>
-inline Foam::UList<T>::UList()
+inline constexpr Foam::UList<T>::UList() noexcept
 :
     size_(0),
     v_(nullptr)
@@ -38,7 +38,7 @@ inline Foam::UList<T>::UList()
 
 
 template<class T>
-inline Foam::UList<T>::UList(T* __restrict__ v, label size)
+inline Foam::UList<T>::UList(T* __restrict__ v, label size) noexcept
 :
     size_(size),
     v_(v)
diff --git a/src/OpenFOAM/meshes/meshShapes/edge/edge.H b/src/OpenFOAM/meshes/meshShapes/edge/edge.H
index ccfc6308e4..7cff69f33e 100644
--- a/src/OpenFOAM/meshes/meshShapes/edge/edge.H
+++ b/src/OpenFOAM/meshes/meshShapes/edge/edge.H
@@ -288,7 +288,7 @@ inline bool operator==(const edge& a, const edge& b);
 inline bool operator!=(const edge& a, const edge& b);
 
 
-//- Hash specialization for hashing edges - a commutative hash value.
+//- Hash specialization for hashing edges as a commutative hash value.
 //  Hash incrementally.
 template<>
 inline unsigned Hash<edge>::operator()(const edge& e, unsigned seed) const
@@ -310,7 +310,7 @@ inline unsigned Hash<edge>::operator()(const edge& e, unsigned seed) const
 }
 
 
-//- Hash specialization for hashing edges - a commutative hash value.
+//- Hash specialization for hashing edges as a commutative hash value.
 //  Hash incrementally.
 template<>
 inline unsigned Hash<edge>::operator()(const edge& e) const
diff --git a/src/OpenFOAM/meshes/meshShapes/face/face.H b/src/OpenFOAM/meshes/meshShapes/face/face.H
index fc0069f192..2691c30f09 100644
--- a/src/OpenFOAM/meshes/meshShapes/face/face.H
+++ b/src/OpenFOAM/meshes/meshShapes/face/face.H
@@ -394,13 +394,10 @@ public:
 };
 
 
-//- Hash specialization to offset faces in ListListOps::combineOffset
+//- Specialization to offset faces, used in ListListOps::combineOffset
 template<>
-class offsetOp<face>
+struct offsetOp<face>
 {
-
-public:
-
     inline face operator()
     (
         const face& x,
diff --git a/src/OpenFOAM/meshes/meshShapes/labelledTri/labelledTri.H b/src/OpenFOAM/meshes/meshShapes/labelledTri/labelledTri.H
index f9feafa610..ad7b55ab6d 100644
--- a/src/OpenFOAM/meshes/meshShapes/labelledTri/labelledTri.H
+++ b/src/OpenFOAM/meshes/meshShapes/labelledTri/labelledTri.H
@@ -128,13 +128,10 @@ template<>
 inline bool contiguous<labelledTri>()  {return true;}
 
 
-//- Hash specialization to offset faces in ListListOps::combineOffset
+//- Specialization to offset faces, used in ListListOps::combineOffset
 template<>
-class offsetOp<labelledTri>
+struct offsetOp<labelledTri>
 {
-
-public:
-
     inline labelledTri operator()
     (
         const labelledTri& x,
diff --git a/src/OpenFOAM/meshes/meshShapes/triFace/triFace.H b/src/OpenFOAM/meshes/meshShapes/triFace/triFace.H
index 2b7f2e62bc..442f1bc16d 100644
--- a/src/OpenFOAM/meshes/meshShapes/triFace/triFace.H
+++ b/src/OpenFOAM/meshes/meshShapes/triFace/triFace.H
@@ -246,8 +246,8 @@ inline bool operator==(const triFace& a, const triFace& b);
 inline bool operator!=(const triFace& a, const triFace& b);
 
 
-//- Hash specialization for hashing triFace - a commutative hash value.
-//  Hash incrementally.
+//- Hash specialization for triFace as a commutative hash value.
+//  Hashes incrementally.
 template<>
 inline unsigned Hash<triFace>::operator()(const triFace& t, unsigned seed) const
 {
@@ -262,7 +262,7 @@ inline unsigned Hash<triFace>::operator()(const triFace& t, unsigned seed) const
 }
 
 
-//- Hash specialization for hashing triFace - a commutative hash value.
+//- Hash specialization for triFace as a commutative hash value.
 template<>
 inline unsigned Hash<triFace>::operator()(const triFace& t) const
 {
@@ -270,13 +270,10 @@ inline unsigned Hash<triFace>::operator()(const triFace& t) const
 }
 
 
-//- Hash specialization to offset faces in ListListOps::combineOffset
+//- Specialization to offset faces, used in ListListOps::combineOffset
 template<>
-class offsetOp<triFace>
+struct offsetOp<triFace>
 {
-
-public:
-
     inline triFace operator()
     (
         const triFace& x,
diff --git a/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapDistribute/mapDistributePolyMesh.C b/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapDistribute/mapDistributePolyMesh.C
index 2f44c1d9a6..3ad711b0ab 100644
--- a/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapDistribute/mapDistributePolyMesh.C
+++ b/src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapDistribute/mapDistributePolyMesh.C
@@ -205,13 +205,7 @@ void Foam::mapDistributePolyMesh::distributePointIndices(labelList& lst) const
     // Construct boolList from selected elements
     boolList isSelected
     (
-        createWithValues<boolList>
-        (
-            nOldPoints(),
-            false,
-            lst,
-            true
-        )
+        ListOps::createWithValue<bool>(nOldPoints(), lst, true, false)
     );
 
     // Distribute
@@ -227,13 +221,7 @@ void Foam::mapDistributePolyMesh::distributeFaceIndices(labelList& lst) const
     // Construct boolList from selected elements
     boolList isSelected
     (
-        createWithValues<boolList>
-        (
-            nOldFaces(),
-            false,
-            lst,
-            true
-        )
+        ListOps::createWithValue<bool>(nOldFaces(), lst, true, false)
     );
 
     // Distribute
@@ -249,13 +237,7 @@ void Foam::mapDistributePolyMesh::distributeCellIndices(labelList& lst) const
     // Construct boolList from selected elements
     boolList isSelected
     (
-        createWithValues<boolList>
-        (
-            nOldCells(),
-            false,
-            lst,
-            true
-        )
+        ListOps::createWithValue<bool>(nOldCells(), lst, true, false)
     );
 
     // Distribute
@@ -271,12 +253,12 @@ void Foam::mapDistributePolyMesh::distributePatchIndices(labelList& lst) const
     // Construct boolList from selected elements
     boolList isSelected
     (
-        createWithValues<boolList>
+        ListOps::createWithValue<bool>
         (
-            oldPatchStarts().size(),    // nOldPatches
-            false,
+            oldPatchStarts().size(), // nOldPatches
             lst,
-            true
+            true, // set value
+            false // default value
         )
     );
 
diff --git a/src/mesh/snappyHexMesh/snappyHexMeshDriver/snappyRefineDriver.C b/src/mesh/snappyHexMesh/snappyHexMeshDriver/snappyRefineDriver.C
index bf98805623..f94ec1da30 100644
--- a/src/mesh/snappyHexMesh/snappyHexMeshDriver/snappyRefineDriver.C
+++ b/src/mesh/snappyHexMesh/snappyHexMeshDriver/snappyRefineDriver.C
@@ -1413,12 +1413,12 @@ Foam::label Foam::snappyRefineDriver::shellRefine
 
     // mark list to remove any refined faces
     meshRefiner_.userFaceData()[0].first() = meshRefinement::REMOVE;
-    meshRefiner_.userFaceData()[0].second() = createWithValues<labelList>
+    meshRefiner_.userFaceData()[0].second() = ListOps::createWithValue<label>
     (
         mesh.nFaces(),
-        -1,
         meshRefiner_.intersectedFaces(),
-        0
+        0, // set value
+        -1 // default value
     );
 
     // Determine the maximum refinement level over all volume refinement
diff --git a/src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolation.C b/src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolation.C
index faf88f579d..0d81b99d87 100644
--- a/src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolation.C
+++ b/src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolation.C
@@ -1007,7 +1007,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
         }
 
         // Send data back to originating procs. Note that contributions
-        // from different processors get added (ListAppendEqOp)
+        // from different processors get added (ListOps::appendEqOp)
 
         mapDistributeBase::distribute
         (
@@ -1019,7 +1019,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
             map.subMap(),
             false,                      // has flip
             tgtAddress_,
-            ListAppendEqOp<label>(),
+            ListOps::appendEqOp<label>(),
             flipOp(),                   // flip operation
             labelList()
         );
@@ -1034,7 +1034,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
             map.subMap(),
             false,
             tgtWeights_,
-            ListAppendEqOp<scalar>(),
+            ListOps::appendEqOp<scalar>(),
             flipOp(),
             scalarList()
         );
diff --git a/src/parallel/distributed/distributedTriSurfaceMesh/distributedTriSurfaceMesh.C b/src/parallel/distributed/distributedTriSurfaceMesh/distributedTriSurfaceMesh.C
index 0e0f5b063b..0206840ef7 100644
--- a/src/parallel/distributed/distributedTriSurfaceMesh/distributedTriSurfaceMesh.C
+++ b/src/parallel/distributed/distributedTriSurfaceMesh/distributedTriSurfaceMesh.C
@@ -1084,13 +1084,7 @@ Foam::triSurface Foam::distributedTriSurfaceMesh::subsetMesh
 {
     const boolList include
     (
-        createWithValues<boolList>
-        (
-            s.size(),
-            false,
-            newToOldFaces,
-            true
-        )
+        ListOps::createWithValue<bool>(s.size(), newToOldFaces, true, false)
     );
 
     newToOldPoints.setSize(s.points().size());
diff --git a/src/sampling/surface/isoSurface/isoSurface.C b/src/sampling/surface/isoSurface/isoSurface.C
index f4e09a4da5..a08b8fb964 100644
--- a/src/sampling/surface/isoSurface/isoSurface.C
+++ b/src/sampling/surface/isoSurface/isoSurface.C
@@ -1266,13 +1266,7 @@ Foam::triSurface Foam::isoSurface::subsetMesh
 {
     const boolList include
     (
-        createWithValues<boolList>
-        (
-            s.size(),
-            false,
-            newToOldFaces,
-            true
-        )
+        ListOps::createWithValue<bool>(s.size(), newToOldFaces, true, false)
     );
 
     newToOldPoints.setSize(s.points().size());
diff --git a/src/sampling/surface/isoSurface/isoSurfaceCell.C b/src/sampling/surface/isoSurface/isoSurfaceCell.C
index ab1e6bfdd4..14091a18d0 100644
--- a/src/sampling/surface/isoSurface/isoSurfaceCell.C
+++ b/src/sampling/surface/isoSurface/isoSurfaceCell.C
@@ -1236,13 +1236,7 @@ Foam::triSurface Foam::isoSurfaceCell::subsetMesh
 {
     const boolList include
     (
-        createWithValues<boolList>
-        (
-            s.size(),
-            false,
-            newToOldFaces,
-            true
-        )
+        ListOps::createWithValue<bool>(s.size(), newToOldFaces, true, false)
     );
 
     newToOldPoints.setSize(s.points().size());