Index: src/tests/concurrent/examples/quickSort.c
===================================================================
--- src/tests/concurrent/examples/quickSort.c	(revision 90449e42a47322a4321a4a214fa9a76e57f61409)
+++ src/tests/concurrent/examples/quickSort.c	(revision edb6f7946715f3d8ccf6255348c2dd7b234b2ba6)
@@ -9,6 +9,6 @@
 // Created On       : Wed Dec  6 12:15:52 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Dec 11 17:00:25 2017
-// Update Count     : 126
+// Last Modified On : Wed Dec 13 18:20:18 2017
+// Update Count     : 138
 // 
 
@@ -19,24 +19,27 @@
 #include <string.h>										// strcmp
 
+forall( otype T | { T ?<?( T, T ); } )
 thread Quicksort {
-	int * values;										// communication variables
+	T * values;											// communication variables
 	int low, high, depth;
 };
 
-void ?{}( Quicksort & qs, int values[], int size, int depth ) {
+forall( otype T | { T ?<?( T, T ); } )
+void ?{}( Quicksort(T) & qs, T values[], int size, int depth ) {
 	qs.values = values;  qs.low = 0;  qs.high = size;  qs.depth = depth;
 } // Quicksort
 
-void main( Quicksort & qs ) {
+forall( otype T | { T ?<?( T, T ); } )
+void main( Quicksort(T) & qs ) {
 	// nested routines: information hiding
 
-	void ?{}( Quicksort & qs, int values[], int low, int high, int depth ) {
+	void ?{}( Quicksort(T) & qs, T values[], int low, int high, int depth ) {
 		qs.values = values;  qs.low = low;  qs.high = high;  qs.depth = depth;
 	} // Quicksort
 
-	void sort( int values[], int low, int high, int depth ) {
+	void sort( T values[], int low, int high, int depth ) {
 		int left, right;								// index to left/right-hand side of the values
-		int pivot;										// pivot value of values
-		int swap;										// temporary
+		T pivot;										// pivot value of values
+		T swap;											// temporary
 
 		//verify();										// check for stack overflow due to recursion
@@ -65,5 +68,5 @@
 				depth -= 1;
 				//sout << &uThisTask() << " " << depth << endl;
-				Quicksort rqs = { values, low, right, depth }; // concurrently sort upper half
+				Quicksort(T) rqs = { values, low, right, depth }; // concurrently sort upper half
 				//Quicksort lqs( values, left, high, depth ); // concurrently sort lower half
 				sort( values, left, high, depth );		// concurrently sort lower half
@@ -92,4 +95,7 @@
 	exit( EXIT_FAILURE );								// TERMINATE!
 } // usage
+
+
+#define ELEMTYPE int
 
 int main( int argc, char * argv[] ) {
@@ -134,5 +140,5 @@
 			unsortedfile | size;						// read number of elements in the list
 		  if ( eof( unsortedfile ) ) break;
-			int * values = anew( size );				// values to be sorted, too large to put on stack
+			ELEMTYPE * values = anew( size );			// values to be sorted, too large to put on stack
 			for ( int counter = 0; counter < size; counter += 1 ) { // read unsorted numbers
 				unsortedfile | values[counter];
@@ -143,5 +149,5 @@
 			sortedfile | endl;
 			if ( size > 0 ) {							// values to sort ?
-				Quicksort QS = { values, size - 1, 0 }; // sort values
+				Quicksort(ELEMTYPE) QS = { values, size - 1, 0 }; // sort values
 			} // wait until sort tasks terminate
 			for ( int counter = 0; counter < size; counter += 1 ) { // print sorted list
@@ -159,10 +165,10 @@
 		processor processors[ (1 << depth) - 1 ] __attribute__(( unused )); // create 2^depth-1 kernel threads
 
-		int * values = anew( size );					// values to be sorted, too large to put on stack
+		ELEMTYPE * values = anew( size );				// values to be sorted, too large to put on stack
 		for ( int counter = 0; counter < size; counter += 1 ) { // generate unsorted numbers
 			values[counter] = size - counter;			// descending values
 		} // for
 		{
-			Quicksort QS = { values, size - 1, depth }; // sort values
+			Quicksort(ELEMTYPE) QS = { values, size - 1, depth }; // sort values
 		} // wait until sort tasks terminate