From 95cd8ee75ca15024fb69a99d85f7b26d38a3ce84 Mon Sep 17 00:00:00 2001
From: Mark Olesen <Mark.Olesen@esi-group.com>
Date: Mon, 12 Apr 2021 17:05:11 +0200
Subject: [PATCH] ENH: improve hashing overloads of string-types and
 HashTable/HashSet

- additional dummy template parameter to assist with supporting
  derived classes. Currently just used for string types, but can be
  extended.

- provide hash specialization for various integer types.
  Removes the need for any forwarding.

- change default hasher for HashSet/HashTable from 'string::hash'
  to `Hash<Key>`. This avoids questionable hashing calls and/or
  avoids compiler resolution problems.

  For example,
  HashSet<label>::hasher and labelHashSet::hasher now both properly
  map to Hash<label> whereas previously HashSet<label> would have
  persistently mapped to string::hash, which was incorrect.

- standardize internal hashing functors.

  Functor name is 'hasher', as per STL set/map and the OpenFOAM
  HashSet/HashTable definitions.

  Older code had a local templated name, which added unnecessary
  clutter and the template parameter was always defaulted.
  For example,

      Old:  `FixedList<label, 3>::Hash<>()`
      New:  `FixedList<label, 3>::hasher()`
      Unchanged:  `labelHashSet::hasher()`

  Existing `Hash<>` functor namings are still supported,
  but deprecated.

- define hasher and Hash specialization for bitSet and PackedList

- add symmetric hasher for 'face'.
  Starts with lowest vertex value and walks in the direction
  of the next lowest value. This ensures that the hash code is
  independent of face orientation and face rotation.

NB:
  - some of keys for multiphase handling (eg, phasePairKey)
    still use yet another function naming: `hash` and `symmHash`.
    This will be targeted for alignment in the future.
---
 .../multiphaseMixtureThermo.H                 |  27 +--
 .../multiphaseMixture/multiphaseMixture.H     |  22 +-
 applications/test/FixedList/Test-FixedList.C  |   4 +-
 .../test/HashPtrTable/Test-HashPtrTable.C     |   6 +-
 applications/test/HashSet/Test-hashSet.C      |   7 +-
 applications/test/Hashing/Make/files          |   3 -
 applications/test/Hashing1/HashFunction.H     | 224 ++++++++++++++++++
 applications/test/Hashing1/Make/files         |   3 +
 .../test/{Hashing => Hashing1}/Make/options   |   0
 applications/test/Hashing1/Test-Hashing1.C    | 163 +++++++++++++
 applications/test/Hashing2/Make/files         |   3 +
 applications/test/Hashing2/Make/options       |   3 +
 .../Test-Hashing2.C}                          |  33 ++-
 .../test/{Hashing => Hashing2}/hashingTests   |   0
 .../test/HashingSpeed/Test-HashingSpeed.C     |   6 +-
 applications/test/List/Test-List.C            |   6 +-
 applications/test/ListOps2/Test-ListOps2.C    |   8 +-
 applications/test/faceHashing/Make/files      |   3 +
 applications/test/faceHashing/Make/options    |   3 +
 .../test/faceHashing/Test-faceHashing.C       | 153 ++++++++++++
 applications/test/string/Test-string.C        |   6 +-
 .../ideasUnvToFoam/ideasUnvToFoam.C           |  44 ++--
 .../netgenNeutralToFoam/netgenNeutralToFoam.C |   2 +-
 .../pointPairs/pointPairs.H                   |   9 +-
 src/OpenFOAM/Make/files                       |   3 +-
 .../containers/Bits/PackedList/PackedList.H   |  25 ++
 src/OpenFOAM/containers/Bits/bitSet/bitSet.H  |   6 +
 .../containers/HashTables/HashOps/HashOps.H   |  10 +-
 .../HashTables/HashPtrTable/HashPtrTable.H    |   2 +-
 .../containers/HashTables/HashSet/HashSet.H   |   4 +-
 .../HashTables/HashTable/HashTable.H          |   2 +-
 .../Lists/DynamicList/DynamicList.H           |   5 +
 .../containers/Lists/FixedList/FixedList.H    |  52 ++--
 src/OpenFOAM/containers/Lists/List/List.H     |  25 +-
 src/OpenFOAM/containers/Lists/UList/UList.H   |  49 ++--
 .../construction/runTimeSelectionTables.H     |   6 +-
 .../memberFunctionSelectionTables.H           |   5 +-
 src/OpenFOAM/meshes/meshShapes/edge/edge.H    |  47 ++--
 src/OpenFOAM/meshes/meshShapes/face/face.C    |  70 +++++-
 src/OpenFOAM/meshes/meshShapes/face/face.H    |  55 ++++-
 .../meshes/meshShapes/triFace/triFace.H       |  42 ++--
 .../processorCyclicPolyPatch.C                |   4 +-
 src/OpenFOAM/primitives/Pair/Pair.H           |  47 +---
 .../primitives/Pair/labelPairHashes.H         |  10 +-
 src/OpenFOAM/primitives/Pair/wordPairHashes.H |  67 ++++++
 src/OpenFOAM/primitives/Tuple2/Tuple2.H       |  23 ++
 src/OpenFOAM/primitives/hashes/Hash/Hash.H    | 151 +++++-------
 src/OpenFOAM/primitives/hashes/Hash/HashFwd.H |  39 +--
 .../hashes/{Hasher => Hash}/Hasher.C          | 212 +++++++++--------
 .../hashes/{Hasher => Hash}/Hasher.H          |  12 +-
 .../hashes/{Hasher => Hash}/HasherInt.H       |   2 +-
 .../primitives/strings/string/string.H        |  30 ++-
 .../primitives/strings/string/stringI.H       |  10 -
 .../primitives/strings/stringOps/stringOps.C  |   4 +-
 .../primitives/strings/stringOps/stringOps.H  |   4 +-
 .../fvMeshDistribute/fvMeshDistribute.C       |   2 +-
 .../meshRefinement/meshRefinement.H           |   4 +-
 .../meshRefinement/meshRefinementBaffles.C    |   9 +-
 .../refinementParameters/wordPairHashTable.H  |  48 +---
 .../snappyHexMeshDriver/snappyRefineDriver.H  |   6 +-
 .../multiphaseSystem/multiphaseSystem.H       |  45 +---
 .../phasesSystem/phasePair/phasePairKey.C     |  66 ++----
 .../phasesSystem/phasePair/phasePairKey.H     |  63 +++--
 .../blendingMethods/hyperbolic/hyperbolic.H   |   2 +-
 .../blendingMethods/linear/linear.H           |   6 +-
 .../multiphaseSystem/phasePair/phasePairKey.C |  89 ++-----
 .../multiphaseSystem/phasePair/phasePairKey.H | 100 ++++----
 .../phaseSystem/phaseSystem.H                 |   3 +-
 .../blendingMethods/hyperbolic/hyperbolic.H   |   2 +-
 .../blendingMethods/linear/linear.H           |   6 +-
 .../twoPhaseSystem/phasePair/phasePairKey.C   |  82 ++-----
 .../twoPhaseSystem/phasePair/phasePairKey.H   |  82 ++++---
 .../twoPhaseSystem/twoPhaseSystem.H           |   2 +-
 .../meshToMesh/meshToMeshParallelOps.C        |   2 +-
 .../cutting/cuttingSurfaceBaseTemplates.C     |   4 +-
 75 files changed, 1429 insertions(+), 955 deletions(-)
 delete mode 100644 applications/test/Hashing/Make/files
 create mode 100644 applications/test/Hashing1/HashFunction.H
 create mode 100644 applications/test/Hashing1/Make/files
 rename applications/test/{Hashing => Hashing1}/Make/options (100%)
 create mode 100644 applications/test/Hashing1/Test-Hashing1.C
 create mode 100644 applications/test/Hashing2/Make/files
 create mode 100644 applications/test/Hashing2/Make/options
 rename applications/test/{Hashing/Test-Hashing.C => Hashing2/Test-Hashing2.C} (91%)
 rename applications/test/{Hashing => Hashing2}/hashingTests (100%)
 create mode 100644 applications/test/faceHashing/Make/files
 create mode 100644 applications/test/faceHashing/Make/options
 create mode 100644 applications/test/faceHashing/Test-faceHashing.C
 create mode 100644 src/OpenFOAM/primitives/Pair/wordPairHashes.H
 rename src/OpenFOAM/primitives/hashes/{Hasher => Hash}/Hasher.C (99%)
 rename src/OpenFOAM/primitives/hashes/{Hasher => Hash}/Hasher.H (86%)
 rename src/OpenFOAM/primitives/hashes/{Hasher => Hash}/HasherInt.H (99%)

diff --git a/applications/solvers/multiphase/compressibleMultiphaseInterFoam/multiphaseMixtureThermo/multiphaseMixtureThermo.H b/applications/solvers/multiphase/compressibleMultiphaseInterFoam/multiphaseMixtureThermo/multiphaseMixtureThermo.H
index 368df01043..5172f537f2 100644
--- a/applications/solvers/multiphase/compressibleMultiphaseInterFoam/multiphaseMixtureThermo/multiphaseMixtureThermo.H
+++ b/applications/solvers/multiphase/compressibleMultiphaseInterFoam/multiphaseMixtureThermo/multiphaseMixtureThermo.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2013-2017 OpenFOAM Foundation
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -59,24 +59,23 @@ class multiphaseMixtureThermo
 {
 public:
 
+    //- Symmetric pair of interface names
     class interfacePair
     :
         public Pair<word>
     {
     public:
 
-        struct hash
-        {
-            label operator()(const interfacePair& key) const
-            {
-                return word::hash()(key.first()) + word::hash()(key.second());
-            }
-        };
+        // Always use symmetric hashing
+        using hasher = Pair<word>::symmHasher;
+
+        // Always use symmetric hashing (alias)
+        using hash = Pair<word>::symmHasher;
 
 
         // Constructors
 
-            interfacePair() {} // = default
+            interfacePair() = default;
 
             interfacePair(const word& alpha1Name, const word& alpha2Name)
             :
@@ -97,11 +96,7 @@ public:
                 const interfacePair& b
             )
             {
-                return
-                (
-                    ((a.first() == b.first()) && (a.second() == b.second()))
-                 || ((a.first() == b.second()) && (a.second() == b.first()))
-                );
+                return (0 != Pair<word>::compare(a, b));
             }
 
             friend bool operator!=
@@ -117,7 +112,7 @@ public:
 
 private:
 
-    // Private data
+    // Private Data
 
         //- Dictionary of phases
         PtrDictionary<phaseModel> phases_;
@@ -140,7 +135,7 @@ private:
         const dimensionedScalar deltaN_;
 
 
-    // Private member functions
+    // Private Member Functions
 
         void calcAlphas();
 
diff --git a/applications/solvers/multiphase/multiphaseInterFoam/multiphaseMixture/multiphaseMixture.H b/applications/solvers/multiphase/multiphaseInterFoam/multiphaseMixture/multiphaseMixture.H
index b320374e06..ddaa807a93 100644
--- a/applications/solvers/multiphase/multiphaseInterFoam/multiphaseMixture/multiphaseMixture.H
+++ b/applications/solvers/multiphase/multiphaseInterFoam/multiphaseMixture/multiphaseMixture.H
@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
+    Copyright (C) 2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -67,24 +68,23 @@ class multiphaseMixture
 {
 public:
 
+    //- Symmetric pair of interface names
     class interfacePair
     :
         public Pair<word>
     {
     public:
 
-        struct hash
-        {
-            label operator()(const interfacePair& key) const
-            {
-                return word::hash()(key.first()) + word::hash()(key.second());
-            }
-        };
+        // Always use symmetric hashing
+        using hasher = Pair<word>::symmHasher;
+
+        // Always use symmetric hashing (alias)
+        using hash = Pair<word>::symmHasher;
 
 
         // Constructors
 
-            interfacePair() {} // = default
+            interfacePair() = default;
 
             interfacePair(const word& alpha1Name, const word& alpha2Name)
             :
@@ -105,11 +105,7 @@ public:
                 const interfacePair& b
             )
             {
-                return
-                (
-                    ((a.first() == b.first()) && (a.second() == b.second()))
-                 || ((a.first() == b.second()) && (a.second() == b.first()))
-                );
+                return (0 != Pair<word>::compare(a, b));
             }
 
             friend bool operator!=
diff --git a/applications/test/FixedList/Test-FixedList.C b/applications/test/FixedList/Test-FixedList.C
index 1257c97091..f75d77e3c8 100644
--- a/applications/test/FixedList/Test-FixedList.C
+++ b/applications/test/FixedList/Test-FixedList.C
@@ -186,14 +186,14 @@ int main(int argc, char *argv[])
         FixedList<label, 4> list1{2, 3, 4, 5};
 
         Info<< "list1:" << list1
-            << " hash:" << FixedList<label, 4>::Hash<>()(list1) << nl
+            << " hash:" << FixedList<label, 4>::hasher()(list1) << nl
             << " hash:" << Hash<FixedList<label, 4>>()(list1) << nl;
 
         label a[4] = {0, 1, 2, 3};
         FixedList<label, 4> list2(a);
 
         Info<< "list2:" << list2
-            << " hash:" << FixedList<label, 4>::Hash<>()(list2) << nl
+            << " hash:" << FixedList<label, 4>::hasher()(list2) << nl
             << " hash:" << Hash<FixedList<label, 4>>()(list2) << nl;
 
 
diff --git a/applications/test/HashPtrTable/Test-HashPtrTable.C b/applications/test/HashPtrTable/Test-HashPtrTable.C
index db15bdde27..31dfb62200 100644
--- a/applications/test/HashPtrTable/Test-HashPtrTable.C
+++ b/applications/test/HashPtrTable/Test-HashPtrTable.C
@@ -127,13 +127,13 @@ int main()
     myTable.insert("sqrt2", autoPtr<double>::New(1.414214));
     myTable.insert("euler", autoPtr<double>::New(0.577216));
 
-    HashTable<std::unique_ptr<double>, word, string::hash> myTable1;
+    HashTable<std::unique_ptr<double>> myTable1;
 
     myTable1.set("abc", std::unique_ptr<double>(new double(42.1)));
     myTable1.set("pi", std::unique_ptr<double>(new double(3.14159)));
     myTable1.set("natlog", std::unique_ptr<double>(new double(2.718282)));
 
-    HashTable<autoPtr<double>, word, string::hash> myTable2;
+    HashTable<autoPtr<double>> myTable2;
 
     myTable2.set("abc", autoPtr<double>(new double(42.1)));
     myTable2.set("pi", autoPtr<double>(new double(3.14159)));
@@ -148,7 +148,7 @@ int main()
 
     {
         auto iter2 = myTable2.find("pi");
-        Info<< nl "Got pi=";
+        Info<< nl << "Got pi=";
         if (iter2.good())
         {
             Info<< **iter2 << nl;
diff --git a/applications/test/HashSet/Test-hashSet.C b/applications/test/HashSet/Test-hashSet.C
index 8e2ac0c409..c84231f91f 100644
--- a/applications/test/HashSet/Test-hashSet.C
+++ b/applications/test/HashSet/Test-hashSet.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
-    Copyright (C) 2018 OpenCFD Ltd.
+    Copyright (C) 2018-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -80,6 +80,11 @@ void printMinMax(const HashSet<Key, Hash>& set)
 
 int main(int argc, char *argv[])
 {
+    Info<< "labelHashSet hasher: "
+        << typeid(labelHashSet::hasher).name() << nl
+        << "HashSet<label> hasher: "
+        << typeid(HashSet<label>::hasher).name() << nl << nl;
+
     hashedWordList words
     {
         "abc",
diff --git a/applications/test/Hashing/Make/files b/applications/test/Hashing/Make/files
deleted file mode 100644
index fd270ac217..0000000000
--- a/applications/test/Hashing/Make/files
+++ /dev/null
@@ -1,3 +0,0 @@
-Test-Hashing.C
-
-EXE = $(FOAM_USER_APPBIN)/Test-Hashing
diff --git a/applications/test/Hashing1/HashFunction.H b/applications/test/Hashing1/HashFunction.H
new file mode 100644
index 0000000000..964b5b2e29
--- /dev/null
+++ b/applications/test/Hashing1/HashFunction.H
@@ -0,0 +1,224 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2021 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::HashFunction
+
+Description
+    Hash function class.
+
+    Verify that template overloads are properly resolved
+
+Note
+    The second template parameter (bool) is used for SFINAE overloading,
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef HashFunction_H
+#define HashFunction_H
+
+#include "Hash.H"
+
+#ifdef FULLDEBUG
+#define HashTypeInfo(Args)  void info() { std::cerr<< "" Args << "\n"; }
+#else
+#define HashTypeInfo(Args)  void info() {}
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                            Class Hash Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class T, class SFINAEType=bool>
+struct HashFun
+{
+    #ifdef FULLDEBUG
+    static constexpr const char* name() noexcept { return "default"; }
+    #endif
+    HashTypeInfo("plain hash")
+
+    unsigned operator()(const T& obj, unsigned seed=0) const
+    {
+        return Foam::Hasher(&obj, sizeof(obj), seed);
+    }
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+//- Hashing for label
+template<> struct HashFun<Foam::label> : Hash<label>
+{
+    #ifdef FULLDEBUG
+    static constexpr const char* name() noexcept { return "label"; }
+    #endif
+    HashTypeInfo("hash label")
+};
+
+
+//- Hashing for pointers, interpret pointer as a integer type
+template<> struct HashFun<void*> : Hash<void *>
+{
+    #ifdef FULLDEBUG
+    static constexpr const char* name() noexcept { return "pointer"; }
+    #endif
+    HashTypeInfo("hash ptr")
+};
+
+
+//- Hashing for string types
+template<class StringType>
+struct HashFun
+<
+    StringType,
+    typename std::enable_if
+    <
+        std::is_base_of<std::string, StringType>::value, bool
+    >::type
+>
+{
+    #ifdef FULLDEBUG
+    static constexpr const char* name() noexcept { return "string"; }
+    #endif
+    HashTypeInfo("hash string")
+
+    unsigned operator()(const std::string& obj, unsigned seed=0) const
+    {
+        return Foam::Hasher(obj.data(), obj.size(), seed);
+    }
+};
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// Various
+#include "edge.H"
+#include "face.H"
+#include "triFace.H"
+#include "Pair.H"
+#include "Tuple2.H"
+#include "DynamicList.H"
+#include "FixedList.H"
+
+namespace Foam
+{
+
+template<> struct HashFun<edge> : Hash<edge>
+{
+    #ifdef FULLDEBUG
+    static constexpr const char* name() noexcept { return "edge"; }
+    #endif
+    HashTypeInfo("hash edge")
+};
+
+
+template<> struct HashFun<face> : Hash<face>
+{
+    #ifdef FULLDEBUG
+    static constexpr const char* name() noexcept { return "face"; }
+    #endif
+    HashTypeInfo("hash face")
+};
+
+
+template<> struct HashFun<triFace> : Hash<triFace>
+{
+    #ifdef FULLDEBUG
+    static constexpr const char* name() noexcept { return "triFace"; }
+    #endif
+    HashTypeInfo("hash triFace")
+};
+
+
+template<class T>
+struct HashFun<Pair<T>> : Hash<Pair<T>>
+{
+    #ifdef FULLDEBUG
+    static constexpr const char* name() noexcept { return "Pair"; }
+    #endif
+    HashTypeInfo("hash Pair")
+};
+
+template<class T1, class T2>
+struct HashFun<Tuple2<T1, T2>> : Hash<Tuple2<T1, T2>>
+{
+    #ifdef FULLDEBUG
+    static constexpr const char* name() noexcept { return "Tuple2"; }
+    #endif
+    HashTypeInfo("hash Tuple2")
+};
+
+
+template<class T>
+struct HashFun<List<T>> : Hash<List<T>>
+{
+    #ifdef FULLDEBUG
+    static constexpr const char* name() noexcept { return "List"; }
+    #endif
+    HashTypeInfo("hash List")
+};
+
+template<class T> struct HashFun<UList<T>> : Hash<UList<T>>
+{
+    #ifdef FULLDEBUG
+    static constexpr const char* name() noexcept { return "UList"; }
+    #endif
+    HashTypeInfo("hash UList")
+};
+
+template<class T, int SizeMin>
+struct HashFun<DynamicList<T, SizeMin>> : Hash<DynamicList<T, SizeMin>>
+{
+    #ifdef FULLDEBUG
+    static constexpr const char* name() noexcept { return "DynamicList"; }
+    #endif
+    HashTypeInfo("hash DynamicList")
+};
+
+template<class T, unsigned N>
+struct HashFun<FixedList<T, N>> : Hash<FixedList<T, N>>
+{
+    #ifdef FULLDEBUG
+    static constexpr const char* name() noexcept { return "FixedList"; }
+    #endif
+    HashTypeInfo("hash FixedList")
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/applications/test/Hashing1/Make/files b/applications/test/Hashing1/Make/files
new file mode 100644
index 0000000000..771978f3ee
--- /dev/null
+++ b/applications/test/Hashing1/Make/files
@@ -0,0 +1,3 @@
+Test-Hashing1.C
+
+EXE = $(FOAM_USER_APPBIN)/Test-Hashing1
diff --git a/applications/test/Hashing/Make/options b/applications/test/Hashing1/Make/options
similarity index 100%
rename from applications/test/Hashing/Make/options
rename to applications/test/Hashing1/Make/options
diff --git a/applications/test/Hashing1/Test-Hashing1.C b/applications/test/Hashing1/Test-Hashing1.C
new file mode 100644
index 0000000000..17672ec662
--- /dev/null
+++ b/applications/test/Hashing1/Test-Hashing1.C
@@ -0,0 +1,163 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2021 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Application
+    Test-Hashing1
+
+Description
+    Test/verify overloads of Hash function
+
+\*---------------------------------------------------------------------------*/
+
+#include "IOstreams.H"
+#include "IOobject.H"
+#include "IFstream.H"
+
+#include "stringList.H"
+#include "labelList.H"
+#include "labelPair.H"
+#include "wordPair.H"
+#include "edgeList.H"
+#include "faceList.H"
+#include "triFaceList.H"
+
+#define FULLDEBUG
+#include "HashFunction.H"
+
+using namespace Foam;
+
+template<class T>
+unsigned rawHasher(const T& obj)
+{
+    return Foam::Hasher(&obj, sizeof(T), 0u);
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+//  Main program:
+
+int main(int argc, char *argv[])
+{
+    {
+        typedef unsigned Type;
+        Type value = 100;
+
+        Info<< "hash " << typeid(value).name() << " of " << value << nl;
+        Info<< "    Hasher: " << rawHasher(value) << nl;
+        Info<< "    Hash<>: " << Hash<Type>()(value) << nl;
+    }
+    {
+        typedef int32_t Type;
+        Type value = 100;
+
+        Info<< "hash " << typeid(value).name() << " of " << value << nl;
+        Info<< "    Hasher: " << rawHasher(value) << nl;
+        Info<< "    Hash<>: " << Hash<Type>()(value) << nl;
+    }
+    {
+        typedef int64_t Type;
+        Type value = 100;
+
+        Info<< "hash " << typeid(value).name() << " of " << value << nl;
+        Info<< "    Hasher: " << rawHasher(value) << nl;
+        Info<< "    Hash<>: " << Hash<Type>()(value) << nl;
+    }
+
+    HashFun<std::string>().info();
+    HashFun<string>().info();
+    HashFun<Foam::word>().info();
+    HashFun<Foam::keyType>().info();
+
+    HashFun<int>().info();
+    HashFun<label>().info();
+    HashFun<float>().info();
+    HashFun<double>().info();
+
+    {
+        float value = 15.f;
+
+        Info<< "hash of " << Foam::name(&value)
+            << " = " << HashFun<void*>()(&value) << nl;
+    }
+
+    HashFun<labelList>().info();
+    HashFun<wordUList>().info();
+    HashFun<edge>().info();
+
+    HashFun<Pair<label>>().info();
+    HashFun<labelPair>().info();
+    HashFun<labelPairPair>().info();
+
+    HashFun<Tuple2<label, word>>().info();
+
+    {
+        typedef Tuple2<label, word> Type;
+        Type obj(10, "test");
+        Info<< obj << " hash=" << Hash<Type>()(obj) << nl;
+    }
+
+    {
+        typedef Tuple2<label, label> Type;
+        Type obj(10, 12);
+        Info<< obj << " hash=" << Hash<Type>()(obj) << nl;
+    }
+
+    {
+        typedef Pair<label> Type;
+        Type obj(10, 12);
+        Info<< obj << " hash=" << Hash<Type>()(obj) << nl;
+    }
+
+    {
+        typedef std::pair<label, label> Type;
+        Type obj(10, 12);
+        Info<< obj << " hash=" << Hash<Type>()(obj) << nl;
+
+        HashSet<Type> hs;
+        hs.insert(obj);
+        hs.erase(obj);
+    }
+
+    {
+        Pair<label>::hasher op;
+        Info<< "hasher: " << op(Pair<label>(10, 12)) << nl;
+    }
+
+    // Not supported
+    #if 0
+    {
+        Tuple2<label, label>::hasher op;
+        Info<< "hasher: " << op(Tuple2<label>(10, 12)) << nl;
+    }
+    #endif
+
+
+    Info<< "\nEnd\n" << nl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //
diff --git a/applications/test/Hashing2/Make/files b/applications/test/Hashing2/Make/files
new file mode 100644
index 0000000000..86776cfe25
--- /dev/null
+++ b/applications/test/Hashing2/Make/files
@@ -0,0 +1,3 @@
+Test-Hashing2.C
+
+EXE = $(FOAM_USER_APPBIN)/Test-Hashing2
diff --git a/applications/test/Hashing2/Make/options b/applications/test/Hashing2/Make/options
new file mode 100644
index 0000000000..7dba39797a
--- /dev/null
+++ b/applications/test/Hashing2/Make/options
@@ -0,0 +1,3 @@
+EXE_INC = ${c++LESSWARN}
+
+/* EXE_LIBS = */
diff --git a/applications/test/Hashing/Test-Hashing.C b/applications/test/Hashing2/Test-Hashing2.C
similarity index 91%
rename from applications/test/Hashing/Test-Hashing.C
rename to applications/test/Hashing2/Test-Hashing2.C
index 0028ef638b..3506e2da4f 100644
--- a/applications/test/Hashing/Test-Hashing.C
+++ b/applications/test/Hashing2/Test-Hashing2.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2018-2020 OpenCFD Ltd.
+    Copyright (C) 2018-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -25,7 +25,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Application
-    testHashing
+    Test-Hashing2
 
 Description
 
@@ -44,6 +44,7 @@ Description
 #include "triFaceList.H"
 
 #include "Hash.H"
+#include "HashSet.H"
 
 using namespace Foam;
 
@@ -84,7 +85,7 @@ void reportHashList(const UList<string>& list)
 
     for (const string& val : list)
     {
-        unsigned hash1 = string::hash()(val);
+        unsigned hash1 = string::hasher()(val);
 
         Info<< hex << hash1 << ": " << val << nl;
     }
@@ -117,11 +118,11 @@ void reportHashList(const UList<face>& list)
     for (const face& f : list)
     {
         // Direct value
-        unsigned hash1 = face::Hash<>()(f);
+        unsigned hash1 = face::hasher()(f);
 
         unsigned hash2 = Hash<face>()(f);
 
-        Info<< hex << "face::Hash<> " << hash1
+        Info<< hex << "face hash " << hash1
             << " Hash<face> " << hash2
             << ": " << dec << flatOutput(f) << nl;
     }
@@ -132,14 +133,10 @@ void reportHashList(const UList<labelList>& list)
 {
     for (const labelList& val : list)
     {
-        unsigned hash1 = Hasher
-        (
-            val.cdata(),
-            val.size() * sizeof(label)
-        );
+        unsigned hash1 = Foam::Hasher(val.cdata(), val.size_bytes());
 
         unsigned hash2 = Hash<labelList>()(val);
-        unsigned hash2b = labelList::Hash<>()(val);
+        unsigned hash2b = labelList::hasher()(val);
 
         Info<< hex << hash1 << " or " << hash2
             << "(" << hash2b << ") "
@@ -147,7 +144,7 @@ void reportHashList(const UList<labelList>& list)
     }
 
     unsigned hash2 = Hash<labelListList>()(list);
-    unsigned hash2bad = HasherT(list);
+    unsigned hash2bad = Foam::Hasher(&list, sizeof(list));
 
     Info<< hex << hash2 << " : " << dec << flatOutput(list) << nl
         << hex << hash2bad << " as direct hash would be wrong"
@@ -164,10 +161,10 @@ void reportHashList(const UList<wordPair>& list)
         unsigned hash1 = Hash<wordPair>()(pr);
 
         // as FixedList
-        unsigned hash2 = wordPair::Hash<>()(pr);
+        unsigned hash2 = wordPair::hasher()(pr);
 
         // as FixedList
-        unsigned hash2sym = wordPair::SymmHash<>()(pr);
+        unsigned hash2sym = wordPair::symmHasher()(pr);
 
         // as FixedList
         unsigned hash3 = Hash<FixedList<word,2>>()(pr);
@@ -189,7 +186,7 @@ void reportHashList(const UList<labelPair>& list)
         unsigned hash1 = Hash<labelPair>()(pr);
 
         // as FixedList
-        unsigned hash2 = labelPair::Hash<>()(pr);
+        unsigned hash2 = labelPair::hasher()(pr);
 
         // as FixedList
         unsigned hash3 = Hash<labelPair>()(pr);
@@ -210,7 +207,7 @@ void reportHashList(const UList<labelPairPair>& list)
         unsigned hash1 = Hash<labelPairPair>()(pr);
 
         // as FixedList
-        unsigned hash2 = labelPairPair::Hash<>()(pr);
+        unsigned hash2 = labelPairPair::hasher()(pr);
 
         // as FixedList
         unsigned hash3 = Hash<labelPairPair>()(pr);
@@ -231,7 +228,7 @@ void reportHashList(const UList<edge>& list)
         unsigned hash1 = Hash<edge>()(e);
 
         // as FixedList
-        unsigned hash2 = labelPair::Hash<>()(e);
+        unsigned hash2 = labelPair::hasher()(e);
 
         // as FixedList
         unsigned hash3 = Hash<labelPair>()(e);
@@ -251,7 +248,7 @@ void reportHashList(const UList<triFace>& list)
     {
         // direct value
         unsigned hash1 = Hash<triFace>()(f);
-        unsigned hash2 = FixedList<label, 3>::Hash<>()(f);
+        unsigned hash2 = FixedList<label, 3>::hasher()(f);
 
         Info<< hex << hash1 << " (as FixedList: " << hash2
             << "): " << dec << f << nl;
diff --git a/applications/test/Hashing/hashingTests b/applications/test/Hashing2/hashingTests
similarity index 100%
rename from applications/test/Hashing/hashingTests
rename to applications/test/Hashing2/hashingTests
diff --git a/applications/test/HashingSpeed/Test-HashingSpeed.C b/applications/test/HashingSpeed/Test-HashingSpeed.C
index 2d759ab99f..cc31bf3d49 100644
--- a/applications/test/HashingSpeed/Test-HashingSpeed.C
+++ b/applications/test/HashingSpeed/Test-HashingSpeed.C
@@ -3,8 +3,8 @@
 #include "Hasher.H"
 #include "int.H"
 
-#include <stdio.h>
-#include <time.h>
+#include <cstdio>
+#include <ctime>
 
 #ifndef CLOCKS_PER_SEC
     #ifdef CLK_TCK
@@ -1048,7 +1048,7 @@ int32_t i;
 
 struct tagtest {
         double res;
-        char * name;
+        const char * name;
         hashFn hash;
 } tests[] = {
 //      { 0.0, "CRC32\t\t", GetCRC32                  },
diff --git a/applications/test/List/Test-List.C b/applications/test/List/Test-List.C
index c78ddaac88..16b3210958 100644
--- a/applications/test/List/Test-List.C
+++ b/applications/test/List/Test-List.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2017-2020 OpenCFD Ltd.
+    Copyright (C) 2017-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -658,11 +658,11 @@ int main(int argc, char *argv[])
 
         Info<<"hash of " << flatOutput(list1)
             << " = " << Hash<labelList>()(list1) << " or "
-            << labelList::Hash<>()(list1) << nl;
+            << labelList::hasher()(list1) << nl;
 
         Info<<"hash of " << flatOutput(list2) << " = "
             << Hash<labelList>()(list2) << " or "
-            << labelList::Hash<>()(list2) << nl;
+            << labelList::hasher()(list2) << nl;
     }
 
     return 0;
diff --git a/applications/test/ListOps2/Test-ListOps2.C b/applications/test/ListOps2/Test-ListOps2.C
index cf33113a66..09afd7946d 100644
--- a/applications/test/ListOps2/Test-ListOps2.C
+++ b/applications/test/ListOps2/Test-ListOps2.C
@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2017 OpenCFD Ltd.
+    Copyright (C) 2017-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -57,7 +57,7 @@ Ostream& operator<<
 );
 
 
-template<class T, class Key, class Hash>
+template<class T, class Key, class Hash=Foam::Hash<Key>>
 class HashSorter
 {
     const HashTable<T, Key, Hash>& table;
@@ -219,8 +219,8 @@ int main(int argc, char *argv[])
         Info<< nl << "Test inplaceMapValue" << nl << nl;
 
         HashTable<label> input;
-        typedef HashSorter<label, label, Hash<label>> Mapper;
-        typedef HashSorter<label, word, string::hash> Sorter;
+        typedef HashSorter<label, label> Mapper;
+        typedef HashSorter<label, word> Sorter;
 
         for (label i=0; i < 10; ++i)
         {
diff --git a/applications/test/faceHashing/Make/files b/applications/test/faceHashing/Make/files
new file mode 100644
index 0000000000..2b69436389
--- /dev/null
+++ b/applications/test/faceHashing/Make/files
@@ -0,0 +1,3 @@
+Test-faceHashing.C
+
+EXE = $(FOAM_USER_APPBIN)/Test-faceHashing
diff --git a/applications/test/faceHashing/Make/options b/applications/test/faceHashing/Make/options
new file mode 100644
index 0000000000..7dba39797a
--- /dev/null
+++ b/applications/test/faceHashing/Make/options
@@ -0,0 +1,3 @@
+EXE_INC = ${c++LESSWARN}
+
+/* EXE_LIBS = */
diff --git a/applications/test/faceHashing/Test-faceHashing.C b/applications/test/faceHashing/Test-faceHashing.C
new file mode 100644
index 0000000000..c0d1f9e7ea
--- /dev/null
+++ b/applications/test/faceHashing/Test-faceHashing.C
@@ -0,0 +1,153 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2021 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Application
+    Test-faceHashing
+
+Description
+    Basic tests of face/triFace hashing
+
+\*---------------------------------------------------------------------------*/
+
+#include "IOstreams.H"
+#include "IOobject.H"
+#include "IFstream.H"
+
+#include "faceList.H"
+#include "triFaceList.H"
+#include "HashSet.H"
+#include "HashTable.H"
+
+using namespace Foam;
+
+template<class HashSetType, class FaceListType>
+void checkHashSet(const HashSetType& hs, const FaceListType& faces)
+{
+    Info<< hs << nl;
+    for (const auto& f : faces)
+    {
+        Info<< "  " << f << " found=" << hs.found(f) << nl;
+    }
+    Info<< nl;
+}
+
+
+void checkHashes(const faceList& faces)
+{
+    face::hasher op1;
+    face::symmHasher op2;
+
+    Info<< "face hasher/symmHasher: " << faces.size() << " faces" << nl;
+    for (const face& f : faces)
+    {
+        Info<< "  " << f << " symmhash=" << op2(f)
+            << " hash=" << op1(f) << nl;
+    }
+    Info<< nl;
+}
+
+
+void checkHashes(const triFaceList& faces)
+{
+    triFace::hasher op1;
+
+    Info<< "triFace hasher: " << faces.size() << " faces" << nl;
+    for (const triFace& f : faces)
+    {
+        Info<< "  " << f << " hash=" << op1(f) << nl;
+    }
+    Info<< nl;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+//  Main program:
+
+int main(int argc, char *argv[])
+{
+    {
+        faceList faces
+        ({
+            face{0, 1, 2, 3},  // regular
+            face{0, 3, 2, 1},  // flip
+            face{2, 3, 0, 1},  // rotate
+            face{2, 1, 0, 3},  // rotate (flip)
+            face{2, 0, 1, 3},  // permute
+            face{2, 1, 0, 3},  // permute
+        });
+
+        checkHashes(faces);
+
+        HashSet<face, face::hasher> hs1;
+        HashSet<face, face::symmHasher> hs2;
+        hs1.insert(faces);
+        hs2.insert(faces);
+
+        Info<< "hashset (hasher)" << nl;
+        checkHashSet(hs1, faces);
+        Info<< nl;
+
+        hs1.erase(faces[0]);
+        Info<< "remove " << faces[0] << nl;
+        Info<< "hashset (hasher)" << nl;
+        checkHashSet(hs1, faces);
+        Info<< nl;
+
+        Info<< "hashset (symmHasher)" << nl;
+        checkHashSet(hs2, faces);
+        Info<< nl;
+
+        hs2.erase(faces[0]);
+        Info<< "remove " << faces[0] << nl;
+        Info<< "hashset (symmHasher)" << nl;
+        checkHashSet(hs2, faces);
+        Info<< nl;
+    }
+
+    {
+        triFaceList faces
+        ({
+            triFace{0, 1, 2},  // regular
+            triFace{0, 2, 1},  // flip
+            triFace{2, 0, 1},  // rotate
+        });
+
+        checkHashes(faces);
+
+        HashSet<triFace> hs1;
+        hs1.insert(faces);
+
+        Info<< "hashset (symmHasher)" << nl;
+        checkHashSet(hs1, faces);
+        Info<< nl;
+    }
+
+    Info<< "\nEnd\n" << nl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //
diff --git a/applications/test/string/Test-string.C b/applications/test/string/Test-string.C
index 88f4579df3..11648ba523 100644
--- a/applications/test/string/Test-string.C
+++ b/applications/test/string/Test-string.C
@@ -167,7 +167,7 @@ int main(int argc, char *argv[])
 
 
     Info<< "string:" << test << nl << "hash:"
-        << unsigned(string::hash()(test)) << endl;
+        << unsigned(string::hasher()(test)) << endl;
 
     Info<<"trimLeft: " << stringOps::trimLeft(test) << endl;
     Info<<"trimRight: " << stringOps::trimRight(test) << endl;
@@ -333,11 +333,11 @@ int main(int argc, char *argv[])
     cout<< "output string with " << s2.length() << " characters\n";
     cout<< "ostream<<  >" << s2 << "<\n";
     Info<< "Ostream<<  >" << s2 << "<\n";
-    Info<< "hash:" << hex << string::hash()(s2) << dec << endl;
+    Info<< "hash:" << hex << string::hasher()(s2) << dec << endl;
 
     cout<< "\ntest Foam::name()\n";
 
-    Info<< "hash: = " << word::printf("0x%012X", string::hash()(s2)) << endl;
+    Info<< "hash: = " << word::printf("0x%012X", string::hasher()(s2)) << endl;
 
     // Test formatting on int
     {
diff --git a/applications/utilities/mesh/conversion/ideasUnvToFoam/ideasUnvToFoam.C b/applications/utilities/mesh/conversion/ideasUnvToFoam/ideasUnvToFoam.C
index 4c3fe7cc47..1d9f361e9d 100644
--- a/applications/utilities/mesh/conversion/ideasUnvToFoam/ideasUnvToFoam.C
+++ b/applications/utilities/mesh/conversion/ideasUnvToFoam/ideasUnvToFoam.C
@@ -850,35 +850,39 @@ int main(int argc, char *argv[])
     Map<label> faceToCell[2];
 
     {
-        HashTable<label, face, face::Hash<>> faceToFaceID(boundaryFaces.size());
-        forAll(boundaryFaces, facei)
+        // Can use face::symmHasher or use sorted indices instead
+        // - choose the latter in case UNV has anything odd
+        HashTable<label, face> faceToFaceID(2*boundaryFaces.size());
+
+        forAll(boundaryFaces, bfacei)
         {
-            SortableList<label> sortedVerts(boundaryFaces[facei]);
-            faceToFaceID.insert(face(sortedVerts), facei);
+            face sortedVerts(boundaryFaces[bfacei]);
+            Foam::sort(sortedVerts);
+            faceToFaceID.insert(sortedVerts, bfacei);
         }
 
         forAll(cellVerts, celli)
         {
-            faceList faces = cellVerts[celli].faces();
-            forAll(faces, i)
+            const cellShape& shape = cellVerts[celli];
+
+            for (const face& f : shape.faces())
             {
-                SortableList<label> sortedVerts(faces[i]);
-                const auto fnd = faceToFaceID.find(face(sortedVerts));
-
-                if (fnd.found())
+                face sortedVerts(f);
+                Foam::sort(sortedVerts);
+                const label bfacei = faceToFaceID.lookup(sortedVerts, -1);
+                if (bfacei != -1)
                 {
-                    label facei = *fnd;
-                    int stat = face::compare(faces[i], boundaryFaces[facei]);
+                    const int cmp = face::compare(f, boundaryFaces[bfacei]);
 
-                    if (stat == 1)
+                    if (cmp == 1)
                     {
                         // Same orientation. Cell is owner.
-                        own[facei] = celli;
+                        own[bfacei] = celli;
                     }
-                    else if (stat == -1)
+                    else if (cmp == -1)
                     {
                         // Opposite orientation. Cell is neighbour.
-                        nei[facei] = celli;
+                        nei[bfacei] = celli;
                     }
                 }
             }
@@ -958,15 +962,13 @@ int main(int argc, char *argv[])
         {
             const cellShape& shape = cellVerts[celli];
 
-            const faceList shapeFaces(shape.faces());
-
-            forAll(shapeFaces, i)
+            for (const face& f : shape.faces())
             {
-                label patchi = findPatch(dofGroups, shapeFaces[i]);
+                label patchi = findPatch(dofGroups, f);
 
                 if (patchi != -1)
                 {
-                    dynPatchFaces[patchi].append(shapeFaces[i]);
+                    dynPatchFaces[patchi].append(f);
                 }
             }
         }
diff --git a/applications/utilities/mesh/conversion/netgenNeutralToFoam/netgenNeutralToFoam.C b/applications/utilities/mesh/conversion/netgenNeutralToFoam/netgenNeutralToFoam.C
index 81e0280d22..3dc8bfb9ed 100644
--- a/applications/utilities/mesh/conversion/netgenNeutralToFoam/netgenNeutralToFoam.C
+++ b/applications/utilities/mesh/conversion/netgenNeutralToFoam/netgenNeutralToFoam.C
@@ -173,7 +173,7 @@ int main(int argc, char *argv[])
     label maxPatch = 0;
 
     // Boundary faces as three vertices
-    HashTable<label, triFace, triFace::Hash<>> vertsToBoundary(nFaces);
+    HashTable<label, triFace> vertsToBoundary(nFaces);
 
     forAll(boundaryFaces, facei)
     {
diff --git a/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/pointPairs/pointPairs.H b/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/pointPairs/pointPairs.H
index d56e4af09d..11feda75d4 100644
--- a/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/pointPairs/pointPairs.H
+++ b/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/pointPairs/pointPairs.H
@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2013-2015 OpenFOAM Foundation
+    Copyright (C) 2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -55,15 +56,15 @@ namespace Foam
 template<class Triangulation>
 class pointPairs
 :
-    public HashSet<labelPairPair, labelPairPair::Hash<>>
+    public HashSet<labelPairPair>
 {
-    // Private typedefs
+    // Private Typedefs
 
-    typedef HashSet<labelPairPair, labelPairPair::Hash<>> StorageContainer;
+    typedef HashSet<labelPairPair> StorageContainer;
     typedef typename Triangulation::Vertex_handle Vertex_handle;
 
 
-    // Private data
+    // Private Data
 
         const Triangulation& triangulation_;
 
diff --git a/src/OpenFOAM/Make/files b/src/OpenFOAM/Make/files
index 5892fa798b..747dbd433a 100644
--- a/src/OpenFOAM/Make/files
+++ b/src/OpenFOAM/Make/files
@@ -180,7 +180,8 @@ $(ops)/flipOp.C
 
 primitives/predicates/scalar/scalarPredicates.C
 
-primitives/hashes/Hasher/Hasher.C
+hash = primitives/hashes/Hash
+$(hash)/Hasher.C
 
 sha1 = primitives/hashes/SHA1
 $(sha1)/SHA1.C
diff --git a/src/OpenFOAM/containers/Bits/PackedList/PackedList.H b/src/OpenFOAM/containers/Bits/PackedList/PackedList.H
index 09f3668cc1..6bc3942c81 100644
--- a/src/OpenFOAM/containers/Bits/PackedList/PackedList.H
+++ b/src/OpenFOAM/containers/Bits/PackedList/PackedList.H
@@ -518,6 +518,24 @@ public:
         );
 
 
+    // Hashing
+
+        //- Hashing functor for PackedList
+        //  Seeded with logical size for disambiguation of padding
+        struct hasher
+        {
+            unsigned operator()(const PackedList<Width>& obj) const
+            {
+                return Foam::Hasher
+                (
+                    obj.cdata(),
+                    obj.size_bytes(),
+                    unsigned(obj.size())
+                );
+            }
+        };
+
+
     // Housekeeping
 
         //- Deprecated(2020-11) use fill()
@@ -533,6 +551,13 @@ public:
 };
 
 
+// * * * * * * * * * * * * * * * * * Traits  * * * * * * * * * * * * * * * * //
+
+//- Hashing for PackedList data
+template<unsigned Width>
+struct Hash<PackedList<Width>> : PackedList<Width>::hasher {};
+
+
 // * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * //
 
 //- Write List to Ostream, as per UList::writeList() with default length.
diff --git a/src/OpenFOAM/containers/Bits/bitSet/bitSet.H b/src/OpenFOAM/containers/Bits/bitSet/bitSet.H
index 5730f29c93..04c524713c 100644
--- a/src/OpenFOAM/containers/Bits/bitSet/bitSet.H
+++ b/src/OpenFOAM/containers/Bits/bitSet/bitSet.H
@@ -594,6 +594,12 @@ public:
 };
 
 
+// * * * * * * * * * * * * * * * * * Traits  * * * * * * * * * * * * * * * * //
+
+//- Hashing for bitSet data
+template<> struct Hash<bitSet> : bitSet::hasher {};
+
+
 // * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * //
 
 //- Write bitset to Ostream with 40 items per line.
diff --git a/src/OpenFOAM/containers/HashTables/HashOps/HashOps.H b/src/OpenFOAM/containers/HashTables/HashOps/HashOps.H
index 288195399f..ba54b61440 100644
--- a/src/OpenFOAM/containers/HashTables/HashOps/HashOps.H
+++ b/src/OpenFOAM/containers/HashTables/HashOps/HashOps.H
@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018-2019 OpenCFD Ltd.
+    Copyright (C) 2018-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -62,10 +62,10 @@ namespace HashSetOps
 {
 
 //- Combine HashSet operation. Equivalent to 'a |= b'
-template<class Key=word, class Hash=string::hash>
+template<class Key=word, class HashType=Foam::Hash<Key>>
 struct plusEqOp
 {
-    typedef HashSet<Key, Hash> value_type;
+    typedef HashSet<Key, HashType> value_type;
 
     void operator()(value_type& a, const value_type& b) const
     {
@@ -131,10 +131,10 @@ namespace HashTableOps
 {
 
 //- Combine HashTable operation. Equivalent to 'a += b'
-template<class T, class Key=word, class Hash=string::hash>
+template<class T, class Key=word, class HashType=Foam::Hash<Key>>
 struct plusEqOp
 {
-    typedef HashTable<T, Key, Hash> value_type;
+    typedef HashTable<T, Key, HashType> value_type;
 
     void operator()(value_type& a, const value_type& b) const
     {
diff --git a/src/OpenFOAM/containers/HashTables/HashPtrTable/HashPtrTable.H b/src/OpenFOAM/containers/HashTables/HashPtrTable/HashPtrTable.H
index 173de687e3..549b4df75e 100644
--- a/src/OpenFOAM/containers/HashTables/HashPtrTable/HashPtrTable.H
+++ b/src/OpenFOAM/containers/HashTables/HashPtrTable/HashPtrTable.H
@@ -62,7 +62,7 @@ Istream& operator>>(Istream& is, HashPtrTable<T, Key, Hash>& tbl);
                         Class HashPtrTable Declaration
 \*---------------------------------------------------------------------------*/
 
-template<class T, class Key=word, class Hash=string::hash>
+template<class T, class Key=word, class Hash=Foam::Hash<Key>>
 class HashPtrTable
 :
     public HashTable<T*, Key, Hash>
diff --git a/src/OpenFOAM/containers/HashTables/HashSet/HashSet.H b/src/OpenFOAM/containers/HashTables/HashSet/HashSet.H
index 2b0f31e341..413dda4aa4 100644
--- a/src/OpenFOAM/containers/HashTables/HashSet/HashSet.H
+++ b/src/OpenFOAM/containers/HashTables/HashSet/HashSet.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2016-2020 OpenCFD Ltd.
+    Copyright (C) 2016-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -80,7 +80,7 @@ template<class T> class MinMax;
                            Class HashSet Declaration
 \*---------------------------------------------------------------------------*/
 
-template<class Key=word, class Hash=string::hash>
+template<class Key=word, class Hash=Foam::Hash<Key>>
 class HashSet
 :
     public HashTable<zero::null, Key, Hash>
diff --git a/src/OpenFOAM/containers/HashTables/HashTable/HashTable.H b/src/OpenFOAM/containers/HashTables/HashTable/HashTable.H
index ab1c2302d9..b3cd98f190 100644
--- a/src/OpenFOAM/containers/HashTables/HashTable/HashTable.H
+++ b/src/OpenFOAM/containers/HashTables/HashTable/HashTable.H
@@ -115,7 +115,7 @@ Ostream& operator<<(Ostream&, const HashTable<T, Key, Hash>&);
                           Class HashTable Declaration
 \*---------------------------------------------------------------------------*/
 
-template<class T, class Key=word, class Hash=string::hash>
+template<class T, class Key=word, class Hash=Foam::Hash<Key>>
 class HashTable
 :
     public HashTableCore
diff --git a/src/OpenFOAM/containers/Lists/DynamicList/DynamicList.H b/src/OpenFOAM/containers/Lists/DynamicList/DynamicList.H
index ae8c61570d..e5e71f558a 100644
--- a/src/OpenFOAM/containers/Lists/DynamicList/DynamicList.H
+++ b/src/OpenFOAM/containers/Lists/DynamicList/DynamicList.H
@@ -372,6 +372,11 @@ inline void Swap(DynamicList<T, SizeMinA>& a, DynamicList<T, SizeMinB>& b)
 }
 
 
+//- Hashing for List data
+template<class T, int SizeMin>
+struct Hash<DynamicList<T, SizeMin>> : List<T>::hasher {};
+
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam
diff --git a/src/OpenFOAM/containers/Lists/FixedList/FixedList.H b/src/OpenFOAM/containers/Lists/FixedList/FixedList.H
index cc4d642f41..59588b2c62 100644
--- a/src/OpenFOAM/containers/Lists/FixedList/FixedList.H
+++ b/src/OpenFOAM/containers/Lists/FixedList/FixedList.H
@@ -46,8 +46,8 @@ SourceFiles
 #include "zero.H"
 #include "contiguous.H"
 #include "autoPtr.H"
+#include "Hash.H"
 #include "Swap.H"
-#include "HashFwd.H"
 #include "SLListFwd.H"
 #include "ListPolicy.H"
 
@@ -455,11 +455,8 @@ public:
 
     // Hashing
 
-        //- Hashing function class for FixedList
-        //  Normally use the global Hash specialization, but can also use
-        //  this one for inheritance in sub-classes
-        template<class HashT=Foam::Hash<T>>
-        struct Hash
+        //- Hashing functor for FixedList.
+        struct hasher
         {
             inline unsigned operator()
             (
@@ -469,18 +466,28 @@ public:
             {
                 if (is_contiguous<T>::value)
                 {
-                    return Hasher(obj.cdata(), N*sizeof(T), seed);
+                    return Foam::Hasher(obj.cdata(), obj.size_bytes(), seed);
                 }
 
+                Foam::Hash<T> op;
                 for (const T& val : obj)
                 {
-                    seed = HashT()(val, seed);
+                    seed = op(val, seed);
                 }
                 return seed;
             }
         };
+
+        //- Deprecated(2021-04) hashing functor. Use hasher()
+        // \deprecated(2021-04) - use hasher() functor
+        template<class Unused=bool>
+        struct Hash : FixedList<T, N>::hasher
+        {
+            FOAM_DEPRECATED_FOR(2021-04, "hasher()") Hash() {}
+        };
 };
 
+
 // * * * * * * * * * * * * * * * * * Traits  * * * * * * * * * * * * * * * * //
 
 //- FixedList is contiguous if the type is contiguous
@@ -495,6 +502,10 @@ struct is_contiguous_label<FixedList<T, N>> : is_contiguous_label<T> {};
 template<class T, unsigned N>
 struct is_contiguous_scalar<FixedList<T, N>> : is_contiguous_scalar<T> {};
 
+//- Hashing for FixedList data
+template<class T, unsigned N>
+struct Hash<FixedList<T, N>> : FixedList<T, N>::hasher {};
+
 
 // * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * * //
 
@@ -507,31 +518,6 @@ inline void Swap(FixedList<T, N>& a, FixedList<T, N>& b)
 }
 
 
-//- Hashing for FixedList data, which uses Hasher for contiguous data and
-//- element-wise incrementally hashing otherwise.
-template<class T, unsigned N>
-struct Hash<FixedList<T, N>>
-{
-    inline unsigned operator()
-    (
-        const FixedList<T, N>& obj,
-        unsigned seed=0
-    ) const
-    {
-        if (is_contiguous<T>::value)
-        {
-            return Hasher(obj.cdata(), N*sizeof(T), seed);
-        }
-
-        for (const T& val : obj)
-        {
-            seed = Hash<T>()(val, seed);
-        }
-        return seed;
-    }
-};
-
-
 // * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
 
 //- Write List to Ostream, as per FixedList::writeList() with default length.
diff --git a/src/OpenFOAM/containers/Lists/List/List.H b/src/OpenFOAM/containers/Lists/List/List.H
index 89bc21a1cf..68da584394 100644
--- a/src/OpenFOAM/containers/Lists/List/List.H
+++ b/src/OpenFOAM/containers/Lists/List/List.H
@@ -364,6 +364,10 @@ public:
 template<>
 Istream& List<char>::readList(Istream& is);
 
+//- Hashing for List data
+template<class T>
+struct Hash<List<T>> : List<T>::hasher {};
+
 
 // * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * * //
 
@@ -372,27 +376,6 @@ Istream& List<char>::readList(Istream& is);
 labelList identity(const label len, label start=0);
 
 
-//- Hashing for List data, which uses Hasher for contiguous data and
-//- element-wise incrementally hashing otherwise.
-template<class T>
-struct Hash<List<T>>
-{
-    inline unsigned operator()(const UList<T>& obj, unsigned seed=0) const
-    {
-        if (is_contiguous<T>::value)
-        {
-            return Hasher(obj.cdata(), obj.size()*sizeof(T), seed);
-        }
-
-        for (const T& val : obj)
-        {
-            seed = Hash<T>()(val, seed);
-        }
-        return seed;
-    }
-};
-
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam
diff --git a/src/OpenFOAM/containers/Lists/UList/UList.H b/src/OpenFOAM/containers/Lists/UList/UList.H
index f0a3ab0d58..9df3e1f912 100644
--- a/src/OpenFOAM/containers/Lists/UList/UList.H
+++ b/src/OpenFOAM/containers/Lists/UList/UList.H
@@ -53,8 +53,8 @@ SourceFiles
 #include "contiguous.H"
 #include "nullObject.H"
 #include "stdFoam.H"
+#include "Hash.H"
 #include "Swap.H"
-#include "HashFwd.H"
 #include "ListPolicy.H"
 
 #include <initializer_list>
@@ -522,13 +522,10 @@ public:
         }
 
 
-    // Other
+    // Hashing
 
-        //- Hashing function class for UList.
-        //  Can use this one (instead of the global Hash<>) for inheritance
-        //  in sub-classes
-        template<class HashT=Foam::Hash<T>>
-        struct Hash
+        //- Hashing functor for UList
+        struct hasher
         {
             inline unsigned operator()
             (
@@ -538,16 +535,25 @@ public:
             {
                 if (is_contiguous<T>::value)
                 {
-                    return Hasher(obj.cdata(), obj.size_bytes(), seed);
+                    return Foam::Hasher(obj.cdata(), obj.size_bytes(), seed);
                 }
 
+                Foam::Hash<T> op;
                 for (const T& val : obj)
                 {
-                    seed = HashT()(val, seed);
+                    seed = op(val, seed);
                 }
                 return seed;
             }
         };
+
+        //- Deprecated(2021-04) hashing functor. Use hasher()
+        // \deprecated(2021-04) - use hasher() functor
+        template<class Unused=bool>
+        struct Hash : UList<T>::hasher
+        {
+            FOAM_DEPRECATED_FOR(2021-04, "hasher()") Hash() {}
+        };
 };
 
 
@@ -617,28 +623,13 @@ inline void Swap(UList<T>& a, UList<T>& b)
 }
 
 
-//- Hashing for UList data, which uses Hasher for contiguous data and
-//- element-wise incrementally hashing otherwise.
-template<class T>
-struct Hash<UList<T>>
-{
-    inline unsigned operator()(const UList<T>& obj, unsigned seed=0) const
-    {
-        if (is_contiguous<T>::value)
-        {
-            return Hasher(obj.cdata(), obj.size_bytes(), seed);
-        }
-        for (const T& val : obj)
-        {
-            seed = Hash<T>()(val, seed);
-        }
-        return seed;
-    }
-};
-
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+//- Hashing for List data
+template<class T>
+struct Hash<UList<T>> : UList<T>::hasher {};
+
+
 //- Object access operator or list access operator.
 //- \sa ListListOps::combine()
 template<class T>
diff --git a/src/OpenFOAM/db/runTimeSelection/construction/runTimeSelectionTables.H b/src/OpenFOAM/db/runTimeSelection/construction/runTimeSelectionTables.H
index d8bd4719c8..336927c38f 100644
--- a/src/OpenFOAM/db/runTimeSelection/construction/runTimeSelectionTables.H
+++ b/src/OpenFOAM/db/runTimeSelection/construction/runTimeSelectionTables.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -52,7 +52,7 @@ Description
     typedef autoPtr<baseType> (*argNames##ConstructorPtr)argList;              \
                                                                                \
     /* Construct from argList function table type */                           \
-    typedef HashTable<argNames##ConstructorPtr, word, string::hash>            \
+    typedef HashTable<argNames##ConstructorPtr, word>                          \
         argNames##ConstructorTable;                                            \
                                                                                \
     /* Construct from argList function pointer table pointer */                \
@@ -152,7 +152,7 @@ Description
     typedef autoPtr<baseType> (*argNames##ConstructorPtr)argList;              \
                                                                                \
     /* Construct from argList function table type */                           \
-    typedef HashTable<argNames##ConstructorPtr, word, string::hash>            \
+    typedef HashTable<argNames##ConstructorPtr, word>                          \
         argNames##ConstructorTable;                                            \
                                                                                \
     /* Construct from argList function pointer table pointer */                \
diff --git a/src/OpenFOAM/db/runTimeSelection/memberFunctions/memberFunctionSelectionTables.H b/src/OpenFOAM/db/runTimeSelection/memberFunctions/memberFunctionSelectionTables.H
index 8698554012..a92954fbd6 100644
--- a/src/OpenFOAM/db/runTimeSelection/memberFunctions/memberFunctionSelectionTables.H
+++ b/src/OpenFOAM/db/runTimeSelection/memberFunctions/memberFunctionSelectionTables.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -46,8 +46,7 @@ Description
     typedef returnType (*memberFunction##argNames##MemberFunctionPtr)argList;  \
                                                                                \
     /* Construct from argList function table type */                           \
-    typedef HashTable                                                          \
-        <memberFunction##argNames##MemberFunctionPtr, word, string::hash>      \
+    typedef HashTable<memberFunction##argNames##MemberFunctionPtr, word>       \
         memberFunction##argNames##MemberFunctionTable;                         \
                                                                                \
     /* Construct from argList function pointer table pointer */                \
diff --git a/src/OpenFOAM/meshes/meshShapes/edge/edge.H b/src/OpenFOAM/meshes/meshShapes/edge/edge.H
index 720788b992..e029daf60d 100644
--- a/src/OpenFOAM/meshes/meshShapes/edge/edge.H
+++ b/src/OpenFOAM/meshes/meshShapes/edge/edge.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2015 OpenFOAM Foundation
-    Copyright (C) 2017-2020 OpenCFD Ltd.
+    Copyright (C) 2017-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -285,32 +285,37 @@ public:
 
     // Hashing
 
-        //- The (commutative) hash-value for edge
-        inline unsigned hashval(unsigned seed=0) const
+        //- The (commutative) hash value for edge, hashes lower value first
+        inline unsigned hash_code(unsigned seed=0) const
         {
-            if (first() < second())
+            Foam::Hash<label> op;
+            if (second() < first())
             {
-                seed = Foam::Hash<label>()(first(), seed);
-                seed = Foam::Hash<label>()(second(), seed);
+                return op(first(), op(second(), seed));
             }
             else
             {
-                seed = Foam::Hash<label>()(second(), seed);
-                seed = Foam::Hash<label>()(first(), seed);
+                return op(second(), op(first(), seed));
             }
-            return seed;
         }
 
-        //- Hashing function class for edge (commutative)
+        //- Hashing functor for edge (commutative)
         //  Also useful for inheritance in sub-classes
-        template<class HashT=Foam::Hash<label>>
-        struct Hash
+        struct hasher
         {
-            inline unsigned operator()(const edge& obj, unsigned seed=0) const
+            unsigned operator()(const edge& obj, unsigned seed=0) const
             {
-                return obj.hashval(seed);
+                return obj.hash_code(seed);
             }
         };
+
+        //- Deprecated(2021-04) hashing functor. Use hasher()
+        // \deprecated(2021-04) - use hasher() functor
+        template<class Unused=bool>
+        struct Hash : edge::hasher
+        {
+            FOAM_DEPRECATED_FOR(2021-04, "hasher()") Hash() {}
+        };
 };
 
 
@@ -322,6 +327,9 @@ template<> struct is_contiguous<edge> : std::true_type {};
 //- Contiguous label data for edge (a pair of labels)
 template<> struct is_contiguous_label<edge> : std::true_type {};
 
+//- Hashing for edge uses commutative (incremental) hash
+template<> struct Hash<edge> : edge::hasher {};
+
 
 // * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * * //
 
@@ -332,17 +340,6 @@ inline edge reverse(const edge& e)
 }
 
 
-//- Hash specialization for edge, using a commutative (incremental) hash.
-template<>
-struct Hash<edge>
-{
-    inline unsigned operator()(const edge& e, unsigned seed=0) const
-    {
-        return e.hashval(seed);
-    }
-};
-
-
 // * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * * //
 
 //- Compare edges for equal content, ignoring orientation
diff --git a/src/OpenFOAM/meshes/meshShapes/face/face.C b/src/OpenFOAM/meshes/meshShapes/face/face.C
index 868c13df89..d7fd7c3d07 100644
--- a/src/OpenFOAM/meshes/meshShapes/face/face.C
+++ b/src/OpenFOAM/meshes/meshShapes/face/face.C
@@ -30,7 +30,6 @@ License
 #include "triFace.H"
 #include "triPointRef.H"
 #include "mathematicalConstants.H"
-#include "Swap.H"
 #include "ConstCirculator.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@@ -304,24 +303,18 @@ int Foam::face::compare(const face& a, const face& b)
     // will be circular in the same order (but not necessarily in the
     // same direction or from the same starting point).
 
-    // Trivial reject: faces are different size
-    label sizeA = a.size();
-    label sizeB = b.size();
+    const label sizeA = a.size();
+    const label sizeB = b.size();
 
+    // Trivial reject: faces are different size
     if (sizeA != sizeB || sizeA == 0)
     {
         return 0;
     }
     else if (sizeA == 1)
     {
-        if (a[0] == b[0])
-        {
-            return 1;
-        }
-        else
-        {
-            return 0;
-        }
+        // Trivial: face with a single vertex
+        return (a[0] == b[0] ? 1 : 0);
     }
 
     ConstCirculator<face> aCirc(a);
@@ -410,7 +403,7 @@ bool Foam::face::sameVertices(const face& a, const face& b)
     {
         return false;
     }
-    // Check faces with a single vertex
+    // Trivial: face with a single vertex
     else if (sizeA == 1)
     {
         return (a[0] == b[0]);
@@ -440,6 +433,57 @@ bool Foam::face::sameVertices(const face& a, const face& b)
 }
 
 
+unsigned Foam::face::symmhash_code(const UList<label>& f, unsigned seed)
+{
+    Foam::Hash<label> op;
+
+    label len = f.size();
+
+    if (!len)
+    {
+        // Trivial: zero-sized
+        return 0;
+    }
+    else if (len == 1)
+    {
+        // Trivial: single vertex
+        return op(f[0], seed);
+    }
+
+    // Find location of the min vertex
+    label pivot = 0;
+    for (label i = 1; i < len; ++i)
+    {
+        if (f[pivot] > f[i])
+        {
+            pivot = i;
+        }
+    }
+
+    // Use next lowest value for deciding direction to circulate
+    if (f.fcValue(pivot) < f.rcValue(pivot))
+    {
+        // Forward circulate
+        while (len--)
+        {
+            seed = op(f[pivot], seed);
+            pivot = f.fcIndex(pivot);
+        }
+    }
+    else
+    {
+        // Reverse circulate
+        while (len--)
+        {
+            seed = op(f[pivot], seed);
+            pivot = f.rcIndex(pivot);
+        }
+    }
+
+    return seed;
+}
+
+
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 Foam::label Foam::face::collapse()
diff --git a/src/OpenFOAM/meshes/meshShapes/face/face.H b/src/OpenFOAM/meshes/meshShapes/face/face.H
index 8d25990751..9c5565fcf8 100644
--- a/src/OpenFOAM/meshes/meshShapes/face/face.H
+++ b/src/OpenFOAM/meshes/meshShapes/face/face.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2017-2020 OpenCFD Ltd.
+    Copyright (C) 2017-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -421,20 +421,55 @@ public:
 
         //- Return true if the faces have the same vertices
         static bool sameVertices(const face& a, const face& b);
+
+
+    // Hashing
+
+        //- The symmetric hash value for face.
+        //  Starts with lowest vertex value and walks in the direction
+        //  of the next lowest value.
+        static unsigned symmhash_code(const UList<label>& f, unsigned seed=0);
+
+        //- The hash value for face.
+        //  Currently hashes as sequential contiguous data,
+        //  but could/should be commutative
+        inline unsigned hash_code(unsigned seed=0) const
+        {
+            return Foam::Hasher(this->cdata(), this->size_bytes(), seed);
+        }
+
+        //- The symmetric hash value for face.
+        //  Starts with lowest vertex value and walks in the direction
+        //  of the next lowest value.
+        inline unsigned symmhash_code(unsigned seed=0) const
+        {
+            return face::symmhash_code(*this, seed);
+        }
+
+        //- Hashing functor for face
+        struct hasher
+        {
+            unsigned operator()(const face& obj, unsigned seed=0) const
+            {
+                return obj.hash_code(seed);
+            }
+        };
+
+        //- Symmetric hashing functor for face
+        struct symmHasher
+        {
+            unsigned operator()(const face& obj, unsigned seed=0) const
+            {
+                return face::symmhash_code(obj, seed);
+            }
+        };
 };
 
 
 // * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
 
-//- Hash specialization for face
-template<>
-struct Hash<face>
-{
-    inline unsigned operator()(const face& obj, unsigned seed=0) const
-    {
-        return Hasher(obj.cdata(), obj.size()*sizeof(label), seed);
-    }
-};
+//- Hash face as contiguous (non-commutative) list data
+template<> struct Hash<face> : face::hasher {};
 
 
 //- Specialization to offset faces, used in ListListOps::combineOffset
diff --git a/src/OpenFOAM/meshes/meshShapes/triFace/triFace.H b/src/OpenFOAM/meshes/meshShapes/triFace/triFace.H
index af08fc4a48..50fd55fe87 100644
--- a/src/OpenFOAM/meshes/meshShapes/triFace/triFace.H
+++ b/src/OpenFOAM/meshes/meshShapes/triFace/triFace.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2017-2020 OpenCFD Ltd.
+    Copyright (C) 2017-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -270,33 +270,35 @@ public:
 
     // Hashing
 
-        //- The (commutative) hash-value for triFace
-        inline unsigned hashval(unsigned seed=0) const
+        //- The (commutative) hash value for triFace
+        inline unsigned hash_code(unsigned seed=0) const
         {
             // Fortunately we don't need this very often
             const uLabel t0((*this)[0]);
             const uLabel t1((*this)[1]);
             const uLabel t2((*this)[2]);
 
-            const uLabel val = (t0*t1*t2 + t0+t1+t2);
+            const uLabel val(t0*t1*t2 + t0+t1+t2);
 
             return Foam::Hash<uLabel>()(val, seed);
         }
 
-        //- Hashing function class for triFace (commutative)
-        //  Also useful for inheritance in sub-classes
-        template<class HashT=Foam::Hash<label>>
-        struct Hash
+        //- Hashing functor for triFace (commutative)
+        struct hasher
         {
-            inline unsigned operator()
-            (
-                const triFace& obj,
-                unsigned seed=0
-            ) const
+            unsigned operator()(const triFace& obj, unsigned seed=0) const
             {
-                return obj.hashval(seed);
+                return obj.hash_code(seed);
             }
         };
+
+        //- Deprecated(2021-04) hashing functor. Use hasher()
+        // \deprecated(2021-04) - use hasher() functor
+        template<class Unused=bool>
+        struct Hash : triFace::hasher
+        {
+            FOAM_DEPRECATED_FOR(2021-04, "hasher()") Hash() {}
+        };
 };
 
 
@@ -308,16 +310,8 @@ template<> struct is_contiguous<triFace> : std::true_type {};
 //- Contiguous label data for triFace
 template<> struct is_contiguous_label<triFace> : std::true_type {};
 
-
-//- Hash specialization for triFace as a commutative hash value.
-template<>
-struct Hash<triFace>
-{
-    inline unsigned operator()(const triFace& obj, unsigned seed=0) const
-    {
-        return obj.hashval(seed);
-    }
-};
+//- Hashing for triFace uses commutative (incremental) hash
+template<> struct Hash<triFace> : triFace::hasher {};
 
 
 //- Specialization to offset faces, used in ListListOps::combineOffset
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.C b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.C
index 939f26210a..36645c38bb 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.C
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.C
@@ -203,11 +203,11 @@ int Foam::processorCyclicPolyPatch::tag() const
 
         if (owner())
         {
-            tag_ = string::hash()(cycPatch.name()) % 32768u;
+            tag_ = string::hasher()(cycPatch.name()) % 32768u;
         }
         else
         {
-            tag_ = string::hash()(cycPatch.neighbPatch().name()) % 32768u;
+            tag_ = string::hasher()(cycPatch.neighbPatch().name()) % 32768u;
         }
 
         if (tag_ == Pstream::msgType() || tag_ == -1)
diff --git a/src/OpenFOAM/primitives/Pair/Pair.H b/src/OpenFOAM/primitives/Pair/Pair.H
index 7420d1bfc5..9a9458bc22 100644
--- a/src/OpenFOAM/primitives/Pair/Pair.H
+++ b/src/OpenFOAM/primitives/Pair/Pair.H
@@ -147,28 +147,21 @@ public:
 
     // Hashing
 
-        //- Symmetrical hashing for Pair data.
-        //  The lower value is hashed first.
-        template<class HashT=Foam::Hash<T>>
-        struct SymmHash
+        //- Symmetric hashing functor for Pair, hashes lower value first
+        //  Regular hasher inherited from FixedList
+        struct symmHasher
         {
-            inline unsigned operator()
-            (
-                const Pair<T>& obj,
-                unsigned seed=0
-            ) const
+            unsigned operator()(const Pair<T>& obj, unsigned seed=0) const
             {
-                if (obj.first() < obj.second())
+                Foam::Hash<T> op;
+                if (obj.second() < obj.first())
                 {
-                    seed = HashT()(obj.first(), seed);
-                    seed = HashT()(obj.second(), seed);
+                    return op(obj.first(), op(obj.second(), seed));
                 }
                 else
                 {
-                    seed = HashT()(obj.second(), seed);
-                    seed = HashT()(obj.first(), seed);
+                    return op(obj.second(), op(obj.first(), seed));
                 }
-                return seed;
             }
         };
 };
@@ -188,29 +181,13 @@ struct is_contiguous_label<Pair<T>> : is_contiguous_label<T> {};
 template<class T>
 struct is_contiguous_scalar<Pair<T>> : is_contiguous_scalar<T> {};
 
+//- Hashing for Pair of data
+template<class T>
+struct Hash<Pair<T>> : Pair<T>::hasher {};
+
 
 // * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * * //
 
-//- Hashing for Pair data, which uses Hasher for contiguous data and
-//- element-wise incrementally hashing otherwise.
-template<class T>
-struct Hash<Pair<T>>
-{
-    inline unsigned operator()(const Pair<T>& obj, unsigned seed=0) const
-    {
-        if (is_contiguous<T>::value)
-        {
-            return Hasher(obj.cdata(), obj.size_bytes(), seed);
-        }
-
-        seed = Hash<T>()(obj.first(), seed);
-        seed = Hash<T>()(obj.second(), seed);
-
-        return seed;
-    }
-};
-
-
 //- Return reverse of a Pair
 template<class T>
 Pair<T> reverse(const Pair<T>& p)
diff --git a/src/OpenFOAM/primitives/Pair/labelPairHashes.H b/src/OpenFOAM/primitives/Pair/labelPairHashes.H
index 82c3ead58d..cd40895358 100644
--- a/src/OpenFOAM/primitives/Pair/labelPairHashes.H
+++ b/src/OpenFOAM/primitives/Pair/labelPairHashes.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
-    Copyright (C) 2017 OpenCFD Ltd.
+    Copyright (C) 2017-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -52,19 +52,19 @@ Description
 #ifndef labelPairHashes_H
 #define labelPairHashes_H
 
-#include "HashSet.H"
 #include "labelPair.H"
+#include "HashSet.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
     template<class T>
-    using LabelPairMap = HashTable<T, labelPair, labelPair::Hash<>>;
+    using LabelPairMap = HashTable<T, labelPair, Foam::Hash<labelPair>>;
 
-    typedef HashSet<labelPair, labelPair::Hash<>> labelPairHashSet;
+    typedef HashSet<labelPair, Foam::Hash<labelPair>> labelPairHashSet;
 
-    typedef HashTable<label, labelPair, labelPair::Hash<>> labelPairLookup;
+    typedef HashTable<label, labelPair, Foam::Hash<labelPair>> labelPairLookup;
 }
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
diff --git a/src/OpenFOAM/primitives/Pair/wordPairHashes.H b/src/OpenFOAM/primitives/Pair/wordPairHashes.H
new file mode 100644
index 0000000000..92eaf28a51
--- /dev/null
+++ b/src/OpenFOAM/primitives/Pair/wordPairHashes.H
@@ -0,0 +1,67 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2015 OpenFOAM Foundation
+    Copyright (C) 2021 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Alias
+    Foam::WordPairMap
+    A HashTable to objects of type \<T\> with a wordPair key.
+
+Typedef
+    Foam::wordPairHashSet
+
+Description
+    A HashSet for a wordPair.
+
+Typedef
+    Foam::wordPairHashTable
+
+Description
+    HashTable of wordPair
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef wordPairHashes_H
+#define wordPairHashes_H
+
+#include "wordPair.H"
+#include "HashSet.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    template<class T>
+    using WordPairMap = HashTable<T, wordPair, Foam::Hash<wordPair>>;
+
+    typedef HashSet<wordPair, Foam::Hash<wordPair>> wordPairHashSet;
+
+    typedef HashTable<word, wordPair, Foam::Hash<wordPair>> wordPairHashTable;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/primitives/Tuple2/Tuple2.H b/src/OpenFOAM/primitives/Tuple2/Tuple2.H
index 244eb7da6a..874f34945d 100644
--- a/src/OpenFOAM/primitives/Tuple2/Tuple2.H
+++ b/src/OpenFOAM/primitives/Tuple2/Tuple2.H
@@ -141,6 +141,29 @@ public:
 };
 
 
+// * * * * * * * * * * * * * * * * * Traits  * * * * * * * * * * * * * * * * //
+
+//- Hashing for Tuple2 data
+template<class T1, class T2>
+struct Hash<Tuple2<T1, T2>>
+{
+    unsigned operator()(const Tuple2<T1, T2>& obj, unsigned seed=0) const
+    {
+        return Hash<T2>()(obj.second(), Hash<T1>()(obj.first(), seed));
+    }
+};
+
+//- Hashing for std::pair data
+template<class T1, class T2>
+struct Hash<std::pair<T1, T2>>
+{
+    unsigned operator()(const std::pair<T1, T2>& obj, unsigned seed=0) const
+    {
+        return Hash<T2>()(obj.second, Hash<T1>()(obj.first, seed));
+    }
+};
+
+
 // * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * * //
 
 //- Return reverse of a Tuple2
diff --git a/src/OpenFOAM/primitives/hashes/Hash/Hash.H b/src/OpenFOAM/primitives/hashes/Hash/Hash.H
index b2acbb5ff9..5329080bf0 100644
--- a/src/OpenFOAM/primitives/hashes/Hash/Hash.H
+++ b/src/OpenFOAM/primitives/hashes/Hash/Hash.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2012 OpenFOAM Foundation
-    Copyright (C) 2018-2019 OpenCFD Ltd.
+    Copyright (C) 2018-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -29,20 +29,22 @@ Class
 
 Description
     Hash function class.
-    The default definition is for primitives, non-primitives used to hash
-    entries on hash tables likely need a specialized version of this class.
+    The default definition is for primitives.
+    Non-primitives used to hash entries on hash tables will likely need
+    a specialized version.
+
+Note
+    The second template parameter (bool) is used for SFINAE overloading,
 
 \*---------------------------------------------------------------------------*/
 
 #ifndef Hash_H
 #define Hash_H
 
-#include "label.H"
-#include "uLabel.H"
 #include "Hasher.H"
-#include "fileName.H"
-#include "keyType.H"
-#include "wordRe.H"
+#include <cstdint>
+#include <string>
+#include <type_traits>
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -53,107 +55,82 @@ namespace Foam
                             Class Hash Declaration
 \*---------------------------------------------------------------------------*/
 
-template<class T>
+template<class T, class SFINAEType=bool>
 struct Hash
 {
-    inline unsigned operator()(const T& obj, unsigned seed=0) const
+    unsigned operator()(const T& obj, unsigned seed=0) const
     {
-        return Hasher(&obj, sizeof(obj), seed);
+        return Foam::Hasher(&obj, sizeof(T), seed);
     }
 };
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-//- Hash specialization for label
-template<>
-struct Hash<Foam::label>
-{
-    //- Incrementally hash a label.
-    //  This will necessarily return a different value than the
-    //  non-incremental version.
-    inline unsigned operator()(const label obj, unsigned seed) const
-    {
-        return Hasher(&obj, sizeof(label), seed);
+// Specialization for trivial (integer) types
+
+#undef  FOAM_INTHASHER
+#define FOAM_INTHASHER(IntType)                                               \
+    /*! \brief Hashing specialization for IntType */                          \
+    /*! Unseeded (single value) uses natural order, otherwise incremental */  \
+    template<> struct Hash<IntType>                                           \
+    {                                                                         \
+        unsigned operator()(const IntType val) const                          \
+        {                                                                     \
+            return static_cast<unsigned>(val);                                \
+        }                                                                     \
+        unsigned operator()(const IntType val, unsigned seed) const           \
+        {                                                                     \
+            return Foam::Hasher(&val, sizeof(IntType), seed);                 \
+        }                                                                     \
     }
 
-    //- Return the unsigned representation of a label.
-    //  This helps if people have relied on the hash value corresponding to
-    //  the natural order.
-    inline unsigned operator()(const label obj) const
+FOAM_INTHASHER(bool);
+FOAM_INTHASHER(char);
+FOAM_INTHASHER(int32_t);
+FOAM_INTHASHER(int64_t);
+FOAM_INTHASHER(uint32_t);
+
+#undef FOAM_INTHASHER
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+//- Hashing specialization for nullptr. Always 0
+template<>
+struct Hash<std::nullptr_t>
+{
+    unsigned operator()(std::nullptr_t, unsigned seed=0) const noexcept
     {
-        return obj;
+        return seed;
     }
 };
 
-
-//- Hash specialization for string
-template<>
-struct Hash<Foam::string>
-{
-    inline unsigned operator()(const string& obj, unsigned seed=0) const
-    {
-        return string::hash()(obj, seed);
-    }
-};
-
-
-//- Hash specialization for word
-template<>
-struct Hash<Foam::word>
-{
-    inline unsigned operator()(const word& obj, unsigned seed=0) const
-    {
-        return string::hash()(obj, seed);
-    }
-};
-
-
-//- Hash specialization for fileName
-template<>
-struct Hash<Foam::fileName>
-{
-    inline unsigned operator()(const fileName& obj, unsigned seed=0) const
-    {
-        return string::hash()(obj, seed);
-    }
-};
-
-
-//- Hash specialization for wordRe
-template<>
-struct Hash<Foam::wordRe>
-{
-    inline unsigned operator()(const wordRe& obj, unsigned seed=0) const
-    {
-        return string::hash()(obj, seed);
-    }
-};
-
-
-//- Hash specialization for keyType
-template<>
-struct Hash<Foam::keyType>
-{
-    inline unsigned operator()(const keyType& obj, unsigned seed=0) const
-    {
-        return string::hash()(obj, seed);
-    }
-};
-
-
-//- Hash specialization for pointers, interpret pointer as a integer type.
+//- Hashing specialization for pointers, interpret pointer as a integer type
 template<>
 struct Hash<void*>
 {
-    inline unsigned operator()(const void* const& obj, unsigned seed) const
+    unsigned operator()(const void* const ptr, unsigned seed=0) const
     {
-        return Hash<intptr_t>()(intptr_t(obj), seed);
+        const uintptr_t addr = uintptr_t(ptr);
+        return Foam::Hasher(&addr, sizeof(addr), seed);
     }
+};
 
-    inline unsigned operator()(const void* const& obj) const
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+//- Hashing partial specialization for derived string types
+template<class StringType>
+struct Hash
+<
+    StringType,
+    typename std::enable_if
+    <std::is_base_of<std::string, StringType>::value, bool>::type
+>
+{
+    unsigned operator()(const std::string& str, unsigned seed=0) const
     {
-        return Hash<intptr_t>()(intptr_t(obj));
+        return Foam::Hasher(str.data(), str.length(), seed);
     }
 };
 
diff --git a/src/OpenFOAM/primitives/hashes/Hash/HashFwd.H b/src/OpenFOAM/primitives/hashes/Hash/HashFwd.H
index e209be8612..cd1a9e00d7 100644
--- a/src/OpenFOAM/primitives/hashes/Hash/HashFwd.H
+++ b/src/OpenFOAM/primitives/hashes/Hash/HashFwd.H
@@ -1,47 +1,14 @@
 /*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | www.openfoam.com
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-    Copyright (C) 2018 OpenCFD Ltd.
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
 Description
-    Forward definition for Hash function class and the definition for
-    the Hasher function.
+    Compatibility include.
+    Previous support for forward declarations is no longer needed.
 
 \*---------------------------------------------------------------------------*/
 
 #ifndef HashFwd_H
 #define HashFwd_H
 
-#include "Hasher.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-    template<class T> struct Hash;
-}
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+#include "Hash.H"
 
 #endif
 
diff --git a/src/OpenFOAM/primitives/hashes/Hasher/Hasher.C b/src/OpenFOAM/primitives/hashes/Hash/Hasher.C
similarity index 99%
rename from src/OpenFOAM/primitives/hashes/Hasher/Hasher.C
rename to src/OpenFOAM/primitives/hashes/Hash/Hasher.C
index cc8a0af325..a3bce4fa83 100644
--- a/src/OpenFOAM/primitives/hashes/Hasher/Hasher.C
+++ b/src/OpenFOAM/primitives/hashes/Hash/Hasher.C
@@ -159,6 +159,114 @@ Description
     }
 
 
+// * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
+
+// ----------------------------------------------------------------------------
+//  This works on all machines.  To be useful, it requires
+//  -- that the key be an array of uint32_t's, and
+//  -- that the length be the number of uint32_t's in the key
+//
+//  The function hashword() is identical to hashlittle() on little-endian
+//  machines, and identical to hashbig() on big-endian machines,
+//  except that the length has to be measured in uint32_ts rather than in
+//  bytes.  hashlittle() is more complicated than hashword() only because
+//  hashlittle() has to dance around fitting the key bytes into registers.
+// ----------------------------------------------------------------------------
+unsigned Foam::HasherInt
+(
+    const uint32_t *k,
+    size_t length,
+    unsigned seed
+)
+{
+    uint32_t a, b, c;
+
+    // Set up the internal state
+    a = b = c = 0xdeadbeef + (static_cast<uint32_t>(length) << 2) + seed;
+
+    // handle most of the key
+    while (length > 3)
+    {
+        a += k[0];
+        b += k[1];
+        c += k[2];
+        bitMixer(a,b,c);
+        length -= 3;
+        k += 3;
+    }
+
+    // handle the last 3 uint32_t's
+    switch (length)  // all case statements fall through
+    {
+        case 3 : c += k[2]; [[fallthrough]];
+        case 2 : b += k[1]; [[fallthrough]];
+        case 1 : a += k[0];
+            bitMixerFinal(a,b,c);
+            [[fallthrough]];
+        case 0 :  // case 0: nothing left to add
+            break;
+    }
+
+    return c;
+}
+
+
+// ----------------------------------------------------------------------------
+// hashword2() -- same as hashword(), but take two seeds and return two
+// 32-bit values.  pc and pb must both be non-null, and *pc and *pb must
+// both be initialized with seeds.  If you pass in (*pb)==0, the output
+// (*pc) will be the same as the return value from hashword().
+// ----------------------------------------------------------------------------
+
+// Currently unused
+#if 0
+unsigned Foam::HasherDual
+(
+    const uint32_t *k,
+    size_t length,
+    unsigned& hash1,  // IN: seed OUT: primary hash value
+    unsigned& hash2   // IN: more seed OUT: secondary hash value
+)
+{
+    uint32_t a, b, c;
+
+    // Set up the internal state
+    a = b = c = 0xdeadbeef + (static_cast<uint32_t>(length) << 2) + hash1;
+    c += hash2;
+
+    // handle most of the key
+    while (length > 3)
+    {
+        a += k[0];
+        b += k[1];
+        c += k[2];
+        bitMixer(a,b,c);
+        length -= 3;
+        k += 3;
+    }
+
+    // handle the last 3 uint32_t's
+    switch (length)  // all case statements fall through
+    {
+        case 3 : c += k[2]; [[fallthrough]];
+        case 2 : b += k[1]; [[fallthrough]];
+        case 1 : a += k[0];
+            bitMixerFinal(a,b,c);
+            [[fallthrough]];
+        case 0 :  // case 0: nothing left to add
+            break;
+    }
+
+    // report the result
+    hash1 = c;
+    hash2 = b;
+
+    // return primary hash value
+    return c;
+}
+#endif
+
+
 // * * * * * * * * * * * * * * Static Functions  * * * * * * * * * * * * * * //
 
 // ----------------------------------------------------------------------------
@@ -304,6 +412,7 @@ static unsigned jenkins_hashlittle
     }
     else
     {
+        // need to read the key one byte at a time
         const uint8_t *k = reinterpret_cast<const uint8_t*>(key);
 
         // all but the last block: affect some 32 bits of (a,b,c)
@@ -468,7 +577,6 @@ static unsigned jenkins_hashbig
 
 // * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
 
-
 unsigned Foam::Hasher
 (
     const void *key,
@@ -486,106 +594,4 @@ unsigned Foam::Hasher
 }
 
 
-// ----------------------------------------------------------------------------
-//  This works on all machines.  To be useful, it requires
-//  -- that the key be an array of uint32_t's, and
-//  -- that the length be the number of uint32_t's in the key
-//
-//  The function hashword() is identical to hashlittle() on little-endian
-//  machines, and identical to hashbig() on big-endian machines,
-//  except that the length has to be measured in uint32_ts rather than in
-//  bytes.  hashlittle() is more complicated than hashword() only because
-//  hashlittle() has to dance around fitting the key bytes into registers.
-// ----------------------------------------------------------------------------
-unsigned Foam::HasherInt
-(
-    const uint32_t *k,
-    size_t length,
-    unsigned seed
-)
-{
-    uint32_t a, b, c;
-
-    // Set up the internal state
-    a = b = c = 0xdeadbeef + (static_cast<uint32_t>(length) << 2) + seed;
-
-    // handle most of the key
-    while (length > 3)
-    {
-        a += k[0];
-        b += k[1];
-        c += k[2];
-        bitMixer(a,b,c);
-        length -= 3;
-        k += 3;
-    }
-
-    // handle the last 3 uint32_t's
-    switch (length)  // all case statements fall through
-    {
-        case 3 : c += k[2]; [[fallthrough]];
-        case 2 : b += k[1]; [[fallthrough]];
-        case 1 : a += k[0];
-            bitMixerFinal(a,b,c);
-            [[fallthrough]];
-        case 0 :  // case 0: nothing left to add
-            break;
-    }
-
-    return c;
-}
-
-
-// ----------------------------------------------------------------------------
-// hashword2() -- same as hashword(), but take two seeds and return two
-// 32-bit values.  pc and pb must both be non-null, and *pc and *pb must
-// both be initialized with seeds.  If you pass in (*pb)==0, the output
-// (*pc) will be the same as the return value from hashword().
-// ----------------------------------------------------------------------------
-unsigned Foam::HasherDual
-(
-    const uint32_t *k,
-    size_t length,
-    unsigned& hash1,  // IN: seed OUT: primary hash value
-    unsigned& hash2   // IN: more seed OUT: secondary hash value
-)
-{
-    uint32_t a, b, c;
-
-    // Set up the internal state
-    a = b = c = 0xdeadbeef + (static_cast<uint32_t>(length) << 2) + hash1;
-    c += hash2;
-
-    // handle most of the key
-    while (length > 3)
-    {
-        a += k[0];
-        b += k[1];
-        c += k[2];
-        bitMixer(a,b,c);
-        length -= 3;
-        k += 3;
-    }
-
-    // handle the last 3 uint32_t's
-    switch (length)  // all case statements fall through
-    {
-        case 3 : c += k[2]; [[fallthrough]];
-        case 2 : b += k[1]; [[fallthrough]];
-        case 1 : a += k[0];
-            bitMixerFinal(a,b,c);
-            [[fallthrough]];
-        case 0 :  // case 0: nothing left to add
-            break;
-    }
-
-    // report the result
-    hash1 = c;
-    hash2 = b;
-
-    // return primary hash value
-    return c;
-}
-
-
 // ************************************************************************* //
diff --git a/src/OpenFOAM/primitives/hashes/Hasher/Hasher.H b/src/OpenFOAM/primitives/hashes/Hash/Hasher.H
similarity index 86%
rename from src/OpenFOAM/primitives/hashes/Hasher/Hasher.H
rename to src/OpenFOAM/primitives/hashes/Hash/Hasher.H
index ff08655a32..fb31cdb9f5 100644
--- a/src/OpenFOAM/primitives/hashes/Hasher/Hasher.H
+++ b/src/OpenFOAM/primitives/hashes/Hash/Hasher.H
@@ -27,7 +27,7 @@ InNamespace
     Foam
 
 Description
-    Misc. hashing functions, mostly from Bob Jenkins.
+    Miscellaneous hashing functions, mostly from Bob Jenkins.
 
     The Jenkins hashing function(s) is similar in speed to Paul Hsieh's
     SuperFast hash, but is public domain, supports incremental hashing
@@ -61,16 +61,6 @@ namespace Foam
 //  \param[in] seed - the previous hash, or an arbitrary value
 unsigned Hasher(const void* data, size_t len, unsigned seed = 0);
 
-
-//- Hashing of bit-wise internal content of given data object.
-//  For primitives and simple collections of primitives this is reasonable,
-//  but ill-advised for more complex data structures.
-template<class T>
-inline unsigned HasherT(const T& obj, unsigned seed = 0)
-{
-    return Hasher(&obj, sizeof(obj), seed);
-}
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam
diff --git a/src/OpenFOAM/primitives/hashes/Hasher/HasherInt.H b/src/OpenFOAM/primitives/hashes/Hash/HasherInt.H
similarity index 99%
rename from src/OpenFOAM/primitives/hashes/Hasher/HasherInt.H
rename to src/OpenFOAM/primitives/hashes/Hash/HasherInt.H
index 725dec250c..7e759ea885 100644
--- a/src/OpenFOAM/primitives/hashes/Hasher/HasherInt.H
+++ b/src/OpenFOAM/primitives/hashes/Hash/HasherInt.H
@@ -38,7 +38,7 @@ See also
 #define HasherInt_H
 
 #include "Hasher.H"
-#include "int.H"
+#include <cstdint>
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
diff --git a/src/OpenFOAM/primitives/strings/string/string.H b/src/OpenFOAM/primitives/strings/string/string.H
index 58e8dd57c1..52794f905c 100644
--- a/src/OpenFOAM/primitives/strings/string/string.H
+++ b/src/OpenFOAM/primitives/strings/string/string.H
@@ -52,9 +52,9 @@ SourceFiles
 
 #include "char.H"
 #include "Hasher.H"
-#include <string>
-#include <cstring>
 #include <cstdlib>
+#include <cstring>
+#include <string>
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -139,6 +139,21 @@ protected:
 
 public:
 
+    // Public Classes
+
+        //- Hashing functor for string and derived string classes
+        struct hasher
+        {
+            unsigned operator()(const std::string& str, unsigned seed=0) const
+            {
+                return Foam::Hasher(str.data(), str.length(), seed);
+            }
+        };
+
+        //- Hashing functor for string and derived string classes
+        struct hash : string::hasher {};
+
+
     // Static Data Members
 
         //- The type name "string"
@@ -151,17 +166,6 @@ public:
         static const string null;
 
 
-    //- Hashing function for string and derived string classes
-    struct hash
-    {
-        inline unsigned operator()
-        (
-            const std::string& str,
-            unsigned seed = 0
-        ) const;
-    };
-
-
     // Constructors
 
         //- Default construct
diff --git a/src/OpenFOAM/primitives/strings/string/stringI.H b/src/OpenFOAM/primitives/strings/string/stringI.H
index 9f51cbf5b4..31a1fbc79a 100644
--- a/src/OpenFOAM/primitives/strings/string/stringI.H
+++ b/src/OpenFOAM/primitives/strings/string/stringI.H
@@ -239,14 +239,4 @@ inline bool Foam::string::operator()(const std::string& text) const
 }
 
 
-inline unsigned Foam::string::hash::operator()
-(
-    const std::string& str,
-    unsigned seed
-) const
-{
-    return Hasher(str.data(), str.size(), seed);
-}
-
-
 // ************************************************************************* //
diff --git a/src/OpenFOAM/primitives/strings/stringOps/stringOps.C b/src/OpenFOAM/primitives/strings/stringOps/stringOps.C
index c634d7d2d9..be512d45d6 100644
--- a/src/OpenFOAM/primitives/strings/stringOps/stringOps.C
+++ b/src/OpenFOAM/primitives/strings/stringOps/stringOps.C
@@ -719,7 +719,7 @@ std::string::size_type Foam::stringOps::count(const char* s, const char c)
 Foam::string Foam::stringOps::expand
 (
     const std::string& s,
-    const HashTable<string, word, string::hash>& mapping,
+    const HashTable<string>& mapping,
     const char sigil
 )
 {
@@ -732,7 +732,7 @@ Foam::string Foam::stringOps::expand
 void Foam::stringOps::inplaceExpand
 (
     std::string& s,
-    const HashTable<string, word, string::hash>& mapping,
+    const HashTable<string>& mapping,
     const char sigil
 )
 {
diff --git a/src/OpenFOAM/primitives/strings/stringOps/stringOps.H b/src/OpenFOAM/primitives/strings/stringOps/stringOps.H
index b7141a23fa..33424ea873 100644
--- a/src/OpenFOAM/primitives/strings/stringOps/stringOps.H
+++ b/src/OpenFOAM/primitives/strings/stringOps/stringOps.H
@@ -93,7 +93,7 @@ namespace stringOps
     string expand
     (
         const std::string& s,
-        const HashTable<string, word, string::hash>& mapping,
+        const HashTable<string>& mapping,
         const char sigil = '$'
     );
 
@@ -135,7 +135,7 @@ namespace stringOps
     void inplaceExpand
     (
         std::string& s,
-        const HashTable<string, word, string::hash>& mapping,
+        const HashTable<string>& mapping,
         const char sigil = '$'
     );
 
diff --git a/src/dynamicMesh/fvMeshDistribute/fvMeshDistribute.C b/src/dynamicMesh/fvMeshDistribute/fvMeshDistribute.C
index f753211b18..f8b89e90b3 100644
--- a/src/dynamicMesh/fvMeshDistribute/fvMeshDistribute.C
+++ b/src/dynamicMesh/fvMeshDistribute/fvMeshDistribute.C
@@ -1196,7 +1196,7 @@ void Foam::fvMeshDistribute::findCouples
 
 
     // Insert all into big map. Find matches
-    HashTable<labelPair, labelPair, labelPair::Hash<>> map(2*sum(nProcFaces));
+    LabelPairMap<labelPair> map(2*sum(nProcFaces));
 
     nProcFaces = 0;
 
diff --git a/src/mesh/snappyHexMesh/meshRefinement/meshRefinement.H b/src/mesh/snappyHexMesh/meshRefinement/meshRefinement.H
index 0fdf183b78..2afda90edb 100644
--- a/src/mesh/snappyHexMesh/meshRefinement/meshRefinement.H
+++ b/src/mesh/snappyHexMesh/meshRefinement/meshRefinement.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2015-2020 OpenCFD Ltd.
+    Copyright (C) 2015-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -55,7 +55,7 @@ SourceFiles
 #include "pointFieldsFwd.H"
 #include "Tuple2.H"
 #include "pointIndexHit.H"
-#include "wordPairHashTable.H"
+#include "wordPairHashes.H"
 #include "surfaceZonesInfo.H"
 #include "volumeType.H"
 #include "DynamicField.H"
diff --git a/src/mesh/snappyHexMesh/meshRefinement/meshRefinementBaffles.C b/src/mesh/snappyHexMesh/meshRefinement/meshRefinementBaffles.C
index 5606e4f731..04b1f916c9 100644
--- a/src/mesh/snappyHexMesh/meshRefinement/meshRefinementBaffles.C
+++ b/src/mesh/snappyHexMesh/meshRefinement/meshRefinementBaffles.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2014 OpenFOAM Foundation
-    Copyright (C) 2015-2020 OpenCFD Ltd.
+    Copyright (C) 2015-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -5155,7 +5155,7 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::zonify
     {
         // 1. Detect inter-region face and allocate names
 
-        HashTable<word, labelPair, labelPair::Hash<>> zoneIDsToFaceZone;
+        LabelPairMap<word> zoneIDsToFaceZone;
 
         for (label faceI = 0; faceI < mesh_.nInternalFaces(); faceI++)
         {
@@ -5208,10 +5208,7 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::zonify
             << endl;
 
         // From cellZone indices to faceZone index
-        HashTable<label, labelPair, labelPair::Hash<>> fZoneLookup
-        (
-            zonesToFaceZone.size()
-        );
+        LabelPairMap<label> fZoneLookup(zonesToFaceZone.size());
 
         const cellZoneMesh& cellZones = mesh_.cellZones();
 
diff --git a/src/mesh/snappyHexMesh/snappyHexMeshDriver/refinementParameters/wordPairHashTable.H b/src/mesh/snappyHexMesh/snappyHexMeshDriver/refinementParameters/wordPairHashTable.H
index 36aa168ea3..d5b8b49c18 100644
--- a/src/mesh/snappyHexMesh/snappyHexMeshDriver/refinementParameters/wordPairHashTable.H
+++ b/src/mesh/snappyHexMesh/snappyHexMeshDriver/refinementParameters/wordPairHashTable.H
@@ -1,57 +1,13 @@
 /*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | www.openfoam.com
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-    Copyright (C) 2015 OpenFOAM Foundation
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Typedef
-    Foam::wordPairHashTable
-
 Description
-    HashTable of Pair<word>
-
-Typedef
-    Foam::wordPairHashTable
-
-Description
-    HashTable of Pair<word>
+    Compatibility include.
 
 \*---------------------------------------------------------------------------*/
 
 #ifndef wordPairHashTable_H
 #define wordPairHashTable_H
 
-#include "Pair.H"
-#include "HashTable.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-    typedef HashTable<word, Pair<word>, FixedList<word, 2>::Hash<>>
-        wordPairHashTable;
-}
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+#include "wordPairHashes.H"
 
 #endif
 
diff --git a/src/mesh/snappyHexMesh/snappyHexMeshDriver/snappyRefineDriver.H b/src/mesh/snappyHexMesh/snappyHexMeshDriver/snappyRefineDriver.H
index 26f1a320cf..30827dcf24 100644
--- a/src/mesh/snappyHexMesh/snappyHexMeshDriver/snappyRefineDriver.H
+++ b/src/mesh/snappyHexMesh/snappyHexMeshDriver/snappyRefineDriver.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2014 OpenFOAM Foundation
-    Copyright (C) 2015-2020 OpenCFD Ltd.
+    Copyright (C) 2015-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -37,7 +37,7 @@ SourceFiles
 #ifndef snappyRefineDriver_H
 #define snappyRefineDriver_H
 
-#include "wordPairHashTable.H"
+#include "wordPairHashes.H"
 #include "labelList.H"
 #include "scalarField.H"
 #include "Tuple2.H"
@@ -51,7 +51,7 @@ SourceFiles
 namespace Foam
 {
 
-// Forward declarations
+// Forward Declarations
 class refinementParameters;
 class snapParameters;
 
diff --git a/src/phaseSystemModels/multiphaseEuler/multiphaseSystem/multiphaseSystem/multiphaseSystem.H b/src/phaseSystemModels/multiphaseEuler/multiphaseSystem/multiphaseSystem/multiphaseSystem.H
index 18c1cfc628..632b2bdeb0 100644
--- a/src/phaseSystemModels/multiphaseEuler/multiphaseSystem/multiphaseSystem/multiphaseSystem.H
+++ b/src/phaseSystemModels/multiphaseEuler/multiphaseSystem/multiphaseSystem/multiphaseSystem.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -68,50 +68,25 @@ class multiphaseSystem
     public IOdictionary,
     public transportModel
 {
-
 public:
 
+    //- Name pair for the interface
     class interfacePair
     :
         public Pair<word>
     {
     public:
 
-        class symmHash
-        :
-            public Hash<interfacePair>
-        {
-        public:
+        // Ordered hashing (alias)
+        using hash = Pair<word>::hasher;
 
-            symmHash()
-            {}
-
-            label operator()(const interfacePair& key) const
-            {
-                return word::hash()(key.first()) + word::hash()(key.second());
-            }
-        };
-
-        class hash
-        :
-             public Hash<interfacePair>
-        {
-        public:
-
-            hash()
-            {}
-
-            label operator()(const interfacePair& key) const
-            {
-                return word::hash()(key.first(), word::hash()(key.second()));
-            }
-        };
+        // Unordered hashing (alias)
+        using symmHash = Pair<word>::symmHasher;
 
 
         // Constructors
 
-            interfacePair()
-            {}
+            interfacePair() = default;
 
             interfacePair(const word& alpha1Name, const word& alpha2Name)
             :
@@ -132,11 +107,7 @@ public:
                 const interfacePair& b
             )
             {
-                return
-                (
-                    ((a.first() == b.first()) && (a.second() == b.second()))
-                 || ((a.first() == b.second()) && (a.second() == b.first()))
-                );
+                return (0 != Pair<word>::compare(a, b));
             }
 
             friend bool operator!=
diff --git a/src/phaseSystemModels/multiphaseInter/phasesSystem/phasePair/phasePairKey.C b/src/phaseSystemModels/multiphaseInter/phasesSystem/phasePair/phasePairKey.C
index de8bddb6a2..e706954636 100644
--- a/src/phaseSystemModels/multiphaseInter/phasesSystem/phasePair/phasePairKey.C
+++ b/src/phaseSystemModels/multiphaseInter/phasesSystem/phasePair/phasePairKey.C
@@ -5,7 +5,8 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2017 OpenCFD Ltd.
+    Copyright (C) 2014-2015 OpenFOAM Foundation
+    Copyright (C) 2017-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -41,35 +42,6 @@ Foam::phasePairKey::phasePairKey
 {}
 
 
-// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
-
-bool Foam::phasePairKey::ordered() const
-{
-    return ordered_;
-}
-
-
-// * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * * //
-
-Foam::label Foam::phasePairKey::hash::operator()
-(
-    const phasePairKey& key
-) const
-{
-    if (key.ordered_)
-    {
-        return
-            word::hash()
-            (
-                key.first(),
-                word::hash()(key.second())
-            );
-    }
-
-    return word::hash()(key.first()) + word::hash()(key.second());
-}
-
-
 // * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * * //
 
 bool Foam::operator==
@@ -78,12 +50,11 @@ bool Foam::operator==
     const phasePairKey& b
 )
 {
-    const auto cmp = Pair<word>::compare(a,b);
-
+    const int cmp = Pair<word>::compare(a, b);
     return
     (
-        (a.ordered_ == b.ordered_)
-     && (a.ordered_ ? (cmp == 1) : cmp)
+        (a.ordered() == b.ordered())
+     && (a.ordered() ? (cmp == 1) : cmp)
     );
 }
 
@@ -102,30 +73,29 @@ bool Foam::operator!=
 
 Foam::Istream& Foam::operator>>(Istream& is, phasePairKey& key)
 {
-    const FixedList<word, 3> temp(is);
+    const FixedList<word, 3> toks(is);
 
-    key.first() = temp[0];
+    key.first() = toks[0];
+    key.second() = toks[2];
+    const word& order = toks[1];
 
-    if (temp[1] == "and")
-    {
-        key.ordered_ = false;
-    }
-    else if (temp[1] == "to")
+    if (order == "to")
     {
         key.ordered_ = true;
     }
+    else if (order == "and")
+    {
+        key.ordered_ = false;
+    }
     else
     {
         FatalErrorInFunction
-            << "Phase pair type is not recognised. "
-            << temp
-            << "Use (phaseDispersed to phaseContinuous) for an ordered pair, "
-            << "or (phase1 and phase2) for an unordered pair."
+            << "Phase pair type is not recognised. " << toks
+            << "Use (phaseDispersed to phaseContinuous) for an ordered pair,"
+               " or (phase1 and phase2) for an unordered pair.\n"
             << exit(FatalError);
     }
 
-    key.second() = temp[2];
-
     return is;
 }
 
@@ -137,7 +107,7 @@ Foam::Ostream& Foam::operator<<(Ostream& os, const phasePairKey& key)
     os  << token::BEGIN_LIST
         << key.first()
         << token::SPACE
-        << (key.ordered_ ? "to" : "and")
+        << (key.ordered() ? "to" : "and")
         << token::SPACE
         << key.second()
         << token::END_LIST;
diff --git a/src/phaseSystemModels/multiphaseInter/phasesSystem/phasePair/phasePairKey.H b/src/phaseSystemModels/multiphaseInter/phasesSystem/phasePair/phasePairKey.H
index 904e06fe1e..b0ffa6b142 100644
--- a/src/phaseSystemModels/multiphaseInter/phasesSystem/phasePair/phasePairKey.H
+++ b/src/phaseSystemModels/multiphaseInter/phasesSystem/phasePair/phasePairKey.H
@@ -5,7 +5,8 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2017 OpenCFD Ltd.
+    Copyright (C) 2014-2016 OpenFOAM Foundation
+    Copyright (C) 2017-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -27,8 +28,15 @@ Class
     Foam::phasePairKey
 
 Description
+    An ordered or unorder pair of phase names.
+    Typically specified as follows.
+    \verbatim
+       (phase1 and phase2)  // unordered
+       (phase1 to  phase2)  // ordered
+    \endverbatim
 
 SourceFiles
+    phasePairKey.C
 
 \*---------------------------------------------------------------------------*/
 
@@ -42,7 +50,7 @@ SourceFiles
 namespace Foam
 {
 
-// Forward declarations
+// Forward Declarations
 class phasePairKey;
 
 bool operator==(const phasePairKey& a, const phasePairKey& b);
@@ -59,7 +67,7 @@ class phasePairKey
 :
     public Pair<word>
 {
-    // Private data
+    // Private Data
 
         //- Flag to indicate whether ordering is important
         bool ordered_;
@@ -67,20 +75,12 @@ class phasePairKey
 
 public:
 
-        //- Ordered or unordered hashing of word pair
-        struct hash
-        {
-            //- Generate a hash from a phase pair key
-            label operator()(const phasePairKey& key) const;
-        };
-
-
     // Constructors
 
-        //- Construct null
-        phasePairKey() {} // = default
+        //- Default construct
+        phasePairKey() = default;
 
-        //- Construct from names and optional ordering flag
+        //- Construct from names and (optional) ordering flag
         phasePairKey
         (
             const word& name1,
@@ -93,10 +93,13 @@ public:
     virtual ~phasePairKey() = default;
 
 
-    // Access
+    // Member Functions
 
         //- Return the ordered flag
-        bool ordered() const;
+        bool ordered() const noexcept
+        {
+            return ordered_;
+        }
 
 
     // Friend Operators
@@ -112,9 +115,37 @@ public:
 
         //- Write to Ostream
         friend Ostream& operator<<(Ostream& os, const phasePairKey& key);
+
+
+    // Hashing
+
+        //- Hashing functor for phasePairKey
+        struct hasher
+        {
+            unsigned operator()(const phasePairKey& key) const
+            {
+                if (key.ordered())
+                {
+                    return Pair<word>::hasher()(key);
+                }
+                else
+                {
+                    return Pair<word>::symmHasher()(key);
+                }
+            }
+        };
+
+        //- Alternative name for functor
+        using hash = phasePairKey::hasher;
 };
 
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+//- Hashing for phasePairKey
+template<> struct Hash<phasePairKey> : phasePairKey::hasher {};
+
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam
diff --git a/src/phaseSystemModels/reactingEuler/multiphaseSystem/BlendedInterfacialModel/blendingMethods/hyperbolic/hyperbolic.H b/src/phaseSystemModels/reactingEuler/multiphaseSystem/BlendedInterfacialModel/blendingMethods/hyperbolic/hyperbolic.H
index dff407001d..a78a2e18a0 100644
--- a/src/phaseSystemModels/reactingEuler/multiphaseSystem/BlendedInterfacialModel/blendingMethods/hyperbolic/hyperbolic.H
+++ b/src/phaseSystemModels/reactingEuler/multiphaseSystem/BlendedInterfacialModel/blendingMethods/hyperbolic/hyperbolic.H
@@ -56,7 +56,7 @@ class hyperbolic
     // Private data
 
         //- Minimum fraction of phases which can be considered continuous
-        HashTable<dimensionedScalar, word, word::hash> minContinuousAlpha_;
+        HashTable<dimensionedScalar> minContinuousAlpha_;
 
         //- Width of the transition
         const dimensionedScalar transitionAlphaScale_;
diff --git a/src/phaseSystemModels/reactingEuler/multiphaseSystem/BlendedInterfacialModel/blendingMethods/linear/linear.H b/src/phaseSystemModels/reactingEuler/multiphaseSystem/BlendedInterfacialModel/blendingMethods/linear/linear.H
index 9edf6f1770..1488032df4 100644
--- a/src/phaseSystemModels/reactingEuler/multiphaseSystem/BlendedInterfacialModel/blendingMethods/linear/linear.H
+++ b/src/phaseSystemModels/reactingEuler/multiphaseSystem/BlendedInterfacialModel/blendingMethods/linear/linear.H
@@ -56,12 +56,10 @@ class linear
     // Private data
 
         //- Minimum fraction of phases which can be considered fully continuous
-        HashTable<dimensionedScalar, word, word::hash>
-            minFullyContinuousAlpha_;
+        HashTable<dimensionedScalar> minFullyContinuousAlpha_;
 
         //- Minimum fraction of phases which can be considered partly continuous
-        HashTable<dimensionedScalar, word, word::hash>
-            minPartlyContinuousAlpha_;
+        HashTable<dimensionedScalar> minPartlyContinuousAlpha_;
 
 
 public:
diff --git a/src/phaseSystemModels/reactingEuler/multiphaseSystem/phasePair/phasePairKey.C b/src/phaseSystemModels/reactingEuler/multiphaseSystem/phasePair/phasePairKey.C
index f452e44cb5..95f8c638c8 100644
--- a/src/phaseSystemModels/reactingEuler/multiphaseSystem/phasePair/phasePairKey.C
+++ b/src/phaseSystemModels/reactingEuler/multiphaseSystem/phasePair/phasePairKey.C
@@ -5,7 +5,8 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2014-2018 OpenFOAM Foundation
+    Copyright (C) 2014-2015 OpenFOAM Foundation
+    Copyright (C) 2017-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -29,14 +30,6 @@ License
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::phasePairKey::hash::hash()
-{}
-
-
-Foam::phasePairKey::phasePairKey()
-{}
-
-
 Foam::phasePairKey::phasePairKey
 (
     const word& name1,
@@ -49,45 +42,6 @@ Foam::phasePairKey::phasePairKey
 {}
 
 
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-Foam::phasePairKey::~phasePairKey()
-{}
-
-
-// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
-
-bool Foam::phasePairKey::ordered() const
-{
-    return ordered_;
-}
-
-
-// * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * * //
-
-Foam::label Foam::phasePairKey::hash::operator()
-(
-    const phasePairKey& key
-) const
-{
-    if (key.ordered_)
-    {
-        return
-            word::hash()
-            (
-                key.first(),
-                word::hash()(key.second())
-            );
-    }
-    else
-    {
-        return
-            word::hash()(key.first())
-          + word::hash()(key.second());
-    }
-}
-
-
 // * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * * //
 
 bool Foam::operator==
@@ -96,14 +50,12 @@ bool Foam::operator==
     const phasePairKey& b
 )
 {
-    const label c = Pair<word>::compare(a, b);
-
+    const int cmp = Pair<word>::compare(a, b);
     return
-        (a.ordered_ == b.ordered_)
-     && (
-            (a.ordered_ && (c == 1))
-         || (!a.ordered_ && (c != 0))
-        );
+    (
+        (a.ordered() == b.ordered())
+     && (a.ordered() ? (cmp == 1) : cmp)
+    );
 }
 
 
@@ -121,30 +73,29 @@ bool Foam::operator!=
 
 Foam::Istream& Foam::operator>>(Istream& is, phasePairKey& key)
 {
-    const FixedList<word, 3> temp(is);
+    const FixedList<word, 3> toks(is);
 
-    key.first() = temp[0];
+    key.first() = toks[0];
+    key.second() = toks[2];
+    const word& order = toks[1];
 
-    if (temp[1] == "and")
-    {
-        key.ordered_ = false;
-    }
-    else if (temp[1] == "in")
+    if (order == "in")
     {
         key.ordered_ = true;
     }
+    else if (order == "and")
+    {
+        key.ordered_ = false;
+    }
     else
     {
         FatalErrorInFunction
-            << "Phase pair type is not recognised. "
-            << temp
-            << "Use (phaseDispersed in phaseContinuous) for an ordered"
-            << "pair, or (phase1 and pase2) for an unordered pair."
+            << "Phase pair type is not recognised. " << toks
+            << "Use (phaseDispersed in phaseContinuous) for an ordered pair,"
+               " or (phase1 and phase2) for an unordered pair.\n"
             << exit(FatalError);
     }
 
-    key.second() = temp[2];
-
     return is;
 }
 
@@ -156,7 +107,7 @@ Foam::Ostream& Foam::operator<<(Ostream& os, const phasePairKey& key)
     os  << token::BEGIN_LIST
         << key.first()
         << token::SPACE
-        << (key.ordered_ ? "in" : "and")
+        << (key.ordered() ? "in" : "and")
         << token::SPACE
         << key.second()
         << token::END_LIST;
diff --git a/src/phaseSystemModels/reactingEuler/multiphaseSystem/phasePair/phasePairKey.H b/src/phaseSystemModels/reactingEuler/multiphaseSystem/phasePair/phasePairKey.H
index d8ffcef896..5bef3cbea3 100644
--- a/src/phaseSystemModels/reactingEuler/multiphaseSystem/phasePair/phasePairKey.H
+++ b/src/phaseSystemModels/reactingEuler/multiphaseSystem/phasePair/phasePairKey.H
@@ -5,7 +5,8 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2014-2018 OpenFOAM Foundation
+    Copyright (C) 2014-2016 OpenFOAM Foundation
+    Copyright (C) 2017-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -27,8 +28,15 @@ Class
     Foam::phasePairKey
 
 Description
+    An ordered or unorder pair of phase names.
+    Typically specified as follows.
+    \verbatim
+       (phase1 and phase2)  // unordered
+       (phase1 in  phase2)  // ordered
+    \endverbatim
 
 SourceFiles
+    phasePairKey.C
 
 \*---------------------------------------------------------------------------*/
 
@@ -42,16 +50,14 @@ SourceFiles
 namespace Foam
 {
 
-// Forward declaration of friend functions and operators
-
+// Forward Declarations
 class phasePairKey;
 
-bool operator==(const phasePairKey&, const phasePairKey&);
-bool operator!=(const phasePairKey&, const phasePairKey&);
-
-Istream& operator>>(Istream&, phasePairKey&);
-Ostream& operator<<(Ostream&, const phasePairKey&);
+bool operator==(const phasePairKey& a, const phasePairKey& b);
+bool operator!=(const phasePairKey& a, const phasePairKey& b);
 
+Istream& operator>>(Istream& is, phasePairKey& key);
+Ostream& operator<<(Ostream& os, const phasePairKey& key);
 
 /*---------------------------------------------------------------------------*\
                          Class phasePairKey Declaration
@@ -61,30 +67,7 @@ class phasePairKey
 :
     public Pair<word>
 {
-public:
-
-        class hash
-        :
-            public Hash<phasePairKey>
-        {
-        public:
-
-            // Constructors
-
-                // Construct null
-                hash();
-
-
-            // Member operators
-
-                // Generate a hash from a phase pair key
-                label operator()(const phasePairKey& key) const;
-        };
-
-
-private:
-
-    // Private data
+    // Private Data
 
         //- Flag to indicate whether ordering is important
         bool ordered_;
@@ -94,10 +77,10 @@ public:
 
     // Constructors
 
-        //- Construct null
-        phasePairKey();
+        //- Default construct
+        phasePairKey() = default;
 
-        //- Construct from names and the ordering flag
+        //- Construct from names and (optional) ordering flag
         phasePairKey
         (
             const word& name1,
@@ -106,32 +89,63 @@ public:
         );
 
 
-    // Destructor
-    virtual ~phasePairKey();
+    //- Destructor
+    virtual ~phasePairKey() = default;
 
 
-    // Access
+    // Member Functions
 
         //- Return the ordered flag
-        bool ordered() const;
+        bool ordered() const noexcept
+        {
+            return ordered_;
+        }
 
 
     // Friend Operators
 
-        //- Test if keys are equal
+        //- Test for equality
         friend bool operator==(const phasePairKey& a, const phasePairKey& b);
 
-        //- Test if keys are unequal
+        //- Test for inequality
         friend bool operator!=(const phasePairKey& a, const phasePairKey& b);
 
-        //- Read from stdin
+        //- Read from Istream
         friend Istream& operator>>(Istream& is, phasePairKey& key);
 
-        //- Write to stdout
+        //- Write to Ostream
         friend Ostream& operator<<(Ostream& os, const phasePairKey& key);
+
+
+    // Hashing
+
+        //- Hashing functor for phasePairKey
+        struct hasher
+        {
+            unsigned operator()(const phasePairKey& key) const
+            {
+                if (key.ordered())
+                {
+                    return Pair<word>::hasher()(key);
+                }
+                else
+                {
+                    return Pair<word>::symmHasher()(key);
+                }
+            }
+        };
+
+        //- Alternative name for functor
+        using hash = phasePairKey::hasher;
 };
 
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+//- Hashing for phasePairKey
+template<> struct Hash<phasePairKey> : phasePairKey::hasher {};
+
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam
diff --git a/src/phaseSystemModels/reactingEuler/multiphaseSystem/phaseSystem/phaseSystem.H b/src/phaseSystemModels/reactingEuler/multiphaseSystem/phaseSystem/phaseSystem.H
index 9ee4a19b62..7b4549dbb5 100644
--- a/src/phaseSystemModels/reactingEuler/multiphaseSystem/phaseSystem/phaseSystem.H
+++ b/src/phaseSystemModels/reactingEuler/multiphaseSystem/phaseSystem/phaseSystem.H
@@ -99,8 +99,7 @@ protected:
             dictTable;
 
         typedef
-            HashTable<autoPtr<blendingMethod>, word, word::hash>
-            blendingMethodTable;
+            HashTable<autoPtr<blendingMethod>> blendingMethodTable;
 
         typedef
             HashTable
diff --git a/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/BlendedInterfacialModel/blendingMethods/hyperbolic/hyperbolic.H b/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/BlendedInterfacialModel/blendingMethods/hyperbolic/hyperbolic.H
index 6a7c5ef970..de72fcbfba 100644
--- a/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/BlendedInterfacialModel/blendingMethods/hyperbolic/hyperbolic.H
+++ b/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/BlendedInterfacialModel/blendingMethods/hyperbolic/hyperbolic.H
@@ -56,7 +56,7 @@ class hyperbolic
     // Private data
 
         //- Maximum fraction of phases which can be considered dispersed
-        HashTable<dimensionedScalar, word, word::hash> maxDispersedAlpha_;
+        HashTable<dimensionedScalar> maxDispersedAlpha_;
 
         //- Width of the transition
         const dimensionedScalar transitionAlphaScale_;
diff --git a/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/BlendedInterfacialModel/blendingMethods/linear/linear.H b/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/BlendedInterfacialModel/blendingMethods/linear/linear.H
index 34c3075ad2..6f819dfc3f 100644
--- a/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/BlendedInterfacialModel/blendingMethods/linear/linear.H
+++ b/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/BlendedInterfacialModel/blendingMethods/linear/linear.H
@@ -56,12 +56,10 @@ class linear
     // Private data
 
         //- Maximum fraction of phases which can be considered fully dispersed
-        HashTable<dimensionedScalar, word, word::hash>
-            maxFullyDispersedAlpha_;
+        HashTable<dimensionedScalar> maxFullyDispersedAlpha_;
 
         //- Maximum fraction of phases which can be considered partly dispersed
-        HashTable<dimensionedScalar, word, word::hash>
-            maxPartlyDispersedAlpha_;
+        HashTable<dimensionedScalar> maxPartlyDispersedAlpha_;
 
 
 public:
diff --git a/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/phasePair/phasePairKey.C b/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/phasePair/phasePairKey.C
index f22d6709e2..95f8c638c8 100644
--- a/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/phasePair/phasePairKey.C
+++ b/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/phasePair/phasePairKey.C
@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2014-2015 OpenFOAM Foundation
+    Copyright (C) 2017-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -29,15 +30,6 @@ License
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-
-Foam::phasePairKey::hash::hash()
-{}
-
-
-Foam::phasePairKey::phasePairKey()
-{}
-
-
 Foam::phasePairKey::phasePairKey
 (
     const word& name1,
@@ -50,37 +42,6 @@ Foam::phasePairKey::phasePairKey
 {}
 
 
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-Foam::phasePairKey::~phasePairKey()
-{}
-
-
-// * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * * //
-
-Foam::label Foam::phasePairKey::hash::operator()
-(
-    const phasePairKey& key
-) const
-{
-    if (key.ordered_)
-    {
-        return
-            word::hash()
-            (
-                key.first(),
-                word::hash()(key.second())
-            );
-    }
-    else
-    {
-        return
-            word::hash()(key.first())
-          + word::hash()(key.second());
-    }
-}
-
-
 // * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * * //
 
 bool Foam::operator==
@@ -89,14 +50,12 @@ bool Foam::operator==
     const phasePairKey& b
 )
 {
-    const auto c = Pair<word>::compare(a,b);
-
+    const int cmp = Pair<word>::compare(a, b);
     return
-        (a.ordered_ == b.ordered_)
-      && (
-            (a.ordered_ && (c == 1))
-         || (!a.ordered_ && (c != 0))
-        );
+    (
+        (a.ordered() == b.ordered())
+     && (a.ordered() ? (cmp == 1) : cmp)
+    );
 }
 
 
@@ -114,30 +73,29 @@ bool Foam::operator!=
 
 Foam::Istream& Foam::operator>>(Istream& is, phasePairKey& key)
 {
-    const FixedList<word, 3> temp(is);
+    const FixedList<word, 3> toks(is);
 
-    key.first() = temp[0];
+    key.first() = toks[0];
+    key.second() = toks[2];
+    const word& order = toks[1];
 
-    if (temp[1] == "and")
-    {
-        key.ordered_ = false;
-    }
-    else if (temp[1] == "in")
+    if (order == "in")
     {
         key.ordered_ = true;
     }
+    else if (order == "and")
+    {
+        key.ordered_ = false;
+    }
     else
     {
-         FatalErrorInFunction
-            << "Phase pair type is not recognised. "
-            << temp
-            << "Use (phaseDispersed in phaseContinuous) for an ordered"
-            << "pair, or (phase1 and pase2) for an unordered pair."
+        FatalErrorInFunction
+            << "Phase pair type is not recognised. " << toks
+            << "Use (phaseDispersed in phaseContinuous) for an ordered pair,"
+               " or (phase1 and phase2) for an unordered pair.\n"
             << exit(FatalError);
     }
 
-    key.second() = temp[2];
-
     return is;
 }
 
@@ -149,7 +107,7 @@ Foam::Ostream& Foam::operator<<(Ostream& os, const phasePairKey& key)
     os  << token::BEGIN_LIST
         << key.first()
         << token::SPACE
-        << (key.ordered_ ? "in" : "and")
+        << (key.ordered() ? "in" : "and")
         << token::SPACE
         << key.second()
         << token::END_LIST;
diff --git a/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/phasePair/phasePairKey.H b/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/phasePair/phasePairKey.H
index e102b1c775..5bef3cbea3 100644
--- a/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/phasePair/phasePairKey.H
+++ b/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/phasePair/phasePairKey.H
@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2014-2016 OpenFOAM Foundation
+    Copyright (C) 2017-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -27,8 +28,15 @@ Class
     Foam::phasePairKey
 
 Description
+    An ordered or unorder pair of phase names.
+    Typically specified as follows.
+    \verbatim
+       (phase1 and phase2)  // unordered
+       (phase1 in  phase2)  // ordered
+    \endverbatim
 
 SourceFiles
+    phasePairKey.C
 
 \*---------------------------------------------------------------------------*/
 
@@ -42,7 +50,7 @@ SourceFiles
 namespace Foam
 {
 
-// Forward declarations
+// Forward Declarations
 class phasePairKey;
 
 bool operator==(const phasePairKey& a, const phasePairKey& b);
@@ -59,59 +67,39 @@ class phasePairKey
 :
     public Pair<word>
 {
-public:
-
-        class hash
-        :
-            public Hash<phasePairKey>
-        {
-        public:
-
-            // Constructors
-
-                // Construct null
-                hash();
-
-
-            // Member operators
-
-                // Generate a hash from a phase pair key
-                label operator()(const phasePairKey& key) const;
-        };
-
-
-private:
-
-    // Private data
+    // Private Data
 
         //- Flag to indicate whether ordering is important
         bool ordered_;
 
-public:
 
+public:
 
     // Constructors
 
-        //- Construct null
-        phasePairKey();
+        //- Default construct
+        phasePairKey() = default;
 
-        //- Construct from names and the ordering flag
+        //- Construct from names and (optional) ordering flag
         phasePairKey
         (
             const word& name1,
             const word& name2,
-            const bool ordered
+            const bool ordered = false
         );
 
 
     //- Destructor
-    virtual ~phasePairKey();
+    virtual ~phasePairKey() = default;
 
 
-    // Access
+    // Member Functions
 
         //- Return the ordered flag
-        bool ordered() const;
+        bool ordered() const noexcept
+        {
+            return ordered_;
+        }
 
 
     // Friend Operators
@@ -127,9 +115,37 @@ public:
 
         //- Write to Ostream
         friend Ostream& operator<<(Ostream& os, const phasePairKey& key);
+
+
+    // Hashing
+
+        //- Hashing functor for phasePairKey
+        struct hasher
+        {
+            unsigned operator()(const phasePairKey& key) const
+            {
+                if (key.ordered())
+                {
+                    return Pair<word>::hasher()(key);
+                }
+                else
+                {
+                    return Pair<word>::symmHasher()(key);
+                }
+            }
+        };
+
+        //- Alternative name for functor
+        using hash = phasePairKey::hasher;
 };
 
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+//- Hashing for phasePairKey
+template<> struct Hash<phasePairKey> : phasePairKey::hasher {};
+
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam
diff --git a/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/twoPhaseSystem/twoPhaseSystem.H b/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/twoPhaseSystem/twoPhaseSystem.H
index 4d5db21671..f8a30db0d7 100644
--- a/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/twoPhaseSystem/twoPhaseSystem.H
+++ b/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/twoPhaseSystem/twoPhaseSystem.H
@@ -96,7 +96,7 @@ class twoPhaseSystem
         autoPtr<orderedPhasePair> pair2In1_;
 
         //- Blending methods
-        HashTable<autoPtr<blendingMethod>, word, word::hash> blendingMethods_;
+        HashTable<autoPtr<blendingMethod>> blendingMethods_;
 
         //- Drag model
         autoPtr<BlendedInterfacialModel<dragModel>> drag_;
diff --git a/src/sampling/meshToMesh/meshToMeshParallelOps.C b/src/sampling/meshToMesh/meshToMeshParallelOps.C
index 8074dba570..b58d795239 100644
--- a/src/sampling/meshToMesh/meshToMeshParallelOps.C
+++ b/src/sampling/meshToMesh/meshToMeshParallelOps.C
@@ -611,7 +611,7 @@ void Foam::meshToMesh::distributeAndMergeCells
 
     // Count any coupled faces
     typedef FixedList<label, 3> label3;
-    typedef HashTable<label, label3, label3::Hash<>> procCoupleInfo;
+    typedef HashTable<label, label3> procCoupleInfo;
     procCoupleInfo procFaceToGlobalCell;
 
     forAll(allNbrProcIDs, proci)
diff --git a/src/sampling/surface/cutting/cuttingSurfaceBaseTemplates.C b/src/sampling/surface/cutting/cuttingSurfaceBaseTemplates.C
index 0f6a3bc6e7..5fd36c392b 100644
--- a/src/sampling/surface/cutting/cuttingSurfaceBaseTemplates.C
+++ b/src/sampling/surface/cutting/cuttingSurfaceBaseTemplates.C
@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018 OpenCFD Ltd.
+    Copyright (C) 2018-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -78,7 +78,7 @@ void Foam::cuttingSurfaceBase::walkCellCuts
     Map<label> endPoints;
 
     // Hash of faces (face points) that are exactly on a cell face
-    HashSet<labelList, labelList::Hash<>> onCellFace;
+    HashSet<labelList> onCellFace;
 
 
     // Failure handling