Index: libcfa/src/collections/string.cfa
===================================================================
--- libcfa/src/collections/string.cfa	(revision 3f631d63dc8a3d8d5bd5e664c971d336878cb507)
+++ libcfa/src/collections/string.cfa	(revision 570e7ad00de8288cde75cec124f5ec3910662225)
@@ -40,20 +40,15 @@
 }
 
-void ?{}( string & s, const string & c ) {
+void ?{}( string & s, string c ) {  // c is a memcpy of the real src string
 	(s.inner) { malloc() };
 	?{}( *s.inner, *c.inner, COPY_VALUE );
 }
 
-void ?{}( string & s, const string & s2, size_t maxlen ) {
+void ?{}( string & s, string s2, size_t maxlen ) {
 	(s.inner) { malloc() };
 	?{}( *s.inner, *s2.inner, COPY_VALUE, maxlen );
 }
 
-
-void ?{}( string & s, string & c ) {
-	?{}( s, (const string &) c );
-}
-
-void ?{}( string & s, const char c ) {
+void ?{}( string & s, char c ) {
 	(s.inner) { malloc() };
 	?{}( *s.inner, c );
@@ -70,5 +65,5 @@
 }
 
-void ?{}( string & s, ssize_t rhs ) {
+void ?{}( string & s, signed long int rhs ) {
 	(s.inner) { malloc() };
 	?{}( *s.inner, rhs );
@@ -151,10 +146,5 @@
 // Assignment
 
-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;
@@ -181,5 +171,5 @@
 }
 
-string & ?=?( string & s, ssize_t rhs ) {
+string & ?=?( string & s, signed long int rhs ) {
 	(*s.inner) = rhs;
 	return s;
@@ -324,5 +314,5 @@
 }
 
-string ?+?( const string & s, char c ) {
+string ?+?( string s, char c ) {
 	string ret = s;
 	ret += c;
@@ -330,5 +320,5 @@
 }
 
-string ?+?( char c, const string & s ) {
+string ?+?( char c, string s ) {
 	string ret = c;
 	ret += s;
@@ -336,5 +326,5 @@
 }
 
-string ?+?( const string & s, const string & s2 ) {
+string ?+?( string s, string s2 ) {
 	string ret = s;
 	ret += s2;
@@ -360,5 +350,5 @@
 }
 
-string ?+?( const char * s1, const string & s2 ) {
+string ?+?( const char * s1, string s2 ) {
 	string ret = s1;
 	ret += s2;
@@ -366,5 +356,5 @@
 }
 
-string ?+?( const string & s, const char * c ) {
+string ?+?( string s, const char * c ) {
 	string ret = s;
 	ret += c;
@@ -381,9 +371,9 @@
 // Repetition
 
-void ?*=?( string & s, size_t factor ) {
+void ?*=?( string & s, strmul_factor_t factor ) {
 	(*s.inner) *= factor;
 }
 
-string ?*?( const string & s, size_t factor ) {
+string ?*?( string s, strmul_factor_t factor ) {
 	string ret = s;
 	ret *= factor;
@@ -391,5 +381,5 @@
 }
 
-string ?*?( char c, size_t factor ) {
+string ?*?( char c, strmul_factor_t factor ) {
 	string ret = c;
 	ret *= factor;
@@ -397,5 +387,5 @@
 }
 
-string ?*?( const char * s, size_t factor ) {
+string ?*?( const char * s, strmul_factor_t factor ) {
 	string ret = s;
 	ret *= factor;
Index: libcfa/src/collections/string.hfa
===================================================================
--- libcfa/src/collections/string.hfa	(revision 3f631d63dc8a3d8d5bd5e664c971d336878cb507)
+++ libcfa/src/collections/string.hfa	(revision 570e7ad00de8288cde75cec124f5ec3910662225)
@@ -27,13 +27,11 @@
 
 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, 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 );
+void ?{}( string & s, signed long int rhs );
 void ?{}( string & s, size_t rhs );
 void ?{}( string & s, double rhs );
@@ -41,4 +39,5 @@
 void ?{}( string & s, double _Complex rhs );
 void ?{}( string & s, long double _Complex rhs );
+static inline void ?{}( string & s, int rhs ) { (s){(signed long int) rhs}; }
 
 // string str( ssize_t rhs );
@@ -49,11 +48,10 @@
 // string str( long double _Complex rhs );
 
-string & ?=?( string & s, const string & c );
-string & ?=?( string & s, 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 );
-string & ?=?( string & s, ssize_t rhs );
+string & ?=?( string & s, signed long int rhs );
 string & ?=?( string & s, size_t rhs );
 string & ?=?( string & s, double rhs );
@@ -61,4 +59,5 @@
 string & ?=?( string & s, double _Complex rhs );
 string & ?=?( string & s, long double _Complex rhs );
+static inline string & ?=?( string & s, int rhs ) { return s = ((signed long int) rhs); } // to match cost of (char * int): int
 
 static inline string & strcpy( string & s, const char * c ) { s = c; return s; }
@@ -161,12 +160,12 @@
 void append( string & s, const char * buffer, size_t bsize );
 
-string ?+?( const string & s, char c );
-string ?+?( char c, const string & s );
-string ?+?( const string & s, const string & s2 );
+string ?+?( string s, char c );
+string ?+?( char c, string s );
+string ?+?( string s, string s2 );
 string ?+?( const char * s, char c );					// not backwards compatible
 string ?+?( char c, const char * s );
 string ?+?( const char * c, const char * s );
-string ?+?( const char * c, const string & s );
-string ?+?( const string & s, const char * c );
+string ?+?( const char * c, string s );
+string ?+?( string s, const char * c );
 string ?+?( char, char );								// not being called 8-(
 
@@ -177,10 +176,17 @@
 
 // Repetition
-void ?*=?( string & s, size_t factor );
-string ?*?( char c, size_t factor );					// not backwards compatible
-string ?*?( const string & s, size_t factor );
-static inline string ?*?( size_t factor, const string & s ) { return s * factor; }
-string ?*?( const char * s, size_t factor );
-static inline string ?*?( size_t factor, const char * s ) { return s * factor; }
+
+// Type `signed long long int` chosen for `factor` argument to achieve cost detente.
+// This way, the call `'a' * 3` gets the same safe conversion cost calling here as for
+// the built-in definition `int * int`.
+typedef signed long long int strmul_factor_t;
+
+void ?*=?( string & s, strmul_factor_t factor );
+string ?*?( char c, strmul_factor_t factor );					// not backwards compatible
+string ?*?( string s, strmul_factor_t factor );
+string ?*?( const char * s, strmul_factor_t factor );
+static inline string ?*?( strmul_factor_t factor, char s ) { return s * factor; }
+static inline string ?*?( strmul_factor_t factor, string s ) { return s * factor; }
+static inline string ?*?( strmul_factor_t factor, const char * s ) { return s * factor; }
 
 // Character access