diff --git a/applications/test/Circulator/Test-Circulator.C b/applications/test/Circulator/Test-Circulator.C
index c158d57626..c41d7b6544 100644
--- a/applications/test/Circulator/Test-Circulator.C
+++ b/applications/test/Circulator/Test-Circulator.C
@@ -37,6 +37,12 @@ Description
 
 using namespace Foam;
 
+void printCompare(const face& a, const face& b)
+{
+    Info<< "Compare " << a << " and " << b
+        << " Match = " << face::compare(a, b) << endl;
+}
+
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 // Main program:
@@ -96,44 +102,35 @@ int main(int argc, char *argv[])
 
     Info<< nl << nl << "Compare two faces: " << endl;
     face a(identity(5));
-    Info<< "Compare " << a << " and " << a << " Match = " << face::compare(a, a)
-        << endl;
+    printCompare(a, a);
 
     face b(reverseList(a));
-    Info<< "Compare " << a << " and " << b << " Match = " << face::compare(a, b)
-        << endl;
+    printCompare(a, b);
 
     face c(a);
     c[4] = 3;
-    Info<< "Compare " << a << " and " << c << " Match = " << face::compare(a, c)
-        << endl;
+    printCompare(a, c);
 
     face d(rotateList(a, 2));
-    Info<< "Compare " << a << " and " << d << " Match = " << face::compare(a, d)
-        << endl;
+    printCompare(a, d);
 
     face g(labelList(5, 1));
     face h(g);
-    Info<< "Compare " << g << " and " << h << " Match = " << face::compare(g, h)
-        << endl;
+    printCompare(g, h);
 
     g[0] = 2;
     h[3] = 2;
-    Info<< "Compare " << g << " and " << h << " Match = " << face::compare(g, h)
-        << endl;
+    printCompare(g, h);
 
     g[4] = 3;
     h[4] = 3;
-    Info<< "Compare " << g << " and " << h << " Match = " << face::compare(g, h)
-        << endl;
+    printCompare(g, h);
 
     face face1(identity(1));
-    Info<< "Compare " << face1 << " and " << face1
-        << " Match = " << face::compare(face1, face1) << endl;
+    printCompare(face1, face1);
 
-    face face2(identity(1)+1);
-    Info<< "Compare " << face1 << " and " << face2
-        << " Match = " << face::compare(face1, face2) << endl;
+    face face2(identity(1, 2));
+    printCompare(face1, face2);
 
     Info<< nl << nl << "Zero face" << nl << endl;
 
diff --git a/applications/test/PatchTools/Test-PatchTools.C b/applications/test/PatchTools/Test-PatchTools.C
index 0af402b57e..5d4217c0e2 100644
--- a/applications/test/PatchTools/Test-PatchTools.C
+++ b/applications/test/PatchTools/Test-PatchTools.C
@@ -261,7 +261,7 @@ int main(int argc, char *argv[])
 //            (
 //                mesh,
 //                pp,
-//                identity(pp.size())+pp.start()
+//                identity(pp.size(), pp.start())
 //            )
 //        );
 //        forAll(pn, pointi)
@@ -278,7 +278,7 @@ int main(int argc, char *argv[])
 //            (
 //                mesh,
 //                pp,
-//                identity(pp.size())+pp.start()
+//                identity(pp.size(), pp.start())
 //            )
 //        );
 //        forAll(pn, pointi)
diff --git a/applications/utilities/surface/surfaceAdd/surfaceAdd.C b/applications/utilities/surface/surfaceAdd/surfaceAdd.C
index 7bdde7d133..f3bd2b956c 100644
--- a/applications/utilities/surface/surfaceAdd/surfaceAdd.C
+++ b/applications/utilities/surface/surfaceAdd/surfaceAdd.C
@@ -247,7 +247,7 @@ int main(int argc, char *argv[])
                 << " by this amount" << nl << endl;
 
             patch1Map = identity(surface1.patches().size());
-            patch2Map = identity(surface2.patches().size()) + patch1Map.size();
+            patch2Map = identity(surface2.patches().size(), patch1Map.size());
 
             nNewPatches = surface1.patches().size()+surface2.patches().size();
         }
diff --git a/applications/utilities/surface/surfaceHookUp/surfaceHookUp.C b/applications/utilities/surface/surfaceHookUp/surfaceHookUp.C
index 7630d0dc5d..00ef02bab7 100644
--- a/applications/utilities/surface/surfaceHookUp/surfaceHookUp.C
+++ b/applications/utilities/surface/surfaceHookUp/surfaceHookUp.C
@@ -165,10 +165,10 @@ void createBoundaryEdgeTrees
 
         // Boundary edges
         treeBoundaryEdges[surfI] =
-            labelList
+            identity
             (
-                identity(surf.nEdges() - surf.nInternalEdges())
-              + surf.nInternalEdges()
+                surf.nEdges() - surf.nInternalEdges(),
+                surf.nInternalEdges()
             );
 
         Random rndGen(17301893);
diff --git a/src/OpenFOAM/containers/Lists/Distribution/Distribution.C b/src/OpenFOAM/containers/Lists/Distribution/Distribution.C
index 992ffd287a..8a7ae778c3 100644
--- a/src/OpenFOAM/containers/Lists/Distribution/Distribution.C
+++ b/src/OpenFOAM/containers/Lists/Distribution/Distribution.C
@@ -84,14 +84,7 @@ Foam::scalar Foam::Distribution<Type>::totalWeight(direction cmpt) const
 template<class Type>
 Foam::List<Foam::label> Foam::Distribution<Type>::keys(direction cmpt) const
 {
-    List<label> keys = identity((*this)[cmpt].size());
-
-    forAll(keys, k)
-    {
-        keys[k] += listStarts_[cmpt];
-    }
-
-    return keys;
+    return identity((*this)[cmpt].size(), listStarts_[cmpt]);
 }
 
 
diff --git a/src/OpenFOAM/containers/Lists/ListOps/ListOps.C b/src/OpenFOAM/containers/Lists/ListOps/ListOps.C
index 8f92bf5c5b..96e2afe42c 100644
--- a/src/OpenFOAM/containers/Lists/ListOps/ListOps.C
+++ b/src/OpenFOAM/containers/Lists/ListOps/ListOps.C
@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
-     \\/     M anipulation  |
+     \\/     M anipulation  | Copyright (C) 2018 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -42,22 +42,23 @@ Foam::labelList Foam::invert
 
     forAll(map, i)
     {
-        const label newPos = map[i];
+        const label newIdx = map[i];
 
-        if (newPos >= 0)
+        if (newIdx >= 0)
         {
-            if (inverse[newPos] >= 0)
+            if (inverse[newIdx] >= 0)
             {
                 FatalErrorInFunction
                     << "Map is not one-to-one. At index " << i
-                    << " element " << newPos << " has already occurred before"
+                    << " element " << newIdx << " has already occurred before"
                     << nl << "Please use invertOneToMany instead"
                     << abort(FatalError);
             }
 
-            inverse[newPos] = i;
+            inverse[newIdx] = i;
         }
     }
+
     return inverse;
 }
 
@@ -68,31 +69,31 @@ Foam::labelListList Foam::invertOneToMany
     const labelUList& map
 )
 {
-    labelList nElems(len, 0);
+    labelList sizes(len, 0);
 
-    forAll(map, i)
+    for (const label newIdx : map)
     {
-        if (map[i] >= 0)
+        if (newIdx >= 0)
         {
-            nElems[map[i]]++;
+            sizes[newIdx]++;
         }
     }
 
     labelListList inverse(len);
 
-    forAll(nElems, i)
+    for (label i=0; i<len; ++i)
     {
-        inverse[i].setSize(nElems[i]);
-        nElems[i] = 0;
+        inverse[i].setSize(sizes[i]);
+        sizes[i] = 0; // reset size counter
     }
 
     forAll(map, i)
     {
-        const label newI = map[i];
+        const label newIdx = map[i];
 
-        if (newI >= 0)
+        if (newIdx >= 0)
         {
-            inverse[newI][nElems[newI]++] = i;
+            inverse[newIdx][sizes[newIdx]++] = i;
         }
     }
 
@@ -100,13 +101,13 @@ Foam::labelListList Foam::invertOneToMany
 }
 
 
-Foam::labelList Foam::identity(const label len)
+Foam::labelList Foam::identity(const label len, const label start)
 {
     labelList map(len);
 
     for (label i = 0; i < len; ++i)
     {
-        map[i] = i;
+        map[i] = i + start;
     }
 
     return map;
diff --git a/src/OpenFOAM/containers/Lists/ListOps/ListOps.H b/src/OpenFOAM/containers/Lists/ListOps/ListOps.H
index db03ad94e5..941a1795e8 100644
--- a/src/OpenFOAM/containers/Lists/ListOps/ListOps.H
+++ b/src/OpenFOAM/containers/Lists/ListOps/ListOps.H
@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2011-2017 OpenFOAM Foundation
-     \\/     M anipulation  | Copyright (C) 2017 OpenCFD Ltd.
+     \\/     M anipulation  | Copyright (C) 2017-2018 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -59,12 +59,12 @@ static const List<Type>& emptyList()
 //- Renumber the values (not the indices) of a list.
 //  Negative ListType elements are left untouched.
 template<class ListType>
-ListType renumber(const labelUList& oldToNew, const ListType& lst);
+ListType renumber(const labelUList& oldToNew, const ListType& input);
 
 //- Inplace renumber the values (not the indices) of a list.
 //  Negative ListType elements are left untouched.
 template<class ListType>
-void inplaceRenumber(const labelUList& oldToNew, ListType& lst);
+void inplaceRenumber(const labelUList& oldToNew, ListType& input);
 
 
 //- Reorder the elements of a list.
@@ -76,7 +76,7 @@ template<class ListType>
 ListType reorder
 (
     const labelUList& oldToNew,
-    const ListType& lst,
+    const ListType& input,
     const bool prune = false
 );
 
@@ -89,7 +89,7 @@ template<class ListType>
 void inplaceReorder
 (
     const labelUList& oldToNew,
-    ListType& lst,
+    ListType& input,
     const bool prune = false
 );
 
@@ -99,22 +99,22 @@ void inplaceReorder
 
 //- Map values. Do not map negative values.
 template<class Container>
-void inplaceMapValue(const labelUList& oldToNew, Container& lst);
+void inplaceMapValue(const labelUList& oldToNew, Container& input);
 
 //- Recreate with mapped keys. Do not map elements with negative key.
 template<class Container>
-void inplaceMapKey(const labelUList& oldToNew, Container& lst);
+void inplaceMapKey(const labelUList& oldToNew, Container& input);
 
 
 //- Generate the (stable) sort order for the list
 template<class T>
-void sortedOrder(const UList<T>& lst, labelList& order);
+void sortedOrder(const UList<T>& input, labelList& order);
 
 //- Sort using specified list compare predicate
 template<class T, class ListComparePredicate>
 void sortedOrder
 (
-    const UList<T>& lst,
+    const UList<T>& input,
     labelList& order,
     const ListComparePredicate& comp
 );
@@ -122,14 +122,14 @@ void sortedOrder
 
 //- Generate (sorted) indices corresponding to duplicate list values
 template<class T>
-void duplicateOrder(const UList<T>& lst, labelList& order);
+void duplicateOrder(const UList<T>& input, labelList& order);
 
 //- Generate (sorted) indices corresponding to duplicate list values
 //  sort using specified list compare predicate
 template<class T, class ListComparePredicate>
 void duplicateOrder
 (
-    const UList<T>& lst,
+    const UList<T>& input,
     labelList& order,
     const ListComparePredicate& comp
 );
@@ -137,14 +137,14 @@ void duplicateOrder
 
 //- Generate (sorted) indices corresponding to unique list values
 template<class T>
-void uniqueOrder(const UList<T>& lst, labelList& order);
+void uniqueOrder(const UList<T>& input, labelList& order);
 
 //- Generate (sorted) indices corresponding to unique list values
 //  sort using specified list compare predicate
 template<class T, class ListComparePredicate>
 void uniqueOrder
 (
-    const UList<T>& lst,
+    const UList<T>& input,
     labelList& order,
     const ListComparePredicate& comp
 );
@@ -153,14 +153,14 @@ void uniqueOrder
 //- Inplace sorting and removal of duplicates.
 //  Do not use FixedList for the input list, since it doesn't resize.
 template<class ListType>
-void inplaceUniqueSort(ListType& lst);
+void inplaceUniqueSort(ListType& input);
 
 //- Inplace sorting and removal of duplicates.
 //  Do not use FixedList for the input list, since it doesn't resize.
 template<class ListType, class ListComparePredicate>
 void inplaceUniqueSort
 (
-    ListType& lst,
+    ListType& input,
     const ListComparePredicate& comp
 );
 
@@ -178,19 +178,19 @@ void inplaceSubset(const UList<T>& select, const T& value, ListType&);
 
 //- Extract elements of List when select is true
 //  eg, to extract all selected elements:
-//    subset<boolList, labelList>(selectedElems, lst);
+//    subset<boolList, labelList>(selectedElems, list);
 //  Note a labelHashSet can also be used as the bool-list.
 //  Do not use FixedList for the input list, since it doesn't resize.
 template<class BoolListType, class ListType>
-ListType subset(const BoolListType& select, const ListType& lst);
+ListType subset(const BoolListType& select, const ListType& input);
 
 //- Inplace extract elements of List when select is true
 //  eg, to extract all selected elements:
-//    inplaceSubset<boolList, labelList>(selectedElems, lst);
+//    inplaceSubset<boolList, labelList>(selectedElems, list);
 //  Note a labelHashSet can also be used as the bool-list.
 //  Do not use FixedList for the input list, since it doesn't resize.
 template<class BoolListType, class ListType>
-void inplaceSubset(const BoolListType& select, ListType& lst);
+void inplaceSubset(const BoolListType& select, ListType& input);
 
 
 //- Copy a subset of the input list when predicate is true.
@@ -199,7 +199,8 @@ template<class ListType, class UnaryPredicate>
 ListType subsetList
 (
     const ListType& input,
-    const UnaryPredicate& pred
+    const UnaryPredicate& pred,
+    const bool invert=false
 );
 
 //- Inplace subset of the list when predicate is true.
@@ -208,7 +209,8 @@ template<class ListType, class UnaryPredicate>
 void inplaceSubsetList
 (
     ListType& input,
-    const UnaryPredicate& pred
+    const UnaryPredicate& pred,
+    const bool invert=false
 );
 
 
@@ -242,7 +244,8 @@ List<OutputIntListType> invertManyToMany
 }
 
 //- Create identity map of the given length with (map[i] == i)
-labelList identity(const label len);
+//  Optionally with an alternative start index, so that (map[i] == i+start)
+labelList identity(const label len, const label start=0);
 
 //- Find first occurence of given element and return index,
 //  return -1 if not found. Linear search.
@@ -265,23 +268,23 @@ labelList findIndices
 (
     const ListType& input,
     typename ListType::const_reference val,
-    const label start=0
+    label start=0
 );
 
 //- Opposite of findIndices: set values at indices to given value
 template<class ListType>
 void setValues
 (
-    ListType& l,
+    ListType& input,
     const labelUList& indices,
-    typename ListType::const_reference t
+    typename ListType::const_reference val
 );
 
 //- Opposite of findIndices: set values at indices to given value
 template<class ListType>
 ListType createWithValues
 (
-    const label sz,
+    const label len,
     typename ListType::const_reference initValue,
     const labelUList& indices,
     typename ListType::const_reference setValue
@@ -290,13 +293,13 @@ ListType createWithValues
 //- Find index of max element (and larger than given element).
 //  return -1 if not found. Linear search.
 template<class ListType>
-label findMax(const ListType& l, const label start=0);
+label findMax(const ListType& input, const label start=0);
 
 
 //- Find index of min element (and less than given element).
 //  return -1 if not found. Linear search.
 template<class ListType>
-label findMin(const ListType& l, const label start=0);
+label findMin(const ListType& input, const label start=0);
 
 
 //- Find first occurrence of given element in sorted list and return index,
@@ -304,21 +307,21 @@ label findMin(const ListType& l, const label start=0);
 template<class ListType>
 label findSortedIndex
 (
-    const ListType& l,
-    typename ListType::const_reference t,
+    const ListType& input,
+    typename ListType::const_reference val,
     const label start=0
 );
 
 
 //- Find last element < given value in sorted list and return index,
 //  return -1 if not found. Binary search.
-template<class ListType, class BinaryOp>
+template<class ListType, class BinaryPredicate>
 label findLower
 (
-    const ListType& l,
-    typename ListType::const_reference t,
+    const ListType& input,
+    typename ListType::const_reference val,
     const label start,
-    const BinaryOp& bop
+    const BinaryPredicate& pred
 );
 
 
@@ -327,8 +330,8 @@ label findLower
 template<class ListType>
 label findLower
 (
-    const ListType& l,
-    typename ListType::const_reference t,
+    const ListType& input,
+    typename ListType::const_reference val,
     const label start=0
 );
 
@@ -369,12 +372,12 @@ public:
 
 //- Reverse a list. First element becomes last element etc.
 template<class ListType>
-ListType reverseList(const ListType& list);
+ListType reverseList(const ListType& input);
 
 
 //- Inplace reversal of a list using Swap.
 template<class ListType>
-void inplaceReverseList(ListType& list);
+void inplaceReverseList(ListType& input);
 
 
 //- Rotate a list by n places. If n is positive rotate clockwise/right/down.
diff --git a/src/OpenFOAM/containers/Lists/ListOps/ListOpsTemplates.C b/src/OpenFOAM/containers/Lists/ListOps/ListOpsTemplates.C
index 41ca98ae28..7de2564cce 100644
--- a/src/OpenFOAM/containers/Lists/ListOps/ListOpsTemplates.C
+++ b/src/OpenFOAM/containers/Lists/ListOps/ListOpsTemplates.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) 2015-2017 OpenCFD Ltd.
+     \\/     M anipulation  | Copyright (C) 2015-2018 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -31,21 +31,23 @@ template<class ListType>
 ListType Foam::renumber
 (
     const labelUList& oldToNew,
-    const ListType& lst
+    const ListType& input
 )
 {
-    ListType newLst(lst.size());
-    newLst.setSize(lst.size()); // Consistent sizing (eg, DynamicList)
+    const label len = input.size();
 
-    forAll(lst, elemI)
+    ListType output(len);
+    output.resize(len);     // Consistent sizing (eg, DynamicList)
+
+    for (label i=0; i < len; ++i)
     {
-        if (lst[elemI] >= 0)
+        if (input[i] >= 0)
         {
-            newLst[elemI] = oldToNew[lst[elemI]];
+            output[i] = oldToNew[input[i]];
         }
     }
 
-    return newLst;
+    return output;
 }
 
 
@@ -53,14 +55,16 @@ template<class ListType>
 void Foam::inplaceRenumber
 (
     const labelUList& oldToNew,
-    ListType& lst
+    ListType& input
 )
 {
-    forAll(lst, elemI)
+    const label len = input.size();
+
+    for (label i=0; i < len; ++i)
     {
-        if (lst[elemI] >= 0)
+        if (input[i] >= 0)
         {
-            lst[elemI] = oldToNew[lst[elemI]];
+            input[i] = oldToNew[input[i]];
         }
     }
 }
@@ -70,25 +74,25 @@ template<class ListType>
 ListType Foam::reorder
 (
     const labelUList& oldToNew,
-    const ListType& lst,
+    const ListType& input,
     const bool prune
 )
 {
-    const label sz = lst.size();
+    const label len = input.size();
 
-    ListType newLst(sz);
-    newLst.setSize(sz);     // Consistent sizing (eg, DynamicList)
+    ListType output(len);
+    output.resize(len);     // Consistent sizing (eg, DynamicList)
 
     label maxIdx = -1;      // For pruning: newSize = maxIdx+1
-    forAll(lst, i)
+    for (label i=0; i < len; ++i)
     {
         const label newIdx = oldToNew[i];
         if (newIdx >= 0)
         {
-            // Could additionally enforce (newIdx < lst.size())
+            // Could enforce (newIdx < len)
             // ... or just rely on FULLDEBUG from UList
 
-            newLst[newIdx] = lst[i];
+            output[newIdx] = input[i];
 
             if (maxIdx < newIdx)
             {
@@ -97,16 +101,16 @@ ListType Foam::reorder
         }
         else if (!prune)
         {
-            newLst[i] = lst[i];
+            output[i] = input[i];
         }
     }
 
     if (prune)
     {
-        newLst.setSize(maxIdx+1);
+        output.resize(maxIdx+1);
     }
 
-    return newLst;
+    return output;
 }
 
 
@@ -114,25 +118,28 @@ template<class ListType>
 void Foam::inplaceReorder
 (
     const labelUList& oldToNew,
-    ListType& lst,
+    ListType& input,
     const bool prune
 )
 {
-    const label sz = lst.size();
+    // NOTE: cannot use std::move() since we have no guarantee that
+    // the oldToNew map is unique (ie, shuffle)
 
-    ListType newLst(sz);
-    newLst.setSize(sz);     // Consistent sizing (eg, DynamicList)
+    const label len = input.size();
+
+    ListType output(len);
+    output.resize(len);     // Consistent sizing (eg, DynamicList)
 
     label maxIdx = -1;      // For pruning: newSize = maxIdx+1
-    forAll(lst, i)
+    for (label i=0; i < len; ++i)
     {
         const label newIdx = oldToNew[i];
         if (newIdx >= 0)
         {
-            // Could additionally enforce (newIdx < lst.size())
+            // Could enforce (newIdx < len)
             // ... or just rely on FULLDEBUG from UList
 
-            newLst[newIdx] = lst[i];
+            output[newIdx] = input[i];
 
             if (maxIdx < newIdx)
             {
@@ -141,16 +148,16 @@ void Foam::inplaceReorder
         }
         else if (!prune)
         {
-            newLst[i] = lst[i];
+            output[i] = input[i];
         }
     }
 
     if (prune)
     {
-        newLst.setSize(maxIdx+1);
+        output.resize(maxIdx+1);
     }
 
-    lst.transfer(newLst);
+    input.transfer(output);
 }
 
 
@@ -158,15 +165,15 @@ template<class Container>
 void Foam::inplaceMapValue
 (
     const labelUList& oldToNew,
-    Container& lst
+    Container& input
 )
 {
-    for (auto iter = lst.begin(); iter != lst.end(); ++iter)
+    for (auto iter = input.begin(); iter != input.end(); ++iter)
     {
         const label oldIdx = iter.object();
         if (oldIdx >= 0)
         {
-            // Could additionally enforce (oldIdx < oldToNew.size())
+            // Could enforce (oldIdx < oldToNew.size())
             // ... or just rely on FULLDEBUG from UList
 
             iter.object() = oldToNew[oldIdx];
@@ -179,57 +186,57 @@ template<class Container>
 void Foam::inplaceMapKey
 (
     const labelUList& oldToNew,
-    Container& lst
+    Container& input
 )
 {
-    Container newLst(lst.size());
+    Container output(input.capacity());
 
-    for (auto iter = lst.begin(); iter != lst.end(); ++iter)
+    for (auto iter = input.begin(); iter != input.end(); ++iter)
     {
         const label oldIdx = iter.key();
         if (oldIdx >= 0)
         {
-            // Could additionally enforce (oldIdx < oldToNew.size())
+            // Could enforce (oldIdx < oldToNew.size())
             // ... or just rely on FULLDEBUG from UList
 
-            newLst.insert(oldToNew[oldIdx], iter.object());
+            output.insert(oldToNew[oldIdx], iter.object());
         }
     }
 
-    lst.transfer(newLst);
+    input.transfer(output);
 }
 
 
 template<class T>
 void Foam::sortedOrder
 (
-    const UList<T>& lst,
+    const UList<T>& input,
     labelList& order
 )
 {
-    sortedOrder(lst, order, typename UList<T>::less(lst));
+    sortedOrder(input, order, typename UList<T>::less(input));
 }
 
 
 template<class T, class ListComparePredicate>
 void Foam::sortedOrder
 (
-    const UList<T>& lst,
+    const UList<T>& input,
     labelList& order,
     const ListComparePredicate& comp
 )
 {
-    const label len = lst.size();
+    const label len = input.size();
 
     // list lengths must be identical
     if (order.size() != len)
     {
-        // Avoid copying any elements, they are overwritten anyhow
+        // Avoid copying elements, they are overwritten anyhow
         order.clear();
-        order.setSize(len);
+        order.resize(len);
     }
 
-    for (label i=0; i<len; ++i)
+    for (label i=0; i < len; ++i)
     {
         order[i] = i; // identity
     }
@@ -241,88 +248,89 @@ void Foam::sortedOrder
 template<class T>
 void Foam::duplicateOrder
 (
-    const UList<T>& lst,
+    const UList<T>& input,
     labelList& order
 )
 {
-    duplicateOrder(lst, order, typename UList<T>::less(lst));
+    duplicateOrder(input, order, typename UList<T>::less(input));
 }
 
 
 template<class T, class ListComparePredicate>
 void Foam::duplicateOrder
 (
-    const UList<T>& lst,
+    const UList<T>& input,
     labelList& order,
     const ListComparePredicate& comp
 )
 {
-    if (lst.size() < 2)
+    if (input.size() < 2)
     {
         order.clear();
         return;
     }
 
-    sortedOrder(lst, order, comp);
+    sortedOrder(input, order, comp);
 
     const label last = (order.size()-1);
-    label n = 0;
+    label count = 0;
     for (label i = 0; i < last; ++i)
     {
-        if (lst[order[i]] == lst[order[i+1]])
+        if (input[order[i]] == input[order[i+1]])
         {
-            order[n++] = order[i];
+            order[count] = order[i];
+            ++count;
         }
     }
-    order.setSize(n);
+    order.resize(count);
 }
 
 
 template<class T>
 void Foam::uniqueOrder
 (
-    const UList<T>& lst,
+    const UList<T>& input,
     labelList& order
 )
 {
-    uniqueOrder(lst, order, typename UList<T>::less(lst));
+    uniqueOrder(input, order, typename UList<T>::less(input));
 }
 
 
 template<class T, class ListComparePredicate>
 void Foam::uniqueOrder
 (
-    const UList<T>& lst,
+    const UList<T>& input,
     labelList& order,
     const ListComparePredicate& comp
 )
 {
-    sortedOrder(lst, order, comp);
+    sortedOrder(input, order, comp);
 
     if (order.size() > 1)
     {
         const label last = (order.size()-1);
-        label n = 0;
+        label count = 0;
         for (label i = 0; i < last; ++i)
         {
-            if (lst[order[i]] != lst[order[i+1]])
+            if (input[order[i]] != input[order[i+1]])
             {
-                order[n++] = order[i];
+                order[count++] = order[i];
             }
         }
-        order[n++] = order[last];
-        order.setSize(n);
+        order[count++] = order[last];
+        order.resize(count);
     }
 }
 
 
 template<class ListType>
-void Foam::inplaceUniqueSort(ListType& lst)
+void Foam::inplaceUniqueSort(ListType& input)
 {
     inplaceUniqueSort
     (
-        lst,
-        typename UList<typename ListType::value_type>::less(lst)
+        input,
+        typename UList<typename ListType::value_type>::less(input)
     );
 }
 
@@ -330,24 +338,24 @@ void Foam::inplaceUniqueSort(ListType& lst)
 template<class ListType, class ListComparePredicate>
 void Foam::inplaceUniqueSort
 (
-    ListType& lst,
+    ListType& input,
     const ListComparePredicate& comp
 )
 {
     labelList order;
-    uniqueOrder(lst, order, comp);
+    uniqueOrder(input, order, comp);
 
     const label len = order.size();
 
-    ListType newLst(len);
-    newLst.setSize(len);  // Consistent sizing (eg, DynamicList)
+    ListType output(len);
+    output.resize(len);     // Consistent sizing (eg, DynamicList)
 
-    for (label i=0; i<len; ++i)
+    for (label i=0; i < len; ++i)
     {
-        newLst[i] = lst[order[i]];
+        output[i] = std::move(input[order[i]]);
     }
 
-    lst.transfer(newLst);
+    input.transfer(output);
 }
 
 
@@ -356,32 +364,35 @@ ListType Foam::subset
 (
     const UList<T>& select,
     const T& value,
-    const ListType& lst
+    const ListType& input
 )
 {
+    const label len = input.size();
+
     // select must at least cover the list range
-    if (select.size() < lst.size())
+    if (select.size() < len)
     {
         FatalErrorInFunction
             << "select is of size " << select.size()
-            << "; but it must index a list of size " << lst.size()
+            << "; but it must index a list of size " << len
             << abort(FatalError);
     }
 
-    ListType newLst(lst.size());
-    newLst.setSize(lst.size()); // Consistent sizing (eg, DynamicList)
+    ListType output(len);
+    output.resize(len);     // Consistent sizing (eg, DynamicList)
 
-    label nElem = 0;
-    forAll(lst, elemI)
+    label count = 0;
+    for (label i=0; i < len; ++i)
     {
-        if (select[elemI] == value)
+        if (select[i] == value)
         {
-            newLst[nElem++] = lst[elemI];
+            output[count] = input[i];
+            ++count;
         }
     }
-    newLst.setSize(nElem);
+    output.resize(count);
 
-    return newLst;
+    return output;
 }
 
 
@@ -390,32 +401,34 @@ void Foam::inplaceSubset
 (
     const UList<T>& select,
     const T& value,
-    ListType& lst
+    ListType& input
 )
 {
+    const label len = input.size();
+
     // select must at least cover the list range
-    if (select.size() < lst.size())
+    if (select.size() < len)
     {
         FatalErrorInFunction
             << "select is of size " << select.size()
-            << "; but it must index a list of size " << lst.size()
+            << "; but it must index a list of size " << len
             << abort(FatalError);
     }
 
-    label nElem = 0;
-    forAll(lst, elemI)
+    label count = 0;
+    for (label i=0; i < len; ++i)
     {
-        if (select[elemI] == value)
+        if (select[i] == value)
         {
-            if (nElem != elemI)
+            if (count != i)
             {
-                lst[nElem] = lst[elemI];
+                input[count] = std::move(input[i]);
             }
-            ++nElem;
+            ++count;
         }
     }
 
-    lst.setSize(nElem);
+    input.resize(count);
 }
 
 
@@ -423,26 +436,28 @@ template<class BoolListType, class ListType>
 ListType Foam::subset
 (
     const BoolListType& select,
-    const ListType& lst
+    const ListType& input
 )
 {
-    // select can have a different size
-    // eg, when it is a PackedBoolList or a labelHashSet
+    const label len = input.size();
 
-    ListType newLst(lst.size());
-    newLst.setSize(lst.size()); // Consistent sizing (eg, DynamicList)
+    // select can have a different size (eg, PackedBoolList, labelHashSet)
 
-    label nElem = 0;
-    forAll(lst, elemI)
+    ListType output(len);
+    output.resize(len);   // Consistent sizing (eg, DynamicList)
+
+    label count = 0;
+    for (label i=0; i < len; ++i)
     {
-        if (select[elemI])
+        if (select[i])
         {
-            newLst[nElem++] = lst[elemI];
+            output[count] = input[i];
+            ++count;
         }
     }
-    newLst.setSize(nElem);
+    output.resize(count);
 
-    return newLst;
+    return output;
 }
 
 
@@ -450,74 +465,80 @@ template<class BoolListType, class ListType>
 void Foam::inplaceSubset
 (
     const BoolListType& select,
-    ListType& lst
+    ListType& input
 )
 {
-    // select can have a different size
-    // eg, when it is a PackedBoolList or a labelHashSet
+    const label len = input.size();
 
-    label nElem = 0;
-    forAll(lst, elemI)
+    // select can have a different size (eg, PackedBoolList, labelHashSet)
+
+    label count = 0;
+    for (label i=0; i < len; ++i)
     {
-        if (select[elemI])
+        if (select[i])
         {
-            if (nElem != elemI)
+            if (count != i)
             {
-                lst[nElem] = lst[elemI];
+                input[count] = std::move(input[i]);
             }
-            ++nElem;
+            ++count;
         }
     }
-
-    lst.setSize(nElem);
+    input.resize(count);
 }
 
 
 template<class ListType, class UnaryPredicate>
 ListType Foam::subsetList
 (
-    const ListType& lst,
-    const UnaryPredicate& pred
+    const ListType& input,
+    const UnaryPredicate& pred,
+    const bool invert
 )
 {
-    ListType newLst(lst.size());
-    newLst.setSize(lst.size()); // Consistent sizing (eg, DynamicList)
+    const label len = input.size();
 
-    label nElem = 0;
-    forAll(lst, elemI)
+    ListType output(len);
+    output.resize(len);  // Consistent sizing (eg, DynamicList)
+
+    label count = 0;
+    for (label i=0; i < len; ++i)
     {
-        if (pred(lst[elemI]))
+        if (pred(input[i]) ? !invert : invert)
         {
-            newLst[nElem++] = lst[elemI];
+            output[count] = input[i];
+            ++count;
         }
     }
-    newLst.setSize(nElem);
+    output.resize(count);
 
-    return newLst;
+    return output;
 }
 
 
 template<class ListType, class UnaryPredicate>
 void Foam::inplaceSubsetList
 (
-    ListType& lst,
-    const UnaryPredicate& pred
+    ListType& input,
+    const UnaryPredicate& pred,
+    const bool invert
 )
 {
-    label nElem = 0;
-    forAll(lst, elemI)
+    const label len = input.size();
+
+    label count = 0;
+    for (label i=0; i < len; ++i)
     {
-        if (pred(lst[elemI]))
+        if (pred(input[i]) ? !invert : invert)
         {
-            if (nElem != elemI)
+            if (count != i)
             {
-                lst[nElem] = lst[elemI];
+                input[count] = std::move(input[i]);
             }
-            ++nElem;
+            ++count;
         }
     }
-
-    lst.setSize(nElem);
+    input.resize(count);
 }
 
 
@@ -568,31 +589,41 @@ void Foam::invertManyToMany
 template<class ListType>
 Foam::labelList Foam::findIndices
 (
-    const ListType& l,
-    typename ListType::const_reference t,
-    const label start
+    const ListType& input,
+    typename ListType::const_reference val,
+    label start
 )
 {
-    // Count occurrences
-    label n = 0;
+    const label len = input.size();
 
-    for (label i = start; i < l.size(); i++)
+    // Pass 1: count occurrences
+    label count = 0;
+    for (label i = start; i < len; ++i)
     {
-        if (l[i] == t)
+        if (input[i] == val)
         {
-            n++;
+            if (!count) start = i;  // adjust start for second pass
+            ++count;
         }
     }
 
-    // Create and fill
-    labelList indices(n);
-    n = 0;
+    labelList indices(count);
 
-    for (label i = start; i < l.size(); i++)
+    // Pass 2: fill content
+    if (count)
     {
-        if (l[i] == t)
+        const label total = count;
+        count = 0;
+        for (label i = start; i < len; ++i)
         {
-            indices[n++] = i;
+            if (input[i] == val)
+            {
+                indices[count] = i;
+                if (++count == total)
+                {
+                    break;
+                }
+            }
         }
     }
 
@@ -603,14 +634,14 @@ Foam::labelList Foam::findIndices
 template<class ListType>
 void Foam::setValues
 (
-    ListType& l,
+    ListType& input,
     const labelUList& indices,
-    typename ListType::const_reference t
+    typename ListType::const_reference val
 )
 {
-    forAll(indices, i)
+    for (const label idx : indices)
     {
-        l[indices[i]] = t;
+        input[idx] = val;
     }
 }
 
@@ -618,87 +649,89 @@ void Foam::setValues
 template<class ListType>
 ListType Foam::createWithValues
 (
-    const label sz,
+    const label len,
     const typename ListType::const_reference initValue,
     const labelUList& indices,
     typename ListType::const_reference setValue
 )
 {
-    ListType l(sz, initValue);
-    setValues(l, indices, setValue);
-    return l;
+    ListType list(len, initValue);
+    setValues(list, indices, setValue);
+    return list;
 }
 
 
 template<class ListType>
-Foam::label Foam::findMax(const ListType& l, const label start)
+Foam::label Foam::findMax(const ListType& input, const label start)
 {
-    if (start >= l.size())
+    const label len = input.size();
+
+    if (start >= len)
     {
         return -1;
     }
 
-    label index = start;
-
-    for (label i = start+1; i < l.size(); i++)
+    label idx = start;
+    for (label i = start+1; i < len; ++i)
     {
-        if (l[i] > l[index])
+        if (input[idx] < input[i])
         {
-            index = i;
+            idx = i;
         }
     }
 
-    return index;
+    return idx;
 }
 
 
 template<class ListType>
-Foam::label Foam::findMin(const ListType& l, const label start)
+Foam::label Foam::findMin(const ListType& input, const label start)
 {
-    if (start >= l.size())
+    const label len = input.size();
+
+    if (start >= len)
     {
         return -1;
     }
 
-    label index = start;
-
-    for (label i = start+1; i < l.size(); i++)
+    label idx = start;
+    for (label i = start+1; i < len; ++i)
     {
-        if (l[i] < l[index])
+        if (input[i] < input[idx])
         {
-            index = i;
+            idx = i;
         }
     }
 
-    return index;
+    return idx;
 }
 
 
 template<class ListType>
 Foam::label Foam::findSortedIndex
 (
-    const ListType& l,
-    typename ListType::const_reference t,
+    const ListType& input,
+    typename ListType::const_reference val,
     const label start
 )
 {
-    if (start >= l.size())
+    label low = start;
+    label high = input.size() - 1;
+
+    if (start >= input.size())
     {
         return -1;
     }
 
-    label low = start;
-    label high = l.size() - 1;
-
     while (low <= high)
     {
-        label mid = (low + high)/2;
+        const label mid = (low + high)/2;
 
-        if (t < l[mid])
+        if (val < input[mid])
         {
             high = mid - 1;
         }
-        else if (t > l[mid])
+        else if (input[mid] < val)
         {
             low = mid + 1;
         }
@@ -712,28 +745,28 @@ Foam::label Foam::findSortedIndex
 }
 
 
-template<class ListType, class BinaryOp>
+template<class ListType, class BinaryPredicate>
 Foam::label Foam::findLower
 (
-    const ListType& l,
-    typename ListType::const_reference t,
+    const ListType& input,
+    typename ListType::const_reference val,
     const label start,
-    const BinaryOp& bop
+    const BinaryPredicate& pred
 )
 {
-    if (start >= l.size())
+    label low = start;
+    label high = input.size() - 1;
+
+    if (start >= input.size())
     {
         return -1;
     }
 
-    label low = start;
-    label high = l.size() - 1;
-
     while ((high - low) > 1)
     {
-        label mid = (low + high)/2;
+        const label mid = (low + high)/2;
 
-        if (bop(l[mid], t))
+        if (pred(input[mid], val))
         {
             low = mid;
         }
@@ -743,20 +776,17 @@ Foam::label Foam::findLower
         }
     }
 
-    if (bop(l[high], t))
+    if (pred(input[high], val))
     {
         return high;
     }
+    else if (pred(input[low], val))
+    {
+        return low;
+    }
     else
     {
-        if (bop(l[low], t))
-        {
-            return low;
-        }
-        else
-        {
-            return -1;
-        }
+        return -1;
     }
 }
 
@@ -764,12 +794,18 @@ Foam::label Foam::findLower
 template<class ListType>
 Foam::label Foam::findLower
 (
-    const ListType& l,
-    typename ListType::const_reference t,
+    const ListType& input,
+    typename ListType::const_reference val,
     const label start
 )
 {
-    return findLower(l, t, start, lessOp<typename ListType::value_type>());
+    return findLower
+    (
+        input,
+        val,
+        start,
+        lessOp<typename ListType::value_type>()
+    );
 }
 
 
@@ -809,13 +845,13 @@ void Foam::ListAppendEqOp<T>::operator()(List<T>& x, const List<T>& y) const
 {
     if (y.size())
     {
-        if (x.size())
+        label len = x.size();
+        if (len)
         {
-            label sz = x.size();
-            x.setSize(sz + y.size());
-            forAll(y, i)
+            x.setSize(len + y.size());
+            for (const T& val : y)
             {
-                x[sz++] = y[i];
+                x[len++] = val;
             }
         }
         else
@@ -833,11 +869,11 @@ void Foam::ListUniqueEqOp<T>::operator()(List<T>& x, const List<T>& y) const
     {
         if (x.size())
         {
-            forAll(y, i)
+            for (const T& val : y)
             {
-                if (!x.found(y[i]))
+                if (!x.found(val))
                 {
-                    x.append(y[i]);
+                    x.append(val);
                 }
             }
         }
@@ -850,81 +886,80 @@ void Foam::ListUniqueEqOp<T>::operator()(List<T>& x, const List<T>& y) const
 
 
 template<class ListType>
-ListType Foam::reverseList(const ListType& list)
+ListType Foam::reverseList(const ListType& input)
 {
-    const label listSize = list.size();
-    const label lastIndex = listSize - 1;
+    const label len = input.size();
+    const label last = (len - 1);
 
-    ListType tmpList(listSize);
+    ListType output(len);
+    output.resize(len);     // Consistent sizing (eg, DynamicList)
 
-    forAll(tmpList, elemI)
+    for (label i=0; i < len; ++i)
     {
-        tmpList[elemI] = list[lastIndex - elemI];
+        output[i] = input[last - i];
     }
 
-    return tmpList;
+    return output;
 }
 
 
 template<class ListType>
-void Foam::inplaceReverseList(ListType& list)
+void Foam::inplaceReverseList(ListType& input)
 {
-    const label listSize = list.size();
-    const label lastIndex = listSize - 1;
-    const label nIterations = listSize >> 1;
+    const label len = input.size();
+    const label last = (len - 1);
+    const label n2 = len >> 1;
 
-    label elemI = 0;
-    while (elemI < nIterations)
+    for (label i=0; i<n2; ++i)
     {
-        Foam::Swap(list[elemI], list[lastIndex - elemI]);
-
-        elemI++;
+        Foam::Swap(input[i], input[last - i]);
     }
 }
 
 
 template<class ListType>
-ListType Foam::rotateList(const ListType& list, const label n)
+ListType Foam::rotateList(const ListType& input, const label n)
 {
-    const label listSize = list.size();
+    const label len = input.size();
 
-    ListType tmpList(listSize);
+    ListType output(len);
+    output.resize(len);     // Consistent sizing (eg, DynamicList)
 
-    forAll(tmpList, elemI)
+    for (label i=0; i<len; ++i)
     {
-        label index = (elemI - n) % listSize;
+        label index = (i - n) % len;
 
         if (index < 0)
         {
-            index += listSize;
+            index += len;
         }
 
-        tmpList[elemI] = list[index];
+        output[i] = input[index];
     }
 
-    return tmpList;
+    return output;
 }
 
 
 template<template<typename> class ListType, class DataType>
-void Foam::inplaceRotateList(ListType<DataType>& list, label n)
+void Foam::inplaceRotateList(ListType<DataType>& input, label n)
 {
-    const label listSize = list.size();
+    const label len = input.size();
 
-    n = (listSize - n) % listSize;
+    n = (len - n) % len;
 
     if (n < 0)
     {
-        n += listSize;
+        n += len;
     }
 
-    SubList<DataType> firstHalf(list, n, 0);
-    SubList<DataType> secondHalf(list, listSize - n, n);
+    SubList<DataType> firstHalf(input, n, 0);
+    SubList<DataType> secondHalf(input, len - n, n);
 
     inplaceReverseList(firstHalf);
     inplaceReverseList(secondHalf);
 
-    inplaceReverseList(list);
+    inplaceReverseList(input);
 }
 
 
diff --git a/src/OpenFOAM/containers/Lists/UList/UListI.H b/src/OpenFOAM/containers/Lists/UList/UListI.H
index 20cdaae6de..bc40e5bda1 100644
--- a/src/OpenFOAM/containers/Lists/UList/UListI.H
+++ b/src/OpenFOAM/containers/Lists/UList/UListI.H
@@ -369,7 +369,7 @@ inline void Foam::UList<T>::swap(UList<T>& lst)
 template<class T>
 inline void Foam::reverse(UList<T>& lst, const label n)
 {
-    for (int i=0; i<n/2; ++i)
+    for (label i=0; i<n/2; ++i)
     {
         Foam::Swap(lst[i], lst[n-1-i]);
     }
diff --git a/src/OpenFOAM/primitives/strings/lists/stringListOps.H b/src/OpenFOAM/primitives/strings/lists/stringListOps.H
index cce3dbc971..e8a3f87c12 100644
--- a/src/OpenFOAM/primitives/strings/lists/stringListOps.H
+++ b/src/OpenFOAM/primitives/strings/lists/stringListOps.H
@@ -54,7 +54,7 @@ namespace Foam
     labelList findMatchingStrings
     (
         const UnaryMatchPredicate& matcher,
-        const UList<StringType>& lst,
+        const UList<StringType>& input,
         const bool invert=false
     );
 
@@ -65,11 +65,11 @@ namespace Foam
     labelList findStrings
     (
         const regExp& matcher,
-        const UList<StringType>& lst,
+        const UList<StringType>& input,
         const bool invert=false
     )
     {
-        return findMatchingStrings(matcher, lst, invert);
+        return findMatchingStrings(matcher, input, invert);
     }
 
 
@@ -79,11 +79,11 @@ namespace Foam
     labelList findStrings
     (
         const char* re,
-        const UList<StringType>& lst,
+        const UList<StringType>& input,
         const bool invert=false
     )
     {
-        return findMatchingStrings(regExp(re), lst, invert);
+        return findMatchingStrings(regExp(re), input, invert);
     }
 
 
@@ -93,11 +93,11 @@ namespace Foam
     labelList findStrings
     (
         const std::string& re,
-        const UList<StringType>& lst,
+        const UList<StringType>& input,
         const bool invert=false
     )
     {
-        return findMatchingStrings(regExp(re), lst, invert);
+        return findMatchingStrings(regExp(re), input, invert);
     }
 
 
@@ -107,11 +107,11 @@ namespace Foam
     labelList findStrings
     (
         const wordRe& matcher,
-        const UList<StringType>& lst,
+        const UList<StringType>& input,
         const bool invert=false
     )
     {
-        return findMatchingStrings(matcher, lst, invert);
+        return findMatchingStrings(matcher, input, invert);
     }
 
 
@@ -121,11 +121,11 @@ namespace Foam
     labelList findStrings
     (
         const wordRes& matcher,
-        const UList<StringType>& lst,
+        const UList<StringType>& input,
         const bool invert=false
     )
     {
-        return findMatchingStrings(matcher, lst, invert);
+        return findMatchingStrings(matcher, input, invert);
     }
 
     //- Return list indices for strings matching one of the regular expression
@@ -148,13 +148,13 @@ namespace Foam
     //  optionally invert the match
     //  eg, to extract all selected elements:
     //  \code
-    //    subsetMatchingStrings<regExp, stringList>(myRegExp, lst);
+    //    subsetMatchingStrings<regExp, stringList>(myRegExp, list);
     //  \endcode
     template<class UnaryMatchPredicate, class StringListType>
     StringListType subsetMatchingStrings
     (
         const UnaryMatchPredicate& matcher,
-        const StringListType& lst,
+        const StringListType& input,
         const bool invert=false
     );
 
@@ -165,11 +165,11 @@ namespace Foam
     StringListType subsetStrings
     (
         const regExp& matcher,
-        const StringListType& lst,
+        const StringListType& input,
         const bool invert=false
     )
     {
-        return subsetMatchingStrings(matcher, lst, invert);
+        return subsetMatchingStrings(matcher, input, invert);
     }
 
 
@@ -179,11 +179,11 @@ namespace Foam
     StringListType subsetStrings
     (
         const char* re,
-        const StringListType& lst,
+        const StringListType& input,
         const bool invert=false
     )
     {
-        return subsetMatchingStrings(regExp(re), lst, invert);
+        return subsetMatchingStrings(regExp(re), input, invert);
     }
 
     //- Extract elements of StringList when regular expression matches
@@ -192,11 +192,11 @@ namespace Foam
     StringListType subsetStrings
     (
         const std::string& re,
-        const StringListType& lst,
+        const StringListType& input,
         const bool invert=false
     )
     {
-        return subsetMatchingStrings(regExp(re), lst, invert);
+        return subsetMatchingStrings(regExp(re), input, invert);
     }
 
     //- Extract elements of StringList when regular expression matches
@@ -205,11 +205,11 @@ namespace Foam
     StringListType subsetStrings
     (
         const wordRe& matcher,
-        const StringListType& lst,
+        const StringListType& input,
         const bool invert=false
     )
     {
-        return subsetMatchingStrings(matcher, lst, invert);
+        return subsetMatchingStrings(matcher, input, invert);
     }
 
     //- Extract elements of StringList when regular expression matches
@@ -218,11 +218,11 @@ namespace Foam
     StringListType subsetStrings
     (
         const wordRes& matcher,
-        const StringListType& lst,
+        const StringListType& input,
         const bool invert=false
     )
     {
-        return subsetMatchingStrings(matcher, lst, invert);
+        return subsetMatchingStrings(matcher, input, invert);
     }
 
 
@@ -248,7 +248,7 @@ namespace Foam
     void inplaceSubsetMatchingStrings
     (
         const UnaryMatchPredicate& matcher,
-        StringListType& lst,
+        StringListType& input,
         const bool invert=false
     );
 
@@ -258,11 +258,11 @@ namespace Foam
     void inplaceSubsetStrings
     (
         const regExp& matcher,
-        StringListType& lst,
+        StringListType& input,
         const bool invert=false
     )
     {
-        inplaceSubsetMatchingStrings(matcher, lst, invert);
+        inplaceSubsetMatchingStrings(matcher, input, invert);
     }
 
     //- Inplace extract elements of StringList when regular expression matches
@@ -271,11 +271,11 @@ namespace Foam
     void inplaceSubsetStrings
     (
         const char* re,
-        StringListType& lst,
+        StringListType& input,
         const bool invert=false
     )
     {
-        inplaceSubsetMatchingStrings(regExp(re), lst, invert);
+        inplaceSubsetMatchingStrings(regExp(re), input, invert);
     }
 
     //- Inplace extract elements of StringList when regular expression matches
@@ -284,11 +284,11 @@ namespace Foam
     void inplaceSubsetStrings
     (
         const std::string& re,
-        StringListType& lst,
+        StringListType& input,
         const bool invert=false
     )
     {
-        inplaceSubsetMatchingStrings(regExp(re), lst, invert);
+        inplaceSubsetMatchingStrings(regExp(re), input, invert);
     }
 
     //- Inplace extract elements of StringList when regular expression matches
@@ -297,11 +297,11 @@ namespace Foam
     void inplaceSubsetStrings
     (
         const wordRe& matcher,
-        StringListType& lst,
+        StringListType& input,
         const bool invert=false
     )
     {
-        inplaceSubsetMatchingStrings(matcher, lst, invert);
+        inplaceSubsetMatchingStrings(matcher, input, invert);
     }
 
     //- Inplace extract elements of StringList when regular expression matches
@@ -310,11 +310,11 @@ namespace Foam
     void inplaceSubsetStrings
     (
         const wordRes& matcher,
-        StringListType& lst,
+        StringListType& input,
         const bool invert=false
     )
     {
-        inplaceSubsetMatchingStrings(matcher, lst, invert);
+        inplaceSubsetMatchingStrings(matcher, input, invert);
     }
 
     //- Inplace extract elements of StringList when regular expression matches
diff --git a/src/OpenFOAM/primitives/strings/lists/stringListOpsTemplates.C b/src/OpenFOAM/primitives/strings/lists/stringListOpsTemplates.C
index ac838c6af4..ed66e60ba3 100644
--- a/src/OpenFOAM/primitives/strings/lists/stringListOpsTemplates.C
+++ b/src/OpenFOAM/primitives/strings/lists/stringListOpsTemplates.C
@@ -29,21 +29,24 @@ template<class UnaryMatchPredicate, class StringType>
 Foam::labelList Foam::findMatchingStrings
 (
     const UnaryMatchPredicate& matcher,
-    const UList<StringType>& lst,
+    const UList<StringType>& input,
     const bool invert
 )
 {
-    labelList indices(lst.size());
+    const label len = input.size();
+
+    labelList indices(len);
 
     label count = 0;
-    forAll(lst, elemi)
+    for (label i=0; i < len; ++i)
     {
-        if (matcher(lst[elemi]) ? !invert : invert)
+        if (matcher(input[i]) ? !invert : invert)
         {
-            indices[count++] = elemi;
+            indices[count] = i;
+            ++count;
         }
     }
-    indices.setSize(count);
+    indices.resize(count);
 
     return indices;
 }
@@ -53,24 +56,27 @@ template<class UnaryMatchPredicate, class StringListType>
 StringListType Foam::subsetMatchingStrings
 (
     const UnaryMatchPredicate& matcher,
-    const StringListType& lst,
+    const StringListType& input,
     const bool invert
 )
 {
-    StringListType newLst(lst.size());
-    newLst.setSize(lst.size()); // Consistent sizing (eg, DynamicList)
+    const label len = input.size();
+
+    StringListType output(len);
+    output.resize(len);   // Consistent sizing (eg, DynamicList)
 
     label count = 0;
-    forAll(lst, elemi)
+    for (label i=0; i < len; ++i)
     {
-        if (matcher(lst[elemi]) ? !invert : invert)
+        if (matcher(input[i]) ? !invert : invert)
         {
-            newLst[count++] = lst[elemi];
+            output[count] = input[i];
+            ++count;
         }
     }
-    newLst.setSize(count);
+    output.resize(count);
 
-    return newLst;
+    return output;
 }
 
 
@@ -78,23 +84,25 @@ template<class UnaryMatchPredicate, class StringListType>
 void Foam::inplaceSubsetMatchingStrings
 (
     const UnaryMatchPredicate& matcher,
-    StringListType& lst,
+    StringListType& input,
     const bool invert
 )
 {
+    const label len = input.size();
+
     label count = 0;
-    forAll(lst, elemi)
+    for (label i=0; i < len; ++i)
     {
-        if (matcher(lst[elemi]) ? !invert : invert)
+        if (matcher(input[i]) ? !invert : invert)
         {
-            if (count != elemi)
+            if (count != i)
             {
-                lst[count] = lst[elemi];
+                input[count] = std::move(input[i]);
             }
             ++count;
         }
     }
-    lst.setSize(count);
+    input.resize(count);
 }
 
 
diff --git a/src/dynamicMesh/fvMeshDistribute/fvMeshDistribute.C b/src/dynamicMesh/fvMeshDistribute/fvMeshDistribute.C
index ef9bde3c1d..d3a2a760b4 100644
--- a/src/dynamicMesh/fvMeshDistribute/fvMeshDistribute.C
+++ b/src/dynamicMesh/fvMeshDistribute/fvMeshDistribute.C
@@ -2120,7 +2120,7 @@ Foam::autoPtr<Foam::mapDistributePolyMesh> Foam::fvMeshDistribute::distribute
 
         // Initialize all addressing into current mesh
         constructCellMap[Pstream::myProcNo()] = identity(mesh_.nCells());
-        constructFaceMap[Pstream::myProcNo()] = identity(mesh_.nFaces()) + 1;
+        constructFaceMap[Pstream::myProcNo()] = identity(mesh_.nFaces(), 1);
         constructPointMap[Pstream::myProcNo()] = identity(mesh_.nPoints());
         constructPatchMap[Pstream::myProcNo()] = identity(patches.size());
 
@@ -2407,7 +2407,7 @@ Foam::autoPtr<Foam::mapDistributePolyMesh> Foam::fvMeshDistribute::distribute
 
 
             constructCellMap[sendProc] = identity(domainMesh.nCells());
-            constructFaceMap[sendProc] = identity(domainMesh.nFaces()) + 1;
+            constructFaceMap[sendProc] = identity(domainMesh.nFaces(), 1);
             constructPointMap[sendProc] = identity(domainMesh.nPoints());
             constructPatchMap[sendProc] =
                 identity(domainMesh.boundaryMesh().size());
diff --git a/src/dynamicMesh/perfectInterface/perfectInterface.C b/src/dynamicMesh/perfectInterface/perfectInterface.C
index 7794e791bf..bca3bda87b 100644
--- a/src/dynamicMesh/perfectInterface/perfectInterface.C
+++ b/src/dynamicMesh/perfectInterface/perfectInterface.C
@@ -455,14 +455,14 @@ void Foam::perfectInterface::setRefinement(polyTopoChange& ref) const
         const polyPatch& patch1 = patches[slavePatchID_.index()];
 
 
-        labelList pp0Labels(identity(patch0.size())+patch0.start());
+        labelList pp0Labels(identity(patch0.size(), patch0.start()));
         indirectPrimitivePatch pp0
         (
             IndirectList<face>(mesh.faces(), pp0Labels),
             mesh.points()
         );
 
-        labelList pp1Labels(identity(patch1.size())+patch1.start());
+        labelList pp1Labels(identity(patch1.size(), patch1.start()));
         indirectPrimitivePatch pp1
         (
             IndirectList<face>(mesh.faces(), pp1Labels),
diff --git a/src/lagrangian/basic/InteractionLists/InteractionLists.C b/src/lagrangian/basic/InteractionLists/InteractionLists.C
index b223232bd3..fbb7aa8683 100644
--- a/src/lagrangian/basic/InteractionLists/InteractionLists.C
+++ b/src/lagrangian/basic/InteractionLists/InteractionLists.C
@@ -324,7 +324,10 @@ void Foam::InteractionLists<ParticleType>::buildInteractionLists()
 
         if (isA<wallPolyPatch>(patch))
         {
-            localWallFaces.append(identity(patch.size()) + patch.start());
+            localWallFaces.append
+            (
+                identity(patch.size(), patch.start())
+            );
         }
     }
 
diff --git a/src/lagrangian/intermediate/submodels/CloudFunctionObjects/ParticleCollector/ParticleCollector.C b/src/lagrangian/intermediate/submodels/CloudFunctionObjects/ParticleCollector/ParticleCollector.C
index 1be0739028..1a8255ae7d 100644
--- a/src/lagrangian/intermediate/submodels/CloudFunctionObjects/ParticleCollector/ParticleCollector.C
+++ b/src/lagrangian/intermediate/submodels/CloudFunctionObjects/ParticleCollector/ParticleCollector.C
@@ -135,7 +135,7 @@ void Foam::ParticleCollector<CloudType>::initPolygons
     forAll(faces_, facei)
     {
         const Field<point>& polyPoints = polygons[facei];
-        face f(identity(polyPoints.size()) + pointOffset);
+        face f(identity(polyPoints.size(), pointOffset));
         UIndirectList<point>(points_, f) = polyPoints;
         area_[facei] = f.mag(points_);
 
diff --git a/src/mesh/snappyHexMesh/meshRefinement/meshRefinement.C b/src/mesh/snappyHexMesh/meshRefinement/meshRefinement.C
index 1c90b6a227..5c9528786f 100644
--- a/src/mesh/snappyHexMesh/meshRefinement/meshRefinement.C
+++ b/src/mesh/snappyHexMesh/meshRefinement/meshRefinement.C
@@ -619,8 +619,11 @@ void Foam::meshRefinement::checkData()
         localPointRegion::findDuplicateFaces
         (
             mesh_,
-            identity(mesh_.nFaces()-mesh_.nInternalFaces())
-          + mesh_.nInternalFaces()
+            identity
+            (
+                mesh_.nFaces() - mesh_.nInternalFaces(),
+                mesh_.nInternalFaces()
+            )
         )
     );
 
diff --git a/src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolation.C b/src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolation.C
index d0a89190af..faf88f579d 100644
--- a/src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolation.C
+++ b/src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolation.C
@@ -372,8 +372,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::agglomerate
 
         // Local constructMap is just identity
         {
-            tgtConstructMap[Pstream::myProcNo()] =
-                identity(targetCoarseSize);
+            tgtConstructMap[Pstream::myProcNo()] = identity(targetCoarseSize);
         }
 
         labelList tgtCompactMap(map.constructSize());
@@ -1134,13 +1133,19 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::append
             {
                 mapMap.append
                 (
-                    identity(srcConstructMap[proci].size())
-                  + mapMap.size() + newMapMap.size()
+                    identity
+                    (
+                        srcConstructMap[proci].size(),
+                        (mapMap.size() + newMapMap.size())
+                    )
                 );
                 newMapMap.append
                 (
-                    identity(newSrcConstructMap[proci].size())
-                  + mapMap.size() + newMapMap.size()
+                    identity
+                    (
+                        newSrcConstructMap[proci].size(),
+                        (mapMap.size() + newMapMap.size())
+                    )
                 );
             }
 
@@ -1188,13 +1193,19 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::append
             {
                 mapMap.append
                 (
-                    identity(tgtConstructMap[proci].size())
-                  + mapMap.size() + newMapMap.size()
+                    identity
+                    (
+                        tgtConstructMap[proci].size(),
+                        (mapMap.size() + newMapMap.size())
+                    )
                 );
                 newMapMap.append
                 (
-                    identity(newTgtConstructMap[proci].size())
-                  + mapMap.size() + newMapMap.size()
+                    identity
+                    (
+                        newTgtConstructMap[proci].size(),
+                        (mapMap.size() + newMapMap.size())
+                    )
                 );
             }
 
diff --git a/src/meshTools/edgeMesh/extendedEdgeMesh/extendedEdgeMesh.C b/src/meshTools/edgeMesh/extendedEdgeMesh/extendedEdgeMesh.C
index be1a3b4bbe..e27bdbabd4 100644
--- a/src/meshTools/edgeMesh/extendedEdgeMesh/extendedEdgeMesh.C
+++ b/src/meshTools/edgeMesh/extendedEdgeMesh/extendedEdgeMesh.C
@@ -1034,20 +1034,20 @@ Foam::extendedEdgeMesh::edgeTreesByType() const
 
         // External edges
         sliceEdges[0] =
-            identity(internalStart_ - externalStart_) + externalStart_;
+            identity((internalStart_ - externalStart_), externalStart_);
 
         // Internal edges
-        sliceEdges[1] = identity(flatStart_ - internalStart_) + internalStart_;
+        sliceEdges[1] = identity((flatStart_ - internalStart_), internalStart_);
 
         // Flat edges
-        sliceEdges[2] = identity(openStart_ - flatStart_) + flatStart_;
+        sliceEdges[2] = identity((openStart_ - flatStart_), flatStart_);
 
         // Open edges
-        sliceEdges[3] = identity(multipleStart_ - openStart_) + openStart_;
+        sliceEdges[3] = identity((multipleStart_ - openStart_), openStart_);
 
         // Multiple edges
         sliceEdges[4] =
-            identity(edges().size() - multipleStart_) + multipleStart_;
+            identity((edges().size() - multipleStart_), multipleStart_);
 
         forAll(edgeTreesByType_, i)
         {
diff --git a/src/meshTools/indexedOctree/treeDataFace.C b/src/meshTools/indexedOctree/treeDataFace.C
index 73983df95d..886cf81079 100644
--- a/src/meshTools/indexedOctree/treeDataFace.C
+++ b/src/meshTools/indexedOctree/treeDataFace.C
@@ -122,8 +122,7 @@ Foam::treeDataFace::treeDataFace
     mesh_(patch.boundaryMesh().mesh()),
     faceLabels_
     (
-        identity(patch.size())
-      + patch.start()
+        identity(patch.size(), patch.start())
     ),
     isTreeFace_(mesh_.nFaces(), 0),
     cacheBb_(cacheBb)
diff --git a/src/meshTools/mappedPatches/mappedPolyPatch/mappedPatchBase.C b/src/meshTools/mappedPatches/mappedPolyPatch/mappedPatchBase.C
index b3bd43d4b3..0eded7a081 100644
--- a/src/meshTools/mappedPatches/mappedPolyPatch/mappedPatchBase.C
+++ b/src/meshTools/mappedPatches/mappedPolyPatch/mappedPatchBase.C
@@ -281,7 +281,7 @@ void Foam::mappedPatchBase::findSamples
             else
             {
                 // patch faces
-                const labelList patchFaces(identity(pp.size()) + pp.start());
+                const labelList patchFaces(identity(pp.size(), pp.start()));
 
                 treeBoundBox patchBb
                 (
diff --git a/src/meshTools/regionSplit/localPointRegion.C b/src/meshTools/regionSplit/localPointRegion.C
index 38e2331f61..6ce5d179c9 100644
--- a/src/meshTools/regionSplit/localPointRegion.C
+++ b/src/meshTools/regionSplit/localPointRegion.C
@@ -626,8 +626,7 @@ Foam::List<Foam::labelPair> Foam::localPointRegion::findDuplicateFacePairs
     // Faces to test: all boundary faces
     labelList testFaces
     (
-        identity(mesh.nFaces()-mesh.nInternalFaces())
-      + mesh.nInternalFaces()
+        identity(mesh.nFaces()-mesh.nInternalFaces(), mesh.nInternalFaces())
     );
 
     // Find correspondencing baffle face (or -1)
diff --git a/src/meshTools/searchableSurfaces/triSurfaceMesh/triSurfaceMesh.C b/src/meshTools/searchableSurfaces/triSurfaceMesh/triSurfaceMesh.C
index 279c75caba..496b5c22dd 100644
--- a/src/meshTools/searchableSurfaces/triSurfaceMesh/triSurfaceMesh.C
+++ b/src/meshTools/searchableSurfaces/triSurfaceMesh/triSurfaceMesh.C
@@ -564,12 +564,7 @@ Foam::triSurfaceMesh::edgeTree() const
         // Boundary edges
         labelList bEdges
         (
-            identity
-            (
-                nEdges()
-               -nInternalEdges()
-            )
-          + nInternalEdges()
+            identity(nEdges() - nInternalEdges(), nInternalEdges())
         );
 
         treeBoundBox bb(Zero, Zero);