Index: libcfa/src/containers/list.hfa
===================================================================
--- libcfa/src/containers/list.hfa	(revision 6f36dde5738ff3ea80437b7ebeab3b8a3f1f4a9d)
+++ libcfa/src/containers/list.hfa	(revision c08c3cfa1e4a6930d362550049713d2d3fd7ed43)
@@ -66,5 +66,5 @@
 #define __DLISTED_MGD_JUSTIMPL(STRUCT)
 
-forall( dtype tE ) {
+forall( tE & ) {
 	struct $mgd_link {
 		tE *elem;
@@ -83,5 +83,5 @@
 		(this.is_terminator){ 1 };
 	}
-	forall ( otype tInit | { void ?{}( $mgd_link(tE) &, tInit); } )
+	forall ( tInit | { void ?{}( $mgd_link(tE) &, tInit); } )
 	static inline void ?=?( $mgd_link(tE) &this, tInit i ) {
 		^?{}( this );
@@ -115,5 +115,5 @@
   __DLISTED_MGD_COMMON(STRUCT, STRUCT, $links)
 
-trait $dlistable(dtype Tnode, dtype Telem) {
+trait $dlistable(Tnode &, Telem &) {
 	$mgd_link(Telem) & $prev_link(Tnode &);
 	$mgd_link(Telem) & $next_link(Tnode &);
@@ -125,5 +125,5 @@
 };
 
-forall (dtype Tnode, dtype Telem | $dlistable(Tnode, Telem)) {
+forall (Tnode &, Telem & | $dlistable(Tnode, Telem)) {
 
 	// implemented as a sentinel item in an underlying cicrular list
Index: libcfa/src/containers/maybe.cfa
===================================================================
--- libcfa/src/containers/maybe.cfa	(revision 6f36dde5738ff3ea80437b7ebeab3b8a3f1f4a9d)
+++ libcfa/src/containers/maybe.cfa	(revision c08c3cfa1e4a6930d362550049713d2d3fd7ed43)
@@ -18,10 +18,10 @@
 
 
-forall(otype T)
+forall(T)
 void ?{}(maybe(T) & this) {
 	this.has_value = false;
 }
 
-forall(otype T)
+forall(T)
 void ?{}(maybe(T) & this, T value) {
 	this.has_value = true;
@@ -29,5 +29,5 @@
 }
 
-forall(otype T)
+forall(T)
 void ?{}(maybe(T) & this, maybe(T) other) {
 	this.has_value = other.has_value;
@@ -37,5 +37,5 @@
 }
 
-forall(otype T)
+forall(T)
 maybe(T) ?=?(maybe(T) & this, maybe(T) that) {
 	if (this.has_value && that.has_value) {
@@ -51,5 +51,5 @@
 }
 
-forall(otype T)
+forall(T)
 void ^?{}(maybe(T) & this) {
 	if (this.has_value) {
@@ -58,25 +58,25 @@
 }
 
-forall(otype T)
+forall(T)
 bool ?!=?(maybe(T) this, zero_t) {
 	return this.has_value;
 }
 
-forall(otype T)
+forall(T)
 maybe(T) maybe_value(T value) {
 	return (maybe(T)){value};
 }
 
-forall(otype T)
+forall(T)
 maybe(T) maybe_none() {
 	return (maybe(T)){};
 }
 
-forall(otype T)
+forall(T)
 bool has_value(maybe(T) * this) {
 	return this->has_value;
 }
 
-forall(otype T)
+forall(T)
 T get(maybe(T) * this) {
 	assertf(this->has_value, "attempt to get from maybe without value");
@@ -84,5 +84,5 @@
 }
 
-forall(otype T)
+forall(T)
 void set(maybe(T) * this, T value) {
 	if (this->has_value) {
@@ -94,5 +94,5 @@
 }
 
-forall(otype T)
+forall(T)
 void set_none(maybe(T) * this) {
 	if (this->has_value) {
Index: libcfa/src/containers/maybe.hfa
===================================================================
--- libcfa/src/containers/maybe.hfa	(revision 6f36dde5738ff3ea80437b7ebeab3b8a3f1f4a9d)
+++ libcfa/src/containers/maybe.hfa	(revision c08c3cfa1e4a6930d362550049713d2d3fd7ed43)
@@ -19,5 +19,5 @@
 
 // DO NOT USE DIRECTLY!
-forall(otype T)
+forall(T)
 struct maybe {
     bool has_value;
@@ -26,40 +26,40 @@
 
 
-forall(otype T)
+forall(T)
 void ?{}(maybe(T) & this);
 
-forall(otype T)
+forall(T)
 void ?{}(maybe(T) & this, T value);
 
-forall(otype T)
+forall(T)
 void ?{}(maybe(T) & this, maybe(T) other);
 
-forall(otype T)
+forall(T)
 void ^?{}(maybe(T) & this);
 
-forall(otype T)
+forall(T)
 maybe(T) ?=?(maybe(T) & this, maybe(T) other);
 
-forall(otype T)
+forall(T)
 bool ?!=?(maybe(T) this, zero_t);
 
 /* Waiting for bug#11 to be fixed.
-forall(otype T)
+forall(T)
 maybe(T) maybe_value(T value);
 
-forall(otype T)
+forall(T)
 maybe(T) maybe_none();
 */
 
-forall(otype T)
+forall(T)
 bool has_value(maybe(T) * this);
 
-forall(otype T)
+forall(T)
 T get(maybe(T) * this);
 
-forall(otype T)
+forall(T)
 void set(maybe(T) * this, T value);
 
-forall(otype T)
+forall(T)
 void set_none(maybe(T) * this);
 
Index: libcfa/src/containers/pair.cfa
===================================================================
--- libcfa/src/containers/pair.cfa	(revision 6f36dde5738ff3ea80437b7ebeab3b8a3f1f4a9d)
+++ libcfa/src/containers/pair.cfa	(revision c08c3cfa1e4a6930d362550049713d2d3fd7ed43)
@@ -13,5 +13,5 @@
 #include <containers/pair.hfa>
 
-forall(otype R, otype S
+forall(R, S
 	| { int ?==?(R, R); int ?<?(R, R); int ?<?(S, S); })
 int ?<?(pair(R, S) p, pair(R, S) q) {
@@ -19,5 +19,5 @@
 }
 
-forall(otype R, otype S
+forall(R, S
 	| { int ?==?(R, R); int ?<?(R, R); int ?<=?(S, S); })
 int ?<=?(pair(R, S) p, pair(R, S) q) {
@@ -25,15 +25,15 @@
 }
 
-forall(otype R, otype S | { int ?==?(R, R); int ?==?(S, S); })
+forall(R, S | { int ?==?(R, R); int ?==?(S, S); })
 int ?==?(pair(R, S) p, pair(R, S) q) {
 	return p.first == q.first && p.second == q.second;
 }
 
-forall(otype R, otype S | { int ?!=?(R, R); int ?!=?(S, S); })
+forall(R, S | { int ?!=?(R, R); int ?!=?(S, S); })
 int ?!=?(pair(R, S) p, pair(R, S) q) {
 	return p.first != q.first || p.second != q.second;
 }
 
-forall(otype R, otype S
+forall(R, S
 	| { int ?==?(R, R); int ?>?(R, R); int ?>?(S, S); })
 int ?>?(pair(R, S) p, pair(R, S) q) {
@@ -41,5 +41,5 @@
 }
 
-forall(otype R, otype S
+forall(R, S
 	| { int ?==?(R, R); int ?>?(R, R); int ?>=?(S, S); })
 int ?>=?(pair(R, S) p, pair(R, S) q) {
Index: libcfa/src/containers/pair.hfa
===================================================================
--- libcfa/src/containers/pair.hfa	(revision 6f36dde5738ff3ea80437b7ebeab3b8a3f1f4a9d)
+++ libcfa/src/containers/pair.hfa	(revision c08c3cfa1e4a6930d362550049713d2d3fd7ed43)
@@ -16,28 +16,28 @@
 #pragma once
 
-forall(otype R, otype S) struct pair {
+forall(R, S) struct pair {
 	R first;
 	S second;
 };
 
-forall(otype R, otype S 
+forall(R, S 
 	| { int ?==?(R, R); int ?<?(R, R); int ?<?(S, S); })
 int ?<?(pair(R, S) p, pair(R, S) q);
 
-forall(otype R, otype S 
+forall(R, S 
 	| { int ?==?(R, R); int ?<?(R, R); int ?<=?(S, S); })
 int ?<=?(pair(R, S) p, pair(R, S) q);
 
-forall(otype R, otype S | { int ?==?(R, R); int ?==?(S, S); })
+forall(R, S | { int ?==?(R, R); int ?==?(S, S); })
 int ?==?(pair(R, S) p, pair(R, S) q);
 
-forall(otype R, otype S | { int ?!=?(R, R); int ?!=?(S, S); })
+forall(R, S | { int ?!=?(R, R); int ?!=?(S, S); })
 int ?!=?(pair(R, S) p, pair(R, S) q);
 
-forall(otype R, otype S 
+forall(R, S 
 	| { int ?==?(R, R); int ?>?(R, R); int ?>?(S, S); })
 int ?>?(pair(R, S) p, pair(R, S) q);
 
-forall(otype R, otype S 
+forall(R, S 
 	| { int ?==?(R, R); int ?>?(R, R); int ?>=?(S, S); })
 int ?>=?(pair(R, S) p, pair(R, S) q);
Index: libcfa/src/containers/result.cfa
===================================================================
--- libcfa/src/containers/result.cfa	(revision 6f36dde5738ff3ea80437b7ebeab3b8a3f1f4a9d)
+++ libcfa/src/containers/result.cfa	(revision c08c3cfa1e4a6930d362550049713d2d3fd7ed43)
@@ -18,5 +18,5 @@
 
 
-forall(otype T, otype E)
+forall(T, E)
 void ?{}(result(T, E) & this) {
 	this.has_value = false;
@@ -24,5 +24,5 @@
 }
 
-forall(otype T, otype E)
+forall(T, E)
 void ?{}(result(T, E) & this, one_t, T value) {
 	this.has_value = true;
@@ -30,5 +30,5 @@
 }
 
-forall(otype T, otype E)
+forall(T, E)
 void ?{}(result(T, E) & this, zero_t, E error) {
 	this.has_value = false;
@@ -36,5 +36,5 @@
 }
 
-forall(otype T, otype E)
+forall(T, E)
 void ?{}(result(T, E) & this, result(T, E) other) {
 	this.has_value = other.has_value;
@@ -46,5 +46,5 @@
 }
 
-forall(otype T, otype E)
+forall(T, E)
 result(T, E) ?=?(result(T, E) & this, result(T, E) that) {
 	if (this.has_value && that.has_value) {
@@ -63,5 +63,5 @@
 }
 
-forall(otype T, otype E)
+forall(T, E)
 void ^?{}(result(T, E) & this) {
 	if (this.has_value) {
@@ -72,25 +72,25 @@
 }
 
-forall(otype T, otype E)
+forall(T, E)
 bool ?!=?(result(T, E) this, zero_t) {
 	return this.has_value;
 }
 
-forall(otype T, otype E)
+forall(T, E)
 result(T, E) result_value(T value) {
 	return (result(T, E)){1, value};
 }
 
-forall(otype T, otype E)
+forall(T, E)
 result(T, E) result_error(E error) {
 	return (result(T, E)){0, error};
 }
 
-forall(otype T, otype E)
+forall(T, E)
 bool has_value(result(T, E) * this) {
 	return this->has_value;
 }
 
-forall(otype T, otype E)
+forall(T, E)
 T get(result(T, E) * this) {
 	assertf(this->has_value, "attempt to get from result without value");
@@ -98,5 +98,5 @@
 }
 
-forall(otype T, otype E)
+forall(T, E)
 E get_error(result(T, E) * this) {
 	assertf(!this->has_value, "attempt to get from result without error");
@@ -104,5 +104,5 @@
 }
 
-forall(otype T, otype E)
+forall(T, E)
 void set(result(T, E) * this, T value) {
 	if (this->has_value) {
@@ -115,5 +115,5 @@
 }
 
-forall(otype T, otype E)
+forall(T, E)
 void set_error(result(T, E) * this, E error) {
 	if (this->has_value) {
Index: libcfa/src/containers/result.hfa
===================================================================
--- libcfa/src/containers/result.hfa	(revision 6f36dde5738ff3ea80437b7ebeab3b8a3f1f4a9d)
+++ libcfa/src/containers/result.hfa	(revision c08c3cfa1e4a6930d362550049713d2d3fd7ed43)
@@ -19,5 +19,5 @@
 
 // DO NOT USE DIRECTLY!
-forall(otype T, otype E)
+forall(T, E)
 union inner_result{
 	T value;
@@ -25,5 +25,5 @@
 };
 
-forall(otype T, otype E)
+forall(T, E)
 struct result {
 	bool has_value;
@@ -32,46 +32,46 @@
 
 
-forall(otype T, otype E)
+forall(T, E)
 void ?{}(result(T, E) & this);
 
-forall(otype T, otype E)
+forall(T, E)
 void ?{}(result(T, E) & this, one_t, T value);
 
-forall(otype T, otype E)
+forall(T, E)
 void ?{}(result(T, E) & this, zero_t, E error);
 
-forall(otype T, otype E)
+forall(T, E)
 void ?{}(result(T, E) & this, result(T, E) other);
 
-forall(otype T, otype E)
+forall(T, E)
 void ^?{}(result(T, E) & this);
 
-forall(otype T, otype E)
+forall(T, E)
 result(T, E) ?=?(result(T, E) & this, result(T, E) other);
 
-forall(otype T, otype E)
+forall(T, E)
 bool ?!=?(result(T, E) this, zero_t);
 
 /* Wating for bug#11 to be fixed.
-forall(otype T, otype E)
+forall(T, E)
 result(T, E) result_value(T value);
 
-forall(otype T, otype E)
+forall(T, E)
 result(T, E) result_error(E error);
 */
 
-forall(otype T, otype E)
+forall(T, E)
 bool has_value(result(T, E) * this);
 
-forall(otype T, otype E)
+forall(T, E)
 T get(result(T, E) * this);
 
-forall(otype T, otype E)
+forall(T, E)
 E get_error(result(T, E) * this);
 
-forall(otype T, otype E)
+forall(T, E)
 void set(result(T, E) * this, T value);
 
-forall(otype T, otype E)
+forall(T, E)
 void set_error(result(T, E) * this, E error);
 
Index: libcfa/src/containers/stackLockFree.hfa
===================================================================
--- libcfa/src/containers/stackLockFree.hfa	(revision 6f36dde5738ff3ea80437b7ebeab3b8a3f1f4a9d)
+++ libcfa/src/containers/stackLockFree.hfa	(revision c08c3cfa1e4a6930d362550049713d2d3fd7ed43)
@@ -17,5 +17,5 @@
 #include <stdint.h>
 
-forall( dtype T )
+forall( T & )
 union Link {
 	struct {											// 32/64-bit x 2
@@ -31,5 +31,5 @@
 }; // Link
 
-forall( otype T | sized(T) | { Link(T) * ?`next( T * ); } ) {
+forall( T | sized(T) | { Link(T) * ?`next( T * ); } ) {
 	struct StackLF {
 		Link(T) stack;
Index: libcfa/src/containers/vector.cfa
===================================================================
--- libcfa/src/containers/vector.cfa	(revision 6f36dde5738ff3ea80437b7ebeab3b8a3f1f4a9d)
+++ libcfa/src/containers/vector.cfa	(revision c08c3cfa1e4a6930d362550049713d2d3fd7ed43)
@@ -18,10 +18,10 @@
 #include <stdlib.hfa>
 
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 void copy_internal(vector(T, allocator_t)* this, vector(T, allocator_t)* other);
 
 //------------------------------------------------------------------------------
 //Initialization
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 void ?{}(vector(T, allocator_t)& this)
 {
@@ -30,5 +30,5 @@
 }
 
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 void ?{}(vector(T, allocator_t)& this, vector(T, allocator_t) rhs)
 {
@@ -37,5 +37,5 @@
 }
 
-// forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+// forall(T, allocator_t | allocator_c(T, allocator_t))
 // vector(T, allocator_t) ?=?(vector(T, allocator_t)* this, vector(T, allocator_t) rhs)
 // {
@@ -45,5 +45,5 @@
 // }
 
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 void ^?{}(vector(T, allocator_t)& this)
 {
@@ -54,5 +54,5 @@
 //------------------------------------------------------------------------------
 //Modifiers
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 void push_back(vector(T, allocator_t)* this, T value)
 {
@@ -62,5 +62,5 @@
 }
 
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 void pop_back(vector(T, allocator_t)* this)
 {
@@ -69,5 +69,5 @@
 }
 
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 void clear(vector(T, allocator_t)* this)
 {
@@ -82,5 +82,5 @@
 //Internal Helpers
 
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 void copy_internal(vector(T, allocator_t)* this, vector(T, allocator_t)* other)
 {
@@ -93,5 +93,5 @@
 //------------------------------------------------------------------------------
 //Allocator
-forall(otype T)
+forall(T)
 void ?{}(heap_allocator(T)& this)
 {
@@ -100,5 +100,5 @@
 }
 
-forall(otype T)
+forall(T)
 void ?{}(heap_allocator(T)& this, heap_allocator(T) rhs)
 {
@@ -107,5 +107,5 @@
 }
 
-forall(otype T)
+forall(T)
 heap_allocator(T) ?=?(heap_allocator(T)& this, heap_allocator(T) rhs)
 {
@@ -115,5 +115,5 @@
 }
 
-forall(otype T)
+forall(T)
 void ^?{}(heap_allocator(T)& this)
 {
@@ -121,5 +121,5 @@
 }
 
-forall(otype T)
+forall(T)
 inline void realloc_storage(heap_allocator(T)* this, size_t size)
 {
Index: libcfa/src/containers/vector.hfa
===================================================================
--- libcfa/src/containers/vector.hfa	(revision 6f36dde5738ff3ea80437b7ebeab3b8a3f1f4a9d)
+++ libcfa/src/containers/vector.hfa	(revision c08c3cfa1e4a6930d362550049713d2d3fd7ed43)
@@ -20,5 +20,5 @@
 //------------------------------------------------------------------------------
 //Allocator
-forall(otype T)
+forall(T)
 struct heap_allocator
 {
@@ -27,20 +27,20 @@
 };
 
-forall(otype T)
+forall(T)
 void ?{}(heap_allocator(T)& this);
 
-forall(otype T)
+forall(T)
 void ?{}(heap_allocator(T)& this, heap_allocator(T) rhs);
 
-forall(otype T)
+forall(T)
 heap_allocator(T) ?=?(heap_allocator(T)& this, heap_allocator(T) rhs);
 
-forall(otype T)
+forall(T)
 void ^?{}(heap_allocator(T)& this);
 
-forall(otype T)
+forall(T)
 void realloc_storage(heap_allocator(T)* this, size_t size);
 
-forall(otype T)
+forall(T)
 static inline T* data(heap_allocator(T)* this)
 {
@@ -50,5 +50,5 @@
 //------------------------------------------------------------------------------
 //Declaration
-trait allocator_c(otype T, otype allocator_t)
+trait allocator_c(T, allocator_t)
 {
 	void realloc_storage(allocator_t*, size_t);
@@ -56,22 +56,22 @@
 };
 
-forall(otype T, otype allocator_t = heap_allocator(T) | allocator_c(T, allocator_t))
+forall(T, allocator_t = heap_allocator(T) | allocator_c(T, allocator_t))
 struct vector;
 
 //------------------------------------------------------------------------------
 //Initialization
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 void ?{}(vector(T, allocator_t)& this);
 
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 void ?{}(vector(T, allocator_t)& this, vector(T, allocator_t) rhs);
 
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 vector(T, allocator_t) ?=?(vector(T, allocator_t)& this, vector(T, allocator_t) rhs);
 
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 void ^?{}(vector(T, allocator_t)& this);
 
-forall(otype T, otype allocator_t = heap_allocator(T) | allocator_c(T, allocator_t))
+forall(T, allocator_t = heap_allocator(T) | allocator_c(T, allocator_t))
 struct vector
 {
@@ -82,5 +82,5 @@
 //------------------------------------------------------------------------------
 //Capacity
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 static inline bool empty(vector(T, allocator_t)* this)
 {
@@ -88,5 +88,5 @@
 }
 
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 static inline size_t size(vector(T, allocator_t)* this)
 {
@@ -94,5 +94,5 @@
 }
 
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 static inline void reserve(vector(T, allocator_t)* this, size_t size)
 {
@@ -102,5 +102,5 @@
 //------------------------------------------------------------------------------
 //Element access
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 static inline T at(vector(T, allocator_t)* this, size_t index)
 {
@@ -108,5 +108,5 @@
 }
 
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 static inline T ?[?](vector(T, allocator_t)* this, size_t index)
 {
@@ -114,5 +114,5 @@
 }
 
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 static inline T front(vector(T, allocator_t)* this)
 {
@@ -120,5 +120,5 @@
 }
 
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 static inline T back(vector(T, allocator_t)* this)
 {
@@ -128,16 +128,16 @@
 //------------------------------------------------------------------------------
 //Modifiers
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 void push_back(vector(T, allocator_t)* this, T value);
 
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 void pop_back(vector(T, allocator_t)* this);
 
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 void clear(vector(T, allocator_t)* this);
 
 //------------------------------------------------------------------------------
 //Iterators
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 static inline T* begin(vector(T, allocator_t)* this)
 {
@@ -145,5 +145,5 @@
 }
 
-// forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+// forall(T, allocator_t | allocator_c(T, allocator_t))
 // static inline const T* cbegin(const vector(T, allocator_t)* this)
 // {
@@ -151,5 +151,5 @@
 // }
 
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 static inline T* end(vector(T, allocator_t)* this)
 {
@@ -157,5 +157,5 @@
 }
 
-// forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+// forall(T, allocator_t | allocator_c(T, allocator_t))
 // static inline const T* cend(const vector(T, allocator_t)* this)
 // {