From 5f1244a22ac4fc3399b03a7df4d925fe64088b5d Mon Sep 17 00:00:00 2001
From: Antony Peacock <ant.peacock@gmail.com>
Date: Sat, 11 May 2024 10:29:00 +0100
Subject: [PATCH 1/4] Initial sanitizer find modules

---
 cmake/modules/FindASan.cmake                  |  37 +++++
 cmake/modules/FindMSan.cmake                  |  29 ++++
 cmake/modules/FindSanitizers.cmake            |   0
 cmake/modules/FindTSan.cmake                  |  29 ++++
 cmake/modules/FindUBSan.cmake                 |  29 ++++
 cmake/morpheus_check_compiler_flags.cmake     | 148 ++++++++++++++++++
 cmake/sanitisers.cmake                        |  11 +-
 .../src/morpheus/core/base/sanitizers.hpp     |   2 +-
 8 files changed, 281 insertions(+), 4 deletions(-)
 create mode 100644 cmake/modules/FindASan.cmake
 create mode 100644 cmake/modules/FindMSan.cmake
 create mode 100644 cmake/modules/FindSanitizers.cmake
 create mode 100644 cmake/modules/FindTSan.cmake
 create mode 100644 cmake/modules/FindUBSan.cmake
 create mode 100644 cmake/morpheus_check_compiler_flags.cmake

diff --git a/cmake/modules/FindASan.cmake b/cmake/modules/FindASan.cmake
new file mode 100644
index 00000000..3444f491
--- /dev/null
+++ b/cmake/modules/FindASan.cmake
@@ -0,0 +1,37 @@
+include_guard(GLOBAL)
+
+option(MORPHEUS_ADDRESS_SANITIZER "Enable AddressSanitizer for sanitized targets." OFF)
+
+if (NOT MORPHEUS_ADDRESS_SANITIZER)
+    return()
+endif()
+
+if (MORPHEUS_ADDRESS_SANITIZER AND (MORPHEUS_MEMORY_SANITIZER OR MORPHEUS_THREAD_SANITIZER))
+    message(FATAL_ERROR "morpheus: AddressSanitizer is not compatible with ThreadSanitizer or MemorySanitizer.")
+endif ()
+
+# For gcc and clang first attempt to sanitize address with full frame pointer information.
+list(APPEND asanCandidateFlag "-g -fsanitize=address -fno-omit-frame-pointer -mno-omit-leaf-frame-pointer") 
+list(APPEND asanCandidateFlag "-g -fsanitize=address -fno-omit-frame-pointer")
+list(APPEND asanCandidateFlag "-g -fsanitize=address")
+list(APPEND asanCandidateFlag "/fsanitize=address") # MSVC syntax
+
+include(morpheus_check_compiler_flags)
+morpheus_check_compiler_flags(
+    NAME "Address Sanitizer"
+    PREFIX ASan
+    FLAGS ${asanCandidateFlag}
+    RESULT asanSupported
+)
+
+find_package_handle_standard_args(ASan REQUIRED_VARS asanSupported)
+
+if (ASan_FOUND AND NOT TARGET ASan::ASan)
+    add_library(ASan INTERFACE)
+    add_library(morpheus::ASan ALIAS ASan)
+    target_compile_options(ASan
+        INTERFACE
+            
+    )
+endif()
+
diff --git a/cmake/modules/FindMSan.cmake b/cmake/modules/FindMSan.cmake
new file mode 100644
index 00000000..ffe1ffb9
--- /dev/null
+++ b/cmake/modules/FindMSan.cmake
@@ -0,0 +1,29 @@
+include_guard(GLOBAL)
+
+option(MORPHEUS_MEMORY_SANITIZER "Enable MemorySanitizer for sanitized targets." OFF)
+
+if (NOT MORPHEUS_MEMORY_SANITIZER)
+    return()
+endif()
+
+list(APPEND msanCandidateFlag "-g -fsanitize=memory") # Gcc & Clang syntax
+list(APPEND msanCandidateFlag "/fsanitize=memory") # MSVC syntax
+
+include(morpheus_check_compiler_flags)
+morpheus_check_compiler_flags(
+    NAME "Thread Sanitizer"
+    PREFIX MSan
+    FLAGS ${msanCandidateFlag}
+    RESULT msanSupported
+)
+
+find_package_handle_standard_args(TSan REQUIRED_VARS msanSupported)
+
+if (MSan_FOUND AND NOT TARGET morpheus::MSan)
+    add_library(MSan INTERFACE)
+    add_library(morpheus::MSan ALIAS MSan)
+    target_compile_options(MSan
+        INTERFACE
+            #msanCandidateFlag 
+    )
+endif()
\ No newline at end of file
diff --git a/cmake/modules/FindSanitizers.cmake b/cmake/modules/FindSanitizers.cmake
new file mode 100644
index 00000000..e69de29b
diff --git a/cmake/modules/FindTSan.cmake b/cmake/modules/FindTSan.cmake
new file mode 100644
index 00000000..0e060707
--- /dev/null
+++ b/cmake/modules/FindTSan.cmake
@@ -0,0 +1,29 @@
+include_guard(GLOBAL)
+
+option(MORPHEUS_THREAD_SANITIZER "Enable ThreadSanitizer for sanitized targets." OFF)
+
+if (NOT MORPHEUS_THREAD_SANITIZER)
+    return()
+endif()
+
+list(APPEND tsanCandidateFlag "-g -fsanitize=thread") # Gcc & Clang syntax
+list(APPEND tsanCandidateFlag "/fsanitize=thread") # MSVC syntax
+
+include(morpheus_check_compiler_flags)
+morpheus_check_compiler_flags(
+    NAME "Thread Sanitizer"
+    PREFIX TSan
+    FLAGS ${tsanCandidateFlag}
+    RESULT tsanSupported
+)
+
+find_package_handle_standard_args(TSan REQUIRED_VARS tsanSupported)
+
+if (TSan_FOUND AND NOT TARGET morpheus::TSan)
+    add_library(TSan INTERFACE)
+    add_library(morpheus::TSan ALIAS TSan)
+    target_compile_options(TSan
+        INTERFACE
+            #tsanCandidateFlag 
+    )
+endif()
diff --git a/cmake/modules/FindUBSan.cmake b/cmake/modules/FindUBSan.cmake
new file mode 100644
index 00000000..e919cae2
--- /dev/null
+++ b/cmake/modules/FindUBSan.cmake
@@ -0,0 +1,29 @@
+include_guard(GLOBAL)
+
+option(MORPHEUS_UNDEFINED_BEHAVIOUR_SANITIZER "Enable UndefineBehaviourSanitizer for sanitized targets." OFF)
+
+if (NOT MORPHEUS_UNDEFINED_BEHAVIOUR_SANITIZER)
+    return()
+endif()
+
+list(APPEND ubsanCandidateFlag "-g -fsanitize=undefined") # Gcc & Clang syntax
+list(APPEND ubsanCandidateFlag "/fsanitize=undefined") # MSVC syntax
+
+include(morpheus_check_compiler_flags)
+morpheus_check_compiler_flags(
+    NAME "Undefined behavior Sanitizer"
+    PREFIX UBSan
+    FLAGS ${ubsanCandidateFlag}
+    RESULT ubsanSupported
+)
+
+find_package_handle_standard_args(UBSan REQUIRED_VARS ubsanSupported)
+
+if (UBSan_FOUND AND NOT TARGET morpheus::UBSan)
+    add_library(UBSan INTERFACE)
+    add_library(morpheus::UBSan ALIAS UBSan)
+    target_compile_options(UBSan
+        INTERFACE
+            #ubsanCandidateFlag 
+    )
+endif()
diff --git a/cmake/morpheus_check_compiler_flags.cmake b/cmake/morpheus_check_compiler_flags.cmake
new file mode 100644
index 00000000..4bf619cc
--- /dev/null
+++ b/cmake/morpheus_check_compiler_flags.cmake
@@ -0,0 +1,148 @@
+include_guard(GLOBAL)
+
+cmake_minimum_required(VERSION 3.25)
+
+#[=======================================================================[.rst:
+morpheus_check_compiler_flag
+------------------
+
+Overview
+^^^^^^^^
+
+Checks for the given compiler if the given flag is supported for the specified languages
+if CMake provides a compiler check module for the underlying language.
+
+.. code-block:: cmake
+
+  morpheus_check_compiler_flag(
+      [FLAG <flag>]
+      [LANGUAGE <langauge>]
+      [RESULT <result>]
+  )
+   -- Confirms support for the compile flag across enabled languages.
+
+  ``FLAG``
+    The ``FLAG`` compiler flag to test if is supported for the specified language.
+
+  ``RESULT``
+    The ``RESULT`` option is required to store the result of the function.  TRUE if
+    there is compiler support for the feature.
+
+#]=======================================================================]
+function(morpheus_check_compiler_flag)
+    set(options)
+    set(oneValueArgs FLAG LANGUAGE RESULT)
+    set(multiValueArgs)
+    cmake_parse_arguments(MORPHEUS "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    if (NOT MORPHEUS_FLAG)
+        message(FATAL_ERROR "FLAG parameter must be supplied")
+    endif()
+    if (NOT MORPHEUS_LANGUAGE)
+        message(FATAL_ERROR "LANGUAGE parameter must be supplied")
+    endif()
+     if (NOT MORPHEUS_RESULT)
+        message(FATAL_ERROR "RESULT parameter must be supplied")
+    endif()
+
+    if (${MORPHEUS_LANGUAGE} STREQUAL "C")
+        include(CheckCCompilerFlag)
+        check_c_compiler_flag("${MORPHEUS_FLAG}" ${MORPHEUS_RESULT})
+    elseif (${MORPHEUS_LANGUAGE} STREQUAL "CXX")
+        include(CheckCXXCompilerFlag)
+        check_cxx_compiler_flag("${MORPHEUS_FLAG}" ${MORPHEUS_RESULT})
+    elseif (${MORPHEUS_LANGUAGE} STREQUAL "Fortran")
+        include(CheckFortranCompilerFlag)
+        check_fortran_compiler_flag("${MORPHEUS_FLAG}" ${MORPHEUS_RESULT})
+    elseif (${MORPHEUS_LANGUAGE} STREQUAL "OBJC")
+        include(CheckOBJCCompilerFlag)
+        check_objc_compiler_flag("${MORPHEUS_FLAG}" ${MORPHEUS_RESULT})
+    elseif (${MORPHEUS_LANGUAGE} STREQUAL "OBJCXX")
+        include(CheckOBJCXXCompilerFlag)
+        check_objcxx_compiler_flag("${MORPHEUS_FLAG}" ${MORPHEUS_RESULT})
+    else()
+        set(${MORPHEUS_RESULT} FALSE)
+        return(PROPAGATE ${MORPHEUS_RESULT})
+    endif()
+endfunction()
+
+
+#[=======================================================================[.rst:
+morpheus_check_compiler_flags
+------------------
+
+Overview
+^^^^^^^^
+
+Checks for the given compile supported of the given flags across all languages in
+use which have compiler check modules provides in CMake.
+
+.. code-block:: cmake
+
+  morpheus_check_compiler_flags(
+      [QUIET]
+      [FLAGS <flags>]
+      [RESULT <result>]
+  )
+   -- Confirms support for compiler flags across enabled languages.
+
+  ``RESULT``
+    The ``RESULT`` option is required to store the results of the function.  TRUE if
+    there is compiler support for the feature.
+
+  ``FLAGS``
+    The ``FLAGS`` compiler flags to test if are supported for the enabled languages.
+
+#]=======================================================================]
+function(morpheus_check_compiler_flags)
+    set(options QUIET)
+    set(oneValueArgs NAME PREFIX RESULT)
+    set(multiValueArgs FLAGS)
+    cmake_parse_arguments(MORPHEUS "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+    if (NOT MORPHEUS_NAME)
+        message(FATAL_ERROR "NAME parameter must be supplied")
+    endif()
+    if (NOT MORPHEUS_PREFIX)
+        message(FATAL_ERROR "PREFIX parameter must be supplied")
+    endif()
+    if (NOT MORPHEUS_RESULT)
+        message(FATAL_ERROR "RESULT parameter must be supplied")
+    endif()
+    if (NOT MORPHEUS_FLAGS)
+        message(FATAL_ERROR "FLAGS parameter must be supplied")
+    endif()
+
+    get_property(languages GLOBAL PROPERTY ENABLED_LANGUAGES)
+
+    foreach(language IN LISTS languages)
+        
+        set(COMPILER ${CMAKE_${language}_COMPILER_ID})
+
+        foreach(flags IN LISTS MORPHEUS_FLAGS)
+            if (NOT MORPHEUS_QUIET)
+                message(STATUS "Try ${COMPILER} ${MORPHEUS_NAME} flag = [${flags}]")
+            endif()
+
+            set(CMAKE_REQUIRED_FLAGS "${flags}")
+            unset(flagsSupported CACHE)
+            morpheus_check_compiler_flag(FLAG "${flags}" LANGUAGE ${language} RESULT flagsSupported)
+            
+            if (flagsSupported)
+                set(${MORPHEUS_PREFIX}_${COMPILER}_FLAGS "${flags}" CACHE STRING  "${MORPHEUS_NAME} flags for ${COMPILER} compiler.")
+                mark_as_advanced(${MORPHEUS_PREFIX}_${COMPILER}_FLAGS)
+                break()
+            endif()
+        endforeach()
+
+        if (NOT ${flagsSupported})
+            set(${MORPHEUS_PREFIX}_${COMPILER}_FLAGS "" CACHE STRING  "${MORPHEUS_NAME} flags for ${COMPILER} compiler.")
+            mark_as_advanced(${MORPHEUS_PREFIX}_${COMPILER}_FLAGS)
+            message(WARNING "${MORPHEUS_NAME} is not available for ${COMPILER} compiler. Targets using "
+                            "this compiler will be compiled without ${MORPHEUS_NAME}.")
+        endif()
+    endforeach()
+
+    set(${MORPHEUS_RESULT} FALSE)
+    return(PROPAGATE ${MORPHEUS_RESULT})
+
+endfunction()
diff --git a/cmake/sanitisers.cmake b/cmake/sanitisers.cmake
index 7d3e0696..35e3f896 100644
--- a/cmake/sanitisers.cmake
+++ b/cmake/sanitisers.cmake
@@ -19,6 +19,7 @@ include_guard(GLOBAL)
 
 include(targets)
 
+#[[
 option(ENABLE_ADDRESS_SANITIZER "Enable AddressSanitizer for sanitized targets." OFF)
 option(ENABLE_MEMORY_SANITIZER "Enable MemorySanitizer for sanitized targets." OFF)
 option(ENABLE_THREAD_SANITIZER "Enable ThreadSanitizer for sanitized targets." OFF)
@@ -27,7 +28,8 @@ option(ENABLE_UNDEFINED_BEHAVIOUR_SANITIZER "Enable UndefineBehaviourSanitizer f
 if(NOT (ENABLE_ADDRESS_SANITIZER OR ENABLE_MEMORY_SANITIZER OR ENABLE_THREAD_SANITIZER OR ENABLE_UNDEFINED_BEHAVIOUR_SANITIZER))
     return()
 endif()
-
+]]
+#[[
 FetchContent_Declare(
     sanitizers
     GIT_REPOSITORY https://github.com/arsenm/sanitizers-cmake
@@ -37,13 +39,16 @@ if(NOT sanitizers_POPULATED)
     FetchContent_Populate(sanitizers)
     list(APPEND CMAKE_MODULE_PATH ${sanitizers_SOURCE_DIR}/cmake)
 endif()
+]]
 
 set(SANITIZE_ADDRESS ${ENABLE_ADDRESS_SANITIZER} CACHE BOOL "Enable AddressSanitizer for sanitized targets." FORCE)
 set(SANITIZE_MEMORY ${ENABLE_MEMORY_SANITIZER} CACHE BOOL "Enable MemorySanitizer for sanitized targets." FORCE)
 set(SANITIZE_THREAD ${ENABLE_THREAD_SANITIZER} CACHE BOOL "Enable ThreadSanitizer for sanitized targets." FORCE)
 set(SANITIZE_UNDEFINED ${ENABLE_UNDEFINED_BEHAVIOUR_SANITIZER} CACHE BOOL "Enable UndefinedBehaviorSanitizer for sanitized targets." FORCE)
-find_package(Sanitizers)
+#find_package(Sanitizers)
+
+find_package(ASan)
 
 targets_get_all(RESULT allTargets DIRECTORY ${PROJECT_SOURCE_DIR})
 targets_filter_for_sources(RESULT targetsWithSource TARGETS ${allTargets})
-add_sanitizers("${targetsWithSource}")
+#add_sanitizers("${targetsWithSource}")
diff --git a/libraries/core/src/morpheus/core/base/sanitizers.hpp b/libraries/core/src/morpheus/core/base/sanitizers.hpp
index 3a76558b..539a11dd 100644
--- a/libraries/core/src/morpheus/core/base/sanitizers.hpp
+++ b/libraries/core/src/morpheus/core/base/sanitizers.hpp
@@ -47,4 +47,4 @@ namespace mopheus
     #define MORPHEUS_NO_SANITIZE_ADDRESS
 #endif
 
-} // namespace mopheus
+} // namespace morpheus

From eea64ae92a3313ec779347ab04cf6c044f88dfdf Mon Sep 17 00:00:00 2001
From: Antony Peacock <ant.peacock@gmail.com>
Date: Sat, 11 May 2024 10:45:48 +0100
Subject: [PATCH 2/4] Add a simple ASAN test case

---
 cmake/modules/FindSanitizers.cmake        |  1 +
 cmake/morpheus_check_compiler_flags.cmake |  3 +++
 libraries/core/tests/cmake/CMakeLists.txt | 10 ++++++++++
 libraries/core/tests/cmake/asan.tests.cpp | 18 ++++++++++++++++++
 4 files changed, 32 insertions(+)
 create mode 100644 libraries/core/tests/cmake/CMakeLists.txt
 create mode 100644 libraries/core/tests/cmake/asan.tests.cpp

diff --git a/cmake/modules/FindSanitizers.cmake b/cmake/modules/FindSanitizers.cmake
index e69de29b..8b137891 100644
--- a/cmake/modules/FindSanitizers.cmake
+++ b/cmake/modules/FindSanitizers.cmake
@@ -0,0 +1 @@
+
diff --git a/cmake/morpheus_check_compiler_flags.cmake b/cmake/morpheus_check_compiler_flags.cmake
index 4bf619cc..1962f369 100644
--- a/cmake/morpheus_check_compiler_flags.cmake
+++ b/cmake/morpheus_check_compiler_flags.cmake
@@ -117,6 +117,9 @@ function(morpheus_check_compiler_flags)
     foreach(language IN LISTS languages)
         
         set(COMPILER ${CMAKE_${language}_COMPILER_ID})
+        if (${MORPHEUS_PREFIX}_${COMPILER}_FLAGS)
+            continue()
+        endif()
 
         foreach(flags IN LISTS MORPHEUS_FLAGS)
             if (NOT MORPHEUS_QUIET)
diff --git a/libraries/core/tests/cmake/CMakeLists.txt b/libraries/core/tests/cmake/CMakeLists.txt
new file mode 100644
index 00000000..c8ab07d5
--- /dev/null
+++ b/libraries/core/tests/cmake/CMakeLists.txt
@@ -0,0 +1,10 @@
+morpheus_add_tests(
+    NAME MorpheusAsanTests
+    FOLDER "Libraries/Core"
+)
+
+find_package(ASan REQUIRED)
+target_sources(MorpheusAsanTests
+    PUBLIC
+        asan.tests.cpp
+)
diff --git a/libraries/core/tests/cmake/asan.tests.cpp b/libraries/core/tests/cmake/asan.tests.cpp
new file mode 100644
index 00000000..0b838cde
--- /dev/null
+++ b/libraries/core/tests/cmake/asan.tests.cpp
@@ -0,0 +1,18 @@
+#include <catch2/catch_all.hpp>
+
+#include <memory>
+#include <functional>
+
+namespace quantbox
+{
+
+TEST_CASE("Ensure the address sanitizer detects unsafe use after free memory usage", "[quantbox.cmake.asan]")
+{
+    auto storage = std::make_unique<int>(1);
+    std::reference_wrapper<int> dangling(*storage);
+    storage.release();
+    REQUIRE(!storage);
+    dangling.get() = 0; // If asan works this is an error!
+}
+
+} // quantbox

From 88f97b37c3ccdae9cd5dda65a552303726a8127a Mon Sep 17 00:00:00 2001
From: Antony Peacock <ant.peacock@gmail.com>
Date: Wed, 26 Jun 2024 14:13:56 +0100
Subject: [PATCH 3/4] Add concept for standard container requirements (#314)

* Add concept for standard container requirements

* Archtypes for container and allocator aware types, with tests.

* std::vector<bool> sepcialisation of get_allocator is not noexcept

* Support sequence containers

* Remove duplication

* Include ranges

* Correct namespace

* Update archtype for from_range

* Range methods fix

* Patch up the sequence concept as best we can

* Contiguous concept with tests

* Concept for reversible container requirements and partial concepts for associativ and unordered

* Complete associative concept

* Try compound requirement for visual studio

* Complete unorder container concepts

* Check for all basic string instantiations
---
 .../core/src/morpheus/core/CMakeLists.txt     |   3 +-
 .../morpheus/core/containers/CMakeLists.txt   |   1 +
 .../core/containers/concepts/CMakeLists.txt   |  12 ++
 .../containers/concepts/allocator_aware.hpp   |  29 +++
 .../core/containers/concepts/associative.hpp  |  66 +++++++
 .../core/containers/concepts/container.hpp    |  34 ++++
 .../core/containers/concepts/contiguous.hpp   |  21 +++
 .../containers/concepts/detail/CMakeLists.txt |   4 +
 .../concepts/detail/return_types.hpp          |  33 ++++
 .../core/containers/concepts/reversible.hpp   |  28 +++
 .../core/containers/concepts/sequence.hpp     |  67 +++++++
 .../core/containers/concepts/unordered.hpp    |  85 +++++++++
 .../morpheus/core/functional/CMakeLists.txt   |   2 +
 .../core/functional/concepts/CMakeLists.txt   |   5 +
 .../core/functional/concepts/function.hpp     |  19 ++
 .../core/functional/concepts/hash.hpp         |  21 +++
 .../core/memory/concepts/allocator.hpp        |  22 ++-
 .../core/memory/concepts/nullable_pointer.hpp |   7 +-
 .../src/morpheus/core/meta/CMakeLists.txt     |   1 +
 .../core/src/morpheus/core/meta/is_array.hpp  |  15 ++
 .../core/testing/morpheus/CMakeLists.txt      |   1 +
 .../morpheus/containers/CMakeLists.txt        |   1 +
 .../containers/concepts/CMakeLists.txt        |   1 +
 .../concepts/archtypes/CMakeLists.txt         |   9 +
 .../concepts/archtypes/allocator_aware.hpp    |  32 ++++
 .../concepts/archtypes/associative.hpp        | 148 +++++++++++++++
 .../concepts/archtypes/container.hpp          |  48 +++++
 .../concepts/archtypes/reversible.hpp         |  29 +++
 .../concepts/archtypes/sequence.hpp           |  55 ++++++
 .../concepts/archtypes/unordered.hpp          | 171 ++++++++++++++++++
 libraries/core/tests/CMakeLists.txt           |   1 +
 .../core/tests/containers/CMakeLists.txt      |   1 +
 .../tests/containers/concepts/CMakeLists.txt  |  10 +
 .../concepts/allocator_aware.tests.cpp        |  38 ++++
 .../containers/concepts/associative.tests.cpp |  45 +++++
 .../containers/concepts/container.tests.cpp   |  44 +++++
 .../containers/concepts/contiguous.tests.cpp  |  51 ++++++
 .../containers/concepts/reversible.tests.cpp  |  43 +++++
 .../containers/concepts/sequence.tests.cpp    |  42 +++++
 .../containers/concepts/unordered.tests.cpp   |  45 +++++
 libraries/core/tests/meta/CMakeLists.txt      |   1 +
 libraries/core/tests/meta/is_array.tests.cpp  |  39 ++++
 42 files changed, 1318 insertions(+), 12 deletions(-)
 create mode 100644 libraries/core/src/morpheus/core/containers/CMakeLists.txt
 create mode 100644 libraries/core/src/morpheus/core/containers/concepts/CMakeLists.txt
 create mode 100644 libraries/core/src/morpheus/core/containers/concepts/allocator_aware.hpp
 create mode 100644 libraries/core/src/morpheus/core/containers/concepts/associative.hpp
 create mode 100644 libraries/core/src/morpheus/core/containers/concepts/container.hpp
 create mode 100644 libraries/core/src/morpheus/core/containers/concepts/contiguous.hpp
 create mode 100644 libraries/core/src/morpheus/core/containers/concepts/detail/CMakeLists.txt
 create mode 100644 libraries/core/src/morpheus/core/containers/concepts/detail/return_types.hpp
 create mode 100644 libraries/core/src/morpheus/core/containers/concepts/reversible.hpp
 create mode 100644 libraries/core/src/morpheus/core/containers/concepts/sequence.hpp
 create mode 100644 libraries/core/src/morpheus/core/containers/concepts/unordered.hpp
 create mode 100644 libraries/core/src/morpheus/core/functional/concepts/CMakeLists.txt
 create mode 100644 libraries/core/src/morpheus/core/functional/concepts/function.hpp
 create mode 100644 libraries/core/src/morpheus/core/functional/concepts/hash.hpp
 create mode 100644 libraries/core/src/morpheus/core/meta/is_array.hpp
 create mode 100644 libraries/core/testing/morpheus/containers/CMakeLists.txt
 create mode 100644 libraries/core/testing/morpheus/containers/concepts/CMakeLists.txt
 create mode 100644 libraries/core/testing/morpheus/containers/concepts/archtypes/CMakeLists.txt
 create mode 100644 libraries/core/testing/morpheus/containers/concepts/archtypes/allocator_aware.hpp
 create mode 100644 libraries/core/testing/morpheus/containers/concepts/archtypes/associative.hpp
 create mode 100644 libraries/core/testing/morpheus/containers/concepts/archtypes/container.hpp
 create mode 100644 libraries/core/testing/morpheus/containers/concepts/archtypes/reversible.hpp
 create mode 100644 libraries/core/testing/morpheus/containers/concepts/archtypes/sequence.hpp
 create mode 100644 libraries/core/testing/morpheus/containers/concepts/archtypes/unordered.hpp
 create mode 100644 libraries/core/tests/containers/CMakeLists.txt
 create mode 100644 libraries/core/tests/containers/concepts/CMakeLists.txt
 create mode 100644 libraries/core/tests/containers/concepts/allocator_aware.tests.cpp
 create mode 100644 libraries/core/tests/containers/concepts/associative.tests.cpp
 create mode 100644 libraries/core/tests/containers/concepts/container.tests.cpp
 create mode 100644 libraries/core/tests/containers/concepts/contiguous.tests.cpp
 create mode 100644 libraries/core/tests/containers/concepts/reversible.tests.cpp
 create mode 100644 libraries/core/tests/containers/concepts/sequence.tests.cpp
 create mode 100644 libraries/core/tests/containers/concepts/unordered.tests.cpp
 create mode 100644 libraries/core/tests/meta/is_array.tests.cpp

diff --git a/libraries/core/src/morpheus/core/CMakeLists.txt b/libraries/core/src/morpheus/core/CMakeLists.txt
index 5ad041c1..b231c883 100644
--- a/libraries/core/src/morpheus/core/CMakeLists.txt
+++ b/libraries/core/src/morpheus/core/CMakeLists.txt
@@ -10,8 +10,9 @@ target_sources(MorpheusCore
 )
 
 add_subdirectory(base)
-add_subdirectory(conformance)
 add_subdirectory(concurrency)
+add_subdirectory(conformance)
+add_subdirectory(containers)
 add_subdirectory(functional)
 add_subdirectory(memory)
 add_subdirectory(meta)
diff --git a/libraries/core/src/morpheus/core/containers/CMakeLists.txt b/libraries/core/src/morpheus/core/containers/CMakeLists.txt
new file mode 100644
index 00000000..e632a43f
--- /dev/null
+++ b/libraries/core/src/morpheus/core/containers/CMakeLists.txt
@@ -0,0 +1 @@
+add_subdirectory(concepts)
\ No newline at end of file
diff --git a/libraries/core/src/morpheus/core/containers/concepts/CMakeLists.txt b/libraries/core/src/morpheus/core/containers/concepts/CMakeLists.txt
new file mode 100644
index 00000000..06e8a108
--- /dev/null
+++ b/libraries/core/src/morpheus/core/containers/concepts/CMakeLists.txt
@@ -0,0 +1,12 @@
+add_subdirectory(detail)
+
+target_sources(MorpheusCore
+    PUBLIC
+        allocator_aware.hpp
+        associative.hpp
+        container.hpp
+        contiguous.hpp
+        reversible.hpp
+        sequence.hpp
+        unordered.hpp
+)
diff --git a/libraries/core/src/morpheus/core/containers/concepts/allocator_aware.hpp b/libraries/core/src/morpheus/core/containers/concepts/allocator_aware.hpp
new file mode 100644
index 00000000..6b1c6adc
--- /dev/null
+++ b/libraries/core/src/morpheus/core/containers/concepts/allocator_aware.hpp
@@ -0,0 +1,29 @@
+#pragma once
+
+#include "morpheus/core/containers/concepts/container.hpp"
+
+#include <concepts>
+#include <utility>
+
+namespace morpheus::containers::concepts
+{
+
+/// \concept AllocatorAware
+///     Concept capturing the requirements for an allocator aware container as outline in the standard at
+///     <a href="https://eel.is/c++draft/container.alloc.reqmts">[container.alloc.reqmts]</a>, details at
+///     <a href="https://en.cppreference.com/w/cpp/named_req/AllocatorAwareContainer">AllocatorAwareContainer</a>.
+template <typename X>
+concept AllocatorAware = Container<X> && requires(X x, X&& rx, typename X::allocator_type a){
+    requires std::same_as<typename X::allocator_type::value_type, typename X::value_type>;
+    requires std::default_initializable<X>;
+    { X(a) };
+    { X(std::as_const(x), a) };
+    { X(std::move(rx)) };
+    { X(std::move(rx), a) };
+    { std::as_const(x).get_allocator() } -> std::same_as<typename X::allocator_type>;
+    { x = x } -> std::same_as<X&>;
+    { x = rx } -> std::same_as<X&>;
+    { x.swap(x) } -> std::same_as<void>;
+};
+
+} // namespace morpheus::containers::concepts
diff --git a/libraries/core/src/morpheus/core/containers/concepts/associative.hpp b/libraries/core/src/morpheus/core/containers/concepts/associative.hpp
new file mode 100644
index 00000000..58df3dbb
--- /dev/null
+++ b/libraries/core/src/morpheus/core/containers/concepts/associative.hpp
@@ -0,0 +1,66 @@
+#pragma once
+
+#include "morpheus/core/containers/concepts/detail/return_types.hpp"
+#include "morpheus/core/containers/concepts/allocator_aware.hpp"
+
+#include <concepts>
+#include <initializer_list>
+
+namespace morpheus::containers::concepts
+{
+
+/// \concept Associative
+///     Concept capturing the requirements for an associative container as outline in the standard at
+///     <a href="https://eel.is/c++draft/container.requirements#associative.reqmts">[associative.reqmts]</a>, details at
+///     <a href="https://en.cppreference.com/w/cpp/named_req/AssociativeContainer">AssociativeContainer</a>.
+template <typename T>
+concept Associative = AllocatorAware<T> && requires(T t, typename T::value_type v, typename T::key_type k, typename T::size_type s, typename T::iterator i, 
+                                                    typename T::const_iterator ci, typename T::key_compare c, typename T::node_type n,
+                                                    std::initializer_list<typename T::value_type> il)
+{
+    requires (std::default_initializable<typename T::key_compare>) and (std::copy_constructible<typename T::key_compare>);
+    { T(c) };
+    { T(i, i, c) };
+    { T(i, i) };
+#if (__cpp_lib_containers_ranges >= 202202L)
+    { T(std::from_range, ranges::subrange<typename T::iterator>{}, c) };
+    { T(std::from_range, ranges::subrange<typename T::iterator>{}) };
+#endif // (__cpp_lib_containers_ranges >= 202202L)
+    { T(il, c) };
+    { T(il) };
+    { t = il };
+    { std::as_const(t).key_comp() } -> std::same_as<typename T::key_compare>;
+    { std::as_const(t).value_comp() } -> std::same_as<typename T::value_compare>; 
+    { t.emplace() } -> detail::InsertReturnType<T>;
+    { t.emplace_hint(i) } -> std::same_as<typename T::iterator>;
+    { t.insert(v) } -> detail::InsertReturnType<T>;
+    { t.insert(ci, v) } -> std::same_as<typename T::iterator>;
+    { t.insert(i, i) } -> std::same_as<void>;
+#if (__cpp_lib_containers_ranges >= 202202L)
+    { t.insert_range(ranges::subrange<typename T::iterator>{}) } -> std::same_as<void>;
+#endif // (__cpp_lib_containers_ranges >= 202202L)
+    { t.insert(il) } -> std::same_as<void>; 
+    { t.insert(std::move(n)) } -> detail::InsertNodeHandleReturnType<T>;
+    { t.insert(ci, std::move(n)) } -> std::same_as<typename T::iterator>;
+    { t.extract(k) } -> std::same_as<typename T::node_type>; 
+    { t.extract(ci) } -> std::same_as<typename T::node_type>; 
+    { t.merge(t) } -> std::same_as<void>; 
+    { t.erase(i) } -> std::same_as<typename T::iterator>; 
+    { t.erase(ci) } -> std::same_as<typename T::iterator>; 
+    { t.erase(i, i) } -> std::same_as<typename T::iterator>; 
+    { t.erase(ci, ci) } -> std::same_as<typename T::iterator>; 
+    { t.erase(k) } -> std::same_as<typename T::size_type>;
+    { t.clear() } -> std::same_as<void>; 
+    { t.find(k) } -> std::same_as<typename T::iterator>; 
+    { std::as_const(t).find(k) } -> std::same_as<typename T::const_iterator>; 
+    { std::as_const(t).count(k) } -> std::same_as<typename T::size_type>;
+    { std::as_const(t).contains(k) } -> std::same_as<bool>;  
+    { t.lower_bound(k) } -> detail::BoundReturnType<T>;
+    { std::as_const(t).lower_bound(k) } -> detail::BoundConstReturnType<T>;
+    { t.equal_range(k) } -> detail::BoundReturnType<T>;
+    { std::as_const(t).equal_range(k) } -> detail::BoundConstReturnType<T>;
+    { t.upper_bound(k) } -> detail::BoundReturnType<T>;
+    { std::as_const(t).upper_bound(k) } -> detail::BoundConstReturnType<T>;
+};
+
+} // namespace morpheus::containers::concepts
diff --git a/libraries/core/src/morpheus/core/containers/concepts/container.hpp b/libraries/core/src/morpheus/core/containers/concepts/container.hpp
new file mode 100644
index 00000000..f8b1c062
--- /dev/null
+++ b/libraries/core/src/morpheus/core/containers/concepts/container.hpp
@@ -0,0 +1,34 @@
+#pragma once
+
+#include <concepts>
+#include <iterator>
+#include <utility>
+
+namespace morpheus::containers::concepts
+{
+
+/// \concept Container
+///     Concept capturing the requirements for a container as outline in the standard at
+///     <a href="https://eel.is/c++draft/container.requirements">[container.requirements]</a>, details at
+///     <a href="https://en.cppreference.com/w/cpp/named_req/Container">Container</a>.
+template<typename C>
+concept Container = requires(C c) {
+    typename C::value_type;
+    typename C::reference;
+    typename C::const_reference;
+    requires std::forward_iterator<typename C::iterator>;
+    requires std::forward_iterator<typename C::const_iterator>;
+    requires std::signed_integral<typename C::difference_type>;
+    requires std::unsigned_integral<typename C::size_type>;
+    requires std::convertible_to<typename C::iterator, typename C::const_iterator>;
+    requires std::regular<C>;
+    { begin(c) } -> std::same_as<typename C::iterator>;
+    { end(c) } -> std::same_as<typename C::iterator>;
+    { cbegin(std::as_const(c)) } -> std::same_as<typename C::const_iterator>;
+    { cend(std::as_const(c)) } -> std::same_as<typename C::const_iterator>;
+    requires (not std::bidirectional_iterator<typename C::iterator>) or requires {{ size(c) } -> std::same_as<typename C::size_type>; };
+    { c.max_size() } -> std::same_as<typename C::size_type>;
+    { empty(c) } -> std::same_as<bool>;
+};
+
+} // namespace morpheus::containers::concepts
\ No newline at end of file
diff --git a/libraries/core/src/morpheus/core/containers/concepts/contiguous.hpp b/libraries/core/src/morpheus/core/containers/concepts/contiguous.hpp
new file mode 100644
index 00000000..8689d46c
--- /dev/null
+++ b/libraries/core/src/morpheus/core/containers/concepts/contiguous.hpp
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "morpheus/core/containers/concepts/sequence.hpp"
+
+#include <concepts>
+#include <iterator>
+
+namespace morpheus::containers::concepts
+{
+
+/// \concept Contiguous
+///     Concept capturing the requirements for a contiguous container, a named requirement outlined in the standard at
+///     <a href="https://eel.is/c++draft/container.requirements.general">[container.requirements.general]</a>, details at
+///     <a href="https://en.cppreference.com/w/cpp/named_req/ContiguousContainer">ContiguousContainer</a>.
+template <typename T>
+concept Contiguous = StrictSequence<T> && requires(T t){
+    requires std::contiguous_iterator<typename T::iterator>;
+    requires std::contiguous_iterator<typename T::const_iterator>; 
+};
+
+} // namespace morpheus::containers::concepts
diff --git a/libraries/core/src/morpheus/core/containers/concepts/detail/CMakeLists.txt b/libraries/core/src/morpheus/core/containers/concepts/detail/CMakeLists.txt
new file mode 100644
index 00000000..0a2cb302
--- /dev/null
+++ b/libraries/core/src/morpheus/core/containers/concepts/detail/CMakeLists.txt
@@ -0,0 +1,4 @@
+target_sources(MorpheusCore
+    PUBLIC
+        return_types.hpp
+)
diff --git a/libraries/core/src/morpheus/core/containers/concepts/detail/return_types.hpp b/libraries/core/src/morpheus/core/containers/concepts/detail/return_types.hpp
new file mode 100644
index 00000000..e522553d
--- /dev/null
+++ b/libraries/core/src/morpheus/core/containers/concepts/detail/return_types.hpp
@@ -0,0 +1,33 @@
+#pragma once
+
+#include <concepts>
+#include <utility>
+
+namespace morpheus::containers::concepts::detail
+{
+
+template <typename I, typename T>
+concept InsertReturnType = requires
+{
+    requires std::same_as<I, typename T::iterator> or std::same_as<I, std::pair<typename T::iterator, bool>>;
+};
+
+template <typename I, typename T>
+concept InsertNodeHandleReturnType = requires
+{
+    requires requires { std::same_as<I, typename T::iterator>; } or requires { std::same_as<I, typename T::insert_return_type>; };
+};
+
+template <typename I, typename T>
+concept BoundReturnType = requires
+{
+    requires std::same_as<I, typename T::iterator> or std::same_as<I, std::pair<typename T::iterator, typename T::iterator>>;
+};
+
+template <typename I, typename T>
+concept BoundConstReturnType = requires
+{
+    requires std::same_as<I, typename T::const_iterator> or std::same_as<I, std::pair<typename T::const_iterator, typename T::const_iterator>>;
+};
+
+} // namespace morpheus::containers::concepts
\ No newline at end of file
diff --git a/libraries/core/src/morpheus/core/containers/concepts/reversible.hpp b/libraries/core/src/morpheus/core/containers/concepts/reversible.hpp
new file mode 100644
index 00000000..9759644d
--- /dev/null
+++ b/libraries/core/src/morpheus/core/containers/concepts/reversible.hpp
@@ -0,0 +1,28 @@
+#pragma once
+
+#include "morpheus/core/containers/concepts/container.hpp"
+
+#include <concepts>
+#include <iterator>
+#include <utility>
+
+namespace morpheus::containers::concepts
+{
+
+/// \concept Reversible
+///     Concept capturing the requirements for a reversible container, a named requirement outlined in the standard at
+///     <a href="https://eel.is/c++draft/container.rev.reqmts">[container.rev.reqmts]</a>, details at
+///     <a href="https://en.cppreference.com/w/cpp/named_req/ReversibleContainer">ReversibleContainer</a>.
+template <typename T>
+concept Reversible = Container<T> && requires(T t){
+    typename T::reverse_iterator;
+    typename T::const_reverse_iterator;
+    requires std::same_as<typename T::reverse_iterator, std::reverse_iterator<typename T::iterator>>;
+    requires std::same_as<typename T::const_reverse_iterator, std::reverse_iterator<typename T::const_iterator>>;
+    { rbegin(t) } -> std::same_as<typename T::reverse_iterator>;
+    { rend(t) } -> std::same_as<typename T::reverse_iterator>;
+    { crbegin(std::as_const(t)) } -> std::same_as<typename T::const_reverse_iterator>;
+    { crend(std::as_const(t)) } -> std::same_as<typename T::const_reverse_iterator>;
+};
+
+} // namespace morpheus::containers::concepts
diff --git a/libraries/core/src/morpheus/core/containers/concepts/sequence.hpp b/libraries/core/src/morpheus/core/containers/concepts/sequence.hpp
new file mode 100644
index 00000000..329cf5ae
--- /dev/null
+++ b/libraries/core/src/morpheus/core/containers/concepts/sequence.hpp
@@ -0,0 +1,67 @@
+#pragma once
+
+#include "morpheus/core/containers/concepts/container.hpp"
+#include "morpheus/core/conformance/ranges.hpp"
+#include "morpheus/core/meta/is_array.hpp"
+#include "morpheus/core/meta/is_string.hpp"
+
+#include <concepts>
+#include <initializer_list>
+#include <forward_list>
+#include <string>
+#include <version>
+
+namespace morpheus::containers::concepts
+{
+
+/// \concept Sequence
+///     Concept capturing the requirements for a sequence container as outline in the standard at
+///     <a href="https://eel.is/c++draft/sequence.reqmts">[sequence.requirements]</a>, details at
+///     <a href="https://en.cppreference.com/w/cpp/named_req/SequenceContainer">SequenceContainer</a>.
+template <typename T>
+concept Sequence = Container<T> && requires(T t, typename T::value_type v, typename T::size_type s, typename T::iterator i, std::initializer_list<typename T::value_type> il){
+    { T(s, v) };
+    { T(i, i) };
+#if (__cpp_lib_containers_ranges >= 202202L)
+    { T(std::from_range, ranges::subrange<typename T::iterator>{}) };
+#endif // (__cpp_lib_containers_ranges >= 202202L)
+    { T(il) };
+    { t = il };
+    { t.insert(i, v) } -> std::same_as<typename T::iterator>;
+    { t.insert(i, std::move(v)) } -> std::same_as<typename T::iterator>;
+    { t.insert(i, s, v) } -> std::same_as<typename T::iterator>;
+    { t.insert(i, i, i) } -> std::same_as<typename T::iterator>;
+#if (__cpp_lib_containers_ranges >= 202202L)
+    { t.insert_range(i, ranges::subrange<typename T::iterator>{}) } -> std::same_as<typename T::iterator>;
+#endif // (__cpp_lib_containers_ranges >= 202202L)
+    { t.insert(i, il) } -> std::same_as<typename T::iterator>;
+    { t.erase(i) } -> std::same_as<typename T::iterator>;
+    { t.erase(i, i) } -> std::same_as<typename T::iterator>;
+    { t.clear() } -> std::same_as<void>;
+    { t.assign(i, i) } -> std::same_as<void>;
+#if (__cpp_lib_containers_ranges >= 202202L)
+    { t.assign_range(ranges::subrange<typename T::iterator>{}) } -> std::same_as<void>;
+#endif // (__cpp_lib_containers_ranges >= 202202L)
+    { t.assign(il) } -> std::same_as<void>;
+    { t.assign(s, v) } -> std::same_as<void>;
+};
+
+/// \concept StrictSequence
+///     Concept strictly capturing the requirements for a sequence container as outline in the standard at
+///     <a href="https://eel.is/c++draft/sequence.reqmts">[sequence.requirements]</a>, details at
+///     <a href="https://en.cppreference.com/w/cpp/named_req/SequenceContainer">SequenceContainer</a>.
+///     The requirements <a href="https://eel.is/c++draft/sequence.reqmts">[sequence.requirements]</a> don't
+///     actually match numerous types listed as sequence containers.  This includes:
+///      - std::string
+///      - std::forward_list
+///      - std::array
+///     Hoever they are listed as as Sequence types while having interfaces that differ from the Sequence
+///     container requirements so this extension concept exactly mirrors that requirement.
+template <typename T>
+concept StrictSequence = meta::is_array_v<T> || 
+                         meta::is_string_v<T> ||
+                         std::same_as<T, std::forward_list<typename T::value_type>> ||
+                         Sequence<T>; 
+
+
+} // namespace morpheus::containers::concepts
diff --git a/libraries/core/src/morpheus/core/containers/concepts/unordered.hpp b/libraries/core/src/morpheus/core/containers/concepts/unordered.hpp
new file mode 100644
index 00000000..10e790f8
--- /dev/null
+++ b/libraries/core/src/morpheus/core/containers/concepts/unordered.hpp
@@ -0,0 +1,85 @@
+#pragma once
+
+#include "morpheus/core/containers/concepts/detail/return_types.hpp"
+#include "morpheus/core/containers/concepts/allocator_aware.hpp"
+#include "morpheus/core/functional/concepts/hash.hpp"
+
+#include <concepts>
+#include <initializer_list>
+
+namespace morpheus::containers::concepts
+{
+
+/// \concept Unordered
+///     Concept capturing the requirements for an unordered associative container as outline in the standard at
+///     <a href="https://eel.is/c++draft/unord.req">[unord.req]</a>, details at
+///     <a href="https://en.cppreference.com/w/cpp/named_req/UnorderedAssociativeContainer">UnorderedAssociativeContainerr</a>.
+template <typename T>
+concept Unordered = AllocatorAware<T> && requires(T t, typename T::value_type v, typename T::key_type k, typename T::size_type s, typename T::iterator i, 
+                                                  typename T::const_iterator ci, typename T::hasher h, typename T::key_equal e, typename T::local_iterator l,
+                                                  typename T::node_type n, std::initializer_list<typename T::value_type> il)
+{
+    requires functional::concepts::Hash<typename T::hasher, typename T::key_type>;                                  
+    requires (std::default_initializable<typename T::key_equal>) && (std::copy_constructible<typename T::key_equal>);
+    { T(s, h, e) };
+    { T(s, h) };
+    { T(s) };
+    { T(i, i, s, h, e) };
+    { T(i, i, s, h) };
+    { T(i, i, s) };
+    { T(i, i) };
+#if (__cpp_lib_containers_ranges >= 202202L)
+    { T(std::from_range, ranges::subrange<typename T::iterator>{}, s, h, e) };
+    { T(std::from_range, ranges::subrange<typename T::iterator>{}, s, h) };
+    { T(std::from_range, ranges::subrange<typename T::iterator>{}, s) };
+    { T(std::from_range, ranges::subrange<typename T::iterator>{}) };
+#endif // (__cpp_lib_containers_ranges >= 202202L)
+    { T(il, s, h, e) }; 
+    { T(il, s, h) };
+    { T(il, s) };
+    { T(il) };
+    { t = il };
+    { std::as_const(t).hash_function() } -> std::same_as<typename T::hasher>;
+    { std::as_const(t).key_eq() } -> std::same_as<typename T::key_equal>;
+    { t.emplace() } -> detail::InsertReturnType<T>;
+    { t.emplace_hint(i) } -> std::same_as<typename T::iterator>;
+    { t.insert(v) } -> detail::InsertReturnType<T>;
+    { t.insert(ci, v) } -> std::same_as<typename T::iterator>;
+    { t.insert(i, i) } -> std::same_as<void>;
+#if (__cpp_lib_containers_ranges >= 202202L)
+    { t.insert_range(ranges::subrange<typename T::iterator>{}) } -> std::same_as<void>;
+#endif // (__cpp_lib_containers_ranges >= 202202L)
+    { t.insert(il) } -> std::same_as<void>; 
+    { t.insert(std::move(n)) } -> detail::InsertNodeHandleReturnType<T>;
+    { t.insert(ci, std::move(n)) } -> std::same_as<typename T::iterator>;
+    { t.extract(k) } -> std::same_as<typename T::node_type>; 
+    { t.extract(ci) } -> std::same_as<typename T::node_type>; 
+    { t.merge(t) } -> std::same_as<void>; 
+    { t.erase(i) } -> std::same_as<typename T::iterator>; 
+    { t.erase(ci) } -> std::same_as<typename T::iterator>; 
+    { t.erase(i, i) } -> std::same_as<typename T::iterator>; 
+    { t.erase(ci, ci) } -> std::same_as<typename T::iterator>; 
+    { t.erase(k) } -> std::same_as<typename T::size_type>;
+    { t.clear() } -> std::same_as<void>; 
+    { t.find(k) } -> std::same_as<typename T::iterator>; 
+    { std::as_const(t).find(k) } -> std::same_as<typename T::const_iterator>; 
+    { std::as_const(t).count(k) } -> std::same_as<typename T::size_type>;
+    { std::as_const(t).contains(k) } -> std::same_as<bool>;
+    { t.equal_range(k) } -> detail::BoundReturnType<T>;
+    { std::as_const(t).equal_range(k) } -> detail::BoundConstReturnType<T>;
+    { std::as_const(t).bucket_count() } -> std::same_as<typename T::size_type>;
+    { std::as_const(t).max_bucket_count() } -> std::same_as<typename T::size_type>;
+    { std::as_const(t).bucket(s) } -> std::same_as<typename T::size_type>;
+    { std::as_const(t).bucket_size(s) } -> std::same_as<typename T::size_type>;
+    { t.begin(s) } -> std::same_as<typename T::local_iterator>;
+    { std::as_const(t).begin(s) } -> std::same_as<typename T::const_local_iterator>;
+    { t.end(s) } -> std::same_as<typename T::local_iterator>;
+    { std::as_const(t).end(s) } -> std::same_as<typename T::const_local_iterator>;
+    { std::as_const(t).load_factor() } -> std::same_as<float>;
+    { std::as_const(t).max_load_factor() } -> std::same_as<float>;
+    { t.max_load_factor(float{}) } -> std::same_as<void>;
+    { t.rehash(s) } -> std::same_as<void>; 
+    { t.reserve(s) } -> std::same_as<void>; 
+};
+
+} // namespace morpheus::containers::concepts
diff --git a/libraries/core/src/morpheus/core/functional/CMakeLists.txt b/libraries/core/src/morpheus/core/functional/CMakeLists.txt
index 60a3a78e..e97113ec 100644
--- a/libraries/core/src/morpheus/core/functional/CMakeLists.txt
+++ b/libraries/core/src/morpheus/core/functional/CMakeLists.txt
@@ -1,3 +1,5 @@
+add_subdirectory(concepts)
+
 target_sources(MorpheusCore
     PUBLIC
         function_ref.hpp
diff --git a/libraries/core/src/morpheus/core/functional/concepts/CMakeLists.txt b/libraries/core/src/morpheus/core/functional/concepts/CMakeLists.txt
new file mode 100644
index 00000000..b80bb2ab
--- /dev/null
+++ b/libraries/core/src/morpheus/core/functional/concepts/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(MorpheusCore
+    PUBLIC
+        function.hpp
+        hash.hpp
+)
diff --git a/libraries/core/src/morpheus/core/functional/concepts/function.hpp b/libraries/core/src/morpheus/core/functional/concepts/function.hpp
new file mode 100644
index 00000000..3acd29f3
--- /dev/null
+++ b/libraries/core/src/morpheus/core/functional/concepts/function.hpp
@@ -0,0 +1,19 @@
+#pragma once
+
+#include <concepts>
+#include <type_traits>
+
+namespace morpheus::functional::concepts
+{
+
+/// \concept Function
+///     Concept capturing the requirements for a function object, a named requirement outlined in the standard at
+///     <a href="https://eel.is/c++draft/func.require">[func.require]</a>, details at
+///     <a href="https://en.cppreference.com/w/cpp/named_req/FunctionObject">FunctionObject</a>.
+template <typename T, typename... Args>
+concept Function = requires(T t){
+    requires std::is_object_v<T>;
+    requires std::invocable<T, Args...>;
+};
+
+} // namespace morpheus::functional::concepts
diff --git a/libraries/core/src/morpheus/core/functional/concepts/hash.hpp b/libraries/core/src/morpheus/core/functional/concepts/hash.hpp
new file mode 100644
index 00000000..ac43f2e4
--- /dev/null
+++ b/libraries/core/src/morpheus/core/functional/concepts/hash.hpp
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "morpheus/core/functional/concepts/function.hpp"
+
+#include <concepts>
+
+namespace morpheus::functional::concepts
+{
+
+/// \concept Hash
+///     Concept capturing the requirements for a hash, a named requirement outlined in the standard at
+///     <a href="https://eel.is/c++draft/hash.requirements">[hash.requirements]</a>, details at
+///     <a href="https://en.cppreference.com/w/cpp/named_req/Hash">Hash</a>.
+template <typename T, typename Arg>
+concept Hash = requires(T t){
+    requires std::copy_constructible<T>;
+    requires std::destructible<T>;
+    requires Function<T, Arg>;
+};
+
+} // namespace morpheus::functional::concepts
diff --git a/libraries/core/src/morpheus/core/memory/concepts/allocator.hpp b/libraries/core/src/morpheus/core/memory/concepts/allocator.hpp
index 67e22548..a744bb17 100644
--- a/libraries/core/src/morpheus/core/memory/concepts/allocator.hpp
+++ b/libraries/core/src/morpheus/core/memory/concepts/allocator.hpp
@@ -16,22 +16,30 @@ namespace morpheus::memory::concepts
 /// \concept Allocator
 ///     Concept capturing the requirements for an allocator as outline in the standard at
 ///     <a href="https://eel.is/c++draft/allocator.requirements">[allocator.requirements]</a>.
-
+/// \par
+///     Allocators provide a number of services:
+///      - Perform allocation, construction, destruction and deallocation.
+///      - Seperate allocation from construction,
+///      - Seperate deallocation from destruction.
+///      - Encapsulate information about the allocation strategy.
+///      - Encapsulate information about the addressing model.
+///      - Hide memory management and addressing model details from users.
+///      - Support the reuse of an allocation strategy across allocation users.
 /// \note
 ///     https://rawgit.com/google/cxx-std-draft/allocator-paper/allocator_user_guide.html#reqs
 template <template <typename> class A, typename T>
-concept Allocator = requires(A<T> a) {
+concept Allocator = requires(A<T> a, typename std::allocator_traits<A<T>>::size_type s, typename std::allocator_traits<A<T>>::pointer p) {
     requires std::same_as<typename A<T>::value_type, T>;
     requires NullablePointer<typename std::allocator_traits<A<T>>::pointer>;
     requires NullablePointer<typename std::allocator_traits<A<T>>::const_pointer>;
-    requires std::unsigned_integral<typename A<T>::size_type>;
-    requires std::signed_integral<typename A<T>::difference_type>;
+    requires std::unsigned_integral<typename std::allocator_traits<A<T>>::size_type>;
+    requires std::signed_integral<typename std::allocator_traits<A<T>>::difference_type>;
 
-    { a.allocate(std::size_t{}) } -> std::same_as<typename std::allocator_traits<A<T>>::pointer>;
-    { a.deallocate(typename std::allocator_traits<A<T>>::pointer{}, std::size_t{}) } -> std::same_as<void>;
+    { a.allocate(s) } -> std::same_as<typename std::allocator_traits<A<T>>::pointer>;
+    { a.deallocate(p, s) } -> std::same_as<void>;
 
 #if (__cpp_lib_allocate_at_least >= 202302L )
-    { a.allocate_at_least(std::size_t{}) } -> std::same_as<std::allocation_result<typename std::allocator_traits<A<T>>::pointer, typename A<T>::size_type>>;
+    { a.allocate_at_least(s) } -> std::same_as<std::allocation_result<typename std::allocator_traits<A<T>>::pointer, typename std::allocator_traits<A<T>>::size_type>>;
 #endif
 };
 
diff --git a/libraries/core/src/morpheus/core/memory/concepts/nullable_pointer.hpp b/libraries/core/src/morpheus/core/memory/concepts/nullable_pointer.hpp
index 4144f67f..93fe18af 100644
--- a/libraries/core/src/morpheus/core/memory/concepts/nullable_pointer.hpp
+++ b/libraries/core/src/morpheus/core/memory/concepts/nullable_pointer.hpp
@@ -11,16 +11,15 @@ namespace morpheus::memory::concepts
 // Requires clang-format 18.0 support for AllowShortCompoundRequirementOnASingleLine: true
 
 /// \concept NullablePointer
-///     Concept capturing the requirements for an nullable pointer as outline in the standard at
-///     <a href="https://eel.is/c++draft/nullablepointer.requirements">[nullablepointer.requirements]</a>.
-///
+///     Concept capturing the requirements for a nullable pointer, a named requirement outlined in the standard at
+///     <a href="https://eel.is/c++draft/nullablepointer.requirements">[nullablepointer.requirements]</a>, details at
+///     <a href="https://en.cppreference.com/w/cpp/named_req/NullablePointer">NullablePointer</a>.
 template <typename T>
 concept NullablePointer = requires(T t) {
     requires std::default_initializable<T>;
     requires std::copy_constructible<T>;
     requires std::assignable_from<T&, T>;
     requires std::destructible<T>;
-    requires std::destructible<T>;
     requires std::equality_comparable<T>;
     requires std::equality_comparable_with<T, std::nullptr_t>;
     requires std::swappable<T>;
diff --git a/libraries/core/src/morpheus/core/meta/CMakeLists.txt b/libraries/core/src/morpheus/core/meta/CMakeLists.txt
index 32d180f9..b3f6b9f2 100644
--- a/libraries/core/src/morpheus/core/meta/CMakeLists.txt
+++ b/libraries/core/src/morpheus/core/meta/CMakeLists.txt
@@ -3,6 +3,7 @@ target_sources(MorpheusCore
         aggregate.hpp
         binary_search.hpp
         complete.hpp
+        is_array.hpp
         is_specialisation.hpp
         is_string.hpp
 )
diff --git a/libraries/core/src/morpheus/core/meta/is_array.hpp b/libraries/core/src/morpheus/core/meta/is_array.hpp
new file mode 100644
index 00000000..25f1274b
--- /dev/null
+++ b/libraries/core/src/morpheus/core/meta/is_array.hpp
@@ -0,0 +1,15 @@
+#pragma once
+
+#include <array>
+#include <type_traits>
+
+namespace morpheus::meta
+{
+
+template <class T>
+inline constexpr bool is_array_v = false;
+
+template <class T, size_t Size>
+inline constexpr bool is_array_v<std::array<T, Size>> = true;
+
+} // namespace morpheus::meta
diff --git a/libraries/core/testing/morpheus/CMakeLists.txt b/libraries/core/testing/morpheus/CMakeLists.txt
index f318e403..512db7eb 100644
--- a/libraries/core/testing/morpheus/CMakeLists.txt
+++ b/libraries/core/testing/morpheus/CMakeLists.txt
@@ -6,4 +6,5 @@ target_sources(MorpheusCoreTesting
 )
 
 add_subdirectory(catch2)
+add_subdirectory(containers)
 add_subdirectory(serialisation)
diff --git a/libraries/core/testing/morpheus/containers/CMakeLists.txt b/libraries/core/testing/morpheus/containers/CMakeLists.txt
new file mode 100644
index 00000000..0cc9b3dc
--- /dev/null
+++ b/libraries/core/testing/morpheus/containers/CMakeLists.txt
@@ -0,0 +1 @@
+add_subdirectory(concepts)
diff --git a/libraries/core/testing/morpheus/containers/concepts/CMakeLists.txt b/libraries/core/testing/morpheus/containers/concepts/CMakeLists.txt
new file mode 100644
index 00000000..5ea08120
--- /dev/null
+++ b/libraries/core/testing/morpheus/containers/concepts/CMakeLists.txt
@@ -0,0 +1 @@
+add_subdirectory(archtypes)
diff --git a/libraries/core/testing/morpheus/containers/concepts/archtypes/CMakeLists.txt b/libraries/core/testing/morpheus/containers/concepts/archtypes/CMakeLists.txt
new file mode 100644
index 00000000..6af0243f
--- /dev/null
+++ b/libraries/core/testing/morpheus/containers/concepts/archtypes/CMakeLists.txt
@@ -0,0 +1,9 @@
+target_sources(MorpheusCoreTesting
+    PUBLIC
+        allocator_aware.hpp
+        associative.hpp
+        container.hpp
+        reversible.hpp
+        sequence.hpp
+        unordered.hpp
+)
\ No newline at end of file
diff --git a/libraries/core/testing/morpheus/containers/concepts/archtypes/allocator_aware.hpp b/libraries/core/testing/morpheus/containers/concepts/archtypes/allocator_aware.hpp
new file mode 100644
index 00000000..dd5862c4
--- /dev/null
+++ b/libraries/core/testing/morpheus/containers/concepts/archtypes/allocator_aware.hpp
@@ -0,0 +1,32 @@
+#pragma once
+
+#include "morpheus/containers/concepts/archtypes/container.hpp"
+
+#include <compare>
+#include <memory>
+
+namespace morpheus::containers::concepts::archtypes
+{
+
+struct AllocatorAware : public Container
+{
+    using allocator_type = std::allocator<int>;
+
+    constexpr AllocatorAware();
+    constexpr AllocatorAware(allocator_type const&);
+    constexpr AllocatorAware(AllocatorAware const&);
+    constexpr AllocatorAware(AllocatorAware const&, allocator_type const&);
+    constexpr AllocatorAware(AllocatorAware&&);
+    constexpr AllocatorAware(AllocatorAware&&, allocator_type const&);
+ 
+    constexpr AllocatorAware& operator=(AllocatorAware const&);
+    constexpr AllocatorAware& operator=(AllocatorAware&&);
+
+    constexpr auto operator<=>(AllocatorAware const&) const = default;
+
+    constexpr allocator_type get_allocator() const noexcept;
+
+    constexpr void swap(AllocatorAware&) noexcept;
+};
+
+} // namespace morpheus::containers::concepts::archtypes 
diff --git a/libraries/core/testing/morpheus/containers/concepts/archtypes/associative.hpp b/libraries/core/testing/morpheus/containers/concepts/archtypes/associative.hpp
new file mode 100644
index 00000000..eb4b06c5
--- /dev/null
+++ b/libraries/core/testing/morpheus/containers/concepts/archtypes/associative.hpp
@@ -0,0 +1,148 @@
+#pragma once
+
+#include "morpheus/containers/concepts/archtypes/allocator_aware.hpp"
+
+#include "morpheus/core/conformance/ranges.hpp"
+
+#include <compare>
+#include <functional>
+#include <initializer_list>
+
+namespace morpheus::containers::concepts::archtypes
+{
+
+namespace detail
+{
+
+template<bool M = false>
+struct Multi
+{
+    struct insert_return_type {};
+    
+    constexpr auto operator<=>(Multi const&) const = default;
+};
+
+template<>
+struct Multi<true>
+{
+    constexpr auto operator<=>(Multi const&) const = default;
+};
+
+
+template<bool M = false>
+struct Mapped
+{
+    using value_type = int;
+    using key_type = value_type; 
+    using allocator_type = std::allocator<value_type>;
+
+    constexpr auto operator<=>(Mapped const&) const = default;
+};
+
+template<>
+struct Mapped<true>
+{
+    using mapped_type = int;
+    using value_type = std::pair<const int, mapped_type>;
+    using key_type = typename value_type::first_type; 
+    using allocator_type = std::allocator<value_type>;
+    constexpr auto operator<=>(Mapped const&) const = default;
+};
+
+} // namespace morpheus::containers::concepts::archtypes::detail
+
+template<bool multi = false, bool mapped = false>
+struct Associative : AllocatorAware, detail::Multi<multi>, detail::Mapped<mapped>
+{
+    using value_type = typename detail::Mapped<mapped>::value_type;
+    using key_type = typename detail::Mapped<mapped>::key_type;
+    using allocator_type = typename detail::Mapped<mapped>::allocator_type;
+    using key_compare = std::less<int>;
+    using value_compare = key_compare;
+    struct node_type{};
+
+    using InsertReturnType = std::conditional_t<multi, iterator, std::pair<iterator, bool>>;
+    using InsertNodeHandleReturnType = std::invoke_result_t<decltype([]
+    { 
+        if constexpr (requires { requires requires {typename detail::Multi<multi>::insert_return_type; }; })
+        {
+            return typename detail::Multi<multi>::insert_return_type{};
+        }
+        else
+        {
+            return typename AllocatorAware::iterator{};
+        }
+    })>;
+    using BoundReturnType = std::conditional_t<multi, iterator, std::pair<iterator, iterator>>;
+    using BoundConstReturnType = std::conditional_t<multi, const_iterator, std::pair<const_iterator, const_iterator>>;
+
+    using AllocatorAware::AllocatorAware;
+    using detail::Mapped<mapped>::Mapped;
+    
+    constexpr Associative();
+    constexpr Associative(key_compare const&);
+    constexpr Associative(iterator, iterator, key_compare const&);
+    constexpr Associative(iterator, iterator);
+#if (__cpp_lib_containers_ranges >= 202202L)
+    constexpr Associative(std::from_range_t, ranges::range auto, key_compare const&);
+    constexpr Associative(std::from_range_t, ranges::range auto);
+#endif // (__cpp_lib_containers_ranges >= 202202L)
+    constexpr Associative(std::initializer_list<value_type>, key_compare const&);
+    constexpr Associative(std::initializer_list<value_type>);
+    constexpr Associative(Associative const&);
+    constexpr Associative(Associative&&);
+    constexpr Associative& operator=(Associative const&);
+    constexpr Associative& operator=(Associative&&);
+    constexpr Associative& operator=(std::initializer_list<value_type>);
+
+    constexpr allocator_type get_allocator() const noexcept;
+
+    constexpr key_compare key_comp() const;
+    constexpr value_compare value_comp() const;
+    
+    constexpr InsertReturnType emplace(auto... args);
+    constexpr iterator emplace_hint(iterator, auto... args);
+
+    constexpr InsertReturnType insert(value_type);
+    constexpr iterator insert(const_iterator, value_type);
+    constexpr void insert(const_iterator, const_iterator);
+#if (__cpp_lib_containers_ranges >= 202202L)
+    constexpr void insert_range(ranges::range auto);
+#endif // (__cpp_lib_containers_ranges >= 202202L)
+    constexpr void insert(std::initializer_list<value_type>);
+    constexpr InsertNodeHandleReturnType insert(node_type&&);
+    constexpr iterator insert(const_iterator, node_type&&);
+
+    constexpr node_type extract(key_type);
+    constexpr node_type extract(const_iterator);
+
+    constexpr void merge(Associative const&);
+    
+    constexpr iterator erase(iterator);
+    constexpr iterator erase(const_iterator);
+    constexpr iterator erase(iterator, iterator);
+    constexpr iterator erase(const_iterator, const_iterator);
+    constexpr size_type erase(key_type const&);
+
+    constexpr void clear();
+    
+    constexpr iterator find(key_type const&);
+    constexpr const_iterator find(key_type const&) const;
+    
+    constexpr size_type count(key_type const&) const;
+
+    constexpr bool contains(key_type const&) const;
+
+    BoundReturnType lower_bound(key_type const&);
+    BoundConstReturnType lower_bound(key_type const&) const;
+    BoundReturnType equal_range(key_type const&);
+    BoundConstReturnType equal_range(key_type const&) const;
+    BoundReturnType upper_bound(key_type const&);
+    BoundConstReturnType upper_bound(key_type const&) const;
+
+    constexpr auto operator<=>(Associative const&) const = default;
+
+
+};
+
+} // namespace morpheus::containers::concepts::archtypes 
diff --git a/libraries/core/testing/morpheus/containers/concepts/archtypes/container.hpp b/libraries/core/testing/morpheus/containers/concepts/archtypes/container.hpp
new file mode 100644
index 00000000..2099a7b8
--- /dev/null
+++ b/libraries/core/testing/morpheus/containers/concepts/archtypes/container.hpp
@@ -0,0 +1,48 @@
+#pragma once
+
+#include <cstddef>
+#include <compare>
+#include <iterator>
+
+namespace morpheus::containers::concepts::archtypes
+{
+
+// Pull range access functions into scope. 
+using std::begin;
+using std::end;
+using std::cbegin;
+using std::cend;
+using std::size;
+using std::empty;
+
+struct Container
+{
+    using value_type = int;
+    using reference = value_type&;
+    using const_reference = value_type const&;
+    using iterator = int*;
+    using const_iterator = int const *;
+    using difference_type = std::ptrdiff_t;
+    using size_type = std::size_t;
+
+    constexpr Container();
+    constexpr Container(Container const&);
+    constexpr Container(Container&&);
+    constexpr ~Container();
+    constexpr Container& operator=(Container const&);
+    constexpr Container& operator=(Container&&);
+
+    constexpr auto operator<=>(Container const&) const = default;
+
+    constexpr iterator begin() noexcept;
+    constexpr iterator end() noexcept;
+    constexpr const_iterator begin() const noexcept;
+    constexpr const_iterator end() const noexcept;
+    constexpr const_iterator cbegin() const noexcept;
+    constexpr const_iterator cend() const noexcept;
+    constexpr size_type size() const noexcept; 
+    constexpr size_type max_size() const noexcept; 
+    constexpr bool empty() const noexcept; 
+};
+
+} // namespace morpheus::containers::concepts::archtypes 
diff --git a/libraries/core/testing/morpheus/containers/concepts/archtypes/reversible.hpp b/libraries/core/testing/morpheus/containers/concepts/archtypes/reversible.hpp
new file mode 100644
index 00000000..e13b0acb
--- /dev/null
+++ b/libraries/core/testing/morpheus/containers/concepts/archtypes/reversible.hpp
@@ -0,0 +1,29 @@
+#pragma once
+
+#include "morpheus/containers/concepts/archtypes/container.hpp"
+
+#include <cstddef>
+#include <compare>
+#include <iterator>
+
+namespace morpheus::containers::concepts::archtypes
+{
+
+// Pull range access functions into scope. 
+using std::rbegin;
+using std::rend;
+using std::crbegin;
+using std::crend;
+
+struct Reversible : Container
+{
+    using reverse_iterator = std::reverse_iterator<iterator>;
+    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
+    constexpr reverse_iterator rbegin() noexcept;
+    constexpr reverse_iterator rend() noexcept;
+    constexpr const_reverse_iterator rbegin() const noexcept;
+    constexpr const_reverse_iterator rend() const noexcept;
+};
+
+} // namespace morpheus::containers::concepts::archtypes 
diff --git a/libraries/core/testing/morpheus/containers/concepts/archtypes/sequence.hpp b/libraries/core/testing/morpheus/containers/concepts/archtypes/sequence.hpp
new file mode 100644
index 00000000..6b19b1bb
--- /dev/null
+++ b/libraries/core/testing/morpheus/containers/concepts/archtypes/sequence.hpp
@@ -0,0 +1,55 @@
+#pragma once
+
+#include "morpheus/containers/concepts/archtypes/container.hpp"
+
+#include "morpheus/core/conformance/ranges.hpp"
+
+#include <cstddef>
+#include <compare>
+#include <initializer_list>
+#include <iterator>
+#include <ranges>
+#include <vector>
+
+namespace morpheus::containers::concepts::archtypes
+{
+
+/// \brief Sequence
+///      Archtype providing the minimal interface required to meet the concepts::Sequence constraints.
+struct Sequence : Container
+{
+    constexpr Sequence();
+    constexpr Sequence(size_type, value_type);
+    constexpr Sequence(iterator, iterator);
+#if (__cpp_lib_containers_ranges >= 202202L)
+    constexpr Sequence(std::from_range_t, ranges::range auto);
+#endif // (__cpp_lib_containers_ranges >= 202202L)
+    constexpr Sequence(std::initializer_list<int>);
+    constexpr Sequence(Sequence const&);
+    constexpr Sequence(Sequence&&);
+    constexpr ~Sequence();
+    constexpr Sequence& operator=(Sequence const&);
+    constexpr Sequence& operator=(Sequence&&);
+    constexpr Sequence& operator=(std::initializer_list<int>);
+
+    constexpr auto operator<=>(Sequence const&) const = default;
+
+    constexpr iterator insert(iterator, value_type);
+    constexpr iterator insert(iterator, size_type, value_type);
+    constexpr iterator insert(iterator, iterator, iterator);
+#if (__cpp_lib_containers_ranges >= 202202L)
+    constexpr iterator insert_range(iterator, ranges::range auto);
+#endif // (__cpp_lib_containers_ranges >= 202202L)
+    constexpr iterator insert(iterator, std::initializer_list<int>);
+    constexpr iterator erase(iterator);
+    constexpr iterator erase(iterator, iterator);
+    constexpr void clear();
+    constexpr void assign(iterator, iterator);
+#if (__cpp_lib_containers_ranges >= 202202L)
+    constexpr void assign_range(ranges::range auto);
+#endif // (__cpp_lib_containers_ranges >= 202202L)
+    constexpr void assign(std::initializer_list<int>);
+    constexpr void assign(size_type, value_type);
+};
+
+} // namespace morpheus::containers::concepts::archtypes
diff --git a/libraries/core/testing/morpheus/containers/concepts/archtypes/unordered.hpp b/libraries/core/testing/morpheus/containers/concepts/archtypes/unordered.hpp
new file mode 100644
index 00000000..91f27411
--- /dev/null
+++ b/libraries/core/testing/morpheus/containers/concepts/archtypes/unordered.hpp
@@ -0,0 +1,171 @@
+#pragma once
+
+#include "morpheus/containers/concepts/archtypes/allocator_aware.hpp"
+
+#include "morpheus/core/conformance/ranges.hpp"
+
+#include <compare>
+#include <functional>
+
+namespace morpheus::containers::concepts::archtypes
+{
+
+namespace detail
+{
+
+template<bool M = false>
+struct Multi
+{
+    struct insert_return_type {};
+    
+    constexpr auto operator<=>(Multi const&) const = default;
+};
+
+template<>
+struct Multi<true>
+{
+    constexpr auto operator<=>(Multi const&) const = default;
+};
+
+
+template<bool M = false>
+struct Mapped
+{
+    using value_type = int;
+    using key_type = value_type; 
+    using allocator_type = std::allocator<value_type>;
+
+    constexpr auto operator<=>(Mapped const&) const = default;
+};
+
+template<>
+struct Mapped<true>
+{
+    using mapped_type = int;
+    using value_type = std::pair<const int, mapped_type>;
+    using key_type = typename value_type::first_type; 
+    using allocator_type = std::allocator<value_type>;
+    constexpr auto operator<=>(Mapped const&) const = default;
+};
+
+} // namespace morpheus::containers::concepts::archtypes::detail
+
+template<bool multi = false, bool mapped = false>
+struct Unordered : public AllocatorAware, detail::Multi<multi>, detail::Mapped<mapped>
+{
+    using value_type = typename detail::Mapped<mapped>::value_type;
+    using key_type = typename detail::Mapped<mapped>::key_type;
+    using allocator_type = typename detail::Mapped<mapped>::allocator_type;
+    using hasher = std::hash<int>;
+    using key_equal = std::equal_to<int>;
+    struct node_type{};
+    struct local_iterator{};
+    using const_local_iterator = local_iterator const;
+
+    using InsertReturnType = std::conditional_t<multi, iterator, std::pair<iterator, bool>>;
+    using InsertNodeHandleReturnType = std::invoke_result_t<decltype([]
+    { 
+        if constexpr (requires { requires requires {typename detail::Multi<multi>::insert_return_type; }; })
+        {
+            return typename detail::Multi<multi>::insert_return_type{};
+        }
+        else
+        {
+            return typename AllocatorAware::iterator{};
+        }
+    })>;
+
+    using BoundReturnType = std::conditional_t<multi, iterator, std::pair<iterator, iterator>>;
+    using BoundConstReturnType = std::conditional_t<multi, const_iterator, std::pair<const_iterator, const_iterator>>;
+
+    using AllocatorAware::AllocatorAware;
+    using AllocatorAware::begin;
+    using AllocatorAware::end;
+
+    constexpr Unordered();
+    constexpr Unordered(size_type, hasher const&, key_equal const&);
+    constexpr Unordered(size_type, hasher const&);
+    constexpr Unordered(size_type);
+    constexpr Unordered(iterator, iterator, size_type, hasher const&, key_equal const&);
+    constexpr Unordered(iterator, iterator, size_type, hasher const&);
+    constexpr Unordered(iterator, iterator, size_type);
+    constexpr Unordered(iterator, iterator);
+    //constexpr Unordered(iterator, iterator, key_compare const&);
+#if (__cpp_lib_containers_ranges >= 202202L)
+    constexpr Unordered(std::from_range_t, ranges::range auto, size_type, hasher const&, key_equal const&);
+    constexpr Unordered(std::from_range_t, ranges::range auto, size_type, hasher const&);
+    constexpr Unordered(std::from_range_t, ranges::range auto, size_type);
+    constexpr Unordered(std::from_range_t, ranges::range auto);
+#endif // (__cpp_lib_containers_ranges >= 202202L)
+    constexpr Unordered(std::initializer_list<value_type>, size_type, hasher const&, key_equal const&);
+    constexpr Unordered(std::initializer_list<value_type>, size_type, hasher const&);
+    constexpr Unordered(std::initializer_list<value_type>, size_type);
+    constexpr Unordered(std::initializer_list<value_type>);
+    constexpr Unordered(Unordered const&);
+    constexpr Unordered(Unordered&&);
+    constexpr Unordered& operator=(Unordered const&);
+    constexpr Unordered& operator=(Unordered&&);
+    constexpr Unordered& operator=(std::initializer_list<value_type>);
+
+    constexpr allocator_type get_allocator() const noexcept;
+
+    constexpr hasher hash_function() const;
+    constexpr key_equal key_eq() const;
+
+    constexpr InsertReturnType emplace(auto... args);
+    constexpr iterator emplace_hint(iterator, auto... args);
+
+    constexpr InsertReturnType insert(value_type);
+    constexpr iterator insert(const_iterator, value_type);
+    constexpr void insert(const_iterator, const_iterator);
+#if (__cpp_lib_containers_ranges >= 202202L)
+    constexpr void insert_range(ranges::range auto);
+#endif // (__cpp_lib_containers_ranges >= 202202L)
+    constexpr void insert(std::initializer_list<value_type>);
+    constexpr InsertNodeHandleReturnType insert(node_type&&);
+    constexpr iterator insert(const_iterator, node_type&&);
+
+    constexpr node_type extract(key_type);
+    constexpr node_type extract(const_iterator);
+
+    constexpr void merge(Unordered const&);
+    
+    constexpr iterator erase(iterator);
+    constexpr iterator erase(const_iterator);
+    constexpr iterator erase(iterator, iterator);
+    constexpr iterator erase(const_iterator, const_iterator);
+    constexpr size_type erase(key_type const&);
+
+    constexpr void clear();
+
+    constexpr iterator find(key_type const&);
+    constexpr const_iterator find(key_type const&) const;
+    
+    constexpr size_type count(key_type const&) const;
+
+    constexpr bool contains(key_type const&) const;
+
+    BoundReturnType equal_range(key_type const&);
+    BoundConstReturnType equal_range(key_type const&) const;
+
+    constexpr size_type bucket_count() const;
+    constexpr size_type max_bucket_count() const;
+    constexpr size_type bucket(size_type) const;
+    constexpr size_type bucket_size(size_type) const;
+    constexpr local_iterator begin(size_type) noexcept;
+    constexpr local_iterator end(size_type) noexcept;
+    constexpr const_local_iterator begin(size_type) const noexcept;
+    constexpr const_local_iterator end(size_type) const noexcept;
+    constexpr float load_factor() const;
+    constexpr float max_load_factor() const;
+    constexpr void max_load_factor(float);
+
+    constexpr void rehash(size_type);
+    constexpr void reserve(size_type);
+
+    constexpr auto operator<=>(Unordered const&) const = default;
+
+
+};
+
+} // namespace morpheus::containers::concepts::archtypes 
diff --git a/libraries/core/tests/CMakeLists.txt b/libraries/core/tests/CMakeLists.txt
index 863f870d..d9d72990 100644
--- a/libraries/core/tests/CMakeLists.txt
+++ b/libraries/core/tests/CMakeLists.txt
@@ -23,6 +23,7 @@ target_link_libraries(MorpheusCoreTests
 
 add_subdirectory(base)
 add_subdirectory(conformance)
+add_subdirectory(containers)
 add_subdirectory(conversion)
 add_subdirectory(functional)
 add_subdirectory(memory)
diff --git a/libraries/core/tests/containers/CMakeLists.txt b/libraries/core/tests/containers/CMakeLists.txt
new file mode 100644
index 00000000..e632a43f
--- /dev/null
+++ b/libraries/core/tests/containers/CMakeLists.txt
@@ -0,0 +1 @@
+add_subdirectory(concepts)
\ No newline at end of file
diff --git a/libraries/core/tests/containers/concepts/CMakeLists.txt b/libraries/core/tests/containers/concepts/CMakeLists.txt
new file mode 100644
index 00000000..19cc99f6
--- /dev/null
+++ b/libraries/core/tests/containers/concepts/CMakeLists.txt
@@ -0,0 +1,10 @@
+target_sources(MorpheusCoreTests
+    PRIVATE
+        allocator_aware.tests.cpp
+        associative.tests.cpp
+        container.tests.cpp
+        contiguous.tests.cpp
+        reversible.tests.cpp
+        sequence.tests.cpp
+        unordered.tests.cpp
+)
\ No newline at end of file
diff --git a/libraries/core/tests/containers/concepts/allocator_aware.tests.cpp b/libraries/core/tests/containers/concepts/allocator_aware.tests.cpp
new file mode 100644
index 00000000..075fe1af
--- /dev/null
+++ b/libraries/core/tests/containers/concepts/allocator_aware.tests.cpp
@@ -0,0 +1,38 @@
+#include "morpheus/containers/concepts/archtypes/allocator_aware.hpp"
+#include "morpheus/core/containers/concepts/allocator_aware.hpp"
+
+#include <catch2/catch_all.hpp>
+
+#include <array>
+#include <deque>
+#include <forward_list>
+#include <list>
+#include <map>
+#include <set>
+#include <unordered_set>
+#include <unordered_map>
+#include <vector>
+
+namespace morpheus::containers::concepts
+{
+
+TEMPLATE_TEST_CASE("Verify allocator aware containers concepts", "[morpheus.containers.concepts.allocator_aware]", bool, std::int8_t, std::uint8_t, std::int16_t, std::uint16_t, std::int32_t, std::uint32_t, std::int64_t, std::uint64_t, float, double)
+{
+    SECTION("Archtype test")
+    {
+        STATIC_REQUIRE(AllocatorAware<archtypes::AllocatorAware>);
+    }
+    SECTION("STL container tests")
+    {
+        STATIC_REQUIRE(AllocatorAware<std::deque<TestType>>);
+        STATIC_REQUIRE(AllocatorAware<std::forward_list<TestType>>);
+        STATIC_REQUIRE(AllocatorAware<std::list<TestType>>);
+        STATIC_REQUIRE(AllocatorAware<std::map<TestType, TestType>>);
+        STATIC_REQUIRE(AllocatorAware<std::set<TestType>>);
+        STATIC_REQUIRE(AllocatorAware<std::unordered_set<TestType>>);
+        STATIC_REQUIRE(AllocatorAware<std::unordered_map<TestType, TestType>>);
+        STATIC_REQUIRE(AllocatorAware<std::vector<TestType>>);
+    }
+}
+
+} // namespace morpheus::containers::concepts
diff --git a/libraries/core/tests/containers/concepts/associative.tests.cpp b/libraries/core/tests/containers/concepts/associative.tests.cpp
new file mode 100644
index 00000000..8da88390
--- /dev/null
+++ b/libraries/core/tests/containers/concepts/associative.tests.cpp
@@ -0,0 +1,45 @@
+#include "morpheus/containers/concepts/archtypes/associative.hpp"
+#include "morpheus/core/containers/concepts/associative.hpp"
+
+#include <catch2/catch_all.hpp>
+
+#include <array>
+#include <deque>
+#include <forward_list>
+#include <list>
+#include <map>
+#include <set>
+#include <unordered_set>
+#include <unordered_map>
+#include <vector>
+
+namespace morpheus::containers::concepts
+{
+
+TEMPLATE_TEST_CASE("Verify associative containers concepts", "[morpheus.containers.concepts.associative]", bool, std::int8_t, std::uint8_t, std::int16_t, std::uint16_t, std::int32_t, std::uint32_t, std::int64_t, std::uint64_t, float, double)
+{
+    SECTION("Archtype test")
+    {
+        STATIC_REQUIRE(Associative<archtypes::Associative<false, false>>);
+        STATIC_REQUIRE(Associative<archtypes::Associative<true, false>>);
+        STATIC_REQUIRE(Associative<archtypes::Associative<false, true>>);
+        STATIC_REQUIRE(Associative<archtypes::Associative<true, true>>);
+    }
+    SECTION("STL container tests")
+    {
+        STATIC_REQUIRE(!Associative<std::deque<TestType>>);
+        STATIC_REQUIRE(!Associative<std::forward_list<TestType>>);
+        STATIC_REQUIRE(!Associative<std::list<TestType>>);
+        STATIC_REQUIRE(Associative<std::map<TestType, TestType>>);
+        STATIC_REQUIRE(Associative<std::multimap<TestType, TestType>>);
+        STATIC_REQUIRE(Associative<std::multiset<TestType>>);
+        STATIC_REQUIRE(Associative<std::set<TestType>>);
+        STATIC_REQUIRE(!Associative<std::unordered_map<TestType, TestType>>);
+        STATIC_REQUIRE(!Associative<std::unordered_multimap<TestType, TestType>>);
+        STATIC_REQUIRE(!Associative<std::unordered_multiset<TestType>>);
+        STATIC_REQUIRE(!Associative<std::unordered_set<TestType>>);
+        STATIC_REQUIRE(!Associative<std::vector<TestType>>);
+    }
+}
+
+} // namespace morpheus::containers::concepts
diff --git a/libraries/core/tests/containers/concepts/container.tests.cpp b/libraries/core/tests/containers/concepts/container.tests.cpp
new file mode 100644
index 00000000..ca8fc74e
--- /dev/null
+++ b/libraries/core/tests/containers/concepts/container.tests.cpp
@@ -0,0 +1,44 @@
+#include "morpheus/containers/concepts/archtypes/container.hpp"
+#include "morpheus/core/containers/concepts/container.hpp"
+#include "morpheus/core/meta/is_specialisation.hpp"
+
+#include <catch2/catch_all.hpp>
+
+#include <array>
+#include <deque>
+#include <forward_list>
+#include <list>
+#include <map>
+#include <set>
+#include <unordered_set>
+#include <unordered_map>
+#include <vector>
+
+namespace morpheus::containers::concepts
+{
+
+TEMPLATE_TEST_CASE("Verify containers concepts", "[morpheus.containers.concepts.container]", bool, std::int8_t, std::uint8_t, std::int16_t, std::uint16_t, std::int32_t, std::uint32_t, std::int64_t, std::uint64_t, float, double)
+{
+    SECTION("Archtype test")
+    {
+        STATIC_REQUIRE(Container<archtypes::Container>);
+    }
+    SECTION("STL container tests")
+    {
+        STATIC_REQUIRE(Container<std::array<TestType, 10>>);
+        STATIC_REQUIRE(Container<std::deque<TestType>>);
+        STATIC_REQUIRE(Container<std::forward_list<TestType>>);
+        STATIC_REQUIRE(Container<std::list<TestType>>);
+        STATIC_REQUIRE(Container<std::map<TestType, TestType>>);
+        STATIC_REQUIRE(Container<std::multimap<TestType, TestType>>);
+        STATIC_REQUIRE(Container<std::multiset<TestType>>);
+        STATIC_REQUIRE(Container<std::set<TestType>>);
+        STATIC_REQUIRE(Container<std::unordered_map<TestType, TestType>>);
+        STATIC_REQUIRE(Container<std::unordered_multimap<TestType, TestType>>);
+        STATIC_REQUIRE(Container<std::unordered_multiset<TestType>>);
+        STATIC_REQUIRE(Container<std::unordered_set<TestType>>);
+        STATIC_REQUIRE(Container<std::vector<TestType>>);
+    }
+}
+
+} // namespace morpheus::containers::concepts
diff --git a/libraries/core/tests/containers/concepts/contiguous.tests.cpp b/libraries/core/tests/containers/concepts/contiguous.tests.cpp
new file mode 100644
index 00000000..a43c3ca9
--- /dev/null
+++ b/libraries/core/tests/containers/concepts/contiguous.tests.cpp
@@ -0,0 +1,51 @@
+#include "morpheus/containers/concepts/archtypes/sequence.hpp"
+#include "morpheus/core/containers/concepts/contiguous.hpp"
+#include "morpheus/core/meta/is_specialisation.hpp"
+
+#include <catch2/catch_all.hpp>
+
+#include <array>
+#include <deque>
+#include <forward_list>
+#include <list>
+#include <map>
+#include <set>
+#include <unordered_set>
+#include <unordered_map>
+#include <vector>
+
+namespace morpheus::containers::concepts
+{
+
+TEMPLATE_TEST_CASE("Verify contiguous containers concepts", "[morpheus.containers.concepts.contiguous]", bool, std::int8_t, std::uint8_t, std::int16_t, std::uint16_t, std::int32_t, std::uint32_t, std::int64_t, std::uint64_t, float, double)
+{
+    SECTION("Archtype test")
+    {
+        STATIC_REQUIRE(Contiguous<archtypes::Sequence>);
+    }
+    SECTION("STL container tests")
+    {
+        STATIC_REQUIRE(Contiguous<std::array<TestType, 10>>);
+        STATIC_REQUIRE(!Contiguous<std::deque<TestType>>);
+        STATIC_REQUIRE(!Contiguous<std::forward_list<TestType>>);
+        STATIC_REQUIRE(!Contiguous<std::list<TestType>>);
+        STATIC_REQUIRE(!Contiguous<std::map<TestType, TestType>>);
+        STATIC_REQUIRE(!Contiguous<std::multimap<TestType, TestType>>);
+        STATIC_REQUIRE(!Contiguous<std::multiset<TestType>>);
+        STATIC_REQUIRE(!Contiguous<std::set<TestType>>);
+        STATIC_REQUIRE(!Contiguous<std::unordered_map<TestType, TestType>>);
+        STATIC_REQUIRE(!Contiguous<std::unordered_multimap<TestType, TestType>>);
+        STATIC_REQUIRE(!Contiguous<std::unordered_multiset<TestType>>);
+        STATIC_REQUIRE(!Contiguous<std::unordered_set<TestType>>);
+        if constexpr(std::is_same_v<TestType, bool>)
+        {
+            STATIC_REQUIRE(!Contiguous<std::vector<TestType>>);
+        }
+        else
+        {
+            STATIC_REQUIRE(Contiguous<std::vector<TestType>>);
+        }
+    }
+}
+
+} // namespace morpheus::containers::concepts
diff --git a/libraries/core/tests/containers/concepts/reversible.tests.cpp b/libraries/core/tests/containers/concepts/reversible.tests.cpp
new file mode 100644
index 00000000..1fa7275f
--- /dev/null
+++ b/libraries/core/tests/containers/concepts/reversible.tests.cpp
@@ -0,0 +1,43 @@
+#include "morpheus/containers/concepts/archtypes/reversible.hpp"
+#include "morpheus/core/containers/concepts/reversible.hpp"
+
+#include <catch2/catch_all.hpp>
+
+#include <array>
+#include <deque>
+#include <forward_list>
+#include <list>
+#include <map>
+#include <set>
+#include <unordered_set>
+#include <unordered_map>
+#include <vector>
+
+namespace morpheus::containers::concepts
+{
+
+TEMPLATE_TEST_CASE("Verify containers concepts", "[morpheus.containers.concepts.iterator]", bool, std::int8_t, std::uint8_t, std::int16_t, std::uint16_t, std::int32_t, std::uint32_t, std::int64_t, std::uint64_t, float, double)
+{
+    SECTION("Archtype test")
+    {
+        STATIC_REQUIRE(Reversible<archtypes::Reversible>);
+    }
+    SECTION("STL container tests")
+    {
+        STATIC_REQUIRE(Reversible<std::array<TestType, 10>>);
+        STATIC_REQUIRE(Reversible<std::deque<TestType>>);
+        STATIC_REQUIRE(!Reversible<std::forward_list<TestType>>);
+        STATIC_REQUIRE(Reversible<std::list<TestType>>);
+        STATIC_REQUIRE(Reversible<std::map<TestType, TestType>>);
+        STATIC_REQUIRE(Reversible<std::multimap<TestType, TestType>>);
+        STATIC_REQUIRE(Reversible<std::multiset<TestType>>);
+        STATIC_REQUIRE(Reversible<std::set<TestType>>);
+        STATIC_REQUIRE(!Reversible<std::unordered_map<TestType, TestType>>);
+        STATIC_REQUIRE(!Reversible<std::unordered_multimap<TestType, TestType>>);
+        STATIC_REQUIRE(!Reversible<std::unordered_multiset<TestType>>);
+        STATIC_REQUIRE(!Reversible<std::unordered_set<TestType>>);
+        STATIC_REQUIRE(Reversible<std::vector<TestType>>);
+    }
+}
+
+} // namespace morpheus::containers::concepts
diff --git a/libraries/core/tests/containers/concepts/sequence.tests.cpp b/libraries/core/tests/containers/concepts/sequence.tests.cpp
new file mode 100644
index 00000000..c737f2b8
--- /dev/null
+++ b/libraries/core/tests/containers/concepts/sequence.tests.cpp
@@ -0,0 +1,42 @@
+#include "morpheus/containers/concepts/archtypes/sequence.hpp"
+#include "morpheus/core/containers/concepts/sequence.hpp"
+
+#include <catch2/catch_all.hpp>
+
+#include <array>
+#include <deque>
+#include <forward_list>
+#include <list>
+#include <string>
+#include <vector>
+
+namespace morpheus::containers::concepts
+{
+
+TEMPLATE_TEST_CASE("Verify sequence containers concepts", "[morpheus.containers.concepts.sequence]", bool, std::int8_t, std::uint8_t, std::int16_t, std::uint16_t, std::int32_t, std::uint32_t, std::int64_t, std::uint64_t, float, double)
+{
+    SECTION("Archtype test")
+    {
+        STATIC_REQUIRE(Sequence<archtypes::Sequence>);
+    }
+    SECTION("STL container tests")
+    {
+        STATIC_REQUIRE(!Sequence<std::array<TestType, 10>>);
+        STATIC_REQUIRE(Sequence<std::deque<TestType>>);
+        STATIC_REQUIRE(!Sequence<std::forward_list<TestType>>);
+        STATIC_REQUIRE(Sequence<std::list<TestType>>);
+        STATIC_REQUIRE(!Sequence<std::string>);
+        STATIC_REQUIRE(Sequence<std::vector<TestType>>);
+    }
+    SECTION("Test strict sequence matches exact STL sequence containers")
+    {
+        STATIC_REQUIRE(StrictSequence<std::array<TestType, 10>>);
+        STATIC_REQUIRE(StrictSequence<std::deque<TestType>>);
+        STATIC_REQUIRE(StrictSequence<std::forward_list<TestType>>);
+        STATIC_REQUIRE(StrictSequence<std::list<TestType>>);
+        STATIC_REQUIRE(StrictSequence<std::string>);
+        STATIC_REQUIRE(StrictSequence<std::vector<TestType>>);
+    }
+}
+
+}
\ No newline at end of file
diff --git a/libraries/core/tests/containers/concepts/unordered.tests.cpp b/libraries/core/tests/containers/concepts/unordered.tests.cpp
new file mode 100644
index 00000000..9b221596
--- /dev/null
+++ b/libraries/core/tests/containers/concepts/unordered.tests.cpp
@@ -0,0 +1,45 @@
+#include "morpheus/containers/concepts/archtypes/unordered.hpp"
+#include "morpheus/core/containers/concepts/unordered.hpp"
+
+#include <catch2/catch_all.hpp>
+
+#include <array>
+#include <deque>
+#include <forward_list>
+#include <list>
+#include <map>
+#include <set>
+#include <unordered_set>
+#include <unordered_map>
+#include <vector>
+
+namespace morpheus::containers::concepts
+{
+
+TEMPLATE_TEST_CASE("Verify unordered containers concepts", "[morpheus.containers.concepts.unordered]", bool, std::int8_t, std::uint8_t, std::int16_t, std::uint16_t, std::int32_t, std::uint32_t, std::int64_t, std::uint64_t, float, double)
+{
+    SECTION("Archtype test")
+    {
+        STATIC_REQUIRE(Unordered<archtypes::Unordered<false, false>>);
+        STATIC_REQUIRE(Unordered<archtypes::Unordered<true, false>>);
+        STATIC_REQUIRE(Unordered<archtypes::Unordered<false, true>>);
+        STATIC_REQUIRE(Unordered<archtypes::Unordered<true, true>>);
+    }
+    SECTION("STL container tests")
+    {
+        STATIC_REQUIRE(!Unordered<std::deque<TestType>>);
+        STATIC_REQUIRE(!Unordered<std::forward_list<TestType>>);
+        STATIC_REQUIRE(!Unordered<std::list<TestType>>);
+        STATIC_REQUIRE(!Unordered<std::map<TestType, TestType>>);
+        STATIC_REQUIRE(!Unordered<std::multimap<TestType, TestType>>);
+        STATIC_REQUIRE(!Unordered<std::multiset<TestType>>);
+        STATIC_REQUIRE(!Unordered<std::set<TestType>>);
+        STATIC_REQUIRE(Unordered<std::unordered_map<TestType, TestType>>);
+        STATIC_REQUIRE(Unordered<std::unordered_multimap<TestType, TestType>>);
+        STATIC_REQUIRE(Unordered<std::unordered_multiset<TestType>>);
+        STATIC_REQUIRE(Unordered<std::unordered_set<TestType>>);
+        STATIC_REQUIRE(!Unordered<std::vector<TestType>>);
+    }
+}
+
+} // namespace morpheus::containers::concepts
diff --git a/libraries/core/tests/meta/CMakeLists.txt b/libraries/core/tests/meta/CMakeLists.txt
index b02c405c..783d6633 100644
--- a/libraries/core/tests/meta/CMakeLists.txt
+++ b/libraries/core/tests/meta/CMakeLists.txt
@@ -4,6 +4,7 @@ target_sources(MorpheusCoreTests
 #        binary_search.tests.cpp
         complete.tests.cpp
         invocable_traits.tests.cpp
+        is_array.tests.cpp
         is_specialisation.tests.cpp
         is_string.tests.cpp
         satisfies.tests.cpp
diff --git a/libraries/core/tests/meta/is_array.tests.cpp b/libraries/core/tests/meta/is_array.tests.cpp
new file mode 100644
index 00000000..c6bd3aff
--- /dev/null
+++ b/libraries/core/tests/meta/is_array.tests.cpp
@@ -0,0 +1,39 @@
+#include "morpheus/core/meta/concepts/string.hpp"
+#include "morpheus/core/meta/is_array.hpp"
+
+#include <catch2/catch_all.hpp>
+
+#include <array>
+#include <cstdint>
+#include <vector>
+
+namespace morpheus::meta
+{
+
+TEST_CASE("Meta is array allows the compile time detection of std::array specialisations", "[morpheus.meta.is_array]")
+{
+    STATIC_REQUIRE(meta::is_array_v<std::array<std::int8_t, 1>>);
+    STATIC_REQUIRE(meta::is_array_v<std::array<std::uint8_t, 2>>);
+    STATIC_REQUIRE(meta::is_array_v<std::array<std::int16_t, 4>>);
+    STATIC_REQUIRE(meta::is_array_v<std::array<std::uint16_t, 8>>);
+    STATIC_REQUIRE(meta::is_array_v<std::array<std::int32_t, 16>>);
+    STATIC_REQUIRE(meta::is_array_v<std::array<std::uint32_t, 32>>);
+    STATIC_REQUIRE(meta::is_array_v<std::array<std::int64_t, 64>>);
+    STATIC_REQUIRE(meta::is_array_v<std::array<std::uint64_t, 128>>);
+    STATIC_REQUIRE(meta::is_array_v<std::array<float, 256>>);
+    STATIC_REQUIRE(meta::is_array_v<std::array<double, 512>>);
+    STATIC_REQUIRE(meta::is_array_v<std::array<bool, 1024>>);
+    STATIC_REQUIRE(!meta::is_array_v<std::vector<bool>>);
+    STATIC_REQUIRE(!meta::is_array_v<bool>);
+    STATIC_REQUIRE(!meta::is_array_v<std::uint8_t>);
+    STATIC_REQUIRE(!meta::is_array_v<std::int16_t>);
+    STATIC_REQUIRE(!meta::is_array_v<std::uint16_t>);
+    STATIC_REQUIRE(!meta::is_array_v<std::int32_t>);
+    STATIC_REQUIRE(!meta::is_array_v<std::uint32_t>);
+    STATIC_REQUIRE(!meta::is_array_v<std::int64_t>);
+    STATIC_REQUIRE(!meta::is_array_v<std::uint64_t>);
+    STATIC_REQUIRE(!meta::is_array_v<float>);
+    STATIC_REQUIRE(!meta::is_array_v<double>);
+}
+
+}
\ No newline at end of file

From 45d48142afb11db0470f18163909751fd74b94a3 Mon Sep 17 00:00:00 2001
From: Antony Peacock <ant.peacock@gmail.com>
Date: Wed, 26 Jun 2024 21:38:00 +0100
Subject: [PATCH 4/4] Fix namespace

---
 libraries/core/tests/cmake/asan.tests.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/libraries/core/tests/cmake/asan.tests.cpp b/libraries/core/tests/cmake/asan.tests.cpp
index 0b838cde..9cb959f6 100644
--- a/libraries/core/tests/cmake/asan.tests.cpp
+++ b/libraries/core/tests/cmake/asan.tests.cpp
@@ -3,7 +3,7 @@
 #include <memory>
 #include <functional>
 
-namespace quantbox
+namespace morpheus
 {
 
 TEST_CASE("Ensure the address sanitizer detects unsafe use after free memory usage", "[quantbox.cmake.asan]")
@@ -15,4 +15,4 @@ TEST_CASE("Ensure the address sanitizer detects unsafe use after free memory usa
     dangling.get() = 0; // If asan works this is an error!
 }
 
-} // quantbox
+} // morpheus