Index: libcfa/src/vec/vec.hfa
===================================================================
--- libcfa/src/vec/vec.hfa	(revision f41b1614e8f77a861276c86c3fd61b86cbde5ac7)
+++ libcfa/src/vec/vec.hfa	(revision c62013ecf0b07694154ca3cbdff83310eedb1dd9)
@@ -59,89 +59,89 @@
 };
 forall(T)
-trait sqrt {
+	trait sqrt {
     T sqrt(T);
 };
 
 static inline {
-// int
-int ?=?(int& n, zero_t) { return n = 0.f; }
-// unsigned int
-int ?=?(unsigned int& n, zero_t) { return n = 0.f; }
-/* float */
-void ?{}(float& a, int b) { a = b; }
-float ?=?(float& n, zero_t) { return n = 0.f; }
-/* double */
-void ?{}(double& a, int b) { a = b; }
-double ?=?(double& n, zero_t) { return n = 0L; }
-// long double
-void ?{}(long double& a, int b) { a = b; }
-long double ?=?(long double& n, zero_t) { return n = 0L; }
-}
+	// int
+	int ?=?( int& n, zero_t ) { return n = 0.f; }
+	// unsigned int
+	int ?=?( unsigned int& n, zero_t ) { return n = 0.f; }
+	// float
+	void ?{}( float& a, int b ) { a = b; }
+	float ?=?( float& n, zero_t ) { return n = 0.f; }
+	// double
+	void ?{}( double& a, int b ) { a = b; }
+	double ?=?( double& n, zero_t ) { return n = 0L; }
+	// long double
+	void ?{}( long double& a, int b ) { a = b; }
+	long double ?=?( long double& n, zero_t ) { return n = 0L; }
+} // static inline
 
-forall(V, T)
+forall( V, T )
 trait dottable {
-    T dot(V, V);
+    T dot( V, V );
 };
 
 static inline {
+	forall( T | sqrt( T ), V | dottable( V, T ) )
+	T length( V v ) {
+		return sqrt( dot( v, v ) );
+	}
 
-forall(T | sqrt(T), V | dottable(V, T))
-T length(V v) {
-   return sqrt(dot(v, v));
-}
+	forall( T, V | dottable( V, T ) )
+	T length_squared( V v ) {
+		return dot( v, v );
+	}
 
-forall(T, V | dottable(V, T))
-T length_squared(V v) {
-   return dot(v, v);
-}
+	forall( T, V | { T length( V ); } | subtract( V ) )
+	T distance( V v1, V v2 ) {
+		return length( v1 - v2 );
+	}
 
-forall(T, V | { T length(V); } | subtract(V))
-T distance(V v1, V v2) {
-    return length(v1 - v2);
-}
+	forall( T, V | { T length( V ); V ?/?( V, T ); })
+	V normalize( V v ) {
+		return v / length( v );
+	}
 
-forall(T, V | { T length(V); V ?/?(V, T); })
-V normalize(V v) {
-    return v / length(v);
-}
+	// Project vector u onto vector v
+	forall( T, V | dottable( V, T ) | { V normalize( V ); V ?*?( V, T ); })
+	V project( V u, V v ) {
+		V v_norm = normalize( v );
+		return v_norm * dot( u, v_norm );
+	}
 
-// Project vector u onto vector v
-forall(T, V | dottable(V, T) | { V normalize(V); V ?*?(V, T); })
-V project(V u, V v) {
-    V v_norm = normalize(v);
-    return v_norm * dot(u, v_norm);
-}
+	// Reflect incident vector v with respect to surface with normal n
+	forall( T | fromint( T ), V | { V project( V, V ); V ?*?( T, V ); V ?-?( V,V ); })
+	V reflect( V v, V n ) {
+		return v - ( T ){2} * project( v, n );
+	}
 
-// Reflect incident vector v with respect to surface with normal n
-forall(T | fromint(T), V | { V project(V, V); V ?*?(T, V); V ?-?(V,V); })
-V reflect(V v, V n) {
-    return v - (T){2} * project(v, n);
-}
+	#pragma GCC diagnostic push
+	// FIX ME: false positive with gcc > 11, so disable.
+	#pragma GCC diagnostic ignored "-Wdangling-pointer"
 
-// Refract incident vector v with respect to surface with normal n
-// eta is the ratio of indices of refraction between starting material and
-// entering material (i.e., from air to water, eta = 1/1.33)
-// v and n must already be normalized
-forall(T | fromint(T) | subtract(T) | multiply(T) | add(T) | lessthan(T) | sqrt(T),
-       V | dottable(V, T) | { V ?*?(T, V); V ?-?(V,V); void ?{}(V&, zero_t); })
-V refract(V v, V n, T eta) {
-    T dotValue = dot(n, v);
-    T k = (T){1} - eta * eta * ((T){1} - dotValue * dotValue);
-    if (k < (T){0}) {
-        return 0;
-    }
-    return eta * v - (eta * dotValue + sqrt(k)) * n;
-}
+	// Refract incident vector v with respect to surface with normal n eta is the ratio of indices of refraction between
+	// starting material and entering material ( i.e., from air to water, eta = 1/1.33 ) v and n must already be
+	// normalized
+	forall( T | fromint( T ) | subtract( T ) | multiply( T ) | add( T ) | lessthan( T ) | sqrt( T ),
+		V | dottable( V, T ) | { V ?*?( T, V ); V ?-?( V,V ); void ?{}( V&, zero_t ); })
+	V refract( V v, V n, T eta ) {
+		T dotValue = dot( n, v );
+		T k = (T){1} - eta * eta * ((T){1} - dotValue * dotValue );
+		if ( k < (T){0}) {
+			return 0;
+		}
+		return eta * v - ( eta * dotValue + sqrt( k ) ) * n;
+	}
 
-// Given a perturbed normal and a geometric normal,
-// flip the perturbed normal if the geometric normal is pointing away
-// from the observer.
-// n is the perturbed vector that we want to align
-// i is the incident vector
-// ng is the geometric normal of the surface
-forall(T | lessthan(T) | zeroinit(T), V | dottable(V, T) | negate(V))
-V faceforward(V n, V i, V ng) {
-    return dot(ng, i) < (T){0} ? n : -n;
-}
+	#pragma GCC diagnostic pop
 
-} // inline
+	// Given a perturbed normal and a geometric normal, flip the perturbed normal if the geometric normal is pointing
+	// away from the observer.  n is the perturbed vector that we want to align i is the incident vector ng is the
+	// geometric normal of the surface
+	forall( T | lessthan( T ) | zeroinit( T ), V | dottable( V, T ) | negate( V ) )
+	V faceforward( V n, V i, V ng ) {
+		return dot( ng, i ) < (T){0} ? n : -n;
+	}
+} // static inline
Index: libcfa/src/vec/vec2.hfa
===================================================================
--- libcfa/src/vec/vec2.hfa	(revision f41b1614e8f77a861276c86c3fd61b86cbde5ac7)
+++ libcfa/src/vec/vec2.hfa	(revision c62013ecf0b07694154ca3cbdff83310eedb1dd9)
@@ -19,5 +19,5 @@
 #include "vec.hfa"
 
-forall (T) {
+forall( T ) {
     struct vec2 {
         T x, y;
@@ -25,262 +25,260 @@
 }
 
-forall (T) {
-    static inline {
-
-    void ?{}(vec2(T)& v, T x, T y) {
-        v.[x, y] = [x, y];
-    }
-
-    forall(| zero_assign(T))
-    void ?{}(vec2(T)& vec, zero_t) with (vec) {
-        x = y = 0;
-    }
-
-    void ?{}(vec2(T)& vec, T val) with (vec) {
-        x = y = val;
-    }
-
-    void ?{}(vec2(T)& vec, vec2(T) other) with (vec) {
-        [x,y] = other.[x,y];
-    }
-
-    void ?=?(vec2(T)& vec, vec2(T) other) with (vec) {
-        [x,y] = other.[x,y];
-    }
-    forall(| zero_assign(T))
-    void ?=?(vec2(T)& vec, zero_t) with (vec) {
-        x = y = 0;
-    }
-
-    // Primitive mathematical operations
-
-    // -
-    forall(| subtract(T)) {
-    vec2(T) ?-?(vec2(T) u, vec2(T) v) {
-        return [u.x - v.x, u.y - v.y];
-    }
-    vec2(T)& ?-=?(vec2(T)& u, vec2(T) v) {
-        u = u - v;
-        return u;
-    }
-    }
-    forall(| negate(T))
-    vec2(T) -?(vec2(T) v) with (v) {
-        return [-x, -y];
-    }
-
-    forall(| { T --?(T&); }) {
-    vec2(T)& --?(vec2(T)& v) {
-        --v.x;
-        --v.y;
-        return v;
-    }
-    vec2(T) ?--(vec2(T)& v) {
-        vec2(T) copy = v;
-        --v;
-        return copy;
-    }
-    }
-
-    // +
-    forall(| add(T)) {
-    vec2(T) ?+?(vec2(T) u, vec2(T) v) {
-        return [u.x + v.x, u.y + v.y];
-    }
-    vec2(T)& ?+=?(vec2(T)& u, vec2(T) v) {
-        u = u + v;
-        return u;
-    }
-    }
-
-    forall(| { T ++?(T&); }) {
-    vec2(T)& ++?(vec2(T)& v) {
-        ++v.x;
-        ++v.y;
-        return v;
-    }
-    vec2(T) ?++(vec2(T)& v) {
-        vec2(T) copy = v;
-        ++v;
-        return copy;
-    }
-    }
-
-    // *
-    forall(| multiply(T)) {
-    vec2(T) ?*?(vec2(T) v, T scalar) with (v) {
-        return [x * scalar, y * scalar];
-    }
-    vec2(T) ?*?(T scalar, vec2(T) v) {
-        return v * scalar;
-    }
-    vec2(T) ?*?(vec2(T) u, vec2(T) v) {
-        return [u.x * v.x, u.y * v.y];
-    }
-    vec2(T)& ?*=?(vec2(T)& v, T scalar) {
-        v = v * scalar;
-        return v;
-    }
-    vec2(T) ?*=?(vec2(T)& u, vec2(T) v) {
-        u = u * v;
-        return u;
-    }
-    }
-
-    // /
-    forall(| divide(T)) {
-    vec2(T) ?/?(vec2(T) v, T scalar) with (v) {
-        return [x / scalar, y / scalar];
-    }
-    vec2(T) ?/?(vec2(T) u, vec2(T) v) {
-        return [u.x / v.x, u.y / v.y];
-    }
-    vec2(T)& ?/=?(vec2(T)& v, T scalar) {
-        v = v / scalar;
-        return v;
-    }
-    vec2(T) ?/=?(vec2(T)& u, vec2(T) v) {
-        u = u / v;
-        return u;
-    }
-    }
-
-    // %
-    forall(| { T ?%?(T,T); }) {
-    vec2(T) ?%?(vec2(T) v, T scalar) with (v) {
-        return [x % scalar, y % scalar];
-    }
-    vec2(T)& ?%=?(vec2(T)& u, T scalar) {
-        u = u % scalar;
-        return u;
-    }
-    vec2(T) ?%?(vec2(T) u, vec2(T) v) {
-        return [u.x % v.x, u.y % v.y];
-    }
-    vec2(T)& ?%=?(vec2(T)& u, vec2(T) v) {
-        u = u % v;
-        return u;
-    }
-    }
-
-    // &
-    forall(| { T ?&?(T,T); }) {
-    vec2(T) ?&?(vec2(T) v, T scalar) with (v) {
-        return [x & scalar, y & scalar];
-    }
-    vec2(T)& ?&=?(vec2(T)& u, T scalar) {
-        u = u & scalar;
-        return u;
-    }
-    vec2(T) ?&?(vec2(T) u, vec2(T) v) {
-        return [u.x & v.x, u.y & v.y];
-    }
-    vec2(T)& ?&=?(vec2(T)& u, vec2(T) v) {
-        u = u & v;
-        return u;
-    }
-    }
-
-    // |
-    forall(| { T ?|?(T,T); }) {
-    vec2(T) ?|?(vec2(T) v, T scalar) with (v) {
-        return [x | scalar, y | scalar];
-    }
-    vec2(T)& ?|=?(vec2(T)& u, T scalar) {
-        u = u | scalar;
-        return u;
-    }
-    vec2(T) ?|?(vec2(T) u, vec2(T) v) {
-        return [u.x | v.x, u.y | v.y];
-    }
-    vec2(T)& ?|=?(vec2(T)& u, vec2(T) v) {
-        u = u | v;
-        return u;
-    }
-    }
-
-    // ^
-    forall(| { T ?^?(T,T); }) {
-    vec2(T) ?^?(vec2(T) v, T scalar) with (v) {
-        return [x ^ scalar, y ^ scalar];
-    }
-    vec2(T)& ?^=?(vec2(T)& u, T scalar) {
-        u = u ^ scalar;
-        return u;
-    }
-    vec2(T) ?^?(vec2(T) u, vec2(T) v) {
-        return [u.x ^ v.x, u.y ^ v.y];
-    }
-    vec2(T)& ?^=?(vec2(T)& u, vec2(T) v) {
-        u = u ^ v;
-        return u;
-    }
-    }
-
-    // <<
-    forall(| { T ?<<?(T,T); }) {
-    vec2(T) ?<<?(vec2(T) v, T scalar) with (v) {
-        return [x << scalar, y << scalar];
-    }
-    vec2(T)& ?<<=?(vec2(T)& u, T scalar) {
-        u = u << scalar;
-        return u;
-    }
-    vec2(T) ?<<?(vec2(T) u, vec2(T) v) {
-        return [u.x << v.x, u.y << v.y];
-    }
-    vec2(T)& ?<<=?(vec2(T)& u, vec2(T) v) {
-        u = u << v;
-        return u;
-    }
-    }
-
-    // >>
-    forall(| { T ?>>?(T,T); }) {
-    vec2(T) ?>>?(vec2(T) v, T scalar) with (v) {
-        return [x >> scalar, y >> scalar];
-    }
-    vec2(T)& ?>>=?(vec2(T)& u, T scalar) {
-        u = u >> scalar;
-        return u;
-    }
-    vec2(T) ?>>?(vec2(T) u, vec2(T) v) {
-        return [u.x >> v.x, u.y >> v.y];
-    }
-    vec2(T)& ?>>=?(vec2(T)& u, vec2(T) v) {
-        u = u >> v;
-        return u;
-    }
-    }
-
-    // ~
-    forall(| { T ~?(T); })
-    vec2(T) ~?(vec2(T) v) with (v) {
-        return [~v.x, ~v.y];
-    }
-
-    // relational
-    forall(| equality(T)) {
-    bool ?==?(vec2(T) u, vec2(T) v) with (u) {
-        return x == v.x && y == v.y;
-    }
-    bool ?!=?(vec2(T) u, vec2(T) v) {
-        return !(u == v);
-    }
-    }
-
-    // Geometric functions
-    forall(| add(T) | multiply(T))
-    T dot(vec2(T) u, vec2(T) v) {
-        return u.x * v.x + u.y * v.y;
-    }
-
-    } // static inline
-}
-
-forall(ostype &, T | writeable(T, ostype)) {
-    ostype & ?|?(ostype & os, vec2(T) v) with (v) {
+static inline forall( T ) {
+
+	void ?{}( vec2( T )& v, T x, T y ) {
+		v.[x, y] = [x, y];
+	}
+
+	forall(| zero_assign( T ))
+		void ?{}( vec2( T )& vec, zero_t ) with ( vec ) {
+		x = y = 0;
+	}
+
+	void ?{}( vec2( T )& vec, T val ) with ( vec ) {
+		x = y = val;
+	}
+
+	void ?{}( vec2( T )& vec, vec2( T ) other ) with ( vec ) {
+		[x,y] = other.[x,y];
+	}
+
+	void ?=?( vec2( T )& vec, vec2( T ) other ) with ( vec ) {
+		[x,y] = other.[x,y];
+	}
+	forall(| zero_assign( T ))
+		void ?=?( vec2( T )& vec, zero_t ) with ( vec ) {
+		x = y = 0;
+	}
+
+	// Primitive mathematical operations
+
+	// -
+	forall(| subtract( T )) {
+		vec2( T ) ?-?( vec2( T ) u, vec2( T ) v ) {
+			return [u.x - v.x, u.y - v.y];
+		}
+		vec2( T )& ?-=?( vec2( T )& u, vec2( T ) v ) {
+			u = u - v;
+			return u;
+		}
+	}
+	forall(| negate( T ))
+		vec2( T ) -?( vec2( T ) v ) with ( v ) {
+		return [-x, -y];
+	}
+
+	forall(| { T --?( T&); }) {
+		vec2( T )& --?( vec2( T )& v ) {
+			--v.x;
+			--v.y;
+			return v;
+		}
+		vec2( T ) ?--( vec2( T )& v ) {
+			vec2( T ) copy = v;
+			--v;
+			return copy;
+		}
+	}
+
+	// +
+	forall(| add( T )) {
+		vec2( T ) ?+?( vec2( T ) u, vec2( T ) v ) {
+			return [u.x + v.x, u.y + v.y];
+		}
+		vec2( T )& ?+=?( vec2( T )& u, vec2( T ) v ) {
+			u = u + v;
+			return u;
+		}
+	}
+
+	forall(| { T ++?( T&); }) {
+		vec2( T )& ++?( vec2( T )& v ) {
+			++v.x;
+			++v.y;
+			return v;
+		}
+		vec2( T ) ?++( vec2( T )& v ) {
+			vec2( T ) copy = v;
+			++v;
+			return copy;
+		}
+	}
+
+	// *
+	forall(| multiply( T )) {
+		vec2( T ) ?*?( vec2( T ) v, T scalar ) with ( v ) {
+			return [x * scalar, y * scalar];
+		}
+		vec2( T ) ?*?( T scalar, vec2( T ) v ) {
+			return v * scalar;
+		}
+		vec2( T ) ?*?( vec2( T ) u, vec2( T ) v ) {
+			return [u.x * v.x, u.y * v.y];
+		}
+		vec2( T )& ?*=?( vec2( T )& v, T scalar ) {
+			v = v * scalar;
+			return v;
+		}
+		vec2( T ) ?*=?( vec2( T )& u, vec2( T ) v ) {
+			u = u * v;
+			return u;
+		}
+	}
+
+	// /
+	forall(| divide( T )) {
+		vec2( T ) ?/?( vec2( T ) v, T scalar ) with ( v ) {
+			return [x / scalar, y / scalar];
+		}
+		vec2( T ) ?/?( vec2( T ) u, vec2( T ) v ) {
+			return [u.x / v.x, u.y / v.y];
+		}
+		vec2( T )& ?/=?( vec2( T )& v, T scalar ) {
+			v = v / scalar;
+			return v;
+		}
+		vec2( T ) ?/=?( vec2( T )& u, vec2( T ) v ) {
+			u = u / v;
+			return u;
+		}
+	}
+
+	// %
+	forall(| { T ?%?( T,T ); }) {
+		vec2( T ) ?%?( vec2( T ) v, T scalar ) with ( v ) {
+			return [x % scalar, y % scalar];
+		}
+		vec2( T )& ?%=?( vec2( T )& u, T scalar ) {
+			u = u % scalar;
+			return u;
+		}
+		vec2( T ) ?%?( vec2( T ) u, vec2( T ) v ) {
+			return [u.x % v.x, u.y % v.y];
+		}
+		vec2( T )& ?%=?( vec2( T )& u, vec2( T ) v ) {
+			u = u % v;
+			return u;
+		}
+	}
+
+	// &
+	forall(| { T ?&?( T,T ); }) {
+		vec2( T ) ?&?( vec2( T ) v, T scalar ) with ( v ) {
+			return [x & scalar, y & scalar];
+		}
+		vec2( T )& ?&=?( vec2( T )& u, T scalar ) {
+			u = u & scalar;
+			return u;
+		}
+		vec2( T ) ?&?( vec2( T ) u, vec2( T ) v ) {
+			return [u.x & v.x, u.y & v.y];
+		}
+		vec2( T )& ?&=?( vec2( T )& u, vec2( T ) v ) {
+			u = u & v;
+			return u;
+		}
+	}
+
+	// |
+	forall(| { T ?|?( T,T ); }) {
+		vec2( T ) ?|?( vec2( T ) v, T scalar ) with ( v ) {
+			return [x | scalar, y | scalar];
+		}
+		vec2( T )& ?|=?( vec2( T )& u, T scalar ) {
+			u = u | scalar;
+			return u;
+		}
+		vec2( T ) ?|?( vec2( T ) u, vec2( T ) v ) {
+			return [u.x | v.x, u.y | v.y];
+		}
+		vec2( T )& ?|=?( vec2( T )& u, vec2( T ) v ) {
+			u = u | v;
+			return u;
+		}
+	}
+
+	// ^
+	forall(| { T ?^?( T,T ); }) {
+		vec2( T ) ?^?( vec2( T ) v, T scalar ) with ( v ) {
+			return [x ^ scalar, y ^ scalar];
+		}
+		vec2( T )& ?^=?( vec2( T )& u, T scalar ) {
+			u = u ^ scalar;
+			return u;
+		}
+		vec2( T ) ?^?( vec2( T ) u, vec2( T ) v ) {
+			return [u.x ^ v.x, u.y ^ v.y];
+		}
+		vec2( T )& ?^=?( vec2( T )& u, vec2( T ) v ) {
+			u = u ^ v;
+			return u;
+		}
+	}
+
+	// <<
+	forall(| { T ?<<?( T,T ); }) {
+		vec2( T ) ?<<?( vec2( T ) v, T scalar ) with ( v ) {
+			return [x << scalar, y << scalar];
+		}
+		vec2( T )& ?<<=?( vec2( T )& u, T scalar ) {
+			u = u << scalar;
+			return u;
+		}
+		vec2( T ) ?<<?( vec2( T ) u, vec2( T ) v ) {
+			return [u.x << v.x, u.y << v.y];
+		}
+		vec2( T )& ?<<=?( vec2( T )& u, vec2( T ) v ) {
+			u = u << v;
+			return u;
+		}
+	}
+
+	// >>
+	forall(| { T ?>>?( T,T ); }) {
+		vec2( T ) ?>>?( vec2( T ) v, T scalar ) with ( v ) {
+			return [x >> scalar, y >> scalar];
+		}
+		vec2( T )& ?>>=?( vec2( T )& u, T scalar ) {
+			u = u >> scalar;
+			return u;
+		}
+		vec2( T ) ?>>?( vec2( T ) u, vec2( T ) v ) {
+			return [u.x >> v.x, u.y >> v.y];
+		}
+		vec2( T )& ?>>=?( vec2( T )& u, vec2( T ) v ) {
+			u = u >> v;
+			return u;
+		}
+	}
+
+	// ~
+	forall(| { T ~?( T ); })
+		vec2( T ) ~?( vec2( T ) v ) with ( v ) {
+		return [~v.x, ~v.y];
+	}
+
+	// relational
+	forall(| equality( T )) {
+		bool ?==?( vec2( T ) u, vec2( T ) v ) with ( u ) {
+			return x == v.x && y == v.y;
+		}
+		bool ?!=?( vec2( T ) u, vec2( T ) v ) {
+			return !( u == v );
+		}
+	}
+
+	// Geometric functions
+	forall(| add( T ) | multiply( T ))
+		T dot( vec2( T ) u, vec2( T ) v ) {
+		return u.x * v.x + u.y * v.y;
+	}
+} // static inline
+
+
+forall( ostype &, T | writeable( T, ostype )) {
+    ostype & ?|?( ostype & os, vec2( T ) v ) with ( v ) {
         return os | '<' | x | ',' | y | '>';
     }
-	OSTYPE_VOID_IMPL( os, vec2(T) )
+	OSTYPE_VOID_IMPL( os, vec2( T ) )
 }
Index: libcfa/src/vec/vec3.hfa
===================================================================
--- libcfa/src/vec/vec3.hfa	(revision f41b1614e8f77a861276c86c3fd61b86cbde5ac7)
+++ libcfa/src/vec/vec3.hfa	(revision c62013ecf0b07694154ca3cbdff83310eedb1dd9)
@@ -19,5 +19,5 @@
 #include "vec.hfa"
 
-forall (T) {
+forall( T ) {
     struct vec3 {
         T x, y, z;
@@ -25,29 +25,28 @@
 }
 
-forall (T) {
-    static inline {
-
-    void ?{}(vec3(T)& v, T x, T y, T z) {
+static inline forall( T ) {
+    void ?{}( vec3( T )& v, T x, T y, T z ) {
         v.[x, y, z] = [x, y, z];
     }
 
-    forall(| zero_assign(T))
-    void ?{}(vec3(T)& vec, zero_t) with (vec) {
+    forall( | zero_assign( T ) )
+    void ?{}( vec3( T )& vec, zero_t ) with ( vec ) {
         x = y = z = 0;
     }
 
-    void ?{}(vec3(T)& vec, T val) with (vec) {
+    void ?{}( vec3( T )& vec, T val ) with ( vec ) {
         x = y = z = val;
     }
 
-    void ?{}(vec3(T)& vec, vec3(T) other) with (vec) {
+    void ?{}( vec3( T )& vec, vec3( T ) other ) with ( vec ) {
         [x,y,z] = other.[x,y,z];
     }
 
-    void ?=?(vec3(T)& vec, vec3(T) other) with (vec) {
+    void ?=?( vec3( T )& vec, vec3( T ) other ) with ( vec ) {
         [x,y,z] = other.[x,y,z];
     }
-    forall(| zero_assign(T))
-    void ?=?(vec3(T)& vec, zero_t) with (vec) {
+
+    forall( | zero_assign( T ) )
+    void ?=?( vec3( T )& vec, zero_t ) with ( vec ) {
         x = y = z = 0;
     }
@@ -56,240 +55,240 @@
 
     // -
-    forall(| subtract(T)) {
-    vec3(T) ?-?(vec3(T) u, vec3(T) v) {
-        return [u.x - v.x, u.y - v.y, u.z - v.z];
-    }
-    vec3(T)& ?-=?(vec3(T)& u, vec3(T) v) {
-        u = u - v;
-        return u;
-    }
-    }
-    forall(| negate(T)) {
-    vec3(T) -?(vec3(T) v) with (v) {
-        return [-x, -y, -z];
-    }
-    }
-    forall(| { T --?(T&); }) {
-    vec3(T)& --?(vec3(T)& v) {
-        --v.x;
-        --v.y;
-        --v.z;
-        return v;
-    }
-    vec3(T) ?--(vec3(T)& v) {
-        vec3(T) copy = v;
-        --v;
-        return copy;
-    }
+    forall( | subtract( T ) ) {
+		vec3( T ) ?-?( vec3( T ) u, vec3( T ) v ) {
+			return [u.x - v.x, u.y - v.y, u.z - v.z];
+		}
+		vec3( T )& ?-=?( vec3( T )& u, vec3( T ) v ) {
+			u = u - v;
+			return u;
+		}
+    }
+
+    forall( | negate( T ) ) {
+		vec3( T ) -?( vec3( T ) v ) with ( v ) {
+			return [-x, -y, -z];
+		}
+    }
+
+    forall( | { T --?( T&); }) {
+		vec3( T )& --?( vec3( T )& v ) {
+			--v.x;
+			--v.y;
+			--v.z;
+			return v;
+		}
+		vec3( T ) ?--( vec3( T )& v ) {
+			vec3( T ) copy = v;
+			--v;
+			return copy;
+		}
     }
 
     // +
-    forall(| add(T)) {
-    vec3(T) ?+?(vec3(T) u, vec3(T) v) {
-        return [u.x + v.x, u.y + v.y, u.z + v.z];
-    }
-    vec3(T)& ?+=?(vec3(T)& u, vec3(T) v) {
-        u = u + v;
-        return u;
-    }
-    }
-
-    forall(| { T ++?(T&); }) {
-    vec3(T)& ++?(vec3(T)& v) {
-        ++v.x;
-        ++v.y;
-        ++v.z;
-        return v;
-    }
-    vec3(T) ?++(vec3(T)& v) {
-        vec3(T) copy = v;
-        ++v;
-        return copy;
-    }
+    forall( | add( T ) ) {
+		vec3( T ) ?+?( vec3( T ) u, vec3( T ) v ) {
+			return [u.x + v.x, u.y + v.y, u.z + v.z];
+		}
+		vec3( T )& ?+=?( vec3( T )& u, vec3( T ) v ) {
+			u = u + v;
+			return u;
+		}
+    }
+
+    forall( | { T ++?( T&); }) {
+		vec3( T )& ++?( vec3( T )& v ) {
+			++v.x;
+			++v.y;
+			++v.z;
+			return v;
+		}
+		vec3( T ) ?++( vec3( T )& v ) {
+			vec3( T ) copy = v;
+			++v;
+			return copy;
+		}
     }
 
     // *
-    forall(| multiply(T)) {
-    vec3(T) ?*?(vec3(T) v, T scalar) with (v) {
-        return [x * scalar, y * scalar, z * scalar];
-    }
-    vec3(T) ?*?(T scalar, vec3(T) v) {
-        return v * scalar;
-    }
-    vec3(T) ?*?(vec3(T) u, vec3(T) v) {
-        return [u.x * v.x, u.y * v.y, u.z * v.z];
-    }
-    vec3(T)& ?*=?(vec3(T)& v, T scalar) {
-        v = v * scalar;
-        return v;
-    }
-    vec3(T)& ?*=?(vec3(T)& u, vec3(T) v) {
-        u = u * v;
-        return u;
-    }
+    forall( | multiply( T ) ) {
+		vec3( T ) ?*?( vec3( T ) v, T scalar ) with ( v ) {
+			return [x * scalar, y * scalar, z * scalar];
+		}
+		vec3( T ) ?*?( T scalar, vec3( T ) v ) {
+			return v * scalar;
+		}
+		vec3( T ) ?*?( vec3( T ) u, vec3( T ) v ) {
+			return [u.x * v.x, u.y * v.y, u.z * v.z];
+		}
+		vec3( T )& ?*=?( vec3( T )& v, T scalar ) {
+			v = v * scalar;
+			return v;
+		}
+		vec3( T )& ?*=?( vec3( T )& u, vec3( T ) v ) {
+			u = u * v;
+			return u;
+		}
     }
 
     // /
-    forall(| divide(T)) {
-    vec3(T) ?/?(vec3(T) v, T scalar) with (v) {
-        return [x / scalar, y / scalar, z / scalar];
-    }
-    vec3(T) ?/?(vec3(T) u, vec3(T) v) {
-        return [u.x / v.x, u.y / v.y, u.z / v.z];
-    }
-    vec3(T)& ?/=?(vec3(T)& v, T scalar) {
-        v = v / scalar;
-        return v;
-    }
-    vec3(T)& ?/=?(vec3(T)& u, vec3(T) v) {
-        u = u / v;
-        return u;
-    }
-    }
-
+    forall( | divide( T ) ) {
+		vec3( T ) ?/?( vec3( T ) v, T scalar ) with ( v ) {
+			return [x / scalar, y / scalar, z / scalar];
+		}
+		vec3( T ) ?/?( vec3( T ) u, vec3( T ) v ) {
+			return [u.x / v.x, u.y / v.y, u.z / v.z];
+		}
+		vec3( T )& ?/=?( vec3( T )& v, T scalar ) {
+			v = v / scalar;
+			return v;
+		}
+		vec3( T )& ?/=?( vec3( T )& u, vec3( T ) v ) {
+			u = u / v;
+			return u;
+		}
+    }
+	
     // %
-    forall(| { T ?%?(T,T); }) {
-    vec3(T) ?%?(vec3(T) v, T scalar) with (v) {
-        return [x % scalar, y % scalar, z % scalar];
-    }
-    vec3(T)& ?%=?(vec3(T)& u, T scalar) {
-        u = u % scalar;
-        return u;
-    }
-    vec3(T) ?%?(vec3(T) u, vec3(T) v) {
-        return [u.x % v.x, u.y % v.y, u.z % v.z];
-    }
-    vec3(T)& ?%=?(vec3(T)& u, vec3(T) v) {
-        u = u % v;
-        return u;
-    }
+    forall( | { T ?%?( T,T ); }) {
+		vec3( T ) ?%?( vec3( T ) v, T scalar ) with ( v ) {
+			return [x % scalar, y % scalar, z % scalar];
+		}
+		vec3( T )& ?%=?( vec3( T )& u, T scalar ) {
+			u = u % scalar;
+			return u;
+		}
+		vec3( T ) ?%?( vec3( T ) u, vec3( T ) v ) {
+			return [u.x % v.x, u.y % v.y, u.z % v.z];
+		}
+		vec3( T )& ?%=?( vec3( T )& u, vec3( T ) v ) {
+			u = u % v;
+			return u;
+		}
     }
 
     // &
-    forall(| { T ?&?(T,T); }) {
-    vec3(T) ?&?(vec3(T) v, T scalar) with (v) {
-        return [x & scalar, y & scalar, z & scalar];
-    }
-    vec3(T)& ?&=?(vec3(T)& u, T scalar) {
-        u = u & scalar;
-        return u;
-    }
-    vec3(T) ?&?(vec3(T) u, vec3(T) v) {
-        return [u.x & v.x, u.y & v.y, u.z & v.z];
-    }
-    vec3(T)& ?&=?(vec3(T)& u, vec3(T) v) {
-        u = u & v;
-        return u;
-    }
+    forall( | { T ?&?( T,T ); }) {
+		vec3( T ) ?&?( vec3( T ) v, T scalar ) with ( v ) {
+			return [x & scalar, y & scalar, z & scalar];
+		}
+		vec3( T )& ?&=?( vec3( T )& u, T scalar ) {
+			u = u & scalar;
+			return u;
+		}
+		vec3( T ) ?&?( vec3( T ) u, vec3( T ) v ) {
+			return [u.x & v.x, u.y & v.y, u.z & v.z];
+		}
+		vec3( T )& ?&=?( vec3( T )& u, vec3( T ) v ) {
+			u = u & v;
+			return u;
+		}
     }
 
     // |
-    forall(| { T ?|?(T,T); }) {
-    vec3(T) ?|?(vec3(T) v, T scalar) with (v) {
-        return [x | scalar, y | scalar, z | scalar];
-    }
-    vec3(T)& ?|=?(vec3(T)& u, T scalar) {
-        u = u | scalar;
-        return u;
-    }
-    vec3(T) ?|?(vec3(T) u, vec3(T) v) {
-        return [u.x | v.x, u.y | v.y, u.z | v.z];
-    }
-    vec3(T)& ?|=?(vec3(T)& u, vec3(T) v) {
-        u = u | v;
-        return u;
-    }
+    forall( | { T ?|?( T,T ); }) {
+		vec3( T ) ?|?( vec3( T ) v, T scalar ) with ( v ) {
+			return [x | scalar, y | scalar, z | scalar];
+		}
+		vec3( T )& ?|=?( vec3( T )& u, T scalar ) {
+			u = u | scalar;
+			return u;
+		}
+		vec3( T ) ?|?( vec3( T ) u, vec3( T ) v ) {
+			return [u.x | v.x, u.y | v.y, u.z | v.z];
+		}
+		vec3( T )& ?|=?( vec3( T )& u, vec3( T ) v ) {
+			u = u | v;
+			return u;
+		}
     }
 
     // ^
-    forall(| { T ?^?(T,T); }) {
-    vec3(T) ?^?(vec3(T) v, T scalar) with (v) {
-        return [x ^ scalar, y ^ scalar, z ^ scalar];
-    }
-    vec3(T)& ?^=?(vec3(T)& u, T scalar) {
-        u = u ^ scalar;
-        return u;
-    }
-    vec3(T) ?^?(vec3(T) u, vec3(T) v) {
-        return [u.x ^ v.x, u.y ^ v.y, u.z ^ v.z];
-    }
-    vec3(T)& ?^=?(vec3(T)& u, vec3(T) v) {
-        u = u ^ v;
-        return u;
-    }
+    forall( | { T ?^?( T,T ); }) {
+		vec3( T ) ?^?( vec3( T ) v, T scalar ) with ( v ) {
+			return [x ^ scalar, y ^ scalar, z ^ scalar];
+		}
+		vec3( T )& ?^=?( vec3( T )& u, T scalar ) {
+			u = u ^ scalar;
+			return u;
+		}
+		vec3( T ) ?^?( vec3( T ) u, vec3( T ) v ) {
+			return [u.x ^ v.x, u.y ^ v.y, u.z ^ v.z];
+		}
+		vec3( T )& ?^=?( vec3( T )& u, vec3( T ) v ) {
+			u = u ^ v;
+			return u;
+		}
     }
 
     // <<
-    forall(| { T ?<<?(T,T); }) {
-    vec3(T) ?<<?(vec3(T) v, T scalar) with (v) {
-        return [x << scalar, y << scalar, z << scalar];
-    }
-    vec3(T)& ?<<=?(vec3(T)& u, T scalar) {
-        u = u << scalar;
-        return u;
-    }
-    vec3(T) ?<<?(vec3(T) u, vec3(T) v) {
-        return [u.x << v.x, u.y << v.y, u.z << v.z];
-    }
-    vec3(T)& ?<<=?(vec3(T)& u, vec3(T) v) {
-        u = u << v;
-        return u;
-    }
+    forall( | { T ?<<?( T,T ); }) {
+		vec3( T ) ?<<?( vec3( T ) v, T scalar ) with ( v ) {
+			return [x << scalar, y << scalar, z << scalar];
+		}
+		vec3( T )& ?<<=?( vec3( T )& u, T scalar ) {
+			u = u << scalar;
+			return u;
+		}
+		vec3( T ) ?<<?( vec3( T ) u, vec3( T ) v ) {
+			return [u.x << v.x, u.y << v.y, u.z << v.z];
+		}
+		vec3( T )& ?<<=?( vec3( T )& u, vec3( T ) v ) {
+			u = u << v;
+			return u;
+		}
     }
 
     // >>
-    forall(| { T ?>>?(T,T); }) {
-    vec3(T) ?>>?(vec3(T) v, T scalar) with (v) {
-        return [x >> scalar, y >> scalar, z >> scalar];
-    }
-    vec3(T)& ?>>=?(vec3(T)& u, T scalar) {
-        u = u >> scalar;
-        return u;
-    }
-    vec3(T) ?>>?(vec3(T) u, vec3(T) v) {
-        return [u.x >> v.x, u.y >> v.y, u.z >> v.z];
-    }
-    vec3(T)& ?>>=?(vec3(T)& u, vec3(T) v) {
-        u = u >> v;
-        return u;
-    }
+    forall( | { T ?>>?( T,T ); }) {
+		vec3( T ) ?>>?( vec3( T ) v, T scalar ) with ( v ) {
+			return [x >> scalar, y >> scalar, z >> scalar];
+		}
+		vec3( T )& ?>>=?( vec3( T )& u, T scalar ) {
+			u = u >> scalar;
+			return u;
+		}
+		vec3( T ) ?>>?( vec3( T ) u, vec3( T ) v ) {
+			return [u.x >> v.x, u.y >> v.y, u.z >> v.z];
+		}
+		vec3( T )& ?>>=?( vec3( T )& u, vec3( T ) v ) {
+			u = u >> v;
+			return u;
+		}
     }
 
     // ~
-    forall(| { T ~?(T); })
-    vec3(T) ~?(vec3(T) v) with (v) {
+    forall( | { T ~?( T ); })
+		vec3( T ) ~?( vec3( T ) v ) with ( v ) {
         return [~v.x, ~v.y, ~v.z];
     }
 
     // relational
-    forall(| equality(T)) {
-    bool ?==?(vec3(T) u, vec3(T) v) with (u) {
-        return x == v.x && y == v.y && z == v.z;
-    }
-    bool ?!=?(vec3(T) u, vec3(T) v) {
-        return !(u == v);
-    }
+    forall( | equality( T ) ) {
+		bool ?==?( vec3( T ) u, vec3( T ) v ) with ( u ) {
+			return x == v.x && y == v.y && z == v.z;
+		}
+		bool ?!=?( vec3( T ) u, vec3( T ) v ) {
+			return !( u == v );
+		}
     }
 
     // Geometric functions
-    forall(| add(T) | multiply(T))
-    T dot(vec3(T) u, vec3(T) v) {
+    forall( | add( T ) | multiply( T ) )
+		T dot( vec3( T ) u, vec3( T ) v ) {
         return u.x * v.x + u.y * v.y + u.z * v.z;
     }
 
-    forall(| subtract(T) | multiply(T))
-    vec3(T) cross(vec3(T) u, vec3(T) v) {
-        return (vec3(T)){ u.y * v.z - v.y * u.z,
-                          u.z * v.x - v.z * u.x,
-                          u.x * v.y - v.x * u.y };
-    }
-
-    } // static inline
+    forall( | subtract( T ) | multiply( T ) )
+		vec3( T ) cross( vec3( T ) u, vec3( T ) v ) {
+        return ( vec3( T ) ){ u.y * v.z - v.y * u.z,
+			u.z * v.x - v.z * u.x,
+			u.x * v.y - v.x * u.y };
+    }
 }
 
-forall(ostype &, T | writeable(T, ostype)) {
-    ostype & ?|?(ostype & os, vec3(T) v) with (v) {
+forall( ostype &, T | writeable( T, ostype ) ) {
+    ostype & ?|?( ostype & os, vec3( T ) v ) with ( v ) {
         return os | '<' | x | ',' | y | ',' | z | '>';
     }
-	OSTYPE_VOID_IMPL( os, vec3(T) )
+	OSTYPE_VOID_IMPL( os, vec3( T ) )
 }
Index: libcfa/src/vec/vec4.hfa
===================================================================
--- libcfa/src/vec/vec4.hfa	(revision f41b1614e8f77a861276c86c3fd61b86cbde5ac7)
+++ libcfa/src/vec/vec4.hfa	(revision c62013ecf0b07694154ca3cbdff83310eedb1dd9)
@@ -19,5 +19,5 @@
 #include "vec.hfa"
 
-forall (T) {
+forall( T ) {
     struct vec4 {
         T x, y, z, w;
@@ -25,29 +25,28 @@
 }
 
-forall (T) {
-    static inline {
-
-    void ?{}(vec4(T)& v, T x, T y, T z, T w) {
+static inline forall( T ) {
+    void ?{}( vec4( T )& v, T x, T y, T z, T w ) {
         v.[x, y, z, w] = [x, y, z, w];
     }
 
-    forall(| zero_assign(T))
-    void ?{}(vec4(T)& vec, zero_t) with (vec) {
+    forall( | zero_assign( T ) )
+    void ?{}( vec4( T )& vec, zero_t ) with ( vec ) {
         x = y = z = w = 0;
     }
 
-    void ?{}(vec4(T)& vec, T val) with (vec) {
+    void ?{}( vec4( T )& vec, T val ) with ( vec ) {
         x = y = z = w = val;
     }
 
-    void ?{}(vec4(T)& vec, vec4(T) other) with (vec) {
+    void ?{}( vec4( T )& vec, vec4( T ) other ) with ( vec ) {
         [x,y,z,w] = other.[x,y,z,w];
     }
 
-    void ?=?(vec4(T)& vec, vec4(T) other) with (vec) {
+    void ?=?( vec4( T )& vec, vec4( T ) other ) with ( vec ) {
         [x,y,z,w] = other.[x,y,z,w];
     }
-    forall(| zero_assign(T))
-    void ?=?(vec4(T)& vec, zero_t) with (vec) {
+
+    forall( | zero_assign( T ) )
+    void ?=?( vec4( T )& vec, zero_t ) with ( vec ) {
         x = y = z = w = 0;
     }
@@ -56,93 +55,94 @@
 
     // -
-    forall(| subtract(T)) {
-    vec4(T) ?-?(vec4(T) u, vec4(T) v) {
-        return [u.x - v.x, u.y - v.y, u.z - v.z, u.w - v.w];
-    }
-    vec4(T)& ?-=?(vec4(T)& u, vec4(T) v) {
-        u = u - v;
-        return u;
-    }
-    }
-    forall(| negate(T)) {
-    vec4(T) -?(vec4(T) v) with (v) {
-        return [-x, -y, -z, -w];
-    }
-    }
-    forall(| { T --?(T&); }) {
-    vec4(T)& --?(vec4(T)& v) {
-        --v.x;
-        --v.y;
-        --v.z;
-        --v.w;
-        return v;
-    }
-    vec4(T) ?--(vec4(T)& v) {
-        vec4(T) copy = v;
-        --v;
-        return copy;
-    }
+    forall( | subtract( T ) ) {
+		vec4( T ) ?-?( vec4( T ) u, vec4( T ) v ) {
+			return [u.x - v.x, u.y - v.y, u.z - v.z, u.w - v.w];
+		}
+		vec4( T )& ?-=?( vec4( T )& u, vec4( T ) v ) {
+			u = u - v;
+			return u;
+		}
+    }
+
+    forall( | negate( T ) ) {
+		vec4( T ) -?( vec4( T ) v ) with ( v ) {
+			return [-x, -y, -z, -w];
+		}
+    }
+    forall( | { T --?( T&); }) {
+		vec4( T )& --?( vec4( T )& v ) {
+			--v.x;
+			--v.y;
+			--v.z;
+			--v.w;
+			return v;
+		}
+		vec4( T ) ?--( vec4( T )& v ) {
+			vec4( T ) copy = v;
+			--v;
+			return copy;
+		}
     }
 
     // +
-    forall(| add(T)) {
-    vec4(T) ?+?(vec4(T) u, vec4(T) v) {
-        return [u.x + v.x, u.y + v.y, u.z + v.z, u.w + v.w];
-    }
-    vec4(T)& ?+=?(vec4(T)& u, vec4(T) v) {
-        u = u + v;
-        return u;
-    }
-    }
-
-    forall(| { T ++?(T&); }) {
-    vec4(T)& ++?(vec4(T)& v) {
-        ++v.x;
-        ++v.y;
-        ++v.z;
-        ++v.w;
-        return v;
-    }
-    vec4(T) ?++(vec4(T)& v) {
-        vec4(T) copy = v;
-        ++v;
-        return copy;
-    }
+    forall( | add( T ) ) {
+		vec4( T ) ?+?( vec4( T ) u, vec4( T ) v ) {
+			return [u.x + v.x, u.y + v.y, u.z + v.z, u.w + v.w];
+		}
+		vec4( T )& ?+=?( vec4( T )& u, vec4( T ) v ) {
+			u = u + v;
+			return u;
+		}
+    }
+
+    forall( | { T ++?( T&); }) {
+		vec4( T )& ++?( vec4( T )& v ) {
+			++v.x;
+			++v.y;
+			++v.z;
+			++v.w;
+			return v;
+		}
+		vec4( T ) ?++( vec4( T )& v ) {
+			vec4( T ) copy = v;
+			++v;
+			return copy;
+		}
     }
 
     // *
-    forall(| multiply(T)) {
-    vec4(T) ?*?(vec4(T) v, T scalar) with (v) {
-        return [x * scalar, y * scalar, z * scalar, w * scalar];
-    }
-    vec4(T) ?*?(T scalar, vec4(T) v) {
-        return v * scalar;
-    }
-    vec4(T) ?*?(vec4(T) u, vec4(T) v) {
-        return [u.x * v.x, u.y * v.y, u.z * v.z, u.w * v.w];
-    }
-    vec4(T)& ?*=?(vec4(T)& v, T scalar) {
-        v = v * scalar;
-        return v;
-    }
-    vec4(T)& ?*=?(vec4(T)& u, vec4(T) v) {
-        u = u * v;
-        return u;
-    }
+    forall( | multiply( T ) ) {
+		vec4( T ) ?*?( vec4( T ) v, T scalar ) with ( v ) {
+			return [x * scalar, y * scalar, z * scalar, w * scalar];
+		}
+		vec4( T ) ?*?( T scalar, vec4( T ) v ) {
+			return v * scalar;
+		}
+		vec4( T ) ?*?( vec4( T ) u, vec4( T ) v ) {
+			return [u.x * v.x, u.y * v.y, u.z * v.z, u.w * v.w];
+		}
+		vec4( T )& ?*=?( vec4( T )& v, T scalar ) {
+			v = v * scalar;
+			return v;
+		}
+		vec4( T )& ?*=?( vec4( T )& u, vec4( T ) v ) {
+			u = u * v;
+			return u;
+		}
     }
 
     // /
-    forall(| divide(T)) {
-    vec4(T) ?/?(vec4(T) v, T scalar) with (v) {
+    forall( | divide( T ) ) {
+    vec4( T ) ?/?( vec4( T ) v, T scalar ) with ( v ) {
         return [x / scalar, y / scalar, z / scalar, w / scalar];
     }
-    vec4(T) ?/?(vec4(T) u, vec4(T) v) {
+    vec4( T ) ?/?( vec4( T ) u, vec4( T ) v ) {
         return [u.x / v.x, u.y / v.y, u.z / v.z, u.w / v.w];
     }
-    vec4(T)& ?/=?(vec4(T)& v, T scalar) {
+    vec4( T )& ?/=?( vec4( T )& v, T scalar ) {
         v = v / scalar;
         return v;
     }
-    vec4(T)& ?/=?(vec4(T)& u, vec4(T) v) {
+    vec4( T )& ?/=?( vec4( T )& u, vec4( T ) v ) {
         u = u / v;
         return u;
@@ -151,141 +151,138 @@
 
     // %
-    forall(| { T ?%?(T,T); }) {
-    vec4(T) ?%?(vec4(T) v, T scalar) with (v) {
-        return [x % scalar, y % scalar, z % scalar, w % scalar];
-    }
-    vec4(T)& ?%=?(vec4(T)& u, T scalar) {
-        u = u % scalar;
-        return u;
-    }
-    vec4(T) ?%?(vec4(T) u, vec4(T) v) {
-        return [u.x % v.x, u.y % v.y, u.z % v.z, u.w % v.w];
-    }
-    vec4(T)& ?%=?(vec4(T)& u, vec4(T) v) {
-        u = u % v;
-        return u;
-    }
+    forall( | { T ?%?( T,T ); }) {
+		vec4( T ) ?%?( vec4( T ) v, T scalar ) with ( v ) {
+			return [x % scalar, y % scalar, z % scalar, w % scalar];
+		}
+		vec4( T )& ?%=?( vec4( T )& u, T scalar ) {
+			u = u % scalar;
+			return u;
+		}
+		vec4( T ) ?%?( vec4( T ) u, vec4( T ) v ) {
+			return [u.x % v.x, u.y % v.y, u.z % v.z, u.w % v.w];
+		}
+		vec4( T )& ?%=?( vec4( T )& u, vec4( T ) v ) {
+			u = u % v;
+			return u;
+		}
     }
 
     // &
-    forall(| { T ?&?(T,T); }) {
-    vec4(T) ?&?(vec4(T) v, T scalar) with (v) {
-        return [x & scalar, y & scalar, z & scalar, w & scalar];
-    }
-    vec4(T)& ?&=?(vec4(T)& u, T scalar) {
-        u = u & scalar;
-        return u;
-    }
-    vec4(T) ?&?(vec4(T) u, vec4(T) v) {
-        return [u.x & v.x, u.y & v.y, u.z & v.z, u.w & v.w];
-    }
-    vec4(T)& ?&=?(vec4(T)& u, vec4(T) v) {
-        u = u & v;
-        return u;
-    }
+    forall( | { T ?&?( T,T ); }) {
+		vec4( T ) ?&?( vec4( T ) v, T scalar ) with ( v ) {
+			return [x & scalar, y & scalar, z & scalar, w & scalar];
+		}
+		vec4( T )& ?&=?( vec4( T )& u, T scalar ) {
+			u = u & scalar;
+			return u;
+		}
+		vec4( T ) ?&?( vec4( T ) u, vec4( T ) v ) {
+			return [u.x & v.x, u.y & v.y, u.z & v.z, u.w & v.w];
+		}
+		vec4( T )& ?&=?( vec4( T )& u, vec4( T ) v ) {
+			u = u & v;
+			return u;
+		}
     }
 
     // |
-    forall(| { T ?|?(T,T); }) {
-    vec4(T) ?|?(vec4(T) v, T scalar) with (v) {
-        return [x | scalar, y | scalar, z | scalar, w | scalar];
-    }
-    vec4(T)& ?|=?(vec4(T)& u, T scalar) {
-        u = u | scalar;
-        return u;
-    }
-    vec4(T) ?|?(vec4(T) u, vec4(T) v) {
-        return [u.x | v.x, u.y | v.y, u.z | v.z, u.w | v.w];
-    }
-    vec4(T)& ?|=?(vec4(T)& u, vec4(T) v) {
-        u = u | v;
-        return u;
-    }
+    forall( | { T ?|?( T,T ); }) {
+		vec4( T ) ?|?( vec4( T ) v, T scalar ) with ( v ) {
+			return [x | scalar, y | scalar, z | scalar, w | scalar];
+		}
+		vec4( T )& ?|=?( vec4( T )& u, T scalar ) {
+			u = u | scalar;
+			return u;
+		}
+		vec4( T ) ?|?( vec4( T ) u, vec4( T ) v ) {
+			return [u.x | v.x, u.y | v.y, u.z | v.z, u.w | v.w];
+		}
+		vec4( T )& ?|=?( vec4( T )& u, vec4( T ) v ) {
+			u = u | v;
+			return u;
+		}
     }
 
     // ^
-    forall(| { T ?^?(T,T); }) {
-    vec4(T) ?^?(vec4(T) v, T scalar) with (v) {
-        return [x ^ scalar, y ^ scalar, z ^ scalar, w ^ scalar];
-    }
-    vec4(T)& ?^=?(vec4(T)& u, T scalar) {
-        u = u ^ scalar;
-        return u;
-    }
-    vec4(T) ?^?(vec4(T) u, vec4(T) v) {
-        return [u.x ^ v.x, u.y ^ v.y, u.z ^ v.z, u.w ^ v.w];
-    }
-    vec4(T)& ?^=?(vec4(T)& u, vec4(T) v) {
-        u = u ^ v;
-        return u;
-    }
+    forall( | { T ?^?( T,T ); }) {
+		vec4( T ) ?^?( vec4( T ) v, T scalar ) with ( v ) {
+			return [x ^ scalar, y ^ scalar, z ^ scalar, w ^ scalar];
+		}
+		vec4( T )& ?^=?( vec4( T )& u, T scalar ) {
+			u = u ^ scalar;
+			return u;
+		}
+		vec4( T ) ?^?( vec4( T ) u, vec4( T ) v ) {
+			return [u.x ^ v.x, u.y ^ v.y, u.z ^ v.z, u.w ^ v.w];
+		}
+		vec4( T )& ?^=?( vec4( T )& u, vec4( T ) v ) {
+			u = u ^ v;
+			return u;
+		}
     }
 
     // <<
-    forall(| { T ?<<?(T,T); }) {
-    vec4(T) ?<<?(vec4(T) v, T scalar) with (v) {
-        return [x << scalar, y << scalar, z << scalar, w << scalar];
-    }
-    vec4(T)& ?<<=?(vec4(T)& u, T scalar) {
-        u = u << scalar;
-        return u;
-    }
-    vec4(T) ?<<?(vec4(T) u, vec4(T) v) {
-        return [u.x << v.x, u.y << v.y, u.z << v.z, u.w << v.w];
-    }
-    vec4(T)& ?<<=?(vec4(T)& u, vec4(T) v) {
-        u = u << v;
-        return u;
-    }
+    forall( | { T ?<<?( T,T ); }) {
+		vec4( T ) ?<<?( vec4( T ) v, T scalar ) with ( v ) {
+			return [x << scalar, y << scalar, z << scalar, w << scalar];
+		}
+		vec4( T )& ?<<=?( vec4( T )& u, T scalar ) {
+			u = u << scalar;
+			return u;
+		}
+		vec4( T ) ?<<?( vec4( T ) u, vec4( T ) v ) {
+			return [u.x << v.x, u.y << v.y, u.z << v.z, u.w << v.w];
+		}
+		vec4( T )& ?<<=?( vec4( T )& u, vec4( T ) v ) {
+			u = u << v;
+			return u;
+		}
     }
 
     // >>
-    forall(| { T ?>>?(T,T); }) {
-    vec4(T) ?>>?(vec4(T) v, T scalar) with (v) {
-        return [x >> scalar, y >> scalar, z >> scalar, w >> scalar];
-    }
-    vec4(T)& ?>>=?(vec4(T)& u, T scalar) {
-        u = u >> scalar;
-        return u;
-    }
-    vec4(T) ?>>?(vec4(T) u, vec4(T) v) {
-        return [u.x >> v.x, u.y >> v.y, u.z >> v.z, u.w >> v.w];
-    }
-    vec4(T)& ?>>=?(vec4(T)& u, vec4(T) v) {
-        u = u >> v;
-        return u;
-    }
+    forall( | { T ?>>?( T,T ); }) {
+		vec4( T ) ?>>?( vec4( T ) v, T scalar ) with ( v ) {
+			return [x >> scalar, y >> scalar, z >> scalar, w >> scalar];
+		}
+		vec4( T )& ?>>=?( vec4( T )& u, T scalar ) {
+			u = u >> scalar;
+			return u;
+		}
+		vec4( T ) ?>>?( vec4( T ) u, vec4( T ) v ) {
+			return [u.x >> v.x, u.y >> v.y, u.z >> v.z, u.w >> v.w];
+		}
+		vec4( T )& ?>>=?( vec4( T )& u, vec4( T ) v ) {
+			u = u >> v;
+			return u;
+		}
     }
 
     // ~
-    forall(| { T ~?(T); })
-    vec4(T) ~?(vec4(T) v) with (v) {
+    forall( | { T ~?( T ); })
+    vec4( T ) ~?( vec4( T ) v ) with ( v ) {
         return [~x, ~y, ~z, ~w];
     }
 
     // relational
-    forall(| equality(T)) {
-    bool ?==?(vec4(T) u, vec4(T) v) with (u) {
-        return x == v.x && y == v.y && z == v.z && w == v.w;
-    }
-    bool ?!=?(vec4(T) u, vec4(T) v) {
-        return !(u == v);
-    }
+    forall( | equality( T ) ) {
+		bool ?==?( vec4( T ) u, vec4( T ) v ) with ( u ) {
+			return x == v.x && y == v.y && z == v.z && w == v.w;
+		}
+		bool ?!=?( vec4( T ) u, vec4( T ) v ) {
+			return !( u == v );
+		}
     }
 
     // Geometric functions
-    forall(| add(T) | multiply(T))
-    T dot(vec4(T) u, vec4(T) v) {
+    forall( | add( T ) | multiply( T ) )
+    T dot( vec4( T ) u, vec4( T ) v ) {
         return u.x * v.x + u.y * v.y + u.z * v.z + u.w * v.w;
     }
-
-    } // static inline
 }
 
-forall(ostype &, T | writeable(T, ostype)) {
-    ostype & ?|?(ostype & os, vec4(T) v) with (v) {
+forall( ostype &, T | writeable( T, ostype ) ) {
+    ostype & ?|?( ostype & os, vec4( T ) v ) with ( v ) {
         return os | '<' | x | ',' | y | ',' | z | ',' | w | '>';
     }
-	OSTYPE_VOID_IMPL( os, vec4(T) )
+	OSTYPE_VOID_IMPL( os, vec4( T ) )
 }
-
Index: tests/enum_tests/planet.cfa
===================================================================
--- tests/enum_tests/planet.cfa	(revision f41b1614e8f77a861276c86c3fd61b86cbde5ac7)
+++ tests/enum_tests/planet.cfa	(revision c62013ecf0b07694154ca3cbdff83310eedb1dd9)
@@ -36,5 +36,11 @@
 
 //	Planet rp = fromInt( prng( countof( Planet ) ) );	// select random orbiting body
+
+	#pragma GCC diagnostic push
+	// FIX ME: false positive with gcc > 11, so disable.
+	#pragma GCC diagnostic ignored "-Wdangling-pointer"
 	Planet rp = fromInt( countof( Planet ) - 1 );		// non-random for test suite
+	#pragma GCC diagnostic pop
+
 	choose( rp ) {										// implicit breaks
 	  case MERCURY, VENUS, EARTH, MARS: