Index: libcfa/src/collections/string.cfa
===================================================================
--- libcfa/src/collections/string.cfa	(revision b8e047a4229d594036e98f1f35d359049e3c7b27)
+++ libcfa/src/collections/string.cfa	(revision af5baae0adea725769db51743818a97dfe619952)
@@ -10,6 +10,6 @@
 // Created On       : Fri Sep 03 11:00:00 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Apr 15 21:56:28 2024
-// Update Count     : 260
+// Last Modified On : Mon Aug  5 23:12:05 2024
+// Update Count     : 273
 //
 
@@ -45,5 +45,5 @@
 }
 
-void ?{}( string & s, const string & s2, size_t maxlen) {
+void ?{}( string & s, const string & s2, size_t maxlen ) {
     (s.inner) { malloc() };
     ?{}( *s.inner, *s2.inner, COPY_VALUE, maxlen );
@@ -65,5 +65,5 @@
 }
 
-void ?{}( string & s, const char * c, size_t size) {
+void ?{}( string & s, const char * c, size_t size ) {
     (s.inner) { malloc() };
     ?{}( *s.inner, c, size );
@@ -98,4 +98,34 @@
     (s.inner) { malloc() };
     ?{}( *s.inner, rhs );
+}
+
+string str( ssize_t rhs ) {
+	string s = rhs;
+	return s;
+}
+
+string str( size_t rhs ) {
+	string s = rhs;
+	return s;
+}
+
+string str( double rhs ) {
+	string s = rhs;
+	return s;
+}
+
+string str( long double rhs ) {
+	string s = rhs;
+	return s;
+}
+
+string str( double _Complex rhs ) {
+	string s = rhs;
+	return s;
+}
+
+string str( long double _Complex rhs ) {
+	string s = rhs;
+	return s;
 }
 
@@ -115,5 +145,5 @@
 
 void ?{}( string & s, string_WithSharedEdits src ) {
-    ?{}( s, *src.s->inner, 0, src.s->inner->Handle.lnth);
+    ?{}( s, *src.s->inner, 0, src.s->inner->Handle.lnth );
 }
 
@@ -121,10 +151,10 @@
 // Assignment
 
-string & ?=?(string & s, const string & c) {
+string & ?=?( string & s, const string & c ) {
     (*s.inner) = (*c.inner);
     return s;
 }
 
-string & ?=?(string & s, string & c) {
+string & ?=?( string & s, string & c ) {
     (*s.inner) = (*c.inner);
     return s;
@@ -141,11 +171,11 @@
 }
 
-string & assign(string & s, const string & c, size_t n) {
-    assign(*s.inner, *c.inner, n);
-    return s;
-}
-
-string & assign(string & s, const char * c, size_t n) {
-    assign(*s.inner, c, n);
+string & assign( string & s, const string & c, size_t n ) {
+    assign( *s.inner, *c.inner, n );
+    return s;
+}
+
+string & assign( string & s, const char * c, size_t n ) {
+    assign( *s.inner, c, n );
     return s;
 }
@@ -205,5 +235,5 @@
 }
 
-ifstream & ?|?(ifstream & in, string & s) {
+ifstream & ?|?( ifstream & in, string & s ) {
     return in | (*s.inner); // read to internal string_res
 }
@@ -236,27 +266,27 @@
 // Comparison
 
-int  strcmp(const string & s1, const string & s2) { return strcmp(*s1.inner, *s2.inner); }
-bool ?==?(const string & s1, const string & s2) { return *s1.inner == *s2.inner; }
-bool ?!=?(const string & s1, const string & s2) { return *s1.inner != *s2.inner; }
-bool ?>? (const string & s1, const string & s2) { return *s1.inner >  *s2.inner; }
-bool ?>=?(const string & s1, const string & s2) { return *s1.inner >= *s2.inner; }
-bool ?<=?(const string & s1, const string & s2) { return *s1.inner <= *s2.inner; }
-bool ?<? (const string & s1, const string & s2) { return *s1.inner <  *s2.inner; }
-
-int  strcmp(const string & s1, const char * s2) { return strcmp(*s1.inner, s2 ); }
-bool ?==?(const string & s1, const char * s2) { return *s1.inner == s2; }
-bool ?!=?(const string & s1, const char * s2) { return *s1.inner != s2; }
-bool ?>? (const string & s1, const char * s2) { return *s1.inner >  s2; }
-bool ?>=?(const string & s1, const char * s2) { return *s1.inner >= s2; }
-bool ?<=?(const string & s1, const char * s2) { return *s1.inner <= s2; }
-bool ?<? (const string & s1, const char * s2) { return *s1.inner <  s2; }
-
-int  strcmp(const char * s1, const string & s2) { return strcmp( s1, *s2.inner); }
-bool ?==?(const char * s1, const string & s2) { return s1 == *s2.inner; }
-bool ?!=?(const char * s1, const string & s2) { return s1 != *s2.inner; }
-bool ?>? (const char * s1, const string & s2) { return s1 >  *s2.inner; }
-bool ?>=?(const char * s1, const string & s2) { return s1 >= *s2.inner; }
-bool ?<=?(const char * s1, const string & s2) { return s1 <= *s2.inner; }
-bool ?<? (const char * s1, const string & s2) { return s1 <  *s2.inner; }
+int strcmp( const string & s1, const string & s2 ) { return strcmp( *s1.inner, *s2.inner ); }
+bool ?==?( const string & s1, const string & s2 ) { return *s1.inner == *s2.inner; }
+bool ?!=?( const string & s1, const string & s2 ) { return *s1.inner != *s2.inner; }
+bool ?>? ( const string & s1, const string & s2 ) { return *s1.inner >  *s2.inner; }
+bool ?>=?( const string & s1, const string & s2 ) { return *s1.inner >= *s2.inner; }
+bool ?<=?( const string & s1, const string & s2 ) { return *s1.inner <= *s2.inner; }
+bool ?<? ( const string & s1, const string & s2 ) { return *s1.inner <  *s2.inner; }
+
+int strcmp( const string & s1, const char * s2 ) { return strcmp( *s1.inner, s2 ); }
+bool ?==?( const string & s1, const char * s2 ) { return *s1.inner == s2; }
+bool ?!=?( const string & s1, const char * s2 ) { return *s1.inner != s2; }
+bool ?>? ( const string & s1, const char * s2 ) { return *s1.inner >  s2; }
+bool ?>=?( const string & s1, const char * s2 ) { return *s1.inner >= s2; }
+bool ?<=?( const string & s1, const char * s2 ) { return *s1.inner <= s2; }
+bool ?<? ( const string & s1, const char * s2 ) { return *s1.inner <  s2; }
+
+int strcmp( const char * s1, const string & s2 ) { return strcmp( s1, *s2.inner ); }
+bool ?==?( const char * s1, const string & s2 ) { return s1 == *s2.inner; }
+bool ?!=?( const char * s1, const string & s2 ) { return s1 != *s2.inner; }
+bool ?>? ( const char * s1, const string & s2 ) { return s1 >  *s2.inner; }
+bool ?>=?( const char * s1, const string & s2 ) { return s1 >= *s2.inner; }
+bool ?<=?( const char * s1, const string & s2 ) { return s1 <= *s2.inner; }
+bool ?<? ( const char * s1, const string & s2 ) { return s1 <  *s2.inner; }
 
 
@@ -264,5 +294,5 @@
 // Getter
 
-size_t size(const string & s) {
+size_t size( const string & s ) {
     return size( *s.inner );
 }
@@ -271,25 +301,25 @@
 // Concatenation
 
-void ?+=?(string & s, char c) {
+void ?+=?( string & s, char c ) {
     (*s.inner) += c;
 }
 
-void ?+=?(string & s, const string & s2) {
+void ?+=?( string & s, const string & s2 ) {
     (*s.inner) += (*s2.inner);
 }
 
-void append(string & s, const string & s2, size_t maxlen) {
+void append( string & s, const string & s2, size_t maxlen ) {
     append( (*s.inner), (*s2.inner), maxlen );
 }
 
-void ?+=?(string & s, const char * c) {
+void ?+=?( string & s, const char * c ) {
     (*s.inner) += c;
 }
 
-void append(string & s, const char * buffer, size_t bsize) {
+void append( string & s, const char * buffer, size_t bsize ) {
     append( (*s.inner), buffer, bsize );
 }
 
-string ?+?(const string & s, char c) {
+string ?+?( const string & s, char c ) {
     string ret = s;
     ret += c;
@@ -297,5 +327,11 @@
 }
 
-string ?+?(const string & s, const string & s2) {
+string ?+?( char c, const string & s ) {
+    string ret = s;
+    ret += c;
+    return ret;
+}
+
+string ?+?( const string & s, const string & s2 ) {
     string ret = s;
     ret += s2;
@@ -303,5 +339,17 @@
 }
 
-string ?+?(const char * s1, const char * s2) {
+string ?+?( const char * s,  char c ) {
+    string ret = s;
+    ret += c;
+    return ret;
+}
+
+string ?+?( char c, const char * s ) {
+    string ret = c;
+    ret += s;
+    return ret;
+}
+
+string ?+?( const char * s1, const char * s2 ) {
     string ret = s1;
     ret += s2;
@@ -309,5 +357,11 @@
 }
 
-string ?+?(const string & s, const char * c) {
+string ?+?( const char * s1, string & s2 ) {
+    string ret = s1;
+    ret += s2;
+    return ret;
+}
+
+string ?+?( const string & s, const char * c ) {
     string ret = s;
     ret += c;
@@ -318,9 +372,9 @@
 // Repetition
 
-void ?*=?(string & s, size_t factor) {
+void ?*=?( string & s, size_t factor ) {
     (*s.inner) *= factor;
 }
 
-string ?*?(const string & s, size_t factor) {
+string ?*?( const string & s, size_t factor ) {
     string ret = s;
     ret *= factor;
@@ -328,5 +382,5 @@
 }
 
-string ?*?(char c, size_t factor) {
+string ?*?( char c, size_t factor ) {
     string ret = c;
     ret *= factor;
@@ -334,5 +388,5 @@
 }
 
-string ?*?(const char * s, size_t factor) {
+string ?*?( const char * s, size_t factor ) {
     string ret = s;
     ret *= factor;
@@ -343,9 +397,9 @@
 // Character access
 
-char ?[?](const string & s, size_t index) {
+char ?[?]( const string & s, size_t index ) {
     return (*s.inner)[index];
 }
 
-string ?[?](string & s, size_t index) {
+string ?[?]( string & s, size_t index ) {
     string ret = { *s.inner, index, 1 };
     return ret`shareEdits;
@@ -355,73 +409,73 @@
 // Search
 
-bool contains(const string & s, char ch) {
+bool contains( const string & s, char ch ) {
     return contains( *s.inner, ch );
 }
 
-int find(const string & s, char search) {
+int find( const string & s, char search ) {
     return find( *s.inner, search );
 }
 
-int find(const string & s, const string & search) {
+int find( const string & s, const string & search ) {
     return find( *s.inner, *search.inner );
 }
 
-int find(const string & s, const char * search) {
-    return find( *s.inner, search);
-}
-
-int find(const string & s, const char * search, size_t searchsize) {
-    return find( *s.inner, search, searchsize);
-}
-
-int findFrom(const string & s, size_t fromPos, char search) {
+int find( const string & s, const char * search ) {
+    return find( *s.inner, search );
+}
+
+int find( const string & s, const char * search, size_t searchsize ) {
+    return find( *s.inner, search, searchsize );
+}
+
+int findFrom( const string & s, size_t fromPos, char search ) {
     return findFrom( *s.inner, fromPos, search );
 }
 
-int findFrom(const string & s, size_t fromPos, const string & search) {
+int findFrom( const string & s, size_t fromPos, const string & search ) {
     return findFrom( *s.inner, fromPos, *search.inner );
 }
 
-int findFrom(const string & s, size_t fromPos, const char * search) {
+int findFrom( const string & s, size_t fromPos, const char * search ) {
     return findFrom( *s.inner, fromPos, search );
 }
 
-int findFrom(const string & s, size_t fromPos, const char * search, size_t searchsize) {
+int findFrom( const string & s, size_t fromPos, const char * search, size_t searchsize ) {
     return findFrom( *s.inner, fromPos, search, searchsize );
 }
 
-bool includes(const string & s, const string & search) {
+bool includes( const string & s, const string & search ) {
     return includes( *s.inner, *search.inner );
 }
 
-bool includes(const string & s, const char * search) {
+bool includes( const string & s, const char * search ) {
     return includes( *s.inner, search );
 }
 
-bool includes(const string & s, const char * search, size_t searchsize) {
+bool includes( const string & s, const char * search, size_t searchsize ) {
     return includes( *s.inner, search, searchsize );
 }
 
-bool startsWith(const string & s, const string & prefix) {
+bool startsWith( const string & s, const string & prefix ) {
     return startsWith( *s.inner, *prefix.inner );
 }
 
-bool startsWith(const string & s, const char * prefix) {
+bool startsWith( const string & s, const char * prefix ) {
     return startsWith( *s.inner, prefix );
 }
 
-bool startsWith(const string & s, const char * prefix, size_t prefixsize) {
+bool startsWith( const string & s, const char * prefix, size_t prefixsize ) {
     return startsWith( *s.inner, prefix, prefixsize );
 }
 
-bool endsWith(const string & s, const string & suffix) {
+bool endsWith( const string & s, const string & suffix ) {
     return endsWith( *s.inner, *suffix.inner );
 }
 
-bool endsWith(const string & s, const char * suffix) {
+bool endsWith( const string & s, const char * suffix ) {
     return endsWith( *s.inner, suffix );
 }
 
-bool endsWith(const string & s, const char * suffix, size_t suffixsize) {
+bool endsWith( const string & s, const char * suffix, size_t suffixsize ) {
     return endsWith( *s.inner, suffix, suffixsize );
 }
@@ -431,5 +485,5 @@
 // charclass, include, exclude
 
-void ?{}( charclass & s, const string & chars) {
+void ?{}( charclass & s, const string & chars ) {
     (s.inner) { malloc() };
     ?{}( *s.inner, *(const string_res *)chars.inner );
@@ -453,19 +507,18 @@
 
 
-int exclude(const string & s, const charclass & mask) {
+int exclude( const string & s, const charclass & mask ) {
     return exclude( *s.inner, *mask.inner );
 }
 /*
-StrSlice exclude(string & s, const charclass & mask) {
+StrSlice exclude( string & s, const charclass & mask ) {
 }
 */
 
-int include(const string & s, const charclass & mask) {
+int include( const string & s, const charclass & mask ) {
     return include( *s.inner, *mask.inner );
 }
 
 /*
-StrSlice include(string & s, const charclass & mask) {
+StrSlice include( string & s, const charclass & mask ) {
 }
 */
-
Index: libcfa/src/collections/string.hfa
===================================================================
--- libcfa/src/collections/string.hfa	(revision b8e047a4229d594036e98f1f35d359049e3c7b27)
+++ libcfa/src/collections/string.hfa	(revision af5baae0adea725769db51743818a97dfe619952)
@@ -10,6 +10,6 @@
 // Created On       : Fri Sep 03 11:00:00 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb  6 20:59:18 2024
-// Update Count     : 118
+// Last Modified On : Mon Aug  5 23:06:14 2024
+// Update Count     : 128
 //
 
@@ -28,16 +28,16 @@
 
 // Getters
-size_t size(const string & s);
-static inline size_t strlen(const string & s) { return size( s ); }
+size_t size( const string & s );
+static inline size_t strlen( const string & s ) { return size( s ); }
 
 // RAII, assignment
-void ?{}(string & s); // empty string
-void ?{}(string & s, const string & s2);
-void ?{}(string & s, const string & s2, size_t maxlen);
-void ?{}(string & s, string & s2);
-
-void ?{}(string & s, char);
-void ?{}(string & s, const char * c); // copy from string literal (NULL-terminated)
-void ?{}(string & s, const char * c, size_t size); // copy specific length from buffer
+void ?{}( string & s ); // empty string
+void ?{}( string & s, const string & s2 );
+void ?{}( string & s, const string & s2, size_t maxlen );
+void ?{}( string & s, string & s2 );
+
+void ?{}( string & s, char );
+void ?{}( string & s, const char * c );					// copy from string literal (NULL-terminated)
+void ?{}( string & s, const char * c, size_t size );	// copy specific length from buffer
 
 void ?{}( string & s, ssize_t rhs );
@@ -48,15 +48,22 @@
 void ?{}( string & s, long double _Complex rhs );
 
-string & ?=?(string & s, const string & c);
-string & ?=?(string & s, string & c);
-string & ?=?(string & s, const char * c); // copy from "literal"
-string & ?=?(string & s, char c);  // copy from 'l'
-string & assign(string & s, const string & c, size_t n);
-string & assign(string & s, const char * c, size_t n);
-
-static inline string & strcpy(string & s, const char * c) { s = c; return s; }
-static inline string & strncpy(string & s, const char * c, size_t n) { assign( s, c, n); return s; }
-static inline string & strcpy(string & s, const string & c) { s = c; return s; }
-static inline string & strncpy(string & s, const string & c, size_t n) { assign(s, c, n); return s; }
+string str( ssize_t rhs );
+string str( size_t rhs );
+string str( double rhs );
+string str( long double rhs );
+string str( double _Complex rhs );
+string str( long double _Complex rhs );
+
+string & ?=?( string & s, const string & c );
+string & ?=?( string & s, string & c );
+string & ?=?( string & s, const char * c );				// copy from "literal"
+string & ?=?( string & s, char c );						// copy from 'l'
+string & assign( string & s, const string & c, size_t n );
+string & assign( string & s, const char * c, size_t n );
+
+static inline string & strcpy( string & s, const char * c ) { s = c; return s; }
+static inline string & strncpy( string & s, const char * c, size_t n ) { assign( s, c, n ); return s; }
+static inline string & strcpy( string & s, const string & c ) { s = c; return s; }
+static inline string & strncpy( string & s, const string & c, size_t n ) { assign( s, c, n ); return s; }
 
 string & ?=?( string & s, ssize_t rhs );
@@ -67,5 +74,5 @@
 string & ?=?( string & s, long double _Complex rhs );
 
-void ^?{}(string & s);
+void ^?{}( string & s );
 
 // Alternate construction: request shared edits
@@ -77,7 +84,7 @@
 
 // IO Operator
-ofstream & ?|?(ofstream & out, const string & s);
-void ?|?(ofstream & out, const string & s);
-ifstream & ?|?(ifstream & in, string & s);
+ofstream & ?|?( ofstream & out, const string & s );
+void ?|?( ofstream & out, const string & s );
+ifstream & ?|?( ifstream & in, string & s );
 
 static inline {
@@ -145,91 +152,95 @@
 
 // Concatenation
-void ?+=?(string & s, char c); // append a character
-void ?+=?(string & s, const string & s2); // append-concatenate to first string
-void append(string & s, const string & s2, size_t maxlen);  // append-concatenate to first string, up to maxlen
-void ?+=?(string & s, const char * s2); // append-concatenate NULL-terminated string to first string
-void append(string & s, const char * buffer, size_t bsize);  // append-concatenate given range to first string
-
-string ?+?(const string & s, char c); // add a character to a copy of the string
-string ?+?(const string & s, const string & s2); // copy and concatenate both strings
-string ?+?(const char * s1, const char * s2); // copy and concatenate both strings
-string ?+?(const string & s, const char * c); // copy and concatenate with NULL-terminated string
-
-static inline string & strcat(string & s, const string & s2) { s += s2; return s; }
-static inline string & strcat(string & s, const char * c) { s += c; return s; }
-static inline string & strncat(string & s, const string & s2, size_t maxlen) { append(s, s2, maxlen); return s; }
-static inline string & strncat(string & s, const char * buffer, size_t bsize) { append(s, buffer, bsize); return s; }
+void ?+=?( string & s, char c );						// append a character
+void ?+=?( string & s, const string & s2 );				// append-concatenate to first string
+void append( string & s, const string & s2, size_t maxlen );  // append-concatenate to first string, up to maxlen
+void ?+=?( string & s, const char * s2 );				// append-concatenate NULL-terminated string to first string
+void append( string & s, const char * buffer, size_t bsize ); // append-concatenate given range to first string
+
+string ?+?( const string & s, char c );					// add a character to a copy of the string
+string ?+?( char c, const string & s );					// add a character to a copy of the string
+string ?+?( const string & s, const string & s2 );		// copy and concatenate both strings
+string ?+?( const char * s, char c );					// copy and concatenate both strings
+string ?+?( char c, const char * s );					// copy and concatenate both strings
+string ?+?( const char * s1, const char * s2 );			// copy and concatenate both strings
+string ?+?( const char * s1, string & s2 );				// copy and concatenate both strings
+string ?+?( const string & s, const char * c );			// copy and concatenate with NULL-terminated string
+
+static inline string & strcat( string & s, const string & s2 ) { s += s2; return s; }
+static inline string & strcat( string & s, const char * c ) { s += c; return s; }
+static inline string & strncat( string & s, const string & s2, size_t maxlen ) { append( s, s2, maxlen ); return s; }
+static inline string & strncat( string & s, const char * buffer, size_t bsize ) { append( s, buffer, bsize ); return s; }
 
 // Repetition
-string ?*?(const string & s, size_t factor);
-void ?*=?(string & s, size_t factor);
-string ?*?(char c, size_t factor);
-string ?*?(const char *s, size_t factor);
+string ?*?( const string & s, size_t factor );
+void ?*=?( string & s, size_t factor );
+string ?*?( char c, size_t factor );
+string ?*?( const char *s, size_t factor );
 
 // Character access
-char ?[?](const string & s, size_t index);
-string ?[?](string & s, size_t index);  // mutable length-1 slice of original
-//char codePointAt(const string & s, size_t index);  // to revisit under Unicode
+char ?[?]( const string & s, size_t index );
+string ?[?]( string & s, size_t index );				// mutable length-1 slice of original
+//char codePointAt(const string & s, size_t index );		// to revisit under Unicode
 
 // Comparisons
-int  strcmp (const string &, const string &);
-bool ?==?(const string &, const string &);
-bool ?!=?(const string &, const string &);
-bool ?>? (const string &, const string &);
-bool ?>=?(const string &, const string &);
-bool ?<=?(const string &, const string &);
-bool ?<? (const string &, const string &);
-
-int  strcmp (const string &, const char *);
-bool ?==?(const string &, const char *);
-bool ?!=?(const string &, const char *);
-bool ?>? (const string &, const char *);
-bool ?>=?(const string &, const char *);
-bool ?<=?(const string &, const char *);
-bool ?<? (const string &, const char *);
-
-int  strcmp (const char *, const string &);
-bool ?==?(const char *, const string &);
-bool ?!=?(const char *, const string &);
-bool ?>? (const char *, const string &);
-bool ?>=?(const char *, const string &);
-bool ?<=?(const char *, const string &);
-bool ?<? (const char *, const string &);
+int strcmp ( const string &, const string &);
+bool ?==?( const string &, const string &);
+bool ?!=?( const string &, const string &);
+bool ?>? ( const string &, const string &);
+bool ?>=?( const string &, const string &);
+bool ?<=?( const string &, const string &);
+bool ?<? ( const string &, const string &);
+
+int strcmp( const string &, const char *);
+bool ?==?( const string &, const char *);
+bool ?!=?( const string &, const char *);
+bool ?>? ( const string &, const char *);
+bool ?>=?( const string &, const char *);
+bool ?<=?( const string &, const char *);
+bool ?<? ( const string &, const char *);
+
+int strcmp( const char *, const string &);
+bool ?==?( const char *, const string &);
+bool ?!=?( const char *, const string &);
+bool ?>? ( const char *, const string &);
+bool ?>=?( const char *, const string &);
+bool ?<=?( const char *, const string &);
+bool ?<? ( const char *, const string &);
 
 
 // Slicing
-string ?()( string & s, size_t start, size_t len );  // TODO const?
-string ?()( string & s, size_t start);
+string ?()( string & s, size_t start, size_t len );		// TODO const?
+string ?()( string & s, size_t start );
 
 // String search
-bool contains(const string & s, char ch); // single character
-
-int find(const string & s, char search);
-int find(const string & s, const string & search);
-int find(const string & s, const char * search);
-int find(const string & s, const char * search, size_t searchsize);
-
-int findFrom(const string & s, size_t fromPos, char search);
-int findFrom(const string & s, size_t fromPos, const string & search);
-int findFrom(const string & s, size_t fromPos, const char * search);
-int findFrom(const string & s, size_t fromPos, const char * search, size_t searchsize);
-
-bool includes(const string & s, const string & search);
-bool includes(const string & s, const char * search);
-bool includes(const string & s, const char * search, size_t searchsize);
-
-bool startsWith(const string & s, const string & prefix);
-bool startsWith(const string & s, const char * prefix);
-bool startsWith(const string & s, const char * prefix, size_t prefixsize);
-
-bool endsWith(const string & s, const string & suffix);
-bool endsWith(const string & s, const char * suffix);
-bool endsWith(const string & s, const char * suffix, size_t suffixsize);
+bool contains( const string & s, char ch );				// single character
+
+int find( const string & s, char search );
+int find( const string & s, const string & search );
+int find( const string & s, const char * search );
+int find( const string & s, const char * search, size_t searchsize );
+
+int findFrom( const string & s, size_t fromPos, char search );
+int findFrom( const string & s, size_t fromPos, const string & search );
+int findFrom( const string & s, size_t fromPos, const char * search );
+int findFrom( const string & s, size_t fromPos, const char * search, size_t searchsize );
+
+bool includes( const string & s, const string & search );
+bool includes( const string & s, const char * search );
+bool includes( const string & s, const char * search, size_t searchsize );
+
+bool startsWith( const string & s, const string & prefix );
+bool startsWith( const string & s, const char * prefix );
+bool startsWith( const string & s, const char * prefix, size_t prefixsize );
+
+bool endsWith( const string & s, const string & suffix );
+bool endsWith( const string & s, const char * suffix );
+bool endsWith( const string & s, const char * suffix, size_t suffixsize );
 
 // 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);
+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 );
 
 
@@ -239,19 +250,19 @@
 
 void ?{}( charclass & ) = void;
-void ?{}( charclass &, charclass) = void;
-charclass ?=?( charclass &, charclass) = void;
-
-void ?{}( charclass &, const string & chars);
+void ?{}( charclass &, charclass ) = void;
+charclass ?=?( charclass &, charclass ) = void;
+
+void ?{}( charclass &, const string & chars );
 void ?{}( charclass &, const char * chars );
 void ?{}( charclass &, const char * chars, size_t charssize );
 void ^?{}( charclass & );
 
-int include(const string & s, const charclass & mask);
-
-int exclude(const string & s, const charclass & mask);
+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);
+StrRet include( string & s, const charclass & mask );
+StrRet exclude( string & s, const charclass & mask );
 */