Index: libcfa/src/collections/array.hfa
===================================================================
--- libcfa/src/collections/array.hfa	(revision fee4436eba1b28227b579391350244cc53817461)
+++ libcfa/src/collections/array.hfa	(revision ce02877193b9b7fb9e2bdf7486d493bf45be2bec)
@@ -45,5 +45,5 @@
 forall( [N], S & | sized(S), Timmed &, Tbase & ) {
 	//
-	// Single-dim array sruct (with explicit packing and atom)
+	// Single-dim array struct (with explicit packing and atom)
 	//
 	struct arpk {
@@ -83,69 +83,69 @@
 	// Mike is open to being shown a smaller set of overloads that still passes the test.
 
-	static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase ) & a, zero_t ) {
+	static inline Timmed & ?[?]( arpk( N, S, Timmed, Tbase ) & a, zero_t ) {
 		//assert( 0 < N );
 		subcheck( a, 0L, 0, N );
-		return (Timmed &) a.strides[0];
-	}
-
-	static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase ) & a, one_t ) {
+		return (Timmed &)a.strides[0];
+	}
+
+	static inline Timmed & ?[?]( arpk( N, S, Timmed, Tbase ) & a, one_t ) {
 		//assert( 1 < N );
 		subcheck( a, 1L, 0, N );
-		return (Timmed &) a.strides[1];
-	}
-
-	static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase ) & a, int i ) {
+		return (Timmed &)a.strides[1];
+	}
+
+	static inline Timmed & ?[?]( arpk( N, S, Timmed, Tbase ) & a, int i ) {
 		//assert( i < N );
 		subcheck( a, (long int)i, 0, N );
-		return (Timmed &) a.strides[i];
-	}
-
-	static inline const Timmed & ?[?]( const arpk(N, S, Timmed, Tbase ) & a, int i ) {
+		return (Timmed &)a.strides[i];
+	}
+
+	static inline const Timmed & ?[?]( const arpk( N, S, Timmed, Tbase ) & a, int i ) {
 		//assert( i < N );
 		subcheck( a, (long int)i, 0, N );
-		return (Timmed &) a.strides[i];
-	}
-
-	static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase ) & a, unsigned int i ) {
+		return (Timmed &)a.strides[i];
+	}
+
+	static inline Timmed & ?[?]( arpk( N, S, Timmed, Tbase ) & a, unsigned int i ) {
 		//assert( i < N );
 		subcheck( a, (long int)i, 0, N );
-		return (Timmed &) a.strides[i];
-	}
-
-	static inline const Timmed & ?[?]( const arpk(N, S, Timmed, Tbase ) & a, unsigned int i ) {
+		return (Timmed &)a.strides[i];
+	}
+
+	static inline const Timmed & ?[?]( const arpk( N, S, Timmed, Tbase ) & a, unsigned int i ) {
 		//assert( i < N );
 		subcheck( a, (unsigned long int)i, 0, N );
-		return (Timmed &) a.strides[i];
-	}
-
-	static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase ) & a, long int i ) {
+		return (Timmed &)a.strides[i];
+	}
+
+	static inline Timmed & ?[?]( arpk( N, S, Timmed, Tbase ) & a, long int i ) {
 		//assert( i < N );
 		subcheck( a, i, 0, N );
-		return (Timmed &) a.strides[i];
-	}
-
-	static inline const Timmed & ?[?]( const arpk(N, S, Timmed, Tbase ) & a, long int i ) {
+		return (Timmed &)a.strides[i];
+	}
+
+	static inline const Timmed & ?[?]( const arpk( N, S, Timmed, Tbase ) & a, long int i ) {
 		//assert( i < N );
 		subcheck( a, i, 0, N );
-		return (Timmed &) a.strides[i];
-	}
-
-	static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase ) & a, unsigned long int i ) {
+		return (Timmed &)a.strides[i];
+	}
+
+	static inline Timmed & ?[?]( arpk( N, S, Timmed, Tbase ) & a, unsigned long int i ) {
 		//assert( i < N );
 		subcheck( a, i, 0, N );
-		return (Timmed &) a.strides[i];
-	}
-
-	static inline const Timmed & ?[?]( const arpk(N, S, Timmed, Tbase ) & a, unsigned long int i ) {
+		return (Timmed &)a.strides[i];
+	}
+
+	static inline const Timmed & ?[?]( const arpk( N, S, Timmed, Tbase ) & a, unsigned long int i ) {
 		//assert( i < N );
 		subcheck( a, i, 0, N );
-		return (Timmed &) a.strides[i];
-	}
-
-	static inline size_t ?`len( arpk(N, S, Timmed, Tbase ) & a ) {
+		return (Timmed &)a.strides[i];
+	}
+
+	static inline size_t ?`len( arpk( N, S, Timmed, Tbase ) & a ) {
 		return N;
 	}
 
-	static inline void __taglen( tag(arpk(N, S, Timmed, Tbase )), tag(N) ) {}
+	static inline void __taglen( tag(arpk( N, S, Timmed, Tbase )), tag(N) ) {}
 }
 
@@ -157,18 +157,18 @@
 
 forall( [N], S & | sized(S), Timmed &, Tbase & | { void ?{}( Timmed & ); } )
-static inline void ?{}( arpk(N, S, Timmed, Tbase ) & this ) {	
+static inline void ?{}( arpk( N, S, Timmed, Tbase ) & this ) {	
 	void ?{}( S (&)[N] ) {}
 	?{}(this.strides);
 
-	for (i; N) ?{}( (Timmed &) this.strides[i] );
+	for (i; N) ?{}( (Timmed &)this.strides[i] );
 }
 
 forall( [N], S & | sized(S), Timmed &, Tbase & | { void ^?{}( Timmed & ); } )
-static inline void ^?{}( arpk(N, S, Timmed, Tbase ) & this ) {
+static inline void ^?{}( arpk( N, S, Timmed, Tbase ) & this ) {
 	void ^?{}( S (&)[N] ) {}
 	^?{}(this.strides);
 
 	for (i; N ) {
-		^?{}( (Timmed &) this.strides[N-i-1] );
+		^?{}( (Timmed &)this.strides[N-i-1] );
 	}
 }
@@ -182,5 +182,5 @@
 
 forall( [N], ZTags ... , Trslt &, Tatom & | { Trslt mkar_( tag(Tatom), ZTags ); } )
-static inline arpk(N, Trslt, Trslt, Tatom) mkar_( tag(Tatom), tag(N), ZTags ) {}
+static inline arpk( N, Trslt, Trslt, Tatom) mkar_( tag(Tatom), tag(N), ZTags ) {}
 
 // based on https://stackoverflow.com/questions/1872220/is-it-possible-to-iterate-over-arguments-in-variadic-macros
@@ -254,13 +254,13 @@
 // Base
 forall( [Nq], Sq & | sized(Sq), Tbase & )
-static inline tag(arpk(Nq, Sq, Tbase, Tbase )) enq_( tag(Tbase ), tag(Nq), tag(Sq), tag(Tbase ) ) {
-	tag(arpk(Nq, Sq, Tbase, Tbase )) ret;
+static inline tag(arpk( Nq, Sq, Tbase, Tbase )) enq_( tag(Tbase ), tag(Nq), tag(Sq), tag(Tbase ) ) {
+	tag(arpk( Nq, Sq, Tbase, Tbase )) ret;
 	return ret;
 }
 
 // Rec
-forall( [Nq], Sq & | sized(Sq), [N], S & | sized(S), recq &, recr &, Tbase & | { tag(recr) enq_( tag(Tbase ), tag(Nq), tag(Sq), tag(recq) ); } )
-static inline tag(arpk(N, S, recr, Tbase )) enq_( tag(Tbase ), tag(Nq), tag(Sq), tag(arpk(N, S, recq, Tbase )) ) {
-	tag(arpk(N, S, recr, Tbase )) ret;
+forall( [Nq], Sq & | sized(Sq), [N], S & | sized(S), recq &, recr &, Tbase & | { tag(recr) enq_( tag(Tbase), tag(Nq), tag(Sq), tag(recq) ); } )
+static inline tag(arpk( N, S, recr, Tbase )) enq_( tag(Tbase ), tag(Nq), tag(Sq), tag(arpk( N, S, recq, Tbase )) ) {
+	tag(arpk( N, S, recr, Tbase )) ret;
 	return ret;
 }
@@ -268,6 +268,6 @@
 // Wrapper
 extern struct all_t {} all;
-forall( [N], S & | sized(S), Te &, result &, Tbase & | { tag(result) enq_( tag(Tbase ), tag(N), tag(S), tag(Te) ); } )
-static inline result & ?[?]( arpk(N, S, Te, Tbase ) & this, all_t ) {
+forall( [N], S & | sized(S), Te &, result &, Tbase & | { tag(result) enq_( tag(Tbase), tag(N), tag(S), tag(Te) ); } )
+static inline result & ?[?]( arpk( N, S, Te, Tbase ) & this, all_t ) {
 	return (result&) this;
 }