diff --git a/cpp/csp/engine/CspType.cpp b/cpp/csp/engine/CspType.cpp
index c5d2599e..884fc17c 100644
--- a/cpp/csp/engine/CspType.cpp
+++ b/cpp/csp/engine/CspType.cpp
@@ -27,16 +27,19 @@ INIT_CSP_ENUM( CspType::Type,
            "DIALECT_GENERIC" 
     );
 
-CspTypePtr & CspArrayType::create( const CspTypePtr & elemType )
+CspTypePtr & CspArrayType::create( const CspTypePtr & elemType, bool isPyStructFastList )
 {
-    using Cache = std::unordered_map<const CspType*,CspTypePtr>;
+    using Cache = std::unordered_map<const CspType *, CspTypePtr>;
     static std::mutex s_mutex;
     static Cache      s_cache;
+    static Cache      s_pyStructFastListCache;
+
+    auto & cache = isPyStructFastList ? s_pyStructFastListCache : s_cache;
 
     std::lock_guard<std::mutex> guard( s_mutex );
-    auto rv = s_cache.emplace( elemType.get(), nullptr );
+    auto rv = cache.emplace( elemType.get(), nullptr );
     if( rv.second )
-        rv.first -> second = std::make_shared<CspArrayType>( elemType );
+        rv.first -> second = std::make_shared<CspArrayType>( elemType, isPyStructFastList );
     return rv.first -> second;
 }
 
diff --git a/cpp/csp/engine/CspType.h b/cpp/csp/engine/CspType.h
index 2ad7c0b9..b85ab414 100644
--- a/cpp/csp/engine/CspType.h
+++ b/cpp/csp/engine/CspType.h
@@ -170,19 +170,21 @@ class CspStructType : public CspType
 class CspArrayType : public CspType
 {
 public:
-    CspArrayType( CspTypePtr elemType ) : CspType( CspType::Type::ARRAY ),
-                                          m_elemType( elemType )
+    CspArrayType( CspTypePtr elemType, bool isPyStructFastList = false ) :
+        CspType( CspType::Type::ARRAY ), m_elemType( elemType ), m_isPyStructFastList( isPyStructFastList )
     {}
     ~CspArrayType() {}
 
     const CspTypePtr & elemType() const { return m_elemType; }
+    bool isPyStructFastList() const     { return m_isPyStructFastList; }
 
     //Used by BURST mode to avoid creating more instances of CspArrayTypes than needed
     //returns CspArrayType with the given elemType
-    static CspTypePtr & create( const CspTypePtr & elemType );
+    static CspTypePtr & create( const CspTypePtr & elemType, bool isPyStructFastList = false );
 
 private:
     CspTypePtr m_elemType;
+    bool       m_isPyStructFastList;
 };
 
 template<> struct CspType::TypeTraits::fromCType<bool>                     { static constexpr CspType::TypeTraits::_enum type = CspType::TypeTraits::BOOL;            };
diff --git a/cpp/csp/python/CMakeLists.txt b/cpp/csp/python/CMakeLists.txt
index c4879410..5242a63f 100644
--- a/cpp/csp/python/CMakeLists.txt
+++ b/cpp/csp/python/CMakeLists.txt
@@ -5,7 +5,9 @@ set(CSPTYPESIMPL_PUBLIC_HEADERS
         PyCspType.h
         PyStruct.h
         PyStructList.h
-        PyStructList_impl.h)
+        PyStructList_impl.h
+        PyStructFastList.h
+        PyStructFastList_impl.h)
 
 add_library(csptypesimpl
             csptypesimpl.cpp
@@ -13,7 +15,10 @@ add_library(csptypesimpl
             PyCspEnum.cpp
             PyCspType.cpp
             PyStruct.cpp
-            PyStructToJson.cpp)
+            PyStructToJson.cpp
+            PyStructList_impl.h
+            PyStructFastList_impl.h
+            VectorWrapper.h)
 set_target_properties(csptypesimpl PROPERTIES PUBLIC_HEADER "${CSPTYPESIMPL_PUBLIC_HEADERS}")
 target_compile_definitions(csptypesimpl PUBLIC RAPIDJSON_HAS_STDSTRING=1)
 target_link_libraries(csptypesimpl csp_core csp_types)
@@ -43,9 +48,7 @@ set(CSPIMPL_PUBLIC_HEADERS
         PyOutputAdapterWrapper.h
         PyOutputProxy.h
         PyConstants.h
-        PyStructToJson.h
-        PyStructList.h
-        PyStructList_impl.h)
+        PyStructToJson.h)
 
 add_library(cspimpl SHARED
         cspimpl.cpp
diff --git a/cpp/csp/python/Conversions.h b/cpp/csp/python/Conversions.h
index 85f1df66..1fe10f56 100644
--- a/cpp/csp/python/Conversions.h
+++ b/cpp/csp/python/Conversions.h
@@ -14,6 +14,7 @@
 #include <csp/python/PyCspType.h>
 #include <csp/python/PyObjectPtr.h>
 #include <csp/python/PyStruct.h>
+#include <csp/python/PyStructFastList.h>
 #include <csp/python/PyStructList.h>
 #include <Python.h>
 #include <string>
@@ -81,7 +82,7 @@ inline T fromPython( PyObject * o )
     return T{};
 }
 
-//work around for inabilty to partially spcialize fromPython on vector<T>
+//work around for inabilty to partially specialize fromPython on vector<T>
 template<typename T>
 struct FromPython
 {
@@ -768,11 +769,11 @@ inline PyObject * toPython( const DictionaryPtr & value)
 }
 
 template<typename StorageT>
-inline PyObject * toPython( const std::vector<StorageT> & v, const CspType & type )
+inline PyObject * toPython( const std::vector<StorageT> & v, const CspType & arrayType )
 {
-    assert( type.type() == CspType::Type::ARRAY );
+    assert( arrayType.type() == CspType::Type::ARRAY );
 
-    const CspType & elemType = *static_cast<const CspArrayType &>( type ).elemType();
+    const CspType & elemType = *static_cast<const CspArrayType &>( arrayType ).elemType();
     size_t size = v.size();
     PyObjectPtr list = PyObjectPtr::check( PyList_New( size ) );
 
@@ -785,18 +786,27 @@ inline PyObject * toPython( const std::vector<StorageT> & v, const CspType & typ
 }
 
 template<typename StorageT>
-inline PyObject * toPython( const std::vector<StorageT> & v, const CspType & type, const PyStruct * pystruct )
+inline PyObject * toPython( const std::vector<StorageT> & v, const CspType & arrayType, const PyStruct * pystruct )
 {
-    assert( type.type() == CspType::Type::ARRAY );
+    assert( arrayType.type() == CspType::Type::ARRAY );
 
-    const CspTypePtr elemType = static_cast<const CspArrayType &>( type ).elemType();
+    const CspArrayType & cspArrayType = static_cast<const CspArrayType &>( arrayType );
+    const CspTypePtr elemType = cspArrayType.elemType();
     using ElemT = typename CspType::Type::toCArrayElemType<StorageT>::type;
     size_t sz = v.size();
 
+    // Create PyStructFastList when requested
+    if( cspArrayType.isPyStructFastList() )
+    {
+        PyObject * fl = PyStructFastList<StorageT>::PyType.tp_alloc( &PyStructFastList<StorageT>::PyType, 0 );
+        new ( fl ) PyStructFastList<StorageT>( const_cast<PyStruct *>( pystruct ), const_cast<std::vector<StorageT> &>( v ), cspArrayType );
+        return fl;
+    }
+    // Create PyStructList otherwise
     // TODO: Implement more efficient list allocation by pre-allocating the space and filling it using PyList_SET_ITEM.
     // As of now, the problem is that Python is not allowing to resize the list via API, and it cannot allocate the list at the base of PyStructList, it can only allocate it somewhere in memory not under control.
     PyObject * psl = PyStructList<StorageT>::PyType.tp_alloc( &PyStructList<StorageT>::PyType, 0 );
-    new ( psl ) PyStructList<StorageT>( const_cast<PyStruct *>( pystruct ), const_cast<std::vector<StorageT> &>( v ), *elemType );
+    new ( psl ) PyStructList<StorageT>( const_cast<PyStruct *>( pystruct ), const_cast<std::vector<StorageT> &>( v ), cspArrayType );
 
     for( size_t index = 0; index < sz; ++index )
     {
@@ -810,15 +820,16 @@ inline PyObject * toPython( const std::vector<StorageT> & v, const CspType & typ
 template<typename StorageT>
 struct FromPython<std::vector<StorageT>>
 {
-    static std::vector<StorageT> impl( PyObject * o, const CspType & type )
+    static std::vector<StorageT> impl( PyObject * o, const CspType & arrayType )
     {
-        assert( type.type() == CspType::Type::ARRAY );
-        const CspType & elemType = *static_cast<const CspArrayType &>( type ).elemType();
+        assert( arrayType.type() == CspType::Type::ARRAY );
 
         using ElemT = typename CspType::Type::toCArrayElemType<StorageT>::type;
 
+        const CspType & elemType = *static_cast<const CspArrayType &>( arrayType ).elemType();
+
         std::vector<StorageT> out;
-        //fast path list and tuples since we can size up front
+        //fast path for list and tuple since we can size up front
         if( PyList_Check( o ) )
         {
             size_t size = PyList_GET_SIZE( o );
diff --git a/cpp/csp/python/CspTypeFactory.cpp b/cpp/csp/python/CspTypeFactory.cpp
index 8e150991..a1bfd027 100644
--- a/cpp/csp/python/CspTypeFactory.cpp
+++ b/cpp/csp/python/CspTypeFactory.cpp
@@ -20,14 +20,24 @@ CspTypePtr & CspTypeFactory::typeFromPyType( PyObject * pyTypeObj )
     // List objects shouldn't be cached since they are temporary objects
     if( PyList_Check( pyTypeObj ) )
     {
-        if( PyList_GET_SIZE( ( PyObject * ) pyTypeObj ) != 1 )
-            CSP_THROW( TypeError, "Expected list types to be single element of sub-type" );
+        if( PyList_GET_SIZE( ( PyObject * ) pyTypeObj ) != 1 && PyList_GET_SIZE( ( PyObject * ) pyTypeObj ) != 2 )
+            CSP_THROW( TypeError, "Expected list types post-normalization to be one or two elements: sub-type and optional FastList flag" );
 
         PyObject *pySubType = PyList_GET_ITEM( pyTypeObj, 0 );
         if( !PyType_Check( pySubType ) )
             CSP_THROW( TypeError, "nested typed lists are not supported" );
+
+        bool useFastList = false;
+        if( PyList_GET_SIZE( ( PyObject * ) pyTypeObj ) == 2 )
+        {
+            PyObject *pyUseFastList = PyList_GET_ITEM( pyTypeObj, 1 );
+            if( !PyBool_Check( pyUseFastList ) || pyUseFastList != Py_True )
+                CSP_THROW( TypeError, "expected bool True as second list type argument" );
+            useFastList = true;
+        }
+
         CspTypePtr elemType = typeFromPyType( pySubType );
-        return CspArrayType::create( elemType );
+        return CspArrayType::create( elemType, useFastList );
     }
 
     PyTypeObject *pyType = (PyTypeObject*) pyTypeObj;
diff --git a/cpp/csp/python/PyObjectPtr.h b/cpp/csp/python/PyObjectPtr.h
index 0fa66bff..448b10f3 100644
--- a/cpp/csp/python/PyObjectPtr.h
+++ b/cpp/csp/python/PyObjectPtr.h
@@ -38,19 +38,11 @@ class PyPtr
         return *this;
     }
 
-    bool operator==( const PyPtr & rhs ) const
-    {
-        if( m_obj == rhs.m_obj )
-            return true;
+    bool operator==( const PyPtr & rhs ) const { return generic_compare( rhs, Py_EQ ); }
 
-        if( !m_obj || !rhs.m_obj )
-            return false;
+    bool operator<( const PyPtr & rhs ) const { return generic_compare( rhs, Py_LT ); }
 
-        int rv = PyObject_RichCompareBool( m_obj, rhs.m_obj, Py_EQ );
-        if( rv == -1 )
-            CSP_THROW( PythonPassthrough, "" );
-        return rv == 1;
-    }
+    bool operator>( const PyPtr & rhs ) const { return generic_compare( rhs, Py_GT ); }
 
     operator bool() const { return m_obj != nullptr; }
 
@@ -101,6 +93,17 @@ class PyPtr
     PyPtr( PyObjectOwn * o ) { m_obj = ( PYOBJECT_T * ) o; }
 
     PYOBJECT_T * m_obj;
+
+    bool generic_compare( const PyPtr & rhs, int opid ) const
+    {
+        if( !m_obj || !rhs.m_obj )
+            CSP_THROW( PythonPassthrough, "" );
+        
+        int rv = PyObject_RichCompareBool( m_obj, rhs.m_obj, opid );
+        if( rv == -1 )
+            CSP_THROW( PythonPassthrough, "" );
+        return rv;
+    }
 };
 
 using PyObjectPtr     = PyPtr<PyObject>;
diff --git a/cpp/csp/python/PyStruct.cpp b/cpp/csp/python/PyStruct.cpp
index 1a9c9a15..fe30fedf 100644
--- a/cpp/csp/python/PyStruct.cpp
+++ b/cpp/csp/python/PyStruct.cpp
@@ -3,6 +3,7 @@
 #include <csp/python/InitHelper.h>
 #include <csp/python/PyObjectPtr.h>
 #include <csp/python/PyStruct.h>
+#include <csp/python/PyStructFastList_impl.h>
 #include <csp/python/PyStructList_impl.h>
 #include <csp/python/PyStructToJson.h>
 #include <unordered_set>
@@ -477,12 +478,9 @@ void PyStruct::setattr( Struct * s, PyObject * attr, PyObject * value )
 
 // Struct printing code
 
-// forward declarations
+// forward declaration
 void repr_struct( const Struct * struct_, std::string & tl_repr, bool show_unset );
 
-template<typename ElemT>
-void repr_array( const std::vector<ElemT> & val, const CspArrayType & arrayType, std::string & tl_repr, bool show_unset );
-
 // helper functions for formatting to Python standard
 void format_bool( const bool val, std::string & tl_repr ) {  tl_repr += ( ( val ? "True" : "False" ) ); }
 void format_double( const double val, std::string & tl_repr )
@@ -555,14 +553,14 @@ void repr_field( const Struct * struct_, const StructFieldPtr & field, std::stri
             auto const * arrayType = static_cast<const CspArrayType*>( field -> type().get() );
             const CspType * elemType = arrayType -> elemType().get();
 
-            switchCspType( elemType, [ field, struct_, &arrayType, &tl_repr, show_unset ]( auto tag )
+            switchCspType( elemType, [ field, struct_, &elemType, &tl_repr, show_unset ]( auto tag )
             {
                 //workaround for MS compiler bug, separate into two using lines... :/
                 using TagType = decltype( tag );
                 using CElemType = typename TagType::type;
                 using ArrayType = typename CspType::Type::toCArrayType<CElemType>::type;
                 const ArrayType & val = field -> value<ArrayType>( struct_ );
-                repr_array( val, *arrayType, tl_repr, show_unset );
+                repr_array( val, *elemType, tl_repr, show_unset );
             } );
 
             break;
@@ -585,7 +583,7 @@ void repr_field( const Struct * struct_, const StructFieldPtr & field, std::stri
 }
 
 template<typename StorageT>
-void repr_array( const std::vector<StorageT> & val, const CspArrayType & arrayType, std::string & tl_repr, bool show_unset )
+void repr_array( const std::vector<StorageT> & val, const CspType & elemType, std::string & tl_repr, bool show_unset )
 {
     using ElemT = typename CspType::Type::toCArrayElemType<StorageT>::type;
     tl_repr += "[";
@@ -611,11 +609,11 @@ void repr_array( const std::vector<StorageT> & val, const CspArrayType & arrayTy
         else if constexpr( std::is_integral<ElemT>::value )
             tl_repr += std::to_string( *it );
         else if constexpr( is_vector<ElemT>::value )
-            repr_array( *it, static_cast<const CspArrayType&>( arrayType.elemType() ), tl_repr, show_unset ); // recursive, allows for nested arrays!
+            repr_array( *it, elemType, tl_repr, show_unset ); // recursive, allows for nested arrays!
         else
         {
             // if the element is an enum, generic or datetime type, convert to python
-            PyObjectPtr attr = PyObjectPtr::own( toPython( *it, *( arrayType.elemType().get() ) ) );
+            PyObjectPtr attr = PyObjectPtr::own( toPython( *it, elemType ) );
             format_pyobject( attr, tl_repr );
         }
     }
@@ -1022,7 +1020,6 @@ REGISTER_TYPE_INIT( &PyStructMeta::PyType, "PyStructMeta" )
 REGISTER_TYPE_INIT( &PyStruct::PyType,     "PyStruct" )
 
 // Instantiate all templates for PyStructList class
-template struct PyStructList<bool>;
 template struct PyStructList<int8_t>;
 template struct PyStructList<uint8_t>;
 template struct PyStructList<int16_t>;
@@ -1041,4 +1038,23 @@ template struct PyStructList<DialectGenericType>;
 template struct PyStructList<StructPtr>;
 template struct PyStructList<CspEnum>;
 
+// Instantiate all templates for PyStructFastList class
+template struct PyStructFastList<int8_t>;
+template struct PyStructFastList<uint8_t>;
+template struct PyStructFastList<int16_t>;
+template struct PyStructFastList<uint16_t>;
+template struct PyStructFastList<int32_t>;
+template struct PyStructFastList<uint32_t>;
+template struct PyStructFastList<int64_t>;
+template struct PyStructFastList<uint64_t>;
+template struct PyStructFastList<double>;
+template struct PyStructFastList<DateTime>;
+template struct PyStructFastList<TimeDelta>;
+template struct PyStructFastList<Date>;
+template struct PyStructFastList<Time>;
+template struct PyStructFastList<std::string>;
+template struct PyStructFastList<DialectGenericType>;
+template struct PyStructFastList<StructPtr>;
+template struct PyStructFastList<CspEnum>;
+
 }
diff --git a/cpp/csp/python/PyStruct.h b/cpp/csp/python/PyStruct.h
index 2a891985..2034268b 100644
--- a/cpp/csp/python/PyStruct.h
+++ b/cpp/csp/python/PyStruct.h
@@ -78,6 +78,10 @@ struct CSPTYPESIMPL_EXPORT PyStruct : public PyObject
     static PyTypeObject PyType;
 };
 
+// Array struct field printing function
+template<typename ElemT>
+void repr_array( const std::vector<ElemT> & val, const CspType & elemType, std::string & tl_repr, bool show_unset );
+
 }
 
 #endif
diff --git a/cpp/csp/python/PyStructFastList.h b/cpp/csp/python/PyStructFastList.h
new file mode 100644
index 00000000..4c065c48
--- /dev/null
+++ b/cpp/csp/python/PyStructFastList.h
@@ -0,0 +1,43 @@
+#ifndef _IN_CSP_PYTHON_PYSTRUCTFASTLIST_H
+#define _IN_CSP_PYTHON_PYSTRUCTFASTLIST_H
+
+#include <csp/python/Conversions.h>
+#include <csp/python/InitHelper.h>
+#include <csp/python/PyIterator.h>
+#include <csp/python/PyStruct.h>
+#include <csp/python/VectorWrapper.h>
+#include <Python.h>
+#include <vector>
+
+namespace csp::python
+{
+
+template<typename StorageT>
+struct PyStructFastList : public PyObject
+{
+    using ElemT = typename CspType::Type::toCArrayElemType<StorageT>::type;
+
+    PyStructFastList( PyStruct * p, std::vector<StorageT> & v, const CspType & type ) : pystruct( p ), vector( VectorWrapper<StorageT>( v ) ), arrayType( type )
+    {
+        Py_INCREF( pystruct );
+    }
+
+    PyStruct * pystruct;              // Pointer to PyStruct for proper reference counting
+    VectorWrapper<StorageT> vector;   // Field value for modifying
+
+    const CspType & arrayType;        // We require the type information of any non-primitive type, i.e. Struct or Enum, since they contain a meta
+    static PyTypeObject PyType;
+    static bool s_typeRegister;
+
+    inline CspTypePtr elemType() const { return static_cast<const CspArrayType &>( arrayType ).elemType(); }
+
+    inline PyObject * toPythonValue( const StorageT & value ) const;
+    inline StorageT fromPythonValue( PyObject * value ) const;
+};
+
+template<typename StorageT> bool PyStructFastList<StorageT>::s_typeRegister = InitHelper::instance().registerCallback( 
+    InitHelper::typeInitCallback( &PyStructFastList<StorageT>::PyType, "" ) );
+
+}
+
+#endif
diff --git a/cpp/csp/python/PyStructFastList_impl.h b/cpp/csp/python/PyStructFastList_impl.h
new file mode 100644
index 00000000..17dc9653
--- /dev/null
+++ b/cpp/csp/python/PyStructFastList_impl.h
@@ -0,0 +1,675 @@
+#ifndef _IN_CSP_PYTHON_PYSTRUCTFASTLIST_IMPL_H
+#define _IN_CSP_PYTHON_PYSTRUCTFASTLIST_IMPL_H
+
+#include <csp/engine/PartialSwitchCspType.h>
+#include <csp/python/Conversions.h>
+#include <csp/python/InitHelper.h>
+#include <csp/python/PyCspType.h>
+#include <csp/python/PyStruct.h>
+#include <csp/python/PyStructFastList.h>
+#include <csp/python/VectorWrapper.h>
+#include <algorithm>
+
+// The Py_TPFLAGS_SEQUENCE flag is used for 'match' statement to work. It is not available prior Python 3.10, so need to use conditional compilation
+#define IS_PYTHON_3_10_OR_GREATER ( PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION >= 10 )
+#if IS_PYTHON_3_10_OR_GREATER 
+#define SEQ_FLAG Py_TPFLAGS_SEQUENCE 
+#else 
+#define SEQ_FLAG 0 
+#endif
+
+namespace csp::python
+{
+
+template<typename StorageT>
+struct PyStructFastListIterator;
+
+template<typename StorageT>
+struct PyStructFastListReverseIterator;
+
+template<typename StorageT>
+inline PyObject * PyStructFastList<StorageT>::toPythonValue( const StorageT & value ) const
+{
+    return toPython<ElemT>( value, *elemType() );
+}
+
+template<typename StorageT>
+inline StorageT PyStructFastList<StorageT>::fromPythonValue( PyObject * value ) const
+{
+    return static_cast<StorageT>( fromPython<ElemT>( value, *elemType() ) );
+}
+
+template<typename StorageT>
+static Py_ssize_t py_struct_fast_list_len( PyObject * sself )
+{
+    CSP_BEGIN_METHOD;
+
+    return ( ( PyStructFastList<StorageT> * ) sself ) -> vector.size();
+
+    CSP_RETURN_INT;
+}
+
+template<typename StorageT>
+static PyObject * PyStructFastList_representation_helper( PyStructFastList<StorageT> * self, bool show_unset )
+{
+    static thread_local std::string tl_repr;
+
+    // Each PyStructFastList is responsible for clearing the TLS string after
+    size_t offset = tl_repr.size();
+    repr_array<StorageT>( self -> vector.getVector(), *self -> elemType(), tl_repr, false );
+
+    PyObject * rv = PyUnicode_FromString( tl_repr.c_str() + offset );
+    tl_repr.erase( offset );
+    return rv;
+}
+
+template<typename StorageT>
+static PyObject * PyStructFastList_Repr( PyStructFastList<StorageT> * self )
+{
+    CSP_BEGIN_METHOD;
+
+    return PyStructFastList_representation_helper( self, false );
+
+    CSP_RETURN_NULL;
+}
+
+template<typename StorageT>
+static PyObject * PyStructFastList_Str( PyStructFastList<StorageT> * self )
+{
+    CSP_BEGIN_METHOD;
+
+    return PyStructFastList_representation_helper( self, true );
+
+    CSP_RETURN_NULL;
+}
+
+template<typename StorageT>
+static PyObject * py_struct_fast_list_item( PyObject * sself, Py_ssize_t index )
+{
+    CSP_BEGIN_METHOD;
+
+    // Return the value from the vector stored in the struct field
+    return ( ( PyStructFastList<StorageT> * ) sself ) -> toPythonValue( ( ( PyStructFastList<StorageT> * ) sself ) -> vector[ index ] );
+
+    CSP_RETURN_NULL;
+}
+
+template<typename StorageT>
+static PyObject * py_struct_fast_list_subscript( PyObject * sself, PyObject * item )
+{
+    CSP_BEGIN_METHOD;
+    
+    // The item is the individual index
+    if( !PySlice_Check( item ) )
+    {
+        Py_ssize_t index = PyNumber_AsSsize_t( item, PyExc_IndexError );
+        if( index == -1 && PyErr_Occurred() )
+            return NULL;
+
+        return py_struct_fast_list_item<StorageT>( sself, index );
+    }
+
+    // The item is a slice
+    Py_ssize_t start, stop, step;
+    if( PySlice_Unpack( item, &start, &stop, &step ) < 0 )
+        return NULL;
+    
+    // Return the slice from the vector stored in the struct field
+    return toPython( ( ( PyStructFastList<StorageT> * ) sself ) -> vector.getSlice( start, stop, step ), ( ( PyStructFastList<StorageT> * ) sself ) -> arrayType );
+
+    CSP_RETURN_NULL;
+}
+
+template<typename StorageT>
+static PyObject * PyStructFastList_Copy( PyStructFastList<StorageT> * self, PyObject * Py_UNUSED( ignored ) )
+{
+    CSP_BEGIN_METHOD;
+
+    PyObject * list = toPython( self -> vector.getVector(), self -> arrayType );
+    return list;
+
+    CSP_RETURN_NONE;
+}
+
+template<typename StorageT>
+static PyObject * PyStructFastList_Index( PyStructFastList<StorageT> * self, PyObject * args )
+{
+    CSP_BEGIN_METHOD;
+    
+    typename VectorWrapper<StorageT>::IndexType sz = self -> vector.size();
+    Py_ssize_t start_index = 0;
+    Py_ssize_t stop_index = sz;
+    PyObject * value;
+    if( !PyArg_ParseTuple( args, "O|nn", &value, &start_index, &stop_index ) )
+        return NULL;
+
+    // Return the index of the the value in the vector stored in the struct field
+    typename VectorWrapper<StorageT>::IndexType index;
+    try
+    {
+        index = self -> vector.index( self -> fromPythonValue( value ), start_index, stop_index );
+    }
+    catch( TypeError const& )
+    {
+        CSP_THROW( ValueError, "Value not found." );
+    }
+    return PyLong_FromSsize_t(index);
+
+    CSP_RETURN_NONE;
+}
+
+template<typename StorageT>
+static PyObject * PyStructFastList_Count( PyStructFastList<StorageT> * self, PyObject * args )
+{
+    CSP_BEGIN_METHOD;
+    
+    PyObject * value;
+    if( !PyArg_ParseTuple( args, "O", &value) )
+        return NULL;
+
+    // Return the count of the value in the vector stored in the struct field
+    typename VectorWrapper<StorageT>::IndexType index;
+    try
+    {
+        index = self -> vector.count( self -> fromPythonValue( value ) );
+    }
+    catch( TypeError const& )
+    {
+        index = 0;
+    }
+
+    return PyLong_FromSsize_t(index);
+
+    CSP_RETURN_NONE;
+}
+
+template<typename StorageT>
+static PyObject * PyStructFastList_Append( PyStructFastList<StorageT> * self, PyObject * args )
+{
+    CSP_BEGIN_METHOD;
+
+    PyObject * value;
+    if( !PyArg_ParseTuple( args, "O", &value ) )
+        return NULL;
+    
+    // Append the value to the vector stored in the struct field
+    self -> vector.append( self -> fromPythonValue( value ) );
+
+    CSP_RETURN_NONE;
+}
+
+template<typename StorageT>
+static PyObject * PyStructFastList_Insert( PyStructFastList<StorageT> * self, PyObject * args )
+{
+    CSP_BEGIN_METHOD;
+
+    Py_ssize_t index;
+    PyObject * value;
+    if( !PyArg_ParseTuple( args, "nO", &index, &value ) )
+        return NULL;
+
+    // Insert the value in the vector stored in the struct field
+    self -> vector.insert( self -> fromPythonValue( value ), index );
+
+    CSP_RETURN_NONE;
+}
+
+template<typename StorageT>
+static PyObject * PyStructFastList_Pop( PyStructFastList<StorageT> * self, PyObject * args )
+{
+    CSP_BEGIN_METHOD;
+
+    Py_ssize_t index = -1;
+    if( !PyArg_ParseTuple( args, "|n", &index ) )
+        return NULL;
+
+    // Pop the value from the vector stored in the struct field
+    return self -> toPythonValue( self -> vector.pop( index ) );
+
+    CSP_RETURN_NULL;
+}
+
+template<typename StorageT>
+static PyObject * PyStructFastList_Reverse( PyStructFastList<StorageT> * self, PyObject * Py_UNUSED( ignored ) )
+{
+    CSP_BEGIN_METHOD;
+
+    // Reverse the vector stored in the struct field
+    self -> vector.reverse();
+
+    CSP_RETURN_NONE;
+}
+
+template<typename StorageT>
+static PyObject * PyStructFastList_Sort( PyStructFastList<StorageT> * self, PyObject * args, PyObject * kwargs )
+{
+    CSP_BEGIN_METHOD;
+
+    if( args && PyObject_Length( args ) > 0 )
+    {
+        PyErr_SetString( PyExc_TypeError, "sort() takes no positional arguments" );
+        return NULL;
+    }
+
+    // We could have implemented sorting using VectorWrapper method, however, decided not to because of:
+    // - When the 'key' argument is present, fuguring out C++ sort is too complex, so still need to fall back to Python method in this case.
+    // - In order to implement sort using VectorWrapper method, we would need to implement comparison ops for all CSP types, even dummy ones for types like DialectGeneric.
+    // - Even with all that, benchmark showed only 3x speed up for using C++ sort.
+    // Because of that, the ultimate decision was to use Python sort and convert.
+    PyObjectPtr list = PyObjectPtr::own( toPython( self -> vector.getVector(), self -> arrayType ) );
+    PyObjectPtr func = PyObjectPtr::own( PyObject_GetAttrString( ( PyObject * ) &PyList_Type, "sort" ) );
+    PyObjectPtr arguments = PyObjectPtr::own( PyTuple_Pack( 1, list.ptr() ) );
+    PyObjectPtr result = PyObjectPtr::check( PyObject_Call( func.ptr(), arguments.ptr(), kwargs ) );
+
+    // Copy sorted list into the vector stored in the struct field
+    typename VectorWrapper<StorageT>::IndexType sz = self -> vector.size();
+    for( typename VectorWrapper<StorageT>::IndexType index = 0; index < sz; ++index )
+    {
+        PyObject * value = PyList_GET_ITEM( list.ptr(), index );
+        self -> vector[ index ] = self -> fromPythonValue( value );
+    }
+
+    CSP_RETURN_NONE;
+}
+
+template<typename StorageT>
+static PyObject * PyStructFastList_Extend( PyStructFastList<StorageT> * self, PyObject * args )
+{
+    CSP_BEGIN_METHOD;
+
+    PyObject * iterable;
+    if( !PyArg_ParseTuple( args, "O", &iterable ) )
+        return NULL;
+
+    std::vector<StorageT> v = FromPython<std::vector<StorageT>>::impl( iterable, self -> arrayType );
+    self -> vector.extend( v );
+
+    CSP_RETURN_NONE;
+}
+
+template<typename StorageT>
+static PyObject * PyStructFastList_Remove( PyStructFastList<StorageT> * self, PyObject * args )
+{
+    CSP_BEGIN_METHOD;
+    
+    PyObject * value;
+    if( !PyArg_ParseTuple( args, "O", &value) )
+        return NULL;
+
+    // Remove the value from the vector stored in the struct field
+    self -> vector.remove( self -> fromPythonValue( value ) );
+
+    CSP_RETURN_NONE;
+}
+
+template<typename StorageT>
+static PyObject * PyStructFastList_Clear( PyStructFastList<StorageT> * self, PyObject * Py_UNUSED( ignored ) )
+{
+    CSP_BEGIN_METHOD;
+
+    // Clear the vector stored in the struct field
+    self -> vector.clear();
+
+    CSP_RETURN_NONE;
+}
+
+template<typename StorageT>
+static int py_struct_fast_list_ass_item( PyObject * sself, Py_ssize_t index, PyObject * value )
+{
+    CSP_BEGIN_METHOD;
+    
+    // Set the value in the vector stored in the struct field
+    // The value is not NULL -> assign it to vector[ index ]
+    if( value != NULL )
+        ( ( PyStructFastList<StorageT> * ) sself ) -> vector[ index ] = ( ( PyStructFastList<StorageT> * ) sself ) -> fromPythonValue( value );
+    // The value is NULL -> erase vector[ index ]
+    else
+        ( ( PyStructFastList<StorageT> * ) sself ) -> vector.eraseItem( index );
+    
+    CSP_RETURN_INT;
+}
+
+template<typename StorageT>
+static int py_struct_fast_list_ass_subscript( PyObject * sself, PyObject * item, PyObject * value )
+{
+    CSP_BEGIN_METHOD;
+    
+    // The item is the individual index
+    if( !PySlice_Check( item ) )
+    {
+        Py_ssize_t index = PyNumber_AsSsize_t( item, PyExc_IndexError );
+        if( index == -1 && PyErr_Occurred() )
+            return -1;
+
+        return py_struct_fast_list_ass_item<StorageT>( sself, index, value );
+    }
+
+    // The item is a slice
+    Py_ssize_t start, stop, step;
+    if( PySlice_Unpack( item, &start, &stop, &step ) < 0 )
+        return -1;
+    
+    // Set the slice in the vector stored in the struct field
+    // The value is not NULL -> assign it to vector[ slice ]
+    if( value != NULL )
+    {
+        // Check that all elements to assign to the slice are of correct type
+        if( !PySequence_Check( value ) )
+        {
+            PyErr_SetString( PyExc_TypeError, "can only assign an iterable" );
+            return -1;
+        }
+        std::vector<StorageT> v = FromPython<std::vector<StorageT>>::impl( value, ( ( PyStructFastList<StorageT> * ) sself ) -> arrayType );
+        ( ( PyStructFastList<StorageT> * ) sself ) -> vector.setSlice( v, start, stop, step );
+    }
+    // The value is NULL -> erase vector[ slice ]
+    else
+    {
+        ( ( PyStructFastList<StorageT> * ) sself ) -> vector.eraseSlice( start, stop, step );
+    }
+
+    CSP_RETURN_INT;
+}
+
+template<typename StorageT>
+static PyObject * py_struct_fast_list_inplace_concat( PyObject * sself, PyObject * other )
+{
+    CSP_BEGIN_METHOD;
+
+    // Emulate concatenation on the vector stored in the struct field
+    std::vector<StorageT> v = FromPython<std::vector<StorageT>>::impl( other, ( ( PyStructFastList<StorageT> * ) sself ) -> arrayType );
+    ( ( PyStructFastList<StorageT> * ) sself ) -> vector.extend( v );
+
+    Py_INCREF( sself );
+    return sself;
+
+    CSP_RETURN_NULL;
+}
+
+template<typename StorageT>
+static PyObject * py_struct_fast_list_concat( PyObject * sself, PyObject * other )
+{
+    CSP_BEGIN_METHOD;
+
+    // Parse iterable provided and check that all elements of iterable are of correct type
+    if( ( !PyList_Check( other ) ) && ( Py_TYPE( other ) != &PyStructFastList<StorageT>::PyType ) )
+    {
+        PyErr_SetString( PyExc_TypeError, "can only concatenate typed list or _cspimpl.PyStructFastList to _cspimpl.PyStructFastList with the same type" );
+        return NULL;
+    }
+
+    // Convert the operands to Python lists and use Python list concatenation
+    PyObjectPtr list = PyObjectPtr::own( toPython( ( ( PyStructFastList<StorageT> * ) sself ) -> vector.getVector(), ( ( PyStructFastList<StorageT> * ) sself ) -> arrayType ) );
+    PyObjectPtr other_list = PyObjectPtr::incref( other );
+
+    if( !PyList_Check( other ))
+        other_list = PyObjectPtr::own( toPython( ( ( PyStructFastList<StorageT> * ) other ) -> vector.getVector(), ( ( PyStructFastList<StorageT> * ) other ) -> arrayType ) );
+
+    PyObjectPtr result = PyObjectPtr::check( PySequence_Concat( list.ptr(), other_list.ptr() ) );
+
+    return result.release();
+
+    CSP_RETURN_NULL;
+}
+
+template<typename StorageT>
+static PyObject * py_struct_fast_list_inplace_repeat( PyObject * sself, Py_ssize_t n )
+{
+    CSP_BEGIN_METHOD;
+
+    // Emulate repeating on the vector stored in the struct field
+    ( ( PyStructFastList<StorageT> * ) sself ) -> vector.repeat( n );
+
+    Py_INCREF( sself );
+    return sself;
+
+    CSP_RETURN_NULL;
+}
+
+template<typename StorageT>
+static PyObject * py_struct_fast_list_repeat( PyObject * sself, Py_ssize_t n )
+{
+    CSP_BEGIN_METHOD;
+
+    // Convert the operand to Python list and use Python list repeating
+    PyObjectPtr list = PyObjectPtr::own( toPython( ( ( PyStructFastList<StorageT> * ) sself ) -> vector.getVector(), ( ( PyStructFastList<StorageT> * ) sself ) -> arrayType ) );
+
+    PyObjectPtr result = PyObjectPtr::check( PySequence_Repeat( list.ptr(), n ) );
+
+    return result.release();
+
+    CSP_RETURN_NULL;
+}
+
+template<typename StorageT>
+static int py_struct_fast_list_contains( PyObject * sself, PyObject * value )
+{
+    CSP_BEGIN_METHOD;
+
+    if( ( ( PyStructFastList<StorageT> * ) sself ) -> vector.contains( ( ( PyStructFastList<StorageT> * ) sself ) -> fromPythonValue( value ) ))
+        return 1;
+
+    return 0;
+
+    CSP_RETURN_INT;
+}
+
+template<typename StorageT>
+static PyObject * py_struct_fast_list_richcompare( PyObject * sself, PyObject * other, int op )
+{
+    CSP_BEGIN_METHOD;
+
+    if( !PyList_Check( other ) && ( Py_TYPE( other ) != &PyStructFastList<StorageT>::PyType ) )
+        Py_RETURN_NOTIMPLEMENTED;
+
+    // We could have implemented rich comparison using VectorWrapper, however, decided not to because of:
+    // - In order to implement rich comparison using VectorWrapper, we would need to implement comparison ops for all CSP types, even dummy ones for types like DialectGeneric.
+    // - Rich comparison is not very frequently used.
+    // Because of that, the ultimate decision was to use Python rich comparison and convert.
+    PyObjectPtr list = PyObjectPtr::own( toPython( ( ( PyStructFastList<StorageT> * ) sself ) -> vector.getVector(), ( ( PyStructFastList<StorageT> * ) sself ) -> arrayType ) );
+    PyObjectPtr other_list = PyObjectPtr::incref( other );
+    if( !PyList_Check( other ) )
+        other_list = PyObjectPtr::own( toPython( ( ( PyStructFastList<StorageT> * ) other ) -> vector.getVector(), ( ( PyStructFastList<StorageT> * ) other ) -> arrayType ) );
+    PyObjectPtr result = PyObjectPtr::check( PyObject_RichCompare( list.ptr(), other_list.ptr(), op ) );
+
+    return result.release();
+
+    CSP_RETURN_NULL;
+}
+
+template<typename StorageT>
+static PyObject * PyStructFastList_Sizeof( PyStructFastList<StorageT> * self, PyObject * Py_UNUSED( ignored ) )
+{
+    CSP_BEGIN_METHOD;
+
+    PyObject * pself = ( PyObject * ) self;
+    size_t result = ( size_t ) Py_TYPE( pself ) -> tp_basicsize;
+    // In Python, sizeof list growth with the number of elements, here we mimic that
+    result += sizeof( self -> vector ) + self -> vector.size() * sizeof( StorageT );
+    return PyLong_FromSize_t( result );
+
+    CSP_RETURN_NONE;
+}
+
+template<typename StorageT>
+static PyObject * py_struct_fast_list_iter( PyObject * sself )
+{
+    CSP_BEGIN_METHOD;
+
+    return PyIterator<PyStructFastListIterator<StorageT>>::create( PyStructFastListIterator<StorageT>( ( PyStructFastList<StorageT> * ) sself ) );
+
+    CSP_RETURN_NULL;
+}
+
+template<typename StorageT>
+static PyObject * PyStructFastList_Reversed( PyStructFastList<StorageT> * self, PyObject * Py_UNUSED( ignored ) )
+{
+    CSP_BEGIN_METHOD;
+
+    return PyIterator<PyStructFastListReverseIterator<StorageT>>::create( PyStructFastListReverseIterator<StorageT>( self ) );
+
+    CSP_RETURN_NULL;
+}
+
+template<typename StorageT>
+static PyMethodDef PyStructFastList_methods[] = {
+    { "__getitem__",   ( PyCFunction ) py_struct_fast_list_subscript<StorageT>,  METH_VARARGS,                  NULL },
+    { "copy",          ( PyCFunction ) PyStructFastList_Copy<StorageT>,          METH_NOARGS,                   NULL },
+    { "index",         ( PyCFunction ) PyStructFastList_Index<StorageT>,         METH_VARARGS,                  NULL },
+    { "count",         ( PyCFunction ) PyStructFastList_Count<StorageT>,         METH_VARARGS,                  NULL },
+    { "__sizeof__",    ( PyCFunction ) PyStructFastList_Sizeof<StorageT>,        METH_NOARGS,                   NULL },
+    { "__reversed__",  ( PyCFunction ) PyStructFastList_Reversed<StorageT>,      METH_NOARGS,                   NULL },
+    { "append",        ( PyCFunction ) PyStructFastList_Append<StorageT>,        METH_VARARGS,                  NULL },
+    { "insert",        ( PyCFunction ) PyStructFastList_Insert<StorageT>,        METH_VARARGS,                  NULL },
+    { "pop",           ( PyCFunction ) PyStructFastList_Pop<StorageT>,           METH_VARARGS,                  NULL },
+    { "reverse",       ( PyCFunction ) PyStructFastList_Reverse<StorageT>,       METH_NOARGS,                   NULL },
+    { "sort",          ( PyCFunction ) PyStructFastList_Sort<StorageT>,          METH_VARARGS | METH_KEYWORDS,  NULL },
+    { "extend",        ( PyCFunction ) PyStructFastList_Extend<StorageT>,        METH_VARARGS,                  NULL },
+    { "remove",        ( PyCFunction ) PyStructFastList_Remove<StorageT>,        METH_VARARGS,                  NULL },
+    { "clear",         ( PyCFunction ) PyStructFastList_Clear<StorageT>,         METH_NOARGS,                   NULL },
+    { NULL},
+};
+
+template<typename StorageT>
+static PySequenceMethods py_struct_fast_list_as_sequence = {
+    py_struct_fast_list_len<StorageT>,                                /* sq_length */
+    py_struct_fast_list_concat<StorageT>,                             /* sq_concat */
+    py_struct_fast_list_repeat<StorageT>,                             /* sq_repeat */
+    py_struct_fast_list_item<StorageT>,                               /* sq_item */
+    0,                                                                /* sq_slice */
+    py_struct_fast_list_ass_item<StorageT>,                           /* sq_ass_item */
+    0,                                                                /* sq_ass_slice */
+    py_struct_fast_list_contains<StorageT>,                           /* sq_contains */
+    py_struct_fast_list_inplace_concat<StorageT>,                     /* sq_inplace_concat */
+    py_struct_fast_list_inplace_repeat<StorageT>                      /* sq_inplace_repeat */
+};
+
+template<typename StorageT>
+static PyMappingMethods py_struct_fast_list_as_mapping = {
+    py_struct_fast_list_len<StorageT>,
+    py_struct_fast_list_subscript<StorageT>,
+    py_struct_fast_list_ass_subscript<StorageT>
+};
+
+static PyObject * PyStructFastList_new( PyTypeObject *type, PyObject *args, PyObject *kwds )
+{
+    // Since the PyStructFastList has no real meaning when created from Python, we can reconstruct the FL's value
+    // by just treating it as a list. Thus, we simply override the tp_new behaviour to return a list object here.
+    // Again, since we don't have tp_init for the FL, we need to rely on the Python list's tp_init function.
+
+    return PyObject_Call( ( PyObject * ) &PyList_Type, args, kwds ); // Calls both tp_new and tp_init for a Python list
+}
+
+template<typename StorageT>
+static int PyStructFastList_tp_clear( PyStructFastList<StorageT> * self )
+{
+    Py_CLEAR( self -> pystruct );
+    return 0;
+}
+
+template<typename StorageT>
+static int PyStructFastList_tp_traverse( PyStructFastList<StorageT> * self, visitproc visit, void * arg )
+{
+    Py_VISIT( self -> pystruct );
+    return 0;
+}
+
+template<typename StorageT>
+static void PyStructFastList_tp_dealloc( PyStructFastList<StorageT> * self )
+{    
+    PyObject_GC_UnTrack( self );
+    Py_CLEAR( self -> pystruct );
+}
+
+template<typename StorageT>
+PyTypeObject  PyStructFastList<StorageT>::PyType = {
+    PyVarObject_HEAD_INIT(nullptr, 0)
+    "_cspimpl.PyStructFastList",   /* tp_name */
+    sizeof(PyStructFastList<StorageT>), /* tp_basicsize */
+    0,                         /* tp_itemsize */
+    ( destructor ) PyStructFastList_tp_dealloc<StorageT>, /* tp_dealloc */
+    0,                         /* tp_print */
+    0,                         /* tp_getattr */
+    0,                         /* tp_setattr */
+    0,                         /* tp_reserved */
+    ( reprfunc ) PyStructFastList_Repr<StorageT>, /* tp_repr */
+    0,                         /* tp_as_number */
+    &py_struct_fast_list_as_sequence<StorageT>, /* tp_as_sequence */
+    &py_struct_fast_list_as_mapping<StorageT>, /* tp_as_mapping */
+    PyObject_HashNotImplemented, /* tp_hash  */
+    0,                         /* tp_call */
+    ( reprfunc ) PyStructFastList_Str<StorageT>, /* tp_str */
+    PyObject_GenericGetAttr,   /* tp_getattro */
+    0,                         /* tp_setattro */
+    0,                         /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | SEQ_FLAG, /* tp_flags */  // adding flag Py_TPFLAGS_SEQUENCE in Python >=3.10
+    "",                        /* tp_doc */
+    ( traverseproc ) PyStructFastList_tp_traverse<StorageT>, /* tp_traverse */
+    ( inquiry ) PyStructFastList_tp_clear<StorageT>, /* tp_clear */
+    py_struct_fast_list_richcompare<StorageT>, /* tp_richcompare */
+    0,                         /* tp_weaklistoffset */
+    py_struct_fast_list_iter<StorageT>, /* tp_iter */
+    0,                         /* tp_iternext */
+    PyStructFastList_methods<StorageT>, /* tp_methods */
+    0,                         /* tp_members */
+    0,                         /* tp_getset */
+    0,                         /* tp_base */
+    0,                         /* tp_dict */
+    0,                         /* tp_descr_get */
+    0,                         /* tp_descr_set */
+    0,                         /* tp_dictoffset */
+    0,                         /* tp_init */
+    PyType_GenericAlloc,       /* tp_alloc */
+    PyStructFastList_new,      /* tp_new */
+    PyObject_GC_Del,           /* tp_free */
+};
+
+template<typename StorageT>
+struct PyStructFastListIterator : public PyObject
+{
+    PyStructFastListIterator( PyStructFastList<StorageT> * v ) : m_v( v ), m_index( 0 )
+    {
+        Py_INCREF( m_v );
+    }
+    ~PyStructFastListIterator()
+    {
+        Py_DECREF( m_v );
+    }
+    PyObject * iternext()
+    {
+        if( m_index < py_struct_fast_list_len<StorageT>( m_v ) )
+            return py_struct_fast_list_item<StorageT>( m_v, m_index++ );
+        PyErr_SetString( PyExc_StopIteration, "" );
+        return NULL;
+    }
+protected:
+    PyStructFastList<StorageT> * m_v;
+    typename VectorWrapper<StorageT>::IndexType m_index;
+};
+
+template<typename StorageT>
+struct PyStructFastListReverseIterator : public PyObject
+{
+    PyStructFastListReverseIterator( PyStructFastList<StorageT> * v ) : m_v( v ), m_index( py_struct_fast_list_len<StorageT>( v ) - 1 )
+    {
+        Py_INCREF( m_v );
+    }
+    ~PyStructFastListReverseIterator()
+    {
+        Py_DECREF( m_v );
+    }
+    PyObject * iternext()
+    {
+        if( m_index >= 0 )
+            return py_struct_fast_list_item<StorageT>( m_v, m_index-- );
+        PyErr_SetString( PyExc_StopIteration, "" );
+        return NULL;
+    }
+protected:
+    PyStructFastList<StorageT> * m_v;
+    typename VectorWrapper<StorageT>::IndexType m_index;
+};
+
+}
+
+#endif
diff --git a/cpp/csp/python/PyStructList.h b/cpp/csp/python/PyStructList.h
index 7a8944ed..3c51758e 100644
--- a/cpp/csp/python/PyStructList.h
+++ b/cpp/csp/python/PyStructList.h
@@ -3,6 +3,7 @@
 
 #include <csp/python/InitHelper.h>
 #include <csp/python/PyStruct.h>
+#include <csp/python/VectorWrapper.h>
 #include <Python.h>
 #include <vector>
 
@@ -14,18 +15,22 @@ struct PyStructList : public PyObject
 {
     using ElemT = typename CspType::Type::toCArrayElemType<StorageT>::type;
 
-    PyStructList( PyStruct * p, std::vector<StorageT> & v, const CspType & type ) : pystruct( p ), vector( v ), field_type( type )
+    PyStructList( PyStruct * p, std::vector<StorageT> & v, const CspType & type ) : pystruct( p ), vector( VectorWrapper<StorageT>( v ) ), arrayType( type )
     {
         Py_INCREF( pystruct );
     }
 
     PyListObject base;                // Inherit from PyListObject
-    PyStruct * pystruct;             // Pointer to PyStruct for proper reference counting
-    std::vector<StorageT> & vector;  // Reference to field value for modifying
+    PyStruct * pystruct;              // Pointer to PyStruct for proper reference counting
+    VectorWrapper<StorageT> vector;   // Field value for modifying
 
-    const CspType & field_type;       // We require the type information of any non-primitive type, i.e. Struct or Enum, since they contain a meta
+    const CspType & arrayType;        // We require the type information of any non-primitive type, i.e. Struct or Enum, since they contain a meta
     static PyTypeObject PyType;
     static bool s_typeRegister;
+
+    inline CspTypePtr elemType() const { return static_cast<const CspArrayType &>( arrayType ).elemType(); }
+
+    inline StorageT fromPythonValue( PyObject * value ) const;
 };
 
 template<typename StorageT> bool PyStructList<StorageT>::s_typeRegister = InitHelper::instance().registerCallback( 
@@ -33,4 +38,4 @@ template<typename StorageT> bool PyStructList<StorageT>::s_typeRegister = InitHe
 
 }
 
-#endif
\ No newline at end of file
+#endif
diff --git a/cpp/csp/python/PyStructList_impl.h b/cpp/csp/python/PyStructList_impl.h
index 05688e2f..b488894a 100644
--- a/cpp/csp/python/PyStructList_impl.h
+++ b/cpp/csp/python/PyStructList_impl.h
@@ -1,24 +1,25 @@
-#ifndef _IN_CSP_PYTHON_PYSTRUCTLIST_HI
-#define _IN_CSP_PYTHON_PYSTRUCTLIST_HI
+#ifndef _IN_CSP_PYTHON_PYSTRUCTLIST_IMPL_H
+#define _IN_CSP_PYTHON_PYSTRUCTLIST_IMPL_H
 
 #include <csp/engine/PartialSwitchCspType.h>
 #include <csp/python/Conversions.h>
 #include <csp/python/InitHelper.h>
 #include <csp/python/PyCspType.h>
 #include <csp/python/PyStructList.h>
+#include <csp/python/VectorWrapper.h>
 #include <algorithm>
 
 namespace csp::python
 {
 
-template<typename StorageT> inline StorageT convertValue( PyStructList<StorageT> * self, PyObject * value )
+template<typename StorageT>
+inline StorageT PyStructList<StorageT>::fromPythonValue( PyObject * value ) const
 {
-    return static_cast<StorageT>( fromPython<typename PyStructList<StorageT>::ElemT>( value, self -> field_type ) );
+    return static_cast<StorageT>( fromPython<ElemT>( value, *elemType() ) );
 }
 
 template<typename StorageT>
-static PyObject *
-PyStructList_Append( PyStructList<StorageT> * self, PyObject * args )
+static PyObject * PyStructList_Append( PyStructList<StorageT> * self, PyObject * args )
 {
     CSP_BEGIN_METHOD;
 
@@ -30,14 +31,13 @@ PyStructList_Append( PyStructList<StorageT> * self, PyObject * args )
         return NULL;
 
     // Append the value to the vector stored in the struct field
-    self -> vector.emplace_back( convertValue( self, value ) );
+    self -> vector.append( self -> fromPythonValue( value ) );
 
     CSP_RETURN_NONE;
 }
 
 template<typename StorageT>
-static PyObject *
-PyStructList_Insert( PyStructList<StorageT> * self, PyObject * args )
+static PyObject * PyStructList_Insert( PyStructList<StorageT> * self, PyObject * args )
 {
     CSP_BEGIN_METHOD;
 
@@ -50,21 +50,13 @@ PyStructList_Insert( PyStructList<StorageT> * self, PyObject * args )
         return NULL;
 
     // Insert the value in the vector stored in the struct field
-    // Deal with Python list indices that can be negative or point outside of the array
-    // Python allows indices for insert to be past the array boundaries, in which case the element is added to the beginning or end of the array
-    int sz = self -> vector.size();
-    if( index < 0 )
-        index += sz;
-    // Insert the value in the vector stored in the struct field
-    auto it = self -> vector.begin() + std::max( 0, std::min( sz, ( int ) index ) );
-    self -> vector.insert( it, convertValue( self, value ) );
+    self -> vector.insert( self -> fromPythonValue( value ), index );
 
     CSP_RETURN_NONE;
 }
 
 template<typename StorageT>
-static PyObject *
-PyStructList_Pop( PyStructList<StorageT> * self, PyObject * args )
+static PyObject * PyStructList_Pop( PyStructList<StorageT> * self, PyObject * args )
 {
     CSP_BEGIN_METHOD;
 
@@ -73,19 +65,10 @@ PyStructList_Pop( PyStructList<StorageT> * self, PyObject * args )
         return NULL;
 
     PyObjectPtr func = PyObjectPtr::own( PyObject_GetAttrString( ( PyObject * ) &PyList_Type, "pop" ) );
-    PyObjectPtr result = PyObjectPtr::own( PyObject_CallFunction( func.ptr(), "On", self, index ) );   
-    if( !result.ptr() )
-        return NULL;
+    PyObjectPtr result = PyObjectPtr::check( PyObject_CallFunction( func.ptr(), "On", self, index ) );
 
-    // Deal with Python list indices that can be negative
-    int sz = self -> vector.size();
-    if( index < 0 )
-        index += sz;
     // Pop the value from the vector stored in the struct field
-    // Python doesn't allow indices for pop to be past the array boundaries, so it is safe
-    assert( index >= 0 && index < sz );
-    auto it = self -> vector.begin() + ( int ) index;
-    self -> vector.erase( it );
+    self -> vector.pop( index );
 
     return result.release();
 
@@ -93,8 +76,7 @@ PyStructList_Pop( PyStructList<StorageT> * self, PyObject * args )
 }
 
 template<typename StorageT>
-static PyObject *
-PyStructList_Reverse( PyStructList<StorageT> * self, PyObject * Py_UNUSED( ignored ) )
+static PyObject * PyStructList_Reverse( PyStructList<StorageT> * self, PyObject * Py_UNUSED( ignored ) )
 {
     CSP_BEGIN_METHOD;
 
@@ -102,44 +84,44 @@ PyStructList_Reverse( PyStructList<StorageT> * self, PyObject * Py_UNUSED( ignor
         return NULL;
 
     // Reverse the vector stored in the struct field
-    std::reverse( self -> vector.begin(), self -> vector.end() );
+    self -> vector.reverse();
 
     CSP_RETURN_NONE;
 }
 
 template<typename StorageT>
-static PyObject *
-PyStructList_Sort( PyStructList<StorageT> * self, PyObject * args, PyObject * kwargs )
+static PyObject * PyStructList_Sort( PyStructList<StorageT> * self, PyObject * args, PyObject * kwargs )
 {
     CSP_BEGIN_METHOD;
 
-    if( PyObject_Length( args ) > 0 )
+    if( args && PyObject_Length( args ) > 0 )
     {
         PyErr_SetString( PyExc_TypeError, "sort() takes no positional arguments" );
         return NULL;
     }
 
+    // We could have implemented sorting using VectorWrapper method, however, decided not to because of:
+    // - When the 'key' argument is present, fuguring out C++ sort is too complex, so still need to fall back to Python method in this case.
+    // - In order to implement sort using VectorWrapper method, we would need to implement comparison ops for all CSP types, even dummy ones for types like DialectGeneric.
+    // - Even with all that, benchmark showed only 3x speed up for using C++ sort.
+    // Because of that, the ultimate decision was to use Python sort and convert.
     PyObjectPtr func = PyObjectPtr::own( PyObject_GetAttrString( ( PyObject * ) &PyList_Type, "sort" ) );
     PyObjectPtr arguments = PyObjectPtr::own( PyTuple_Pack( 1, ( PyObject * ) self ) );
-    PyObjectPtr result = PyObjectPtr::own( PyObject_Call( func.ptr(), arguments.ptr(), kwargs ) );   
-    if( !result.ptr() )
-        return NULL;
+    PyObjectPtr result = PyObjectPtr::check( PyObject_Call( func.ptr(), arguments.ptr(), kwargs ) );   
 
     // Copy sorted list into the vector stored in the struct field
-    size_t sz = self -> vector.size();
-
-    for( size_t index = 0; index < sz; ++index )
+    typename VectorWrapper<StorageT>::IndexType sz = self -> vector.size();
+    for( typename VectorWrapper<StorageT>::IndexType index = 0; index < sz; ++index )
     {
         PyObject * value = PyList_GET_ITEM( ( PyObject * ) self, index );
-        self -> vector[ index ] = convertValue( self, value );
+        self -> vector[ index ] = self -> fromPythonValue( value );
     }
 
     CSP_RETURN_NONE;
 }
 
 template<typename StorageT>
-static PyObject *
-PyStructList_Extend( PyStructList<StorageT> * self, PyObject * args )
+static PyObject * PyStructList_Extend( PyStructList<StorageT> * self, PyObject * args )
 {
     CSP_BEGIN_METHOD;
 
@@ -148,31 +130,17 @@ PyStructList_Extend( PyStructList<StorageT> * self, PyObject * args )
         return NULL;
 
     PyObjectPtr func = PyObjectPtr::own( PyObject_GetAttrString( ( PyObject * ) &PyList_Type, "extend" ) );
-    PyObjectPtr result = PyObjectPtr::own( PyObject_CallFunctionObjArgs( func.ptr(), self, iterable, NULL ) );
-    if( !result.ptr() )
-        return NULL;
-
-    // Copy new elements of the extended list into the vector stored in the struct field
-    size_t new_sz = ( size_t ) PyObject_Length( ( PyObject * ) self );
-    size_t old_sz = self -> vector.size();
+    PyObjectPtr result = PyObjectPtr::check( PyObject_CallFunctionObjArgs( func.ptr(), self, iterable, NULL ) );
 
-    // Check that all elements of a modified vector are of correct type
-    std::vector<StorageT> v = self -> vector;
-    v.resize( new_sz );
-    for( size_t index = old_sz; index < new_sz; ++index )
-    {
-        PyObject * value = PyList_GET_ITEM( ( PyObject * ) self, index );
-        v[ index ] = convertValue( self, value );
-    }
+    std::vector<StorageT> v = FromPython<std::vector<StorageT>>::impl( iterable, self -> arrayType );
 
-    self -> vector.swap( v );
+    self -> vector.extend( v );
 
     CSP_RETURN_NONE;
 }
 
 template<typename StorageT>
-static PyObject *
-PyStructList_Remove( PyStructList<StorageT> * self, PyObject * args )
+static PyObject * PyStructList_Remove( PyStructList<StorageT> * self, PyObject * args )
 {
     CSP_BEGIN_METHOD;
     
@@ -181,29 +149,21 @@ PyStructList_Remove( PyStructList<StorageT> * self, PyObject * args )
         return NULL;
 
     PyObjectPtr func = PyObjectPtr::own( PyObject_GetAttrString( ( PyObject * ) &PyList_Type, "remove" ) );
-    PyObjectPtr result = PyObjectPtr::own( PyObject_CallFunctionObjArgs( func.ptr(), self, value, NULL ) );   
-    if( !result.ptr() )
-        return NULL;
+    PyObjectPtr result = PyObjectPtr::check( PyObject_CallFunctionObjArgs( func.ptr(), self, value, NULL ) );   
 
     // Remove the value from the vector stored in the struct field
-    // The find always succeeds, as otherwise the above Python method call would have failed
-    auto it = std::find( self -> vector.begin(), self -> vector.end(), convertValue( self, value ) );
-    assert( it != self -> vector.end() );
-    self -> vector.erase( it );
+    self -> vector.remove( self -> fromPythonValue( value ) );
 
     CSP_RETURN_NONE;
 }
 
 template<typename StorageT>
-static PyObject *
-PyStructList_Clear( PyStructList<StorageT> * self, PyObject * Py_UNUSED( ignored ) )
+static PyObject * PyStructList_Clear( PyStructList<StorageT> * self, PyObject * Py_UNUSED( ignored ) )
 {
     CSP_BEGIN_METHOD;
     
     PyObjectPtr func = PyObjectPtr::own( PyObject_GetAttrString( ( PyObject * ) &PyList_Type, "clear" ) );
-    PyObjectPtr result = PyObjectPtr::own( PyObject_CallFunctionObjArgs( func.ptr(), self, NULL ) );   
-    if( !result.ptr() )
-        return NULL;
+    PyObjectPtr result = PyObjectPtr::check( PyObject_CallFunctionObjArgs( func.ptr(), self, NULL ) );   
 
     // Clear the vector stored in the struct field
     self -> vector.clear();
@@ -212,61 +172,47 @@ PyStructList_Clear( PyStructList<StorageT> * self, PyObject * Py_UNUSED( ignored
 }
 
 template<typename StorageT>
-static int
-py_struct_list_ass_item( PyObject * sself, Py_ssize_t index, PyObject * value )
+static int py_struct_list_ass_item( PyObject * sself, Py_ssize_t index, PyObject * value )
 {
     CSP_BEGIN_METHOD;
-    
-    PyStructList<StorageT> * self = ( PyStructList<StorageT> * ) sself;
 
     // Deal with Python list indices that can be negative
-    int sz = self -> vector.size();
-    if( index < 0 )
-        index += sz;
+    index = ( ( PyStructList<StorageT> * ) sself ) -> vector.normalizeIndex( index );
     
     PyObjectPtr result;
     // The value is not NULL -> assign it to vector[ index ]
     if( value != NULL )
     {
         Py_INCREF( value );
-        if( PyList_SetItem( ( PyObject * ) self, index, value ) < 0 )
+        if( PyList_SetItem( sself, index, value ) < 0 )
             return -1;
     }
     // The value is NULL -> erase vector[ index ]
     else
     {
         PyObjectPtr func = PyObjectPtr::own( PyObject_GetAttrString( ( PyObject * ) &PyList_Type, "__delitem__" ) );
-        PyObjectPtr arguments = PyObjectPtr::own( PyTuple_Pack( 2, ( PyObject * ) self, PyLong_FromSsize_t( index ) ) );
+        PyObjectPtr arguments = PyObjectPtr::own( PyTuple_Pack( 2, sself, PyLong_FromSsize_t( index ) ) );
         result = PyObjectPtr::own( PyObject_Call( func.ptr(), arguments.ptr(), NULL ) );
         if( !result.ptr() )
             return -1;
     }
 
     // Set the value in the vector stored in the struct field
-    // Python doesn't allow indices for set_item to be past the array boundaries, so it is safe
     // The value is not NULL -> assign it to vector[ index ]
-    assert( index >= 0 && index < sz );
     if( value != NULL )
-    {
-        self -> vector[ index ] = convertValue( self, value );
-    }
+        ( ( PyStructList<StorageT> * ) sself ) -> vector[ index ] = ( ( PyStructList<StorageT> * ) sself ) -> fromPythonValue( value );
     // The value is NULL -> erase vector[ index ]
     else
-    {
-        auto it = self -> vector.begin() + ( int ) index;
-        self -> vector.erase( it );
-    }
+        ( ( PyStructList<StorageT> * ) sself ) -> vector.eraseItem( index );
     
     CSP_RETURN_INT;
 }
 
 template<typename StorageT>
-static int
-py_struct_list_ass_subscript( PyObject * sself, PyObject * item, PyObject * value )
+static int py_struct_list_ass_subscript( PyObject * sself, PyObject * item, PyObject * value )
 {
     CSP_BEGIN_METHOD;
     
-    PyStructList<StorageT> * self = ( PyStructList<StorageT> * ) sself;
     // The item is the individual index
     if( !PySlice_Check( item ) )
     {
@@ -274,103 +220,94 @@ py_struct_list_ass_subscript( PyObject * sself, PyObject * item, PyObject * valu
         if( index == -1 && PyErr_Occurred() )
             return -1;
 
-        return py_struct_list_ass_item<StorageT>( ( PyObject * ) self, index, value );
+        return py_struct_list_ass_item<StorageT>( sself, index, value );
     }
 
     // The item is a slice
+    Py_ssize_t start, stop, step;
+    if( PySlice_Unpack( item, &start, &stop, &step ) < 0 )
+        return -1;
     PyObjectPtr result;
     // The value is not NULL -> assign it to vector[ slice ]
     if( value != NULL )
     {
         PyObjectPtr func = PyObjectPtr::own( PyObject_GetAttrString( ( PyObject * ) &PyList_Type, "__setitem__" ) );
-        PyObjectPtr arguments = PyObjectPtr::own( PyTuple_Pack( 3, ( PyObject * ) self, item, value ) );
+        PyObjectPtr arguments = PyObjectPtr::own( PyTuple_Pack( 3, sself, item, value ) );
         result = PyObjectPtr::own( PyObject_Call( func.ptr(), arguments.ptr(), NULL ) );
     }
     // The value is NULL -> erase vector[ slice ]
     else
     {
         PyObjectPtr func = PyObjectPtr::own( PyObject_GetAttrString( ( PyObject * ) &PyList_Type, "__delitem__" ) );
-        PyObjectPtr arguments = PyObjectPtr::own( PyTuple_Pack( 2, ( PyObject * ) self, item ) );
+        PyObjectPtr arguments = PyObjectPtr::own( PyTuple_Pack( 2, sself, item ) );
         result = PyObjectPtr::own( PyObject_Call( func.ptr(), arguments.ptr(), NULL ) );
     }
     if( !result.ptr() )
         return -1;
-
-    // Copy modified list into the vector stored in the struct field
-    size_t sz = ( size_t ) PyObject_Length( ( PyObject * ) self );
-
-    // Check that all elements of a modified vector are of correct type
-    std::vector<StorageT> v( sz ); 
-    for( size_t index = 0; index < sz; ++index )
+    
+    // Set the slice in the vector stored in the struct field
+    // The value is not NULL -> assign it to vector[ slice ]
+    if( value != NULL )
     {
-        PyObject * value = PyList_GET_ITEM( ( PyObject * ) self, index );
-        v[ index ] = convertValue( self, value );
+        // Check that all elements to assign to the slice are of correct type
+        if( !PySequence_Check( value ) )
+        {
+            PyErr_SetString( PyExc_TypeError, "can only assign an iterable" );
+            return -1;
+        }
+        std::vector<StorageT> v = FromPython<std::vector<StorageT>>::impl( value, ( ( PyStructList<StorageT> * ) sself ) -> arrayType );
+        ( ( PyStructList<StorageT> * ) sself ) -> vector.setSlice( v, start, stop, step );
+    }
+    // The value is NULL -> erase vector[ slice ]
+    else
+    {
+        ( ( PyStructList<StorageT> * ) sself ) -> vector.eraseSlice( start, stop, step );
     }
-
-    self -> vector.swap( v );
 
     CSP_RETURN_INT;
 }
 
 template<typename StorageT>
-static PyObject *
-py_struct_list_inplace_concat( PyObject * sself, PyObject * other )
+static PyObject * py_struct_list_inplace_concat( PyObject * sself, PyObject * other )
 {    
     CSP_BEGIN_METHOD;
     
-    PyStructList<StorageT> * self = ( PyStructList<StorageT> * ) sself;
     PyObjectPtr arguments = PyObjectPtr::own( PyTuple_Pack( 1, other ) );
-    PyObjectPtr result = PyObjectPtr::own( PyStructList_Extend<StorageT>( self, arguments.ptr() ) );
-    if( !result.ptr() )
-        return NULL;
-    Py_INCREF( self );
-    return self;
+    PyObjectPtr result = PyObjectPtr::check( PyStructList_Extend<StorageT>( ( PyStructList<StorageT> * ) sself, arguments.ptr() ) );
+    Py_INCREF( sself );
+    return sself;
 
     CSP_RETURN_NULL;
 }
 
 template<typename StorageT>
-static PyObject *
-py_struct_list_inplace_repeat( PyObject * sself, Py_ssize_t n )
+static PyObject * py_struct_list_inplace_repeat( PyObject * sself, Py_ssize_t n )
 {    
     CSP_BEGIN_METHOD;
     
-    PyStructList<StorageT> * self = ( PyStructList<StorageT> * ) sself;
-    
     PyObjectPtr func = PyObjectPtr::own( PyObject_GetAttrString( ( PyObject * ) &PyList_Type, "__imul__" ) );
-    PyObjectPtr result = PyObjectPtr::own( PyObject_CallFunction( func.ptr(), "On", self, n ) );   
-    if( !result.ptr() )
-        return NULL;
+    PyObjectPtr result = PyObjectPtr::check( PyObject_CallFunction( func.ptr(), "On", ( PyStructList<StorageT> * ) sself, n ) );   
 
     // Emulate repeating on the vector stored in the struct field
-    if( n <= 0 )
-        self -> vector.clear();
-    else
-    {
-        int sz = self -> vector.size();
-        self -> vector.resize( sz * n );
-        for( int i = 1; i < n; ++i )
-            for( int j = 0; j < sz; ++j )
-                self -> vector[ i * sz + j ] = self -> vector[ j ];
-    }
+    ( ( PyStructList<StorageT> * ) sself ) -> vector.repeat( n );
     
-    Py_INCREF( self );
-    return self;
+    Py_INCREF( sself );
+    return sself;
 
     CSP_RETURN_NULL;
 }
 
 template<typename StorageT>
 static PyMethodDef PyStructList_methods[] = {
-    {"append", ( PyCFunction ) PyStructList_Append<StorageT>, METH_VARARGS, NULL},
-    {"insert", ( PyCFunction ) PyStructList_Insert<StorageT>, METH_VARARGS, NULL},
-    {"pop", ( PyCFunction ) PyStructList_Pop<StorageT>, METH_VARARGS, NULL},
-    {"reverse", ( PyCFunction ) PyStructList_Reverse<StorageT>, METH_NOARGS, NULL},
-    {"sort", ( PyCFunction ) PyStructList_Sort<StorageT>, METH_VARARGS | METH_KEYWORDS, NULL},
-    {"extend", ( PyCFunction ) PyStructList_Extend<StorageT>, METH_VARARGS, NULL},
-    {"remove", ( PyCFunction ) PyStructList_Remove<StorageT>, METH_VARARGS, NULL},
-    {"clear", ( PyCFunction ) PyStructList_Clear<StorageT>, METH_NOARGS, NULL},
-    {NULL},
+    { "append",   ( PyCFunction ) PyStructList_Append<StorageT>,   METH_VARARGS,                  NULL },
+    { "insert",   ( PyCFunction ) PyStructList_Insert<StorageT>,   METH_VARARGS,                  NULL },
+    { "pop",      ( PyCFunction ) PyStructList_Pop<StorageT>,      METH_VARARGS,                  NULL },
+    { "reverse",  ( PyCFunction ) PyStructList_Reverse<StorageT>,  METH_NOARGS,                   NULL },
+    { "sort",     ( PyCFunction ) PyStructList_Sort<StorageT>,     METH_VARARGS | METH_KEYWORDS,  NULL },
+    { "extend",   ( PyCFunction ) PyStructList_Extend<StorageT>,   METH_VARARGS,                  NULL },
+    { "remove",   ( PyCFunction ) PyStructList_Remove<StorageT>,   METH_VARARGS,                  NULL },
+    { "clear",    ( PyCFunction ) PyStructList_Clear<StorageT>,    METH_NOARGS,                   NULL },
+    { NULL},
 };
 
 template<typename StorageT>
@@ -379,12 +316,12 @@ static PySequenceMethods py_struct_list_as_sequence = {
     PyList_Type.tp_as_sequence -> sq_concat,                                /* sq_concat */
     PyList_Type.tp_as_sequence -> sq_repeat,                                /* sq_repeat */
     PyList_Type.tp_as_sequence -> sq_item,                                  /* sq_item */
-    0,                                          /* sq_slice */
-    py_struct_list_ass_item<StorageT>,                              /* sq_ass_item */
-    0,                                          /* sq_ass_slice */
+    0,                                                                      /* sq_slice */
+    py_struct_list_ass_item<StorageT>,                                      /* sq_ass_item */
+    0,                                                                      /* sq_ass_slice */
     PyList_Type.tp_as_sequence -> sq_contains,                              /* sq_contains */
-    py_struct_list_inplace_concat<StorageT>,                        /* sq_inplace_concat */
-    py_struct_list_inplace_repeat<StorageT>                        /* sq_inplace_repeat */
+    py_struct_list_inplace_concat<StorageT>,                                /* sq_inplace_concat */
+    py_struct_list_inplace_repeat<StorageT>                                 /* sq_inplace_repeat */
 };
 
 template<typename StorageT>
@@ -394,8 +331,7 @@ static PyMappingMethods py_struct_list_as_mapping = {
     py_struct_list_ass_subscript<StorageT>
 };
 
-static PyObject *
-PyStructList_new( PyTypeObject *type, PyObject *args, PyObject *kwds )
+static PyObject * PyStructList_new( PyTypeObject *type, PyObject *args, PyObject *kwds )
 {
     // Since the PyStructList has no real meaning when created from Python, we can reconstruct the PSL's value
     // by just treating it as a list. Thus, we simply override the tp_new behaviour to return a list object here.
@@ -405,18 +341,16 @@ PyStructList_new( PyTypeObject *type, PyObject *args, PyObject *kwds )
 }
 
 template<typename StorageT>
-static int
-PyStructList_tp_clear( PyStructList<StorageT> * self )
+static int PyStructList_tp_clear( PyStructList<StorageT> * self )
 {
     Py_CLEAR( self -> pystruct );
     PyObject * pself = ( PyObject * ) self;
-    Py_TYPE( pself )-> tp_base -> tp_clear( pself );
+    Py_TYPE( pself ) -> tp_base -> tp_clear( pself );
     return 0;
 }
 
 template<typename StorageT>
-static int
-PyStructList_traverse( PyStructList<StorageT> * self, visitproc visit, void * arg )
+static int PyStructList_tp_traverse( PyStructList<StorageT> * self, visitproc visit, void * arg )
 {
     Py_VISIT( self -> pystruct );
     PyObject * pself = ( PyObject * ) self;
@@ -425,8 +359,7 @@ PyStructList_traverse( PyStructList<StorageT> * self, visitproc visit, void * ar
 }
 
 template<typename StorageT>
-static void
-PyStructList_dealloc( PyStructList<StorageT> * self )
+static void PyStructList_tp_dealloc( PyStructList<StorageT> * self )
 {    
     PyObject_GC_UnTrack( self );
     Py_CLEAR( self -> pystruct );
@@ -435,12 +368,12 @@ PyStructList_dealloc( PyStructList<StorageT> * self )
 }
 
 template<typename StorageT>
-PyTypeObject  PyStructList<StorageT>::PyType = {
+PyTypeObject PyStructList<StorageT>::PyType = {
     PyVarObject_HEAD_INIT(nullptr, 0)
     "_cspimpl.PyStructList",   /* tp_name */
     sizeof(PyStructList<StorageT>), /* tp_basicsize */
     0,                         /* tp_itemsize */
-    ( destructor ) PyStructList_dealloc<StorageT>, /* tp_dealloc */
+    ( destructor ) PyStructList_tp_dealloc<StorageT>, /* tp_dealloc */
     0,                         /* tp_print */
     0,                         /* tp_getattr */
     0,                         /* tp_setattr */
@@ -457,7 +390,7 @@ PyTypeObject  PyStructList<StorageT>::PyType = {
     0,                         /* tp_as_buffer */
     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_LIST_SUBCLASS, /* tp_flags */
     "",                        /* tp_doc */
-    ( traverseproc ) PyStructList_traverse<StorageT>,         /* tp_traverse */
+    ( traverseproc ) PyStructList_tp_traverse<StorageT>,         /* tp_traverse */
     ( inquiry ) PyStructList_tp_clear<StorageT>,             /* tp_clear */
     0,                         /* tp_richcompare */
     0,                         /* tp_weaklistoffset */
diff --git a/cpp/csp/python/VectorWrapper.h b/cpp/csp/python/VectorWrapper.h
new file mode 100644
index 00000000..8a35a69a
--- /dev/null
+++ b/cpp/csp/python/VectorWrapper.h
@@ -0,0 +1,269 @@
+// Wrapper class that extends std::vector interface with Python list API
+
+#ifndef _IN_CSP_PYTHON_VECTORWRAPPER_H
+#define _IN_CSP_PYTHON_VECTORWRAPPER_H
+
+#include <Python.h>
+#include <algorithm>
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace csp
+{
+
+template<typename StorageT>
+class VectorWrapper
+{
+public:
+    using IndexType = Py_ssize_t;
+
+    VectorWrapper( std::vector<StorageT> & m_v ) : m_vector( m_v ) {};
+
+    bool operator==( const VectorWrapper & rhs ) const { return m_vector == rhs.m_vector; }
+    bool operator!=( const VectorWrapper & rhs ) const { return m_vector != rhs.m_vector; }
+
+    StorageT & operator[]( IndexType index )
+    {
+        index = verify_index( index );
+        return m_vector[ index ];
+    }
+    const StorageT & operator[]( IndexType index ) const
+    {
+        index = verify_index( index );
+        return m_vector[ index ];
+    }
+
+    // Make negative indices (from the array end) to be positive (from the array start)
+    // If the index pointed outside of the array, it will continue to do so after the call to this function
+    inline IndexType normalizeIndex( IndexType index ) const
+    {
+        if( unlikely( index < 0 ) )
+            index += size();
+        return index;
+    }
+
+    struct Slice
+    {
+        IndexType start_index;
+        IndexType stop_index;
+        IndexType step;
+        IndexType length;
+
+        Slice( IndexType start_i, IndexType stop_i, IndexType sp, IndexType len ): start_index( start_i ), stop_index( stop_i ), step( sp ), length( len ) {}
+
+        bool belongs( IndexType index )
+        {
+            return ( ( index - start_index ) % step == 0 ) && ( ( index - start_index ) / step >= 0 ) && ( ( index - start_index ) / step < length );
+        }
+    };
+
+    // Make slice canonical:
+    // - normalize start and stop indices as normalizeIndex() does
+    // - if the step is 0, raise ValueError
+    // - if the step is positive, start and stop indices will be between 0 and one-past-the-last array element inclusive
+    // - if the step is negative, start and stop indices will be between -1 and the last array element inclusive
+    // - number of elements in the slice will be computed
+    inline Slice normalizeSlice( IndexType start_index, IndexType stop_index, IndexType step ) const;
+
+    const std::vector<StorageT> & getVector() const                                                                     { return m_vector; }
+    IndexType size() const                                                                                              { return ( IndexType ) m_vector.size(); }
+    void append( const StorageT & value )                                                                               { m_vector.emplace_back( value ); }
+    void insert( const StorageT & value, IndexType index );
+    StorageT pop( IndexType index = -1 );
+    void reverse()                                                                                                      { std::reverse( m_vector.begin(), m_vector.end() ); }
+    void extend( const std::vector<StorageT> & other )                                                                  { m_vector.insert( m_vector.end(), other.begin(), other.end() ); }
+    IndexType count( const StorageT & value ) const                                                                     { return ( IndexType ) std::count( m_vector.begin(), m_vector.end(), value ); }
+    // Return the 0-based index of the first element that equals value in the subsequence [start_index, stop_index)
+    IndexType index( const StorageT & value, IndexType start_index, IndexType stop_index ) const;
+    void remove( const StorageT & value );
+    void clear()                                                                                                        { m_vector.clear(); }
+    void eraseItem( IndexType index );
+    std::vector<StorageT> getSlice( IndexType start_index, IndexType stop_index, IndexType step ) const;
+    void setSlice( const std::vector<StorageT> & other, IndexType start_index, IndexType stop_index, IndexType step );
+    void eraseSlice( IndexType start_index, IndexType stop_index, IndexType step );
+    void repeat( int n );
+    bool contains( const StorageT & value ) const                                                                       { return std::find( m_vector.begin(), m_vector.end(), value ) != m_vector.end(); }
+
+protected:
+    std::vector<StorageT> & m_vector;
+
+private:
+    // Check that the index value is in the array bounds
+    inline bool check_index_in_bounds( IndexType index ) const
+    {
+        return ( index >= 0 && index < size() );
+    }
+    // Make index to be strictly inside provided bounds
+    inline IndexType force_index_in_bounds( IndexType index, IndexType l_bound, IndexType u_bound ) const
+    {
+        return std::max( l_bound, std::min( u_bound, index ) );
+    }
+    // Run normalizeIndex() on index and throw if it's not in array bounds
+    inline IndexType verify_index( IndexType index ) const;
+};
+
+template<typename StorageT>
+inline typename VectorWrapper<StorageT>::IndexType VectorWrapper<StorageT>::verify_index( IndexType index ) const
+{
+    // We allow list indices that are negative or point outside of the array
+    index = normalizeIndex( index );
+    // We don't allow indices to be past the array boundaries
+    if( unlikely( !check_index_in_bounds( index ) ) )
+        CSP_THROW( RangeError, "Index " << index << " is out of range." );
+    return index;
+}
+
+template<typename StorageT>
+inline typename VectorWrapper<StorageT>::Slice VectorWrapper<StorageT>::normalizeSlice( IndexType start_index, IndexType stop_index, IndexType step ) const
+{    
+    if( unlikely( step == 0 ) )
+        CSP_THROW( ValueError, "Slice step cannot be zero." );
+
+    IndexType sz = size();
+    // Call Python API method that computes the size of the slice and properly adjusts start_index and stop_index
+    IndexType slice_len = PySlice_AdjustIndices( sz, &start_index, &stop_index, step );
+            
+    return VectorWrapper<StorageT>::Slice( start_index, stop_index, step, slice_len );
+}
+
+template<typename StorageT>
+void VectorWrapper<StorageT>::insert( const StorageT & value, IndexType index )
+{
+    // We allow list indices that are negative or point outside of the array
+    // We allow indices for insert to be past the array boundaries, in which case the element is added to the beginning or end of the array
+    auto it = m_vector.begin() + force_index_in_bounds( normalizeIndex( index ), 0, size() );
+    m_vector.insert( it, value );
+}
+
+template<typename StorageT>
+StorageT VectorWrapper<StorageT>::pop( IndexType index )
+{
+    index = verify_index( index );
+    auto it = m_vector.begin() + index;
+    StorageT elem = *it;
+    m_vector.erase( it );
+    return elem;
+}
+
+template<typename StorageT>
+typename VectorWrapper<StorageT>::IndexType VectorWrapper<StorageT>::index( const StorageT & value, IndexType start_index, IndexType stop_index ) const
+{
+    // We allow list indices that are negative or point outside of the array
+    VectorWrapper<StorageT>::IndexType sz = m_vector.size();
+    auto normalized_slice = normalizeSlice( start_index, stop_index, 1 );
+    if( likely( normalized_slice.start_index < sz ) )
+    {
+        auto start_it = m_vector.begin() + normalized_slice.start_index;
+        auto stop_it = ( normalized_slice.stop_index < sz ) ? m_vector.begin() + normalized_slice.stop_index : m_vector.end();
+        auto it = std::find( start_it, stop_it, value );
+        if( likely( it != stop_it ) )
+            return it - m_vector.begin();
+    }
+    CSP_THROW( ValueError, "Value not found." ); 
+}
+
+template<typename StorageT>
+void VectorWrapper<StorageT>::remove( const StorageT & value )
+{
+    auto it = std::find( m_vector.begin(), m_vector.end(), value );
+    if( likely( it != m_vector.end() ) )
+        m_vector.erase( it );
+    else
+        CSP_THROW( ValueError, "Value not found." ); 
+}
+
+template<typename StorageT>
+void VectorWrapper<StorageT>::eraseItem( IndexType index )
+{
+    index = verify_index( index );
+    auto it = m_vector.begin() + index;
+    m_vector.erase( it );
+}
+
+template<typename StorageT>
+std::vector<StorageT> VectorWrapper<StorageT>::getSlice( IndexType start_index, IndexType stop_index, IndexType step ) const
+{
+    // We allow list indices that are negative or point outside of the array
+    auto normalized_slice = normalizeSlice( start_index, stop_index, step );
+
+    std::vector<StorageT> result;
+    result.reserve( normalized_slice.length );
+
+    // Go through the slice and copy its elements
+    for( VectorWrapper<StorageT>::IndexType index = normalized_slice.start_index; normalized_slice.belongs( index ); index += normalized_slice.step )
+        result.emplace_back( m_vector[ index ] );
+
+    return result;
+}
+
+template<typename StorageT>
+void VectorWrapper<StorageT>::setSlice( const std::vector<StorageT> & other, IndexType start_index, IndexType stop_index, IndexType step )
+{
+    // We allow list indices that are negative or point outside of the array
+    VectorWrapper<StorageT>::IndexType sz = m_vector.size();
+    auto normalized_slice = normalizeSlice( start_index, stop_index, step );
+
+    // In case of step size 1, mismatch between lengths of the slice and the iterable to be set on the slice is allowed
+    // In that case, we erase the full slice and insert the iterable in place of it
+    if( normalized_slice.step == 1 && normalized_slice.length != ( VectorWrapper<StorageT>::IndexType ) other.size() )
+    {
+        auto start_it = ( normalized_slice.start_index < sz ) ? m_vector.begin() + normalized_slice.start_index : m_vector.end();
+        auto stop_it = ( normalized_slice.stop_index < sz ) ? m_vector.begin() + normalized_slice.stop_index : m_vector.end();
+        if( normalized_slice.length > 0 && normalized_slice.start_index < sz )
+            m_vector.erase( start_it, stop_it );
+        auto it = m_vector.begin() + normalized_slice.start_index;
+        m_vector.insert( it, other.begin(), other.end() );
+    }
+    // In case of step size other then 1, mismatch between lengths of the slice and the iterable to be set on the slice is not allowed
+    else
+    {
+        if( unlikely( normalized_slice.length != ( VectorWrapper<StorageT>::IndexType ) other.size() ) )
+            CSP_THROW( ValueError, "Attempt to assign a sequence of mismatched size to extended slice." );
+        
+        // Go through the slice and assign its elements
+        VectorWrapper<StorageT>::IndexType i = 0;
+        for( VectorWrapper<StorageT>::IndexType index = normalized_slice.start_index; normalized_slice.belongs( index ); index += normalized_slice.step )
+        {
+            m_vector[ index ] = other[ i ];
+            i++;
+        }
+    }
+}
+
+template<typename StorageT>
+void VectorWrapper<StorageT>::eraseSlice( IndexType start_index, IndexType stop_index, IndexType step )
+{
+    // We allow list indices that are negative or point outside of the array
+    VectorWrapper<StorageT>::IndexType sz = m_vector.size();
+    auto normalized_slice = normalizeSlice( start_index, stop_index, step );
+
+    if( normalized_slice.length != 0 )
+    {
+        std::vector<StorageT> result;
+        result.reserve( sz - normalized_slice.length );
+        // Go through the vector and copy elements that don't belong to the slice
+        for( VectorWrapper<StorageT>::IndexType index = 0; index < sz; ++index )
+            if( !normalized_slice.belongs( index ) )
+                result.emplace_back( m_vector[ index ] );
+        m_vector = std::move( result );
+    }
+}
+
+template<typename StorageT>
+void VectorWrapper<StorageT>::repeat( int n )
+{    
+    if( n <= 0 )
+        m_vector.clear();
+    else
+    {
+        VectorWrapper<StorageT>::IndexType sz = m_vector.size();
+        m_vector.resize( sz * n );
+        for( int i = 1; i < n; ++i )
+            std::copy( m_vector.begin(), m_vector.begin() + sz, m_vector.begin() + i * sz );
+    }
+}
+
+}
+
+#endif
diff --git a/csp/impl/struct.py b/csp/impl/struct.py
index 89eaa254..aaf2bcd2 100644
--- a/csp/impl/struct.py
+++ b/csp/impl/struct.py
@@ -1,11 +1,12 @@
 import io
 import ruamel.yaml
 import typing
+from copy import deepcopy
 
 import csp
 from csp.impl.__csptypesimpl import _csptypesimpl
 from csp.impl.types.container_type_normalizer import ContainerTypeNormalizer
-from csp.impl.types.typing_utils import CspTypingUtils
+from csp.impl.types.typing_utils import CspTypingUtils, FastList
 
 # Avoid recreating this object every call its expensive!
 g_YAML = ruamel.yaml.YAML()
@@ -29,6 +30,9 @@ def __new__(cls, name, bases, dct):
         if annotations:
             for k, v in annotations.items():
                 actual_type = v
+                # Lists need to be normalized too as potentially we need to add a boolean flag to use FastList
+                if v == FastList:
+                    raise TypeError(f"{v} annotation is not supported without args")
                 if CspTypingUtils.is_generic_container(v):
                     actual_type = ContainerTypeNormalizer.normalized_type_to_actual_python_type(v)
                     if CspTypingUtils.is_generic_container(actual_type):
@@ -39,10 +43,15 @@ def __new__(cls, name, bases, dct):
                         "struct field '%s' expected field annotation as a type got '%s'" % (k, type(v).__name__)
                     )
 
-                if isinstance(actual_type, list) and (len(actual_type) != 1 or not isinstance(actual_type[0], type)):
+                if isinstance(actual_type, list) and (
+                    len(actual_type) not in (1, 2)
+                    or not isinstance(actual_type[0], type)
+                    or (len(actual_type) == 2 and (not isinstance(actual_type[1], bool) or not actual_type[1]))
+                    or (isinstance(v, list) and len(actual_type) != 1)
+                ):
                     raise TypeError(
-                        "struct field '%s' expected list field annotation to be single element list of type got '%s'"
-                        % (k, type(v).__name__)
+                        "struct field '%s' expected list field annotation to be a single-element list of type got '%s'"
+                        % (k, (actual_type))
                     )
 
                 metadata_typed[k] = v
@@ -108,7 +117,9 @@ def _obj_to_python(cls, obj):
             )
         elif isinstance(obj, dict):
             return {k: cls._obj_to_python(v) for k, v in obj.items()}
-        elif isinstance(obj, (list, tuple, set)):
+        elif (
+            isinstance(obj, (list, tuple, set)) or type(obj).__name__ == "FastList"
+        ):  # hack for FastList that is not a list
             return type(obj)(cls._obj_to_python(v) for v in obj)
         elif isinstance(obj, csp.Enum):
             return obj.name  # handled in _obj_from_python
@@ -123,7 +134,7 @@ def _preprocess_dict_from_python(cls, d):
     def _obj_from_python(cls, json, obj_type):
         obj_type = ContainerTypeNormalizer.normalize_type(obj_type)
         if CspTypingUtils.is_generic_container(obj_type):
-            if CspTypingUtils.get_origin(obj_type) in (typing.List, typing.Set, typing.Tuple):
+            if CspTypingUtils.get_origin(obj_type) in (typing.List, typing.Set, typing.Tuple, FastList):
                 return_type = ContainerTypeNormalizer.normalized_type_to_actual_python_type(obj_type)
                 (expected_item_type,) = obj_type.__args__
                 return_type = list if isinstance(return_type, list) else return_type
@@ -208,7 +219,7 @@ def __dir__(self):
 def defineStruct(name, metadata: dict, defaults: dict = {}, base=Struct):
     """Helper method to dynamically create struct types"""
 
-    dct = defaults.copy()
+    dct = deepcopy(defaults)
     dct["__annotations__"] = metadata
     clazz = StructMeta(name, (base,), dct)
     return clazz
@@ -217,8 +228,8 @@ def defineStruct(name, metadata: dict, defaults: dict = {}, base=Struct):
 def defineNestedStruct(name, metadata: dict, defaults: dict = {}, base=Struct):
     """Helper method to dynamically create nested struct types.
     metadata and defaults can be a nested dictionaries"""
-    metadata = metadata.copy()
-    defaults = defaults.copy()
+    metadata = deepcopy(metadata)
+    defaults = deepcopy(defaults)
     child_structs = {
         field: defineNestedStruct(f"{name}_{field}", submeta, defaults.get(field, {}))
         for field, submeta in metadata.items()
diff --git a/csp/impl/types/container_type_normalizer.py b/csp/impl/types/container_type_normalizer.py
index a4361839..b4bb4a32 100644
--- a/csp/impl/types/container_type_normalizer.py
+++ b/csp/impl/types/container_type_normalizer.py
@@ -2,7 +2,7 @@
 import typing
 
 import csp.typing
-from csp.impl.types.typing_utils import CspTypingUtils
+from csp.impl.types.typing_utils import CspTypingUtils, FastList
 
 
 class ContainerTypeNormalizer:
@@ -56,6 +56,8 @@ def _convert_containers_to_typing_generic_meta(cls, typ, is_within_container):
     @classmethod
     def normalized_type_to_actual_python_type(cls, typ, level=0):
         if CspTypingUtils.is_generic_container(typ):
+            if CspTypingUtils.get_origin(typ) is FastList and level == 0:
+                return [cls.normalized_type_to_actual_python_type(typ.__args__[0], level + 1), True]
             if CspTypingUtils.get_origin(typ) is typing.List and level == 0:
                 return [cls.normalized_type_to_actual_python_type(typ.__args__[0], level + 1)]
             return cls._NORMALIZED_TYPE_MAPPING.get(CspTypingUtils.get_origin(typ), typ)
diff --git a/csp/impl/types/instantiation_type_resolver.py b/csp/impl/types/instantiation_type_resolver.py
index baafef2e..7945b84f 100644
--- a/csp/impl/types/instantiation_type_resolver.py
+++ b/csp/impl/types/instantiation_type_resolver.py
@@ -10,7 +10,7 @@
 from csp.impl.types.container_type_normalizer import ContainerTypeNormalizer
 from csp.impl.types.numpy_type_util import map_numpy_dtype_to_python_type
 from csp.impl.types.tstype import AttachType, SnapKeyType, SnapType, TsType, isTsDynamicBasket
-from csp.impl.types.typing_utils import CspTypingUtils
+from csp.impl.types.typing_utils import CspTypingUtils, FastList
 from csp.impl.wiring.edge import Edge
 
 
@@ -250,7 +250,13 @@ def _resolve_types(self):
 
     def _is_expected_generic_meta(self, typ, expected_generic_meta):
         is_generic_container = CspTypingUtils.is_generic_container(typ)
-        return (is_generic_container and CspTypingUtils.get_origin(typ) is expected_generic_meta) or (
+        return (
+            is_generic_container
+            and (
+                CspTypingUtils.get_origin(typ) is expected_generic_meta
+                or (expected_generic_meta is typing.List and CspTypingUtils.get_origin(typ) is FastList)
+            )
+        ) or (
             not is_generic_container
             and isinstance(expected_generic_meta, typ)
             and issubclass(expected_generic_meta, typ)
diff --git a/csp/impl/types/typing_utils.py b/csp/impl/types/typing_utils.py
index 9a362e2d..30d0ad83 100644
--- a/csp/impl/types/typing_utils.py
+++ b/csp/impl/types/typing_utils.py
@@ -4,6 +4,13 @@
 
 import csp.typing
 
+T = typing.TypeVar("T")
+
+
+class FastList(typing.Generic[T]):
+    def __init__(self):
+        raise NotImplementedError("Can not init FastList class")
+
 
 class CspTypingUtils37:
     _ORIGIN_COMPAT_MAP = {list: typing.List, set: typing.Set, dict: typing.Dict, tuple: typing.Tuple}
diff --git a/csp/tests/impl/test_struct.py b/csp/tests/impl/test_struct.py
index 6f76339a..33fc3b44 100644
--- a/csp/tests/impl/test_struct.py
+++ b/csp/tests/impl/test_struct.py
@@ -7,6 +7,7 @@
 
 import csp
 from csp.impl.struct import defineStruct
+from csp.impl.types.typing_utils import FastList
 
 
 class MyEnum(csp.Enum):
@@ -21,9 +22,9 @@ class StructNoDefaults(csp.Struct):
     s: str
     bt: bytes
     o: object
-    a1: [int]
+    a1: FastList[int]
     a2: [str]
-    a3: [object]
+    a3: FastList[object]
     a4: [bytes]
 
 
@@ -34,7 +35,7 @@ class StructWithDefaults(csp.Struct):
     s: str = "456"
     e: MyEnum = MyEnum.FOO
     o: object
-    a1: [int] = [1, 2, 3]
+    a1: FastList[int] = [1, 2, 3]
     a2: [str] = ["1", "2", "3"]
     a3: [object] = ["hey", 123, (1, 2, 3)]
     np_arr: np.ndarray = np.array([1, 9])
@@ -72,7 +73,7 @@ class BaseMixed(csp.Struct):
     l: list
     o: object
     a1: [int]
-    a2: [str]
+    a2: FastList[str]
     a3: [object]
 
 
@@ -123,6 +124,7 @@ class StructWithMutableStruct(csp.Struct):
 class StructWithLists(csp.Struct):
     # native_list: [int]
     struct_list: [BaseNative]
+    fast_list: FastList[BaseNative]
     dialect_generic_list: [list]
 
 
@@ -138,6 +140,7 @@ class AllTypes(csp.Struct):
     e: MyEnum = MyEnum.FOO
     struct: BaseNative = BaseNative(i=123, b=True, f=456.789)
     arr: [int] = [1, 2, 3]
+    fl: FastList[int] = [1, 2, 3, 4]
     o: object = {"k": "v"}
 
 
@@ -166,12 +169,12 @@ def __init__(self, x: int):
         self.x = x
 
 
-# Common set of values for PyStructList tests
+# Common set of values for Struct list field tests
 # For each type:
 # items[:-2] are normal values of the given type that should be handled,
 # items[-2] is a normal value for non-generic and non-str types and None for generic and str types (the purpose is to test the raise of TypeError if a single object instead of a sequence is passed),
 # items[-1] is a value of a different type that is not convertible to the give type for non-generic types and None for generic types (the purpose is to test the raise of TypeError if an object of the wrong type is passed).
-pystruct_list_test_values = {
+struct_list_test_values = {
     int: [4, 2, 3, 5, 6, 7, 8, "s"],
     bool: [True, True, True, False, True, False, True, 2],
     float: [1.4, 3.2, 2.7, 1.0, -4.5, -6.0, -2.0, "s"],
@@ -258,6 +261,7 @@ def __init__(self, x: int):
         None,
     ],  # generic type user-defined
 }
+struct_list_annotation_types = (typing.List, FastList)
 
 
 class TestCspStruct(unittest.TestCase):
@@ -482,15 +486,20 @@ def test_deepcopy(self):
         o.s.l[0] = -1
         self.assertNotEqual(o, o_deepcopy)
 
-        o = StructWithLists(struct_list=[BaseNative(i=123)], dialect_generic_list=[{"a": 1}])
+        o = StructWithLists(
+            struct_list=[BaseNative(i=123)], fast_list=[BaseNative(i=123)], dialect_generic_list=[{"a": 1}]
+        )
 
         o_deepcopy = o.deepcopy()
         o.struct_list[0].i = -1
+        o.fast_list[0].i = -2
         o.dialect_generic_list[0]["b"] = 2
 
         self.assertEqual(o.struct_list[0].i, -1)
+        self.assertEqual(o.fast_list[0].i, -2)
         self.assertEqual(o.dialect_generic_list[0], {"a": 1, "b": 2})
         self.assertEqual(o_deepcopy.struct_list[0].i, 123)
+        self.assertEqual(o_deepcopy.fast_list[0].i, 123)
         self.assertEqual(o_deepcopy.dialect_generic_list[0], {"a": 1})
 
         # TODO struct deepcopy doesnt actually account for this case right now, which relies on memo passing
@@ -687,17 +696,22 @@ def test_copy_from_unsets(self):
         self.assertFalse(hasattr(dest2, "a1"))
 
     def test_deepcopy_from(self):
-        source = StructWithLists(struct_list=[BaseNative(i=123)], dialect_generic_list=[{"a": 1}])
+        source = StructWithLists(
+            struct_list=[BaseNative(i=123)], fast_list=[BaseNative(i=123)], dialect_generic_list=[{"a": 1}]
+        )
 
         blank = StructWithLists()
         blank.deepcopy_from(source)
 
         source.struct_list[0].i = -1
+        source.fast_list[0].i = -2
         source.dialect_generic_list[0]["b"] = 2
 
         self.assertEqual(source.struct_list[0].i, -1)
+        self.assertEqual(source.fast_list[0].i, -2)
         self.assertEqual(source.dialect_generic_list[0], {"a": 1, "b": 2})
         self.assertEqual(blank.struct_list[0].i, 123)
+        self.assertEqual(blank.fast_list[0].i, 123)
         self.assertEqual(blank.dialect_generic_list[0], {"a": 1})
 
     def test_update_from(self):
@@ -1049,21 +1063,31 @@ def test_defineNestedStruct(self):
                 "x": MyEnum,
                 "y": [int],
             },
-            "d": {"s": object, "t": [object]},
+            "d": {"s": object, "t": FastList[object]},
+        }
+
+        normalized_metadata = {
+            "a": float,
+            "b": int,
+            "c": {
+                "x": MyEnum,
+                "y": [int],
+            },
+            "d": {"s": object, "t": [object, True]},
         }
         TestStruct = defineNestedStruct("TestStruct", metadata)
         self.assertEqual(TestStruct.__name__, "TestStruct")
-        self.assertEqual(list(TestStruct.metadata().keys()), ["a", "b", "c", "d"])
-        self.assertEqual(TestStruct.metadata()["a"], float)
-        self.assertEqual(TestStruct.metadata()["b"], int)
+        self.assertEqual(list(TestStruct.metadata().keys()), list(normalized_metadata.keys()))
+        self.assertEqual(TestStruct.metadata()["a"], normalized_metadata["a"])
+        self.assertEqual(TestStruct.metadata()["b"], normalized_metadata["b"])
         c = TestStruct.metadata()["c"]
         self.assertTrue(issubclass(c, csp.Struct))
         self.assertEqual(c.__name__, "TestStruct_c")
-        self.assertEqual(c.metadata(), metadata["c"])
+        self.assertEqual(c.metadata(), normalized_metadata["c"])
         d = TestStruct.metadata()["d"]
         self.assertTrue(issubclass(d, csp.Struct))
         self.assertEqual(d.__name__, "TestStruct_d")
-        self.assertEqual(d.metadata(), metadata["d"])
+        self.assertEqual(d.metadata(), normalized_metadata["d"])
 
         defaults = {"a": 0.0, "c": {"y": []}, "d": {}}
         TestStruct2 = defineNestedStruct("TestStruct2", metadata, defaults)
@@ -1886,170 +1910,190 @@ def custom_jsonifier(obj):
 
     def test_list_field_append(self):
         """Was a BUG when the struct with list field was not recognizing changes made to this field in python"""
-        for typ, v in pystruct_list_test_values.items():
+        for ann_typ in struct_list_annotation_types:
+            for typ, v in struct_list_test_values.items():
 
-            class A(csp.Struct):
-                a: [typ]
+                class A(csp.Struct):
+                    a: ann_typ[typ]
 
-            s = A(a=[])
-            s.a.append(v[0])
+                s = A(a=[])
+                s.a.append(v[0])
 
-            self.assertEqual(s.a, [v[0]])
+                self.assertEqual(s.a, [v[0]])
 
-            s.a.append(v[1])
-            s.a.append(v[2])
+                s.a.append(v[1])
+                s.a.append(v[2])
 
-            self.assertEqual(s.a, [v[0], v[1], v[2]])
+                self.assertEqual(s.a, [v[0], v[1], v[2]])
 
-            # Check if not generic type
-            if v[-1] is not None:
-                with self.assertRaises(TypeError) as e:
-                    s.a.append(v[-1])
+                # Check if not generic type
+                if v[-1] is not None:
+                    with self.assertRaises(TypeError) as e:
+                        s.a.append(v[-1])
 
     def test_list_field_insert(self):
         """Was a BUG when the struct with list field was not recognizing changes made to this field in python"""
-        for typ, v in pystruct_list_test_values.items():
+        for ann_typ in struct_list_annotation_types:
+            for typ, v in struct_list_test_values.items():
 
-            class A(csp.Struct):
-                a: [typ]
+                class A(csp.Struct):
+                    a: ann_typ[typ]
 
-            s = A(a=[])
-            s.a.insert(0, v[0])
+                s = A(a=[])
+                s.a.insert(0, v[0])
 
-            self.assertEqual(s.a, [v[0]])
+                self.assertEqual(s.a, [v[0]])
 
-            s.a.insert(1, v[1])
-            s.a.insert(1, v[2])
+                s.a.insert(1, v[1])
+                s.a.insert(1, v[2])
 
-            self.assertEqual(s.a, [v[0], v[2], v[1]])
+                self.assertEqual(s.a, [v[0], v[2], v[1]])
 
-            s.a.insert(-1, v[3])
+                s.a.insert(-1, v[3])
 
-            self.assertEqual(s.a, [v[0], v[2], v[3], v[1]])
+                self.assertEqual(s.a, [v[0], v[2], v[3], v[1]])
 
-            s.a.insert(100, v[4])
-            s.a.insert(-100, v[5])
+                s.a.insert(100, v[4])
+                s.a.insert(-100, v[5])
 
-            self.assertEqual(s.a, [v[5], v[0], v[2], v[3], v[1], v[4]])
+                self.assertEqual(s.a, [v[5], v[0], v[2], v[3], v[1], v[4]])
 
-            # Check if not generic type
-            if v[-1] is not None:
-                with self.assertRaises(TypeError) as e:
-                    s.a.insert(-1, v[-1])
+                # Check if not generic type
+                if v[-1] is not None:
+                    with self.assertRaises(TypeError) as e:
+                        s.a.insert(-1, v[-1])
 
     def test_list_field_pop(self):
         """Was a BUG when the struct with list field was not recognizing changes made to this field in python"""
-        for typ, v in pystruct_list_test_values.items():
+        for ann_typ in struct_list_annotation_types:
+            for typ, v in struct_list_test_values.items():
 
-            class A(csp.Struct):
-                a: [typ]
+                class A(csp.Struct):
+                    a: ann_typ[typ]
 
-            s = A(a=[v[0], v[1], v[2], v[3], v[4]])
-            b = s.a.pop()
+                s = A(a=[v[0], v[1], v[2], v[3], v[4]])
+                b = s.a.pop()
 
-            self.assertEqual(s.a, [v[0], v[1], v[2], v[3]])
-            self.assertEqual(b, v[4])
+                self.assertEqual(s.a, [v[0], v[1], v[2], v[3]])
+                self.assertEqual(b, v[4])
 
-            b = s.a.pop(-1)
+                b = s.a.pop(-1)
 
-            self.assertEqual(s.a, [v[0], v[1], v[2]])
-            self.assertEqual(b, v[3])
+                self.assertEqual(s.a, [v[0], v[1], v[2]])
+                self.assertEqual(b, v[3])
 
-            b = s.a.pop(1)
+                b = s.a.pop(1)
 
-            self.assertEqual(s.a, [v[0], v[2]])
-            self.assertEqual(b, v[1])
+                self.assertEqual(s.a, [v[0], v[2]])
+                self.assertEqual(b, v[1])
 
-            with self.assertRaises(IndexError) as e:
-                s.a.pop()
-                s.a.pop()
-                s.a.pop()
+                with self.assertRaises(IndexError) as e:
+                    s.a.pop()
+                    s.a.pop()
+                    s.a.pop()
 
-            s = A(a=[v[0], v[1], v[2], v[3], v[4]])
+                s = A(a=[v[0], v[1], v[2], v[3], v[4]])
 
-            b = s.a.pop(-3)
+                b = s.a.pop(-3)
 
-            self.assertEqual(s.a, [v[0], v[1], v[3], v[4]])
-            self.assertEqual(b, v[2])
+                self.assertEqual(s.a, [v[0], v[1], v[3], v[4]])
+                self.assertEqual(b, v[2])
 
-            with self.assertRaises(IndexError) as e:
-                s.a.pop(-5)
+                with self.assertRaises(IndexError) as e:
+                    s.a.pop(-5)
 
-            with self.assertRaises(IndexError) as e:
-                s.a.pop(4)
+                with self.assertRaises(IndexError) as e:
+                    s.a.pop(4)
 
     def test_list_field_set_item(self):
         """Was a BUG when the struct with list field was not recognizing changes made to this field in python"""
-        for typ, v in pystruct_list_test_values.items():
+        for ann_typ in struct_list_annotation_types:
+            for typ, v in struct_list_test_values.items():
 
-            class A(csp.Struct):
-                a: [typ]
+                class A(csp.Struct):
+                    a: ann_typ[typ]
 
-            s = A(a=[v[0], v[1], v[2]])
-            s.a.__setitem__(0, v[3])
+                s = A(a=[v[0], v[1], v[2]])
+                s.a.__setitem__(0, v[3])
 
-            self.assertEqual(s.a, [v[3], v[1], v[2]])
+                self.assertEqual(s.a, [v[3], v[1], v[2]])
 
-            s.a[1] = v[4]
+                s.a[1] = v[4]
 
-            self.assertEqual(s.a, [v[3], v[4], v[2]])
+                self.assertEqual(s.a, [v[3], v[4], v[2]])
 
-            s.a[-1] = v[5]
+                s.a[-1] = v[5]
 
-            self.assertEqual(s.a, [v[3], v[4], v[5]])
+                self.assertEqual(s.a, [v[3], v[4], v[5]])
 
-            with self.assertRaises(IndexError) as e:
-                s.a[100] = v[0]
+                with self.assertRaises(IndexError) as e:
+                    s.a[100] = v[0]
 
-            with self.assertRaises(IndexError) as e:
-                s.a[-100] = v[0]
+                with self.assertRaises(IndexError) as e:
+                    s.a[-100] = v[0]
 
-            s.a[5:6] = [v[0], v[1], v[2]]
+                s.a[5:6] = [v[0], v[0], v[0]]
 
-            self.assertEqual(s.a, [v[3], v[4], v[5], v[0], v[1], v[2]])
+                self.assertEqual(s.a, [v[3], v[4], v[5], v[0], v[0], v[0]])
 
-            s.a[2:4] = [v[2]]
+                s.a[4:] = [v[1], v[2]]
 
-            self.assertEqual(s.a, [v[3], v[4], v[2], v[1], v[2]])
+                self.assertEqual(s.a, [v[3], v[4], v[5], v[0], v[1], v[2]])
 
-            s.a[3:5] = [v[0], v[5]]
+                s.a[2:4] = [v[2]]
 
-            self.assertEqual(s.a, [v[3], v[4], v[2], v[0], v[5]])
+                self.assertEqual(s.a, [v[3], v[4], v[2], v[1], v[2]])
 
-            s.a[1:10:2] = [v[1], v[2]]
+                s.a[3:5] = [v[0], v[5]]
 
-            self.assertEqual(s.a, [v[3], v[1], v[2], v[2], v[5]])
+                self.assertEqual(s.a, [v[3], v[4], v[2], v[0], v[5]])
 
-            # Check if not str or generic type (as str is a sequence of str)
-            if v[-2] is not None:
-                with self.assertRaises(TypeError) as e:
-                    s.a[1:4] = v[-2]
+                s.a[1:10:2] = [v[1], v[2]]
 
-            self.assertEqual(s.a, [v[3], v[1], v[2], v[2], v[5]])
+                self.assertEqual(s.a, [v[3], v[1], v[2], v[2], v[5]])
 
-            # Check if not generic type
-            if v[-1] is not None:
-                with self.assertRaises(TypeError) as e:
-                    s.a[1:4] = [v[-1]]
+                # Check if not str or generic type (as str is a sequence of str)
+                if v[-2] is not None:
+                    with self.assertRaises(TypeError) as e:
+                        s.a[1:4] = v[-2]
+
+                self.assertEqual(s.a, [v[3], v[1], v[2], v[2], v[5]])
 
-            self.assertEqual(s.a, [v[3], v[1], v[2], v[2], v[5]])
+                # Check if not generic type
+                if v[-1] is not None:
+                    with self.assertRaises(TypeError) as e:
+                        s.a[1:4] = [v[-1]]
 
-            with self.assertRaises(ValueError) as e:
-                s.a[1:10:2] = [v[0]]
+                self.assertEqual(s.a, [v[3], v[1], v[2], v[2], v[5]])
 
-            self.assertEqual(s.a, [v[3], v[1], v[2], v[2], v[5]])
+                with self.assertRaises(ValueError) as e:
+                    s.a[1:10:2] = [v[0]]
+
+                self.assertEqual(s.a, [v[3], v[1], v[2], v[2], v[5]])
+
+                s.a[:2:-1] = [v[3], v[4]]
+
+                self.assertEqual(s.a, [v[3], v[1], v[2], v[4], v[3]])
+
+                with self.assertRaises(ValueError) as e:
+                    s.a[-1:1:-2] = [v[0]]
+
+                s.a[-1:1:-2] = [v[0], v[5]]
+
+                self.assertEqual(s.a, [v[3], v[1], v[5], v[4], v[0]])
 
     def test_list_field_reverse(self):
         """Was a BUG when the struct with list field was not recognizing changes made to this field in python"""
-        for typ, v in pystruct_list_test_values.items():
+        for ann_typ in struct_list_annotation_types:
+            for typ, v in struct_list_test_values.items():
 
-            class A(csp.Struct):
-                a: [typ]
+                class A(csp.Struct):
+                    a: ann_typ[typ]
 
-            s = A(a=[v[0], v[1], v[2], v[3]])
-            s.a.reverse()
+                s = A(a=[v[0], v[1], v[2], v[3]])
+                s.a.reverse()
 
-            self.assertEqual(s.a, [v[3], v[2], v[1], v[0]])
+                self.assertEqual(s.a, [v[3], v[2], v[1], v[0]])
 
     def test_list_field_sort(self):
         """Was a BUG when the struct with list field was not recognizing changes made to this field in python"""
@@ -2088,194 +2132,613 @@ def test_list_field_sort(self):
             str: ["s", "xyz", "w", "w", "bds", "a", None],
         }
 
-        for typ, v in values.items():
+        for ann_typ in struct_list_annotation_types:
+            for typ, v in values.items():
 
-            class A(csp.Struct):
-                a: [typ]
+                class A(csp.Struct):
+                    a: ann_typ[typ]
 
-            s = A(a=[v[0], v[1], v[2], v[3], v[4], v[5]])
+                s = A(a=[v[0], v[1], v[2], v[3], v[4], v[5]])
 
-            s.a.sort()
+                s.a.sort()
 
-            self.assertEqual(s.a, [v[5], v[4], v[0], v[2], v[3], v[1]])
+                self.assertEqual(s.a, [v[5], v[4], v[0], v[2], v[3], v[1]])
 
-            s.a.sort(reverse=True)
+                s.a.sort(reverse=True)
 
-            self.assertEqual(s.a, [v[1], v[2], v[3], v[0], v[4], v[5]])
+                self.assertEqual(s.a, [v[1], v[2], v[3], v[0], v[4], v[5]])
 
-            with self.assertRaises(TypeError) as e:
-                s.a.sort(1)
+                with self.assertRaises(TypeError) as e:
+                    s.a.sort(1)
 
-            with self.assertRaises(TypeError) as e:
-                s.a.sort(key=abs, a=3)
+                with self.assertRaises(TypeError) as e:
+                    s.a.sort(key=abs, a=3)
+
+                # Check if sorting key abs() is defined
+                if v[6] is not None:
+                    s.a.sort(key=abs)
+
+                    self.assertEqual(s.a, [v[0], v[4], v[2], v[3], v[1], v[5]])
 
-            # Check if sorting key abs() is defined
-            if v[6] is not None:
-                s.a.sort(key=abs)
+            class B(csp.Struct):
+                a: [MyEnum]
 
-                self.assertEqual(s.a, [v[0], v[4], v[2], v[3], v[1], v[5]])
+            s = B(a=[MyEnum.A, MyEnum.FOO])
+
+            with self.assertRaises(TypeError) as e:
+                s.a.sort()
+            with self.assertRaises(TypeError) as e:
+                s.a.sort(reverse=True)
+            s.a.sort(reverse=True, key=str)
+            self.assertEqual(s.a, [MyEnum.FOO, MyEnum.A])
 
     def test_list_field_extend(self):
         """Was a BUG when the struct with list field was not recognizing changes made to this field in python"""
-        for typ, v in pystruct_list_test_values.items():
+        for ann_typ in struct_list_annotation_types:
+            for typ, v in struct_list_test_values.items():
 
-            class A(csp.Struct):
-                a: [typ]
+                class A(csp.Struct):
+                    a: ann_typ[typ]
 
-            s = A(a=[v[0], v[1], v[2]])
-            s.a.extend([v[3]])
+                s = A(a=[v[0], v[1], v[2]])
+                s.a.extend([v[3]])
 
-            self.assertEqual(s.a, [v[0], v[1], v[2], v[3]])
+                self.assertEqual(s.a, [v[0], v[1], v[2], v[3]])
 
-            s.a.extend([])
-            s.a.extend((v[4], v[5]))
+                s.a.extend([])
+                s.a.extend((v[4], v[5]))
 
-            self.assertEqual(s.a, [v[0], v[1], v[2], v[3], v[4], v[5]])
+                self.assertEqual(s.a, [v[0], v[1], v[2], v[3], v[4], v[5]])
 
-            # Check if not str or generic type (as str is a sequence of str)
-            if v[-2] is not None:
-                with self.assertRaises(TypeError) as e:
-                    s.a.extend(v[-2])
+                # Check if not str or generic type (as str is a sequence of str)
+                if v[-2] is not None:
+                    with self.assertRaises(TypeError) as e:
+                        s.a.extend(v[-2])
 
-            # Check if not generic type
-            if v[-1] is not None:
-                with self.assertRaises(TypeError) as e:
-                    s.a.extend([v[-1]])
+                # Check if not generic type
+                if v[-1] is not None:
+                    with self.assertRaises(TypeError) as e:
+                        s.a.extend([v[-1]])
 
     def test_list_field_remove(self):
         """Was a BUG when the struct with list field was not recognizing changes made to this field in python"""
-        for typ, v in pystruct_list_test_values.items():
+        for ann_typ in struct_list_annotation_types:
+            for typ, v in struct_list_test_values.items():
 
-            class A(csp.Struct):
-                a: [typ]
+                class A(csp.Struct):
+                    a: ann_typ[typ]
 
-            s = A(a=[v[0], v[1], v[0], v[2]])
-            s.a.remove(v[0])
+                s = A(a=[v[0], v[1], v[0], v[2]])
+                s.a.remove(v[0])
 
-            self.assertEqual(s.a, [v[1], v[0], v[2]])
+                self.assertEqual(s.a, [v[1], v[0], v[2]])
 
-            s.a.remove(v[2])
+                s.a.remove(v[2])
 
-            self.assertEqual(s.a, [v[1], v[0]])
+                self.assertEqual(s.a, [v[1], v[0]])
 
-            with self.assertRaises(ValueError) as e:
-                s.a.remove(v[3])
+                with self.assertRaises(ValueError) as e:
+                    s.a.remove(v[3])
 
     def test_list_field_clear(self):
         """Was a BUG when the struct with list field was not recognizing changes made to this field in python"""
-        for typ, v in pystruct_list_test_values.items():
+        for ann_typ in struct_list_annotation_types:
+            for typ, v in struct_list_test_values.items():
 
-            class A(csp.Struct):
-                a: [typ]
+                class A(csp.Struct):
+                    a: ann_typ[typ]
 
-            s = A(a=[v[0], v[1], v[2], v[3]])
-            s.a.clear()
+                s = A(a=[v[0], v[1], v[2], v[3]])
+                s.a.clear()
 
-            self.assertEqual(s.a, [])
+                self.assertEqual(s.a, [])
 
     def test_list_field_del(self):
         """Was a BUG when the struct with list field was not recognizing changes made to this field in python"""
-        for typ, v in pystruct_list_test_values.items():
+        for ann_typ in struct_list_annotation_types:
+            for typ, v in struct_list_test_values.items():
 
-            class A(csp.Struct):
-                a: [typ]
+                class A(csp.Struct):
+                    a: ann_typ[typ]
+
+                s = A(a=[v[0], v[1], v[2], v[3]])
+                del s.a[0]
+
+                self.assertEqual(s.a, [v[1], v[2], v[3]])
 
-            s = A(a=[v[0], v[1], v[2], v[3]])
-            del s.a[0]
+                del s.a[1]
 
-            self.assertEqual(s.a, [v[1], v[2], v[3]])
+                self.assertEqual(s.a, [v[1], v[3]])
 
-            del s.a[1]
+                s = A(a=[v[0], v[1], v[2], v[3]])
+                del s.a[1:3]
 
-            self.assertEqual(s.a, [v[1], v[3]])
+                self.assertEqual(s.a, [v[0], v[3]])
 
-            s = A(a=[v[0], v[1], v[2], v[3]])
-            del s.a[1:3]
+                del s.a[5:100]
 
-            self.assertEqual(s.a, [v[0], v[3]])
+                self.assertEqual(s.a, [v[0], v[3]])
 
-            del s.a[5:100]
+                del s.a[1:]
 
-            self.assertEqual(s.a, [v[0], v[3]])
+                self.assertEqual(s.a, [v[0]])
 
-            with self.assertRaises(IndexError) as e:
-                del s.a[5]
+                s = A(a=[v[0], v[1], v[2], v[3]])
+                del s.a[:1:-1]
+
+                self.assertEqual(s.a, [v[0], v[1]])
+
+                with self.assertRaises(IndexError) as e:
+                    del s.a[5]
 
     def test_list_field_inplace_concat(self):
         """Was a BUG when the struct with list field was not recognizing changes made to this field in python"""
-        for typ, v in pystruct_list_test_values.items():
-
-            class A(csp.Struct):
-                a: [typ]
+        for ann_typ in struct_list_annotation_types:
+            for typ, v in struct_list_test_values.items():
 
-            s = A(a=[v[0], v[1]])
-            s.a.__iadd__([v[2], v[3]])
+                class A(csp.Struct):
+                    a: ann_typ[typ]
 
-            self.assertEqual(s.a, [v[0], v[1], v[2], v[3]])
+                s = A(a=[v[0], v[1]])
+                s.a.__iadd__([v[2], v[3]])
 
-            s.a += (v[4], v[5])
+                self.assertEqual(s.a, [v[0], v[1], v[2], v[3]])
 
-            self.assertEqual(s.a, [v[0], v[1], v[2], v[3], v[4], v[5]])
+                s.a += (v[4], v[5])
 
-            s.a += []
+                self.assertEqual(s.a, [v[0], v[1], v[2], v[3], v[4], v[5]])
 
-            self.assertEqual(s.a, [v[0], v[1], v[2], v[3], v[4], v[5]])
+                s.a += []
 
-            with self.assertRaises(TypeError) as e:
-                s.a += v[-1]
+                self.assertEqual(s.a, [v[0], v[1], v[2], v[3], v[4], v[5]])
 
-            # Check if not generic type
-            if v[-1] is not None:
                 with self.assertRaises(TypeError) as e:
-                    s.a += [v[-1]]
+                    s.a += v[-1]
 
-            self.assertEqual(s.a, [v[0], v[1], v[2], v[3], v[4], v[5]])
+                # Check if not generic type
+                if v[-1] is not None:
+                    with self.assertRaises(TypeError) as e:
+                        s.a += [v[-1]]
+
+                self.assertEqual(s.a, [v[0], v[1], v[2], v[3], v[4], v[5]])
 
     def test_list_field_inplace_repeat(self):
         """Was a BUG when the struct with list field was not recognizing changes made to this field in python"""
-        for typ, v in pystruct_list_test_values.items():
+        for ann_typ in struct_list_annotation_types:
+            for typ, v in struct_list_test_values.items():
+
+                class A(csp.Struct):
+                    a: ann_typ[typ]
+
+                s = A(a=[v[0], v[1]])
+                s.a.__imul__(1)
+
+                self.assertEqual(s.a, [v[0], v[1]])
+
+                s.a *= 2
+
+                self.assertEqual(s.a, [v[0], v[1], v[0], v[1]])
+
+                with self.assertRaises(TypeError) as e:
+                    s.a *= [3]
+
+                with self.assertRaises(TypeError) as e:
+                    s.a *= "s"
+
+                s.a *= 0
+
+                self.assertEqual(s.a, [])
+
+                s.a += [v[2], v[3]]
+
+                self.assertEqual(s.a, [v[2], v[3]])
+
+                s.a *= -1
+
+                self.assertEqual(s.a, [])
+
+    def test_list_field_lifetime(self):
+        """Ensure that the lifetime of struct list field exceeds the lifetime of struct holding it"""
+        for ann_typ in struct_list_annotation_types:
 
             class A(csp.Struct):
-                a: [typ]
+                a: ann_typ[int]
+
+            s = A(a=[1, 2, 3])
+            l = s.a
+            del s
 
-            s = A(a=[v[0], v[1]])
-            s.a.__imul__(1)
+            self.assertEqual(l, [1, 2, 3])
 
-            self.assertEqual(s.a, [v[0], v[1]])
+    def test_list_field_len(self):
+        """Ensure that non-list-modifying operations on list fields work fine"""
+        for ann_typ in struct_list_annotation_types:
+            for typ, v in struct_list_test_values.items():
 
-            s.a *= 2
+                class A(csp.Struct):
+                    a: ann_typ[typ]
 
-            self.assertEqual(s.a, [v[0], v[1], v[0], v[1]])
+                s = A(a=[v[0], v[1]])
 
-            with self.assertRaises(TypeError) as e:
-                s.a *= [3]
+                self.assertEqual(len(s.a), 2)
+
+                s.a *= 2
+
+                self.assertEqual(len(s.a), 4)
+
+                s.a.clear()
+
+                self.assertEqual(len(s.a), 0)
+
+    def test_list_field_repr(self):
+        """Ensure that non-list-modifying operations on list fields work fine"""
+        for ann_typ in struct_list_annotation_types:
+            for typ, v in struct_list_test_values.items():
+                # Excluding str due to own repr implementation
+                if typ != str:
+
+                    class A(csp.Struct):
+                        a: ann_typ[typ]
+
+                    s = A(a=[v[0], v[1]])
+
+                    self.assertEqual(repr(s.a), f"[{repr(v[0])}, {repr(v[1])}]")
+
+                    s.a *= 2
+
+                    self.assertEqual(repr(s.a), f"[{repr(v[0])}, {repr(v[1])}, {repr(v[0])}, {repr(v[1])}]")
+
+                    s.a.clear()
+
+                    self.assertEqual(repr(s.a), "[]")
+
+    def test_list_field_str(self):
+        """Ensure that non-list-modifying operations on list fields work fine"""
+        for ann_typ in struct_list_annotation_types:
+            for typ, v in struct_list_test_values.items():
+                # Excluding str due to own repr implementation
+                if typ != str:
+
+                    class A(csp.Struct):
+                        a: ann_typ[typ]
+
+                    s = A(a=[v[0], v[1]])
+
+                    self.assertEqual(str(s.a), f"[{repr(v[0])}, {repr(v[1])}]")
+
+                    s.a *= 2
+
+                    self.assertEqual(str(s.a), f"[{repr(v[0])}, {repr(v[1])}, {repr(v[0])}, {repr(v[1])}]")
+
+                    s.a.clear()
+
+                    self.assertEqual(str(s.a), "[]")
+
+    def test_list_field_get_item(self):
+        """Ensure that non-list-modifying operations on list fields work fine"""
+        for ann_typ in struct_list_annotation_types:
+            for typ, v in struct_list_test_values.items():
+
+                class A(csp.Struct):
+                    a: ann_typ[typ]
+
+                s = A(a=[v[0], v[1], v[2]])
+
+                self.assertEqual(s.a.__getitem__(0), v[0])
+
+                self.assertEqual(s.a[1], v[1])
+
+                self.assertEqual(s.a[-1], v[2])
+
+                with self.assertRaises(IndexError) as e:
+                    b = s.a[100]
+
+                with self.assertRaises(IndexError) as e:
+                    b = s.a[-100]
+
+                self.assertEqual(s.a[5:6], [])
+
+                self.assertEqual(s.a[1:], [v[1], v[2]])
+
+                self.assertEqual(s.a[1:2], [v[1]])
+
+                self.assertEqual(s.a[:10:2], [v[0], v[2]])
+
+                self.assertEqual(s.a[-1::-1], [v[2], v[1], v[0]])
+
+                self.assertEqual(s.a[-1:-3:-1], [v[2], v[1]])
+
+    def test_list_field_copy(self):
+        """Ensure that non-list-modifying operations on list fields work fine"""
+        for ann_typ in struct_list_annotation_types:
+            for typ, v in struct_list_test_values.items():
+
+                class A(csp.Struct):
+                    a: ann_typ[typ]
+
+                s = A(a=[v[0], v[1], v[2]])
+
+                self.assertEqual(s.a.copy(), [v[0], v[1], v[2]])
+
+                b = s.a.copy()
+                b.append(v[4])
+                s.a.append(v[3])
+
+                self.assertEqual(s.a, [v[0], v[1], v[2], v[3]])
+                self.assertEqual(b, [v[0], v[1], v[2], v[4]])
 
+                with self.assertRaises(TypeError) as e:
+                    s.a.copy(1)
+
+                with self.assertRaises(TypeError) as e:
+                    s.a.copy(s=2)
+
+                with self.assertRaises(IndexError) as e:
+                    b = s.a[-100]
+
+                self.assertEqual(type(s.a.copy()), list)
+
+    def test_list_field_index(self):
+        """Ensure that non-list-modifying operations on list fields work fine"""
+        for ann_typ in struct_list_annotation_types:
+            for typ, v in struct_list_test_values.items():
+
+                class A(csp.Struct):
+                    a: ann_typ[typ]
+
+                s = A(a=[v[0], v[3], v[0]])
+
+                self.assertEqual(s.a.index(v[0]), 0)
+
+                self.assertEqual(s.a.index(v[3]), 1)
+
+                self.assertEqual(s.a.index(v[0], 1), 2)
+
+                self.assertEqual(s.a.index(v[0], 1, 3), 2)
+
+                self.assertEqual(s.a.index(v[0], -2), 2)
+
+                self.assertEqual(s.a.index(v[0], -100, -1), 0)
+
+                self.assertEqual(s.a.index(v[3], -100, 100), 1)
+
+                with self.assertRaises(ValueError) as e:
+                    s.a.index(v[3], 2)
+
+                with self.assertRaises(ValueError) as e:
+                    s.a.index(v[3], -1, 100)
+
+                with self.assertRaises(ValueError) as e:
+                    s.a.index(v[-1])
+
+    def test_list_field_count(self):
+        """Ensure that non-list-modifying operations on list fields work fine"""
+        for ann_typ in struct_list_annotation_types:
+            for typ, v in struct_list_test_values.items():
+
+                class A(csp.Struct):
+                    a: ann_typ[typ]
+
+                s = A(a=[v[0], v[3], v[0]])
+
+                self.assertEqual(s.a.count(v[0]), 2)
+
+                self.assertEqual(s.a.count(v[3]), 1)
+
+                self.assertEqual(s.a.count(v[-1]), 0)
+
+    def test_list_field_compare(self):
+        """Ensure that non-list-modifying operations on list fields work fine"""
+        # Not using pystruct_list_test_values, as comaprison tests are of different semantics (order and comparison key existance matters).
+        values = {
+            int: [1, 5, 2, 2, -1, -5, "s"],
+            float: [1.4, 5.2, 2.7, 2.7, -1.4, -5.2, "s"],
+            datetime: [
+                datetime(2022, 12, 6, 1, 2, 3),
+                datetime(2022, 12, 8, 3, 2, 3),
+                datetime(2022, 12, 7, 2, 2, 3),
+                datetime(2022, 12, 7, 2, 2, 3),
+                datetime(2022, 12, 5, 2, 2, 3),
+                datetime(2022, 12, 3, 2, 2, 3),
+                None,
+            ],
+            timedelta: [
+                timedelta(seconds=1),
+                timedelta(seconds=123),
+                timedelta(seconds=12),
+                timedelta(seconds=12),
+                timedelta(seconds=0.1),
+                timedelta(seconds=0.01),
+                None,
+            ],
+            date: [
+                date(2022, 12, 6),
+                date(2022, 12, 8),
+                date(2022, 12, 7),
+                date(2022, 12, 7),
+                date(2022, 12, 5),
+                date(2022, 12, 3),
+                None,
+            ],
+            time: [time(5, 2, 3), time(7, 2, 3), time(6, 2, 3), time(6, 2, 3), time(4, 2, 3), time(3, 2, 3), None],
+            str: ["s", "xyz", "w", "w", "bds", "a", None],
+        }
+
+        for ann_typ in struct_list_annotation_types:
+            for typ, v in values.items():
+
+                class A(csp.Struct):
+                    a: ann_typ[typ]
+
+                s1 = A(a=[v[0], v[1], v[2], v[5]])
+                s1a = [v[0], v[1], v[2], v[5]]
+                s2 = A(a=[v[0], v[1], v[3], v[4]])
+                s2a = [v[0], v[1], v[3], v[4]]
+
+                self.assertEqual(s1.a < s2.a, True)
+                self.assertEqual(s1.a <= s2.a, True)
+                self.assertEqual(s1.a > s2.a, False)
+                self.assertEqual(s1.a >= s2.a, False)
+                self.assertEqual(s1.a != s2.a, True)
+                self.assertEqual(s1.a == s2.a, False)
+
+                self.assertEqual(s1.a == s1a, True)
+                self.assertEqual(s1.a != s1a, False)
+                self.assertEqual(s1.a == s2a, False)
+                self.assertEqual(s1.a != s2a, True)
+
+                self.assertEqual(s1.a < s2a, True)
+                self.assertEqual(s1.a <= s2a, True)
+                self.assertEqual(s1.a > s2a, False)
+                self.assertEqual(s1.a >= s2a, False)
+
+                s3 = A(a=[v[0], v[1], v[2]])
+
+                self.assertEqual(s3.a < s1.a, True)
+
+                s4 = A(a=[v[0], v[1], v[2]])
+
+                self.assertEqual(s4.a == s3.a, True)
+
+            class B(csp.Struct):
+                a: [MyEnum]
+
+            s = B(a=[MyEnum.A, MyEnum.FOO])
+            t = B(a=[MyEnum.FOO, MyEnum.FOO])
+
+            with self.assertRaises(TypeError) as e:
+                s.a < t.a
+            with self.assertRaises(TypeError) as e:
+                s.a <= t.a
+            with self.assertRaises(TypeError) as e:
+                s.a > t.a
             with self.assertRaises(TypeError) as e:
-                s.a *= "s"
+                s.a >= t.a
+            self.assertEqual(s.a == t.a, False)
+            self.assertEqual(s.a != t.a, True)
 
-            s.a *= 0
+    def test_list_field_iter(self):
+        """Ensure that non-list-modifying operations on list fields work fine"""
+        for ann_typ in struct_list_annotation_types:
+            for typ, v in struct_list_test_values.items():
 
-            self.assertEqual(s.a, [])
+                class A(csp.Struct):
+                    a: ann_typ[typ]
 
-            s.a += [v[2], v[3]]
+                s = A(a=[v[0], v[1], v[2]])
 
-            self.assertEqual(s.a, [v[2], v[3]])
+                b = iter(s.a)
+                c = s.a.__iter__()
+                d = s.a.__reversed__()
 
-            s.a *= -1
+                self.assertEqual(next(b), v[0])
+                self.assertEqual(next(c), v[0])
+                self.assertEqual(next(d), v[2])
 
-            self.assertEqual(s.a, [])
+                self.assertEqual(next(b), v[1])
+                self.assertEqual(next(c), v[1])
+                self.assertEqual(next(d), v[1])
 
-    def test_list_field_lifetime(self):
-        """Ensure that the lifetime of PyStructList field exceeds the lifetime of struct holding it"""
+                self.assertEqual(next(b), v[2])
+                self.assertEqual(next(c), v[2])
+                self.assertEqual(next(d), v[0])
+
+                with self.assertRaises(StopIteration) as e:
+                    next(b)
+                with self.assertRaises(StopIteration) as e:
+                    next(c)
+                with self.assertRaises(StopIteration) as e:
+                    next(d)
+
+    def test_list_field_concat(self):
+        """Ensure that non-list-modifying operations on list fields work fine"""
+        for ann_typ in struct_list_annotation_types:
+            for typ, v in struct_list_test_values.items():
+
+                class A(csp.Struct):
+                    a: ann_typ[typ]
+
+                s = A(a=[v[0], v[1]])
+                t = A(a=[v[2], v[3]])
+
+                self.assertEqual(s.a.__add__([v[2], v[3]]), [v[0], v[1], v[2], v[3]])
+                self.assertEqual(s.a.__add__(t.a), [v[0], v[1], v[2], v[3]])
+
+                self.assertEqual(s.a + [v[2], v[3]], [v[0], v[1], v[2], v[3]])
+                self.assertEqual(s.a + t.a, [v[0], v[1], v[2], v[3]])
+
+                self.assertEqual(s.a + [], [v[0], v[1]])
+
+                with self.assertRaises(TypeError) as e:
+                    tmp = s.a = v[-1]
+
+                self.assertEqual(s.a, [v[0], v[1]])
+
+    def test_list_field_repeat(self):
+        """Ensure that non-list-modifying operations on list fields work fine"""
+        for ann_typ in struct_list_annotation_types:
+            for typ, v in struct_list_test_values.items():
+
+                class A(csp.Struct):
+                    a: ann_typ[typ]
+
+                s = A(a=[v[0], v[1]])
+
+                self.assertEqual(s.a.__mul__(1), [v[0], v[1]])
+
+                self.assertEqual(s.a * 2, [v[0], v[1], v[0], v[1]])
+
+                with self.assertRaises(TypeError) as e:
+                    tmp = s.a * [3]
+
+                with self.assertRaises(TypeError) as e:
+                    tmp = s.a * "s"
+
+                self.assertEqual(s.a * 0, [])
+
+                self.assertEqual(s.a * -1, [])
+
+    def test_list_field_correct_type_used(self):
+        """Check that FastList and PyStructList types are used correctly"""
+
+        class A(csp.Struct):
+            a: [int]
+
+        with self.assertRaises(TypeError):
+
+            class B(csp.Struct):
+                a: [int, False]
+
+        class C(csp.Struct):
+            a: typing.List[int]
+
+        class D(csp.Struct):
+            a: FastList[int]
+
+        with self.assertRaises(TypeError):
+
+            class E(csp.Struct):
+                a: [int, True]
+
+        p = A(a=[1, 2])
+        r = C(a=[1, 2])
+        s = D(a=[1, 2])
+
+        self.assertEqual(str(type(p.a)), "<class '_cspimpl.PyStructList'>")
+        self.assertEqual(str(type(r.a)), "<class '_cspimpl.PyStructList'>")
+        self.assertEqual(str(type(s.a)), "<class '_cspimpl.PyStructFastList'>")
+
+    def test_list_field_correct_type_passed(self):
+        """Check that FastList can be passed to where Python list is expected"""
 
         class A(csp.Struct):
             a: [int]
 
-        s = A(a=[1, 2, 3])
-        l = s.a
-        del s
+        class B(csp.Struct):
+            a: FastList[int]
 
-        self.assertEqual(l, [1, 2, 3])
+        p = csp.unroll(csp.const(A(a=[1, 2, 3])).a)
+        q = csp.unroll(csp.const(B(a=[1, 2, 3])).a)
 
 
 if __name__ == "__main__":
diff --git a/docs/wiki/api-references/csp.Struct-API.md b/docs/wiki/api-references/csp.Struct-API.md
index 78f0ec5a..dba95553 100644
--- a/docs/wiki/api-references/csp.Struct-API.md
+++ b/docs/wiki/api-references/csp.Struct-API.md
@@ -64,6 +64,72 @@ csp.run( my_graph, starttime = datetime( 2020, 1, 1 ))
 
 `trades` is defined as a timeseries of `Trade` objects. On line 13 we access the `size` field of the `trades` timeseries, then accumulate the sizes to get `cumqty` edge.
 
+## List fields
+
+List fields in a `csp.Struct` can be specified as three different types - untyped Python list, typed regular list and typed `FastList`.
+
+A Python list field keeps its value as a Python object, it is not typed. It can be created by annotating the field as `list`.
+
+A regular list field is typed and internally implemented as a subclass of the Python list class, so it behaves exactly like Python list and passes the `isinstance` check for list. It can be created by annotating the field as `typing.List[T]` or `[T]`.
+
+A `FastList` field is typed and a more efficient implementation, implementing all Python list operations natively in C++. However, it doesn't pass `isinstance` check for list. It can be created by annotating the field as `csp.impl.types.typing_utils.FastList[T]`.
+
+Example of using Python list field:
+
+```python
+import csp
+
+class A(csp.Struct):
+    a: list
+
+s = A(a = [1, 'x'])
+
+s.a.append(True)
+
+print(f"Using Python list field: value {s.a}, type {type(s.a)}, is Python list: {isinstance(s.a, list)}")
+
+
+>>> Using Python list field: value [1, 'x', True], type <class 'list'>, is Python list: True
+```
+
+Example of using regular list field:
+
+```python
+from typing import List
+import csp
+
+class A(csp.Struct):
+    a: List[int]
+
+s = A(a = [1, 2])
+
+s.a.append(3)
+
+print(f"Using list field: value {s.a}, type {type(s.a)}, is Python list: {isinstance(s.a, list)}")
+
+
+>>> Using list field: value [1, 2, 3], type <class '_cspimpl.PyStructList'>, is Python list: True
+```
+
+Example of using `FastList` field:
+
+```python
+import csp
+from csp.impl.types.typing_utils import FastList
+
+class A(csp.Struct):
+    a: FastList[int]
+
+s = A(a = [1, 2])
+
+s.a.append(3)
+
+print(f"Using FastList field: value {s.a}, type {type(s.a)}, is Python list: {isinstance(s.a, list)}")
+
+
+>>> Using FastList field: value [1, 2, 3], type <class '_cspimpl.PyStructFastList'>, is Python list: False
+```
+
 ## Available methods
 
 - **`clear(self)`** clear all fields on the struct