Index: libcfa/src/collections/string.cfa
===================================================================
--- libcfa/src/collections/string.cfa	(revision ed5023d1a93d52e928c7120920781fefeb7fe26b)
+++ libcfa/src/collections/string.cfa	(revision b1b513dccca0c7daa8d71671b956e73a7b44fd82)
@@ -10,6 +10,6 @@
 // Created On       : Fri Sep 03 11:00:00 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Apr  5 15:18:30 2025
-// Update Count     : 318
+// Last Modified On : Wed Apr  9 22:27:40 2025
+// Update Count     : 368
 //
 
@@ -295,12 +295,4 @@
 bool ?<? ( const char * s1, const string & s2 ) { return s1 <  *s2.inner; }
 
-
-////////////////////////////////////////////////////////
-// Getter
-
-size_t len( const string & s ) {
-	return len( *s.inner );
-}
-
 ////////////////////////////////////////////////////////
 // Concatenation
@@ -424,5 +416,5 @@
 }
 
-int find( const string & s, size_t start, size_t len, const string & key, size_t kstart, size_t klen ) {
+size_t find( const string & s, size_t start, size_t len, const string & key, size_t kstart, size_t klen ) {
 	if ( start < 0 ) { start += len( s ); }
 	if ( len < 0 ) { len = -len; start -= len; }
@@ -434,33 +426,33 @@
 	if ( kstart >= len( key ) ) return 0;
 	if ( kstart + klen > len( key ) ) klen = len( key ) - kstart;
-	
+
 	return findFrom( *s.inner, start, *key.inner );
 }
 
-int find( const string & s, char key ) {
+size_t find( const string & s, char key ) {
 	return find( *s.inner, key );
 }
 
-int find( const string & s, const string & key ) {
+size_t find( const string & s, const string & key ) {
 	return find( *s.inner, *key.inner );
 }
 
-int find( const string & s, const char * key ) {
+size_t find( const string & s, const char * key ) {
 	return find( *s.inner, key );
 }
 
-int find( const string & s, const char * key, size_t keysize ) {
+size_t find( const string & s, const char * key, size_t keysize ) {
 	return find( *s.inner, key, keysize );
 }
 
-int find( const string & s, size_t start, char key ) {
+size_t find( const string & s, size_t start, char key ) {
 	return findFrom( *s.inner, start, key );
 }
 
-int find( const string & s, size_t start, const char * key ) {
+size_t find( const string & s, size_t start, const char * key ) {
 	return findFrom( *s.inner, start, key );
 }
 
-int find( const string & s, size_t start, const char * key, size_t keysize ) {
+size_t find( const string & s, size_t start, const char * key, size_t keysize ) {
 	return findFrom( *s.inner, start, key, keysize );
 }
@@ -527,19 +519,42 @@
 }
 
-
-int exclude( const string & s, const charclass & mask ) {
+size_t exclude( const string & s, const charclass & mask ) {
 	return exclude( *s.inner, *mask.inner );
 }
-/*
-StrSlice exclude( string & s, const charclass & mask ) {
-}
-*/
-
-int include( const string & s, const charclass & mask ) {
+
+size_t include( const string & s, const charclass & mask ) {
 	return include( *s.inner, *mask.inner );
 }
 
-/*
-StrSlice include( string & s, const charclass & mask ) {
-}
-*/
+size_t test( const string & s, int (*f)( int ) ) {
+	size_t l = len( s );
+	for ( i; l ) {
+		if ( ! f( s[i] ) ) return i;
+	} // for
+	return l;
+}
+
+string replace( string & s, const string & from, const string & to ) {
+	ssize_t pos;
+    string r;
+
+    pos = find( s, from );
+    if ( pos < len( s ) ) {
+		r = s( 0, pos ) + to + replace( s( pos + (ssize_t)len( from ) ), from, to );
+		string front = s( 0, pos );
+		string back = s( pos + (ssize_t)len( from ) );
+		r = front + to + replace( back, from, to );
+    } else {
+		r = s;
+    } // if
+    return r;
+}
+
+string translate( const string & s, int (*f)( int ) ) {
+	string r = s;
+	size_t l = len( r );
+	for ( i; l ) {
+		r[i] = (char)f( r[i] );
+	} // for
+	return r;
+}
Index: libcfa/src/collections/string.hfa
===================================================================
--- libcfa/src/collections/string.hfa	(revision ed5023d1a93d52e928c7120920781fefeb7fe26b)
+++ libcfa/src/collections/string.hfa	(revision b1b513dccca0c7daa8d71671b956e73a7b44fd82)
@@ -10,6 +10,6 @@
 // Created On       : Fri Sep 03 11:00:00 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Apr  5 15:16:23 2025
-// Update Count     : 180
+// Last Modified On : Wed Apr  9 22:27:41 2025
+// Update Count     : 259
 //
 
@@ -17,9 +17,5 @@
 
 #include <fstream.hfa>
-
-
-// in string_res.hfa
-struct string_res;
-struct charclass_res;
+#include <string_res.hfa>
 
 struct string {
@@ -28,6 +24,6 @@
 
 // Getters
+static inline size_t len( const string & s ) { return len( *s.inner ); }
 static inline size_t len( const char * cs ) { return strlen( cs ); };
-size_t len( const string & s );
 static inline size_t strlen( const string & s ) { return len( s ); }
 
@@ -215,16 +211,18 @@
 bool contains( const string & s, char ch );				// single character
 
-int find( const string & s, char key );
-static inline int ?^? ( const string & s, char key ) { return find( s, key ); }
-int find( const string & s, const char * key );
-static inline int ?^? ( const string & s, const char * key ) { return find( s, key ); }
-int find( const string & s, const string & key );
-static inline int ?^? ( const string & s, const string & key ) { return find( s, key ); }
-int find( const string & s, const char * key, size_t keysize );
-
-int find( const string & s, size_t start, char key );
-int find( const string & s, size_t start, const string & key );
-int find( const string & s, size_t start, const char * key );
-int find( const string & s, size_t start, const char * key, size_t keysize );
+//int find( const string & s, size_t start, size_t len, const string & key, size_t kstart, size_t klen );
+size_t find$( const string_res & s, size_t start, size_t len, const string & key_res, size_t kstart, size_t klen );
+
+size_t find( const string & s, char key );
+size_t find( const string & s, const char * key );
+size_t find( const string & s, const string & key );
+size_t find( const string & s, const char * key, size_t keysize );
+
+size_t find( const string & s, size_t start, char key );
+size_t find( const string & s, size_t start, const string & key );
+size_t find( const string & s, size_t start, const char * key );
+size_t find( const string & s, size_t start, const char * key, size_t keysize );
+static inline ?^?( const string & key, const string & s ) { return find( s, key ); }
+static inline ?^?( const char * key, const string & s ) { return find( s, key ); }
 
 bool includes( const string & s, const string & mask );
@@ -241,16 +239,14 @@
 
 // Slicing
-string ?()( string & s, ssize_t start, ssize_t len );		// TODO const?
+string ?()( string & s, ssize_t start, ssize_t len );
+static inline string ?()( const string & s, ssize_t start, ssize_t len ) { string & w = (string &)s; return w( start, len ); } // FIX ME
 string ?()( string & s, ssize_t start );
+static inline string ?()( const string & s, ssize_t start ) { string & w = (string &)s; return w( start ); } // FIX ME
 static inline string ?()( string & s, char m ) { return s( find( s, m ), 1 )`share; }
+static inline string ?()( const string & s, char m ) { string & w = (string &)s; return w( find( s, m ), 1 )`share; } // FIX ME
 static inline string ?()( string & s, const char * m ) { return s( find( s, m ), len( m ) )`share; }
+static inline string ?()( const string & s, const char * m ) { string & w = (string &)s; return w( find( s, m ), len( m ) )`share; } // FIX ME
 static inline string ?()( string & s, const string & m ) { return s( find( s, m ), len( m ) )`share; }
-
-// Modifiers
-void padStart( string & s, size_t n );
-void padStart( string & s, size_t n, char padding );
-void padEnd( string & s, size_t n );
-void padEnd( string & s, size_t n, char padding );
-
+static inline string ?()( const string & s, const string & m ) { string & w = (string &)s; return w( find( s, m ), len( m ) )`share; } // FIX ME
 
 struct charclass {
@@ -267,11 +263,41 @@
 void ^?{}( charclass & );
 
-int include( const string & s, const charclass & mask );
-
-int exclude( const string & s, const charclass & mask );
-
-/*
-What to do with?
-StrRet include( string & s, const charclass & mask );
-StrRet exclude( string & s, const charclass & mask );
-*/
+size_t include( const string & s, const charclass & mask );
+static inline size_t include( const char * s, const charclass & mask ) { string temp = s; return include( temp, mask ); }
+static inline string include( const string & s, const charclass & mask ) { ssize_t i = include( s, mask ); return s( 0, i )`share; }
+static inline string include( const char * s, const charclass & mask ) { string temp = s; ssize_t i = include( temp, mask ); return temp( 0, i ); }
+
+size_t exclude( const string & s, const charclass & mask );
+static inline size_t exclude( const char * s, const charclass & mask ) { string temp = s; return exclude( temp, mask ); }
+static inline string exclude( const string & s, const charclass & mask ) { ssize_t i = exclude( s, mask ); return s( 0, i )`share; }
+static inline string exclude( const char * s, const charclass & mask ) { string temp = s; ssize_t i = exclude( temp, mask ); return temp( 0, i ); }
+
+size_t test( const string & s, int (*f)( int ) );
+static inline size_t test( const char * c, int (*f)( int ) ) {
+	const string S = c;
+	return test( S, f );
+}
+
+string replace( string & s, const string & from, const string & to );
+static inline string replace( const char * s, const char * from, const char * to ) {
+	string S = s, From = from, To = to;
+	return replace( S, From, To );
+}
+static inline string replace( string & s, const char * from, const char * to ) {
+	string From = from, To = to;
+	return replace( s, From, To );
+}
+static inline string replace( string & s, const char * from, const string & to ) {
+	string From = from;
+	return replace( s, From, to );
+}
+static inline string replace( string & s, string & from, const char * to ) {
+	string To = to;
+	return replace( s, from, To );
+}
+
+string translate( const string & s, int (*f)( int ) );
+static inline string translate( const char * c, int (*f)( int ) ) {
+	const string S = c;
+	return translate( S, f );
+}
Index: libcfa/src/collections/string_res.cfa
===================================================================
--- libcfa/src/collections/string_res.cfa	(revision ed5023d1a93d52e928c7120920781fefeb7fe26b)
+++ libcfa/src/collections/string_res.cfa	(revision b1b513dccca0c7daa8d71671b956e73a7b44fd82)
@@ -10,6 +10,6 @@
 // Created On       : Fri Sep 03 11:00:00 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Apr  6 07:38:02 2025
-// Update Count     : 111
+// Last Modified On : Wed Apr  9 08:44:17 2025
+// Update Count     : 128
 //
 
@@ -190,9 +190,4 @@
 const char * DEBUG_string_heap_start( VbyteHeap * heap ) {
 	return heap->StartVbyte;
-}
-
-// Returns the size of the string in bytes
-size_t len(const string_res & s) with(s) {
-	return Handle.lnth;
 }
 
@@ -756,9 +751,32 @@
 }
 
-int find(const string_res & s, char search) {
+// int find$( const string_res & s, ssize_t start, ssize_t len, const string_res & k, ssize_t kstart, ssize_t klen ) {
+//     if ( start < 0 ) start = s.Handle.lnth + start;		// adjust negative starting locations
+//     if ( kstart < 0 ) kstart = k.Handle.lnth + kstart;
+
+// 	if ( start + len > s.Handle.lnth ) return start + 1;  // cannot be there
+// 	if ( kstart + len > k.Handle.lnth ) return start + 1;
+// 	if ( klen > len ) return start + 1;
+
+// 	int i, r;
+
+// 	for ( i = max( start, 1 ); ; i += 1 ) {
+// 		if ( i > s.Handle.lnth - k.Handle.lnth + 1 ) {
+// 			r = s.Handle.lnth + 1;
+// 			break;
+// 	    } // exit
+// 		if ( HeapArea->ByteCmp( s.Handle.s, i, k.Handle.lnth, k.Handle.s, 1, k.Handle.lnth ) == 0 ) {
+// 			r = i;
+// 			break;
+// 	    } // exit
+// 	} // for
+// 	return r;
+// }
+
+int find( const string_res & s, char search ) {
 	return findFrom(s, 0, search);
 }
 
-int findFrom(const string_res & s, size_t fromPos, char search) {
+int findFrom( const string_res & s, size_t fromPos, char search ) {
 	// FIXME: This paricular overload (find of single char) is optimized to use memchr.
 	// The general overload (find of string, memchr applying to its first character) and `contains` should be adjusted to match.
Index: libcfa/src/collections/string_res.hfa
===================================================================
--- libcfa/src/collections/string_res.hfa	(revision ed5023d1a93d52e928c7120920781fefeb7fe26b)
+++ libcfa/src/collections/string_res.hfa	(revision b1b513dccca0c7daa8d71671b956e73a7b44fd82)
@@ -10,6 +10,6 @@
 // Created On       : Fri Sep 03 11:00:00 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Apr  6 07:35:44 2025
-// Update Count     : 70
+// Last Modified On : Wed Apr  9 15:16:29 2025
+// Update Count     : 76
 //
 
@@ -70,5 +70,5 @@
 
 // Getters
-size_t len( const string_res & s);
+static inline size_t len( const string_res & s ) { return s.Handle.lnth; }
 
 // Constructors, Assignment Operators, Destructor
@@ -220,4 +220,6 @@
 bool contains( const string_res & s, char ch); // single character
 
+int find$( const string_res & s, ssize_t start, ssize_t len, const string_res & key, ssize_t kstart, ssize_t klen );
+
 int find( const string_res & s, char search);
 int find( const string_res & s, const string_res & search);
@@ -245,8 +247,2 @@
 int exclude( const string_res & s, const charclass_res & mask);
 
-// Modifiers
-void padStart(string_res & s, size_t n);
-void padStart(string_res & s, size_t n, char padding);
-void padEnd(string_res & s, size_t n);
-void padEnd(string_res &s, size_t n, char padding);
-
