Index: libcfa/src/vec/vec.hfa
===================================================================
--- libcfa/src/vec/vec.hfa	(revision 94df8deefcefe5bac7ef400a07492b532b8c8ade)
+++ libcfa/src/vec/vec.hfa	(revision 250dbaedadee6c9f63e82f0f166ca46323969089)
@@ -74,5 +74,4 @@
 }
 
-
 forall(otype T, otype V | { T length(V); V ?/?(V, T); })
 V normalize(V v) {
@@ -114,5 +113,4 @@
 // i is the incident vector
 // ng is the geometric normal of the surface
-/* forall(| add(T) | multiply(T) | lessthan(T) | fromint(T) | subtract(T)) */
 forall(otype T | lessthan(T) | zeroinit(T), otype V | dottable(V, T) | negate(V))
 V faceforward(V n, V i, V ng) {
Index: libcfa/src/vec/vec2.hfa
===================================================================
--- libcfa/src/vec/vec2.hfa	(revision 94df8deefcefe5bac7ef400a07492b532b8c8ade)
+++ libcfa/src/vec/vec2.hfa	(revision 250dbaedadee6c9f63e82f0f166ca46323969089)
@@ -10,5 +10,4 @@
 }
 
-
 forall (otype T) {
     static inline {
@@ -31,5 +30,4 @@
     }
 
-    // Assignment
     void ?=?(vec2(T)& vec, vec2(T) other) with (vec) {
         [x,y] = other.[x,y];
@@ -42,6 +40,7 @@
     // Primitive mathematical operations
 
+    // -
     forall(| subtract(T)) {
-    vec2(T) ?-?(vec2(T) u, vec2(T) v) { // TODO( can't make this const ref )
+    vec2(T) ?-?(vec2(T) u, vec2(T) v) {
         return [u.x - v.x, u.y - v.y];
     }
@@ -69,6 +68,7 @@
     }
 
+    // +
     forall(| add(T)) {
-    vec2(T) ?+?(vec2(T) u, vec2(T) v) { // TODO( can't make this const ref )
+    vec2(T) ?+?(vec2(T) u, vec2(T) v) {
         return [u.x + v.x, u.y + v.y];
     }
@@ -92,9 +92,10 @@
     }
 
+    // *
     forall(| multiply(T)) {
-    vec2(T) ?*?(vec2(T) v, T scalar) with (v) { // TODO (can't make this const ref)
+    vec2(T) ?*?(vec2(T) v, T scalar) with (v) {
         return [x * scalar, y * scalar];
     }
-    vec2(T) ?*?(T scalar, vec2(T) v) { // TODO (can't make this const ref)
+    vec2(T) ?*?(T scalar, vec2(T) v) {
         return v * scalar;
     }
@@ -112,4 +113,5 @@
     }
 
+    // /
     forall(| divide(T)) {
     vec2(T) ?/?(vec2(T) v, T scalar) with (v) {
@@ -119,5 +121,5 @@
         return [u.x / v.x, u.y / v.y];
     }
-    vec2(T)& ?/=?(vec2(T)& v, T scalar) with (v) {
+    vec2(T)& ?/=?(vec2(T)& v, T scalar) {
         v = v / scalar;
         return v;
@@ -129,4 +131,5 @@
     }
 
+    // %
     forall(| { T ?%?(T,T); }) {
     vec2(T) ?%?(vec2(T) v, T scalar) with (v) {
@@ -146,4 +149,5 @@
     }
 
+    // &
     forall(| { T ?&?(T,T); }) {
     vec2(T) ?&?(vec2(T) v, T scalar) with (v) {
@@ -163,4 +167,5 @@
     }
 
+    // |
     forall(| { T ?|?(T,T); }) {
     vec2(T) ?|?(vec2(T) v, T scalar) with (v) {
@@ -180,4 +185,5 @@
     }
 
+    // ^
     forall(| { T ?^?(T,T); }) {
     vec2(T) ?^?(vec2(T) v, T scalar) with (v) {
@@ -197,4 +203,5 @@
     }
 
+    // <<
     forall(| { T ?<<?(T,T); }) {
     vec2(T) ?<<?(vec2(T) v, T scalar) with (v) {
@@ -214,4 +221,5 @@
     }
 
+    // >>
     forall(| { T ?>>?(T,T); }) {
     vec2(T) ?>>?(vec2(T) v, T scalar) with (v) {
@@ -231,4 +239,5 @@
     }
 
+    // ~
     forall(| { T ~?(T); })
     vec2(T) ~?(vec2(T) v) with (v) {
@@ -236,5 +245,5 @@
     }
 
-    // Relational Operators
+    // relational
     forall(| equality(T)) {
     bool ?==?(vec2(T) u, vec2(T) v) with (u) {
Index: libcfa/src/vec/vec3.hfa
===================================================================
--- libcfa/src/vec/vec3.hfa	(revision 94df8deefcefe5bac7ef400a07492b532b8c8ade)
+++ libcfa/src/vec/vec3.hfa	(revision 250dbaedadee6c9f63e82f0f166ca46323969089)
@@ -10,5 +10,4 @@
 }
 
-
 forall (otype T) {
     static inline {
@@ -31,5 +30,4 @@
     }
 
-    // Assignment
     void ?=?(vec3(T)& vec, vec3(T) other) with (vec) {
         [x,y,z] = other.[x,y,z];
@@ -44,5 +42,5 @@
     // -
     forall(| subtract(T)) {
-    vec3(T) ?-?(vec3(T) u, vec3(T) v) { // TODO( can't make this const ref )
+    vec3(T) ?-?(vec3(T) u, vec3(T) v) {
         return [u.x - v.x, u.y - v.y, u.z - v.z];
     }
@@ -52,5 +50,4 @@
     }
     }
-
     forall(| negate(T)) {
     vec3(T) -?(vec3(T) v) with (v) {
@@ -58,5 +55,4 @@
     }
     }
-
     forall(| { T --?(T&); }) {
     vec3(T)& --?(vec3(T)& v) {
@@ -75,5 +71,5 @@
     // +
     forall(| add(T)) {
-    vec3(T) ?+?(vec3(T) u, vec3(T) v) { // TODO( can't make this const ref )
+    vec3(T) ?+?(vec3(T) u, vec3(T) v) {
         return [u.x + v.x, u.y + v.y, u.z + v.z];
     }
@@ -83,5 +79,4 @@
     }
     }
-
 
     forall(| { T ++?(T&); }) {
@@ -101,8 +96,8 @@
     // *
     forall(| multiply(T)) {
-    vec3(T) ?*?(vec3(T) v, T scalar) with (v) { // TODO (can't make this const ref)
+    vec3(T) ?*?(vec3(T) v, T scalar) with (v) {
         return [x * scalar, y * scalar, z * scalar];
     }
-    vec3(T) ?*?(T scalar, vec3(T) v) { // TODO (can't make this const ref)
+    vec3(T) ?*?(T scalar, vec3(T) v) {
         return v * scalar;
     }
@@ -128,5 +123,5 @@
         return [u.x / v.x, u.y / v.y, u.z / v.z];
     }
-    vec3(T)& ?/=?(vec3(T)& v, T scalar) with (v) {
+    vec3(T)& ?/=?(vec3(T)& v, T scalar) {
         v = v / scalar;
         return v;
Index: libcfa/src/vec/vec4.hfa
===================================================================
--- libcfa/src/vec/vec4.hfa	(revision 94df8deefcefe5bac7ef400a07492b532b8c8ade)
+++ libcfa/src/vec/vec4.hfa	(revision 250dbaedadee6c9f63e82f0f166ca46323969089)
@@ -10,5 +10,4 @@
 }
 
-
 forall (otype T) {
     static inline {
@@ -31,5 +30,4 @@
     }
 
-    // Assignment
     void ?=?(vec4(T)& vec, vec4(T) other) with (vec) {
         [x,y,z,w] = other.[x,y,z,w];
@@ -44,5 +42,5 @@
     // -
     forall(| subtract(T)) {
-    vec4(T) ?-?(vec4(T) u, vec4(T) v) { // TODO( can't make this const ref )
+    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];
     }
@@ -52,5 +50,4 @@
     }
     }
-
     forall(| negate(T)) {
     vec4(T) -?(vec4(T) v) with (v) {
@@ -58,5 +55,4 @@
     }
     }
-
     forall(| { T --?(T&); }) {
     vec4(T)& --?(vec4(T)& v) {
@@ -102,8 +98,8 @@
     // *
     forall(| multiply(T)) {
-    vec4(T) ?*?(vec4(T) v, T scalar) with (v) { // TODO (can't make this const ref)
+    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) { // TODO (can't make this const ref)
+    vec4(T) ?*?(T scalar, vec4(T) v) {
         return v * scalar;
     }
@@ -121,5 +117,5 @@
     }
 
-    // Scalar Division
+    // /
     forall(| divide(T)) {
     vec4(T) ?/?(vec4(T) v, T scalar) with (v) {
@@ -129,5 +125,5 @@
         return [u.x / v.x, u.y / v.y, u.z / v.z, u.w / v.w];
     }
-    vec4(T)& ?/=?(vec4(T)& v, T scalar) with (v) {
+    vec4(T)& ?/=?(vec4(T)& v, T scalar) {
         v = v / scalar;
         return v;
@@ -253,5 +249,5 @@
     }
 
-    // Relational Operators
+    // relational
     forall(| equality(T)) {
     bool ?==?(vec4(T) u, vec4(T) v) with (u) {