Index: libcfa/src/collections/list.hfa
===================================================================
--- libcfa/src/collections/list.hfa	(revision 768d091feb9f29c04c5a4e5a3706e149d43d290d)
+++ libcfa/src/collections/list.hfa	(revision 9dd1dd6f547ddd569b2e2a944a2e8311e7736008)
@@ -10,6 +10,6 @@
 // Created On       : Wed Apr 22 18:00:00 2020
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb  2 11:32:26 2023
-// Update Count     : 2
+// Last Modified On : Thu Apr 17 07:28:47 2025
+// Update Count     : 3
 //
 
@@ -20,10 +20,10 @@
 forall( Decorator &, T & )
 struct tytagref {
-    inline T &;
+	inline T &;
 };
 
 forall( tOuter &, tMid &, tInner & )
 trait embedded {
-    tytagref( tMid, tInner ) ?`inner( tOuter & );
+	tytagref( tMid, tInner ) ?`inner( tOuter & );
 };
 
@@ -37,6 +37,6 @@
 //
 // struct foo {
-//    int a, b, c;
-//    inline (bar);
+//	int a, b, c;
+//	inline (bar);
 // };
 // P9_EMBEDDED( foo, bar )
@@ -44,25 +44,25 @@
 
 // usual version, for structs that are top-level declarations
-#define P9_EMBEDDED(        derived, immedBase ) P9_EMBEDDED_DECL_( derived, immedBase, static ) P9_EMBEDDED_BDY_( immedBase )
+#define P9_EMBEDDED( derived, immedBase ) P9_EMBEDDED_DECL_( derived, immedBase, static ) P9_EMBEDDED_BDY_( immedBase )
 
 // special version, for structs that are declared in functions
-#define P9_EMBEDDED_INFUNC( derived, immedBase ) P9_EMBEDDED_DECL_( derived, immedBase,        ) P9_EMBEDDED_BDY_( immedBase )
+#define P9_EMBEDDED_INFUNC( derived, immedBase ) P9_EMBEDDED_DECL_( derived, immedBase, ) P9_EMBEDDED_BDY_( immedBase )
 
 // forward declarations of both the above; generally not needed
 // may help you control where the P9_EMBEEDED cruft goes, in case "right after the stuct" isn't where you want it
-#define P9_EMBEDDED_FWD(        derived, immedBase )      P9_EMBEDDED_DECL_( derived, immedBase, static ) ;
-#define P9_EMBEDDED_FWD_INFUNC( derived, immedBase ) auto P9_EMBEDDED_DECL_( derived, immedBase,        ) ;
+#define P9_EMBEDDED_FWD( derived, immedBase ) P9_EMBEDDED_DECL_( derived, immedBase, static ) ;
+#define P9_EMBEDDED_FWD_INFUNC( derived, immedBase ) auto P9_EMBEDDED_DECL_( derived, immedBase, ) ;
 
 // private helpers
 #define P9_EMBEDDED_DECL_( derived, immedBase, STORAGE ) \
-    forall( Tbase &, TdiscardPath & | { tytagref( TdiscardPath, Tbase ) ?`inner( immedBase & ); } ) \
-    STORAGE inline tytagref(immedBase, Tbase) ?`inner( derived & this )
-    
+	forall( Tbase &, TdiscardPath & | { tytagref( TdiscardPath, Tbase ) ?`inner( immedBase & ); } ) \
+	STORAGE inline tytagref(immedBase, Tbase) ?`inner( derived & this )
+
 #define P9_EMBEDDED_BDY_( immedBase ) { \
-        immedBase & ib = this; \
-        Tbase & b = ib`inner; \
-        tytagref(immedBase, Tbase) result = { b }; \
-        return result; \
-    }
+		immedBase & ib = this; \
+		Tbase & b = ib`inner; \
+		tytagref(immedBase, Tbase) result = { b }; \
+		return result; \
+	}
 
 #define EMBEDDED_VIA( OUTER, MID, INNER ) \
@@ -88,15 +88,15 @@
 
 #if defined( __x86_64 )
-    // Preferred case: tag in the most-significant bit.  Dereference
-    // has been shown to segfault consistently.  Maintenance should
-    // list more architectures as "ok" here, to let them use the
-    // preferred case, when valid.
-    #define ORIGIN_TAG_BITNO ( 8 * sizeof( size_t ) - 1 )
+	// Preferred case: tag in the most-significant bit.  Dereference
+	// has been shown to segfault consistently.  Maintenance should
+	// list more architectures as "ok" here, to let them use the
+	// preferred case, when valid.
+	#define ORIGIN_TAG_BITNO ( 8 * sizeof( size_t ) - 1 )
 #else
-    // Fallback case: tag in the least-significant bit.  Dereference
-    // will often give an alignment error, but may not, e.g. if
-    // accessing a char-typed member.  32-bit x86 uses the most-
-    // significant bit for real room on the heap.
-    #define ORIGIN_TAG_BITNO 0
+	// Fallback case: tag in the least-significant bit.  Dereference
+	// will often give an alignment error, but may not, e.g. if
+	// accessing a char-typed member.  32-bit x86 uses the most-
+	// significant bit for real room on the heap.
+	#define ORIGIN_TAG_BITNO 0
 #endif
 #define ORIGIN_TAG_MASK (((size_t)1) << ORIGIN_TAG_BITNO)
@@ -109,33 +109,33 @@
 forall( tE & ) {
 
-    struct dlink{
-        tE *next;
-        tE *prev;
-    };
-
-    static inline void ?{}( dlink(tE) & this ) {
-        this.next = 0p;
-        this.prev = 0p;
-    }
-
-    forall( tLinks & = dlink(tE) )
-    struct dlist {
-        inline dlink(tE);
-    };
-
-    forall( tLinks & | embedded( tE, tLinks, dlink(tE) ) ) {
-        static inline tE * $get_list_origin_addr( dlist(tE, tLinks) & lst ) {
-            dlink(tE) & link_from_null = ( * (tE *) 0p )`inner;
-            ptrdiff_t link_offset = (ptrdiff_t) & link_from_null;
-            size_t origin_addr = ((size_t) & lst) - link_offset;
-            size_t preResult = ORIGIN_TAG_SET( origin_addr );
-            return (tE *)preResult;
-        }
-
-        static inline void ?{}( dlist(tE, tLinks) & this ) {
-            tE * listOrigin = $get_list_origin_addr( this );
-            ( ( dlink(tE) & ) this ){ listOrigin, listOrigin } ;
-        }
-    }
+	struct dlink{
+		tE *next;
+		tE *prev;
+	};
+
+	static inline void ?{}( dlink(tE) & this ) {
+		this.next = 0p;
+		this.prev = 0p;
+	}
+
+	forall( tLinks & = dlink(tE) )
+	struct dlist {
+		inline dlink(tE);
+	};
+
+	forall( tLinks & | embedded( tE, tLinks, dlink(tE) ) ) {
+		static inline tE * $get_list_origin_addr( dlist(tE, tLinks) & lst ) {
+			dlink(tE) & link_from_null = ( * (tE *) 0p )`inner;
+			ptrdiff_t link_offset = (ptrdiff_t) & link_from_null;
+			size_t origin_addr = ((size_t) & lst) - link_offset;
+			size_t preResult = ORIGIN_TAG_SET( origin_addr );
+			return (tE *)preResult;
+		}
+
+		static inline void ?{}( dlist(tE, tLinks) & this ) {
+			tE * listOrigin = $get_list_origin_addr( this );
+			( ( dlink(tE) & ) this ){ listOrigin, listOrigin } ;
+		}
+	}
 
 }
@@ -147,18 +147,18 @@
 		verify (&list_pos != 0p);
 		verify (&to_insert != 0p);
-        dlink(tE) & linkToInsert = to_insert`inner;
+		dlink(tE) & linkToInsert = to_insert`inner;
 		verify(linkToInsert.prev == 0p);
 		verify(linkToInsert.next == 0p);
-        tE & list_pos_elem = * (tE *) ORIGIN_TAG_CLEAR( (size_t) & list_pos );
-        dlink(tE) & list_pos_links = list_pos_elem`inner;
-        asm( "" : : : "memory" );
-        tE & after_raw = * list_pos_links.next;
-        tE & after_elem = * (tE *) ORIGIN_TAG_CLEAR( (size_t) & after_raw );
+		tE & list_pos_elem = * (tE *) ORIGIN_TAG_CLEAR( (size_t) & list_pos );
+		dlink(tE) & list_pos_links = list_pos_elem`inner;
+		asm( "" : : : "memory" );
+		tE & after_raw = * list_pos_links.next;
+		tE & after_elem = * (tE *) ORIGIN_TAG_CLEAR( (size_t) & after_raw );
 		linkToInsert.prev = & list_pos;
 		linkToInsert.next = & after_raw;
-        dlink(tE) & afterLinks = after_elem`inner;
-        afterLinks.prev = &to_insert;
+		dlink(tE) & afterLinks = after_elem`inner;
+		afterLinks.prev = &to_insert;
 		list_pos_links.next = &to_insert;
-        asm( "" : : : "memory" );
+		asm( "" : : : "memory" );
 	}
 
@@ -166,154 +166,154 @@
 		verify (&list_pos != 0p);
 		verify (&to_insert != 0p);
-        dlink(tE) & linkToInsert = to_insert`inner;
+		dlink(tE) & linkToInsert = to_insert`inner;
 		verify(linkToInsert.next == 0p);
 		verify(linkToInsert.prev == 0p);
-        tE & list_pos_elem = * (tE *) ORIGIN_TAG_CLEAR( (size_t) & list_pos );
-        dlink(tE) & list_pos_links = list_pos_elem`inner;
-        asm( "" : : : "memory" );
-        tE & before_raw = * (list_pos_links).prev;
-        tE & before_elem = * (tE *) ORIGIN_TAG_CLEAR( (size_t) & before_raw );
+		tE & list_pos_elem = * (tE *) ORIGIN_TAG_CLEAR( (size_t) & list_pos );
+		dlink(tE) & list_pos_links = list_pos_elem`inner;
+		asm( "" : : : "memory" );
+		tE & before_raw = * (list_pos_links).prev;
+		tE & before_elem = * (tE *) ORIGIN_TAG_CLEAR( (size_t) & before_raw );
 		linkToInsert.next = & list_pos;
 		linkToInsert.prev = & before_raw;
-        dlink(tE) & beforeLinks = before_elem`inner;
-        beforeLinks.next = &to_insert;
+		dlink(tE) & beforeLinks = before_elem`inner;
+		beforeLinks.next = &to_insert;
 		(list_pos_links).prev = &to_insert;
-        asm( "" : : : "memory" );
+		asm( "" : : : "memory" );
 	}
 
 	static inline tE & remove(tE & list_pos) {
 		verify (&list_pos != 0p);
-        verify( ! ORIGIN_TAG_QUERY((size_t) & list_pos) );
-        dlink(tE) & list_pos_links = list_pos`inner;
-        tE & before_raw = * list_pos_links.prev;
-        tE & before_elem = * (tE *) ORIGIN_TAG_CLEAR( (size_t) & before_raw );
-        dlink(tE) & before_links = before_elem`inner;
-        tE & after_raw = * list_pos_links.next;
-        tE & after_elem = * (tE *) ORIGIN_TAG_CLEAR( (size_t) & after_raw );
-        dlink(tE) & after_links = after_elem`inner;
-        before_links.next = &after_raw;
-        after_links.prev = &before_raw;
-        asm( "" : : : "memory" );
+		verify( ! ORIGIN_TAG_QUERY((size_t) & list_pos) );
+		dlink(tE) & list_pos_links = list_pos`inner;
+		tE & before_raw = * list_pos_links.prev;
+		tE & before_elem = * (tE *) ORIGIN_TAG_CLEAR( (size_t) & before_raw );
+		dlink(tE) & before_links = before_elem`inner;
+		tE & after_raw = * list_pos_links.next;
+		tE & after_elem = * (tE *) ORIGIN_TAG_CLEAR( (size_t) & after_raw );
+		dlink(tE) & after_links = after_elem`inner;
+		before_links.next = &after_raw;
+		after_links.prev = &before_raw;
+		asm( "" : : : "memory" );
 		list_pos_links.prev = 0p;
 		list_pos_links.next = 0p;
-        asm( "" : : : "memory" );
-        return list_pos;
-	}
-
-    static inline tE & ?`first( dlist(tE, tLinks) &lst ) {
-        tE * firstPtr = lst.next;
-        if (ORIGIN_TAG_QUERY((size_t)firstPtr)) firstPtr = 0p;
-        return *firstPtr;
-    }
-    static inline tE & ?`last ( dlist(tE, tLinks) &lst ) {
-        tE * lastPtr = lst.prev;
-        if (ORIGIN_TAG_QUERY((size_t)lastPtr)) lastPtr = 0p;
-        return *lastPtr;
-    }
-
-    static inline bool ?`isEmpty( dlist(tE, tLinks) & lst ) {
-        tE * firstPtr = lst.next;
-        if (ORIGIN_TAG_QUERY((size_t)firstPtr)) firstPtr = 0p;
-        return firstPtr == 0p;
-    }
-
-    static inline bool ?`isListed( tE & e ) {
+		asm( "" : : : "memory" );
+		return list_pos;
+	}
+
+	static inline tE & ?`first( dlist(tE, tLinks) &lst ) {
+		tE * firstPtr = lst.next;
+		if (ORIGIN_TAG_QUERY((size_t)firstPtr)) firstPtr = 0p;
+		return *firstPtr;
+	}
+	static inline tE & ?`last ( dlist(tE, tLinks) &lst ) {
+		tE * lastPtr = lst.prev;
+		if (ORIGIN_TAG_QUERY((size_t)lastPtr)) lastPtr = 0p;
+		return *lastPtr;
+	}
+
+	static inline bool ?`isEmpty( dlist(tE, tLinks) & lst ) {
+		tE * firstPtr = lst.next;
+		if (ORIGIN_TAG_QUERY((size_t)firstPtr)) firstPtr = 0p;
+		return firstPtr == 0p;
+	}
+
+	static inline bool ?`isListed( tE & e ) {
 		verify (&e != 0p);
-        dlink(tE) & e_links = e`inner;
+		dlink(tE) & e_links = e`inner;
 		return (e_links.prev != 0p) || (e_links.next != 0p);
-    }
-
-    static inline tE & ?`elems( dlist(tE, tLinks) & lst ) {
-        tE * origin = $get_list_origin_addr( lst );
-        return *origin;
-    }
-
-    static inline bool ?`moveNext( tE && refx ) {
-        tE && ref_inner = refx;
-        tE & oldReferent = * (tE*) ORIGIN_TAG_CLEAR( (size_t) & ref_inner );
-        &ref_inner = oldReferent`inner.next;
-        return &ref_inner != 0p  &&
-            ! ORIGIN_TAG_QUERY( (size_t) & ref_inner );
-    }
-
-    static inline bool ?`movePrev( tE && refx ) {
-        tE && ref_inner = refx;
-        tE & oldReferent = * (tE*) ORIGIN_TAG_CLEAR( (size_t) & ref_inner );
-        &ref_inner = oldReferent`inner.prev;
-        return &ref_inner != 0p  &&
-            ! ORIGIN_TAG_QUERY( (size_t) & ref_inner );
-    }
-
-    static inline bool ?`hasNext( tE & e ) {
-        return e`moveNext;
-    }
-
-    static inline bool ?`hasPrev( tE & e ) {
-        return e`movePrev;
-    }
-
-    static inline tE & ?`next( tE & e ) {
-        if( e`moveNext ) return e;
-        return * 0p;
-    }
-
-    static inline tE & ?`prev( tE & e ) {
-        if( e`movePrev ) return e;
-        return * 0p;
-    }
-
-    static inline void insert_first( dlist(tE, tLinks) &lst, tE & e ) {
-        insert_after(lst`elems, e);
-    }
-
-    static inline void insert_last( dlist(tE, tLinks) &lst, tE & e ) {
-        insert_before(lst`elems, e);
-    }
-
-    static inline tE & try_pop_front( dlist(tE, tLinks) &lst ) {
-        tE & first_inlist = lst`first;
-        tE & first_item = first_inlist;
-        if (&first_item) remove(first_inlist);
-        return first_item;
-    }
-
-    static inline tE & try_pop_back( dlist(tE, tLinks) &lst ) {
-        tE & last_inlist = lst`last;
-        tE & last_item = last_inlist;
-        if (&last_item) remove(last_inlist);
-        return last_item;
-    }
+	}
+
+	static inline tE & ?`elems( dlist(tE, tLinks) & lst ) {
+		tE * origin = $get_list_origin_addr( lst );
+		return *origin;
+	}
+
+	static inline bool ?`moveNext( tE && refx ) {
+		tE && ref_inner = refx;
+		tE & oldReferent = * (tE*) ORIGIN_TAG_CLEAR( (size_t) & ref_inner );
+		&ref_inner = oldReferent`inner.next;
+		return &ref_inner != 0p  &&
+			! ORIGIN_TAG_QUERY( (size_t) & ref_inner );
+	}
+
+	static inline bool ?`movePrev( tE && refx ) {
+		tE && ref_inner = refx;
+		tE & oldReferent = * (tE*) ORIGIN_TAG_CLEAR( (size_t) & ref_inner );
+		&ref_inner = oldReferent`inner.prev;
+		return &ref_inner != 0p  &&
+			! ORIGIN_TAG_QUERY( (size_t) & ref_inner );
+	}
+
+	static inline bool ?`hasNext( tE & e ) {
+		return e`moveNext;
+	}
+
+	static inline bool ?`hasPrev( tE & e ) {
+		return e`movePrev;
+	}
+
+	static inline tE & ?`next( tE & e ) {
+		if( e`moveNext ) return e;
+		return * 0p;
+	}
+
+	static inline tE & ?`prev( tE & e ) {
+		if( e`movePrev ) return e;
+		return * 0p;
+	}
+
+	static inline void insert_first( dlist(tE, tLinks) &lst, tE & e ) {
+		insert_after(lst`elems, e);
+	}
+
+	static inline void insert_last( dlist(tE, tLinks) &lst, tE & e ) {
+		insert_before(lst`elems, e);
+	}
+
+	static inline tE & try_pop_front( dlist(tE, tLinks) &lst ) {
+		tE & first_inlist = lst`first;
+		tE & first_item = first_inlist;
+		if (&first_item) remove(first_inlist);
+		return first_item;
+	}
+
+	static inline tE & try_pop_back( dlist(tE, tLinks) &lst ) {
+		tE & last_inlist = lst`last;
+		tE & last_item = last_inlist;
+		if (&last_item) remove(last_inlist);
+		return last_item;
+	}
 
 
   #if !defined(NDEBUG) && (defined(__CFA_DEBUG__) || defined(__CFA_VERIFY__))
 	static bool $validate_fwd( dlist(tE, tLinks) & this ) {
-        if ( ! & this`first ) return ( (& this`last) == 0p);
-
-        tE & lagElem = *0p;
-
-        while ( tE & it = this`elems; it`moveNext ) {
-            if (& lagElem == 0p &&  &it != & this`first ) return false;
-            & lagElem = & it;
-        }
-
-        if (& lagElem != & this`last) return false;
-
-        // TODO: verify that it is back at this`elems;
-        return true;
+		if ( ! & this`first ) return ( (& this`last) == 0p);
+
+		tE & lagElem = *0p;
+
+		while ( tE & it = this`elems; it`moveNext ) {
+			if (& lagElem == 0p &&  &it != & this`first ) return false;
+			& lagElem = & it;
+		}
+
+		if (& lagElem != & this`last) return false;
+
+		// TODO: verify that it is back at this`elems;
+		return true;
 	}
 	static bool $validate_rev( dlist(tE, tLinks) & this ) {
-        if ( ! & this`last ) return ( (& this`first) == 0p);
-
-        tE & lagElem = *0p;
-
-        while ( tE & it = this`elems; it`movePrev ) {
-            if (& lagElem == 0p &&  &it != & this`last ) return false;
-            & lagElem = & it;
-        }
-
-        if (& lagElem != & this`first) return false;
-
-        // TODO: verify that it is back at this`elems;
-        return true;
+		if ( ! & this`last ) return ( (& this`first) == 0p);
+
+		tE & lagElem = *0p;
+
+		while ( tE & it = this`elems; it`movePrev ) {
+			if (& lagElem == 0p &&  &it != & this`last ) return false;
+			& lagElem = & it;
+		}
+
+		if (& lagElem != & this`first) return false;
+
+		// TODO: verify that it is back at this`elems;
+		return true;
 	}
 	static inline bool validate( dlist(tE, tLinks) & this ) {