Index: doc/generic_types/evaluation/cfa-bench.c
===================================================================
--- doc/generic_types/evaluation/cfa-bench.c	(revision 457013197df212effd5e36568f1d38ea6ca3704e)
+++ doc/generic_types/evaluation/cfa-bench.c	(revision 79b8dc383bfab842e3790a2d71f85fb491db40e7)
@@ -1,4 +1,3 @@
 #include <stdlib>
-#include <stdlib.h>
 #include <stdio.h>
 #include "pair"
@@ -7,56 +6,22 @@
 #include "cfa-print.h"
 
-int main(int argc, char** argv) {
-	FILE* out = fopen("cfa-out.txt", "w");
-	srand(20171025);
+int main( int argc, char *argv[] ) {
+	FILE * out = fopen( "cfa-out.txt", "w" );
+	int max = 0;
+	stack(int) s, t;
+	REPEAT_TIMED( "push_int", push( &s, _i ); )
+	TIMED( "copy_int", t = s; )
+	TIMED( "clear_int", clear( &s ); )
+	REPEAT_TIMED( "pop_int", max = max( max, pop( &t ) ); )
+	REPEAT_TIMED( "print_int", print( out, _i, ":", _i, "\n" ); )
 
-	stack(int) s;
-	REPEAT_TIMED( "push_int",
-		push( &s, rand() );
-	)
-
-	stack(int) t;
-	TIMED( "copy_int", 
-		t = s;
-	)
-
-	TIMED( "clear_int", 
-		clear( &s );
-	)
-
-	int max = 0;
-	REPEAT_TIMED( "pop_int", 
-		max = max( max, pop( &t ) );
-	)
-	print( out, max, "\n" );
-
-	REPEAT_N_TIMED( "print_int", N/2, 
-		print( out, rand(), ":", rand(), "\n" );
-	)
-
-	stack(pair(_Bool, char)) s2;
-	REPEAT_TIMED( "push_bool_char",
-		push( &s2, (pair(_Bool, char)){ rand() & 0x1, rand() & 0x7F } );
-	)
-
-	stack(pair(_Bool, char)) t2;
-	TIMED( "copy_bool_char", 
-		t2 = s2;
-	)
-
-	TIMED( "clear_bool_char", 
-		clear( &s2 );
-	)
-
-	pair(_Bool, char) max2 = { (_Bool)0, '\0' };
-	REPEAT_TIMED( "pop_bool_char",
-		max2 = max( max2, pop( &t2 ) );
-	)
-	print( out, max2, "\n" );
-
-	REPEAT_N_TIMED( "print_pair", N/2, 
-		print( out, (pair(_Bool, char)){ rand() & 0x1, rand() & 0x7F }, ":",
-				(pair(_Bool, char)){ rand() & 0x1, rand() & 0x7F }, "\n" );
-	)
+	stack(pair(_Bool, char)) s1, t1;
+	pair(_Bool, char) max = { (_Bool)0, '\0' };
+	REPEAT_TIMED( "push_pair", push( &s1, (pair(_Bool, char)){ _i & 1, _i &0x7F } ); )
+	TIMED( "copy_pair", t1 = s1; )
+	TIMED( "clear_pair", clear( &s1 ); )
+	REPEAT_TIMED( "pop_pair", max = max( max, pop( &t1 ) ); )
+	REPEAT_TIMED( "print_pair",
+		 print( out, (pair(_Bool, char)){  _i & 1, _i &0x7F }, ":", (pair(_Bool, char)){  _i & 1, _i &0x7F }, "\n" ); )
 	fclose(out);
 }
Index: doc/generic_types/evaluation/cpp-bench.cpp
===================================================================
--- doc/generic_types/evaluation/cpp-bench.cpp	(revision 457013197df212effd5e36568f1d38ea6ca3704e)
+++ doc/generic_types/evaluation/cpp-bench.cpp	(revision 79b8dc383bfab842e3790a2d71f85fb491db40e7)
@@ -1,5 +1,4 @@
 #include <algorithm>
 #include <fstream>
-#include <stdlib.h>
 #include <utility>
 #include "bench.hpp"
@@ -9,53 +8,22 @@
 int main(int argc, char** argv) {
 	std::ofstream out{"cpp-out.txt"};
-	srand(20171025);
+	stack<int> s, t;
+	int max = 0;
+	REPEAT_TIMED( "push_int", s.push( _i ); )
+	TIMED( "copy_int", t = s; )
+	TIMED( "clear_int", s.clear(); )
+	REPEAT_TIMED( "pop_int", max = std::max( max, t.pop() ); )
+	print( out, max, "\n" );
+	REPEAT_N_TIMED( "print_int", N/2, print( out, _i, ":", _i, "\n" ); )
 
-	stack<int> s;
-	REPEAT_TIMED( "push_int",
-		s.push( rand() );
-	)
-
-	stack<int> t;
-	TIMED( "copy_int", 
-		t = s;
-	)
-
-	TIMED( "clear_int", 
-		s.clear();
-	)
-
-	int max = 0;
-	REPEAT_TIMED( "pop_int",
-		max = std::max( max, t.pop() );
-	)
-	print( out, max, "\n" );
-
-	REPEAT_N_TIMED( "print_int", N/2, 
-		print( out, rand(), ":", rand(), "\n" );
-	)
-
-	stack<std::pair<bool, char>> s2;
-	REPEAT_TIMED( "push_bool_char",
-		s2.push( std::pair<bool, char>{ rand() & 0x1, rand() & 0x7F } );
-	)
-
-	stack<std::pair<bool,char>> t2;
-	TIMED( "copy_bool_char", 
-		t2 = s2;
-	)
-
-	TIMED( "clear_bool_char", 
-		s2.clear();
-	)
-
-	std::pair<bool, char> max2 = { false, '\0' };
-	REPEAT_TIMED( "pop_bool_char",
-		max2 = std::max( max2, t2.pop() );
-	)
-	print( out, max2, "\n" );
-
+	stack<std::pair<bool, char>> s1, t1;
+	std::pair<bool, char> max1 = { false, '\0' };
+	REPEAT_TIMED( "push_bool_char", s1.push( std::pair<bool, char>{ _i & 0x1, _i & 0x7F } ); )
+	TIMED( "copy_bool_char", t1 = s1; )
+	TIMED( "clear_bool_char", s1.clear(); )
+	REPEAT_TIMED( "pop_bool_char", max1 = std::max( max1, t1.pop() ); )
+	print( out, max1, "\n" );
 	REPEAT_N_TIMED( "print_pair", N/2, 
-		print( out, std::pair<bool, char>{ rand() & 0x1, rand() & 0x7F }, ":",
-				std::pair<bool, char>{ rand() & 0x1, rand() & 0x7F }, "\n" );
-	)
+		print( out, std::pair<bool, char>{ _i & 0x1, _i & 0x7F }, ":",
+				std::pair<bool, char>{ _i & 0x1, _i & 0x7F }, "\n" ); )
 }
Index: doc/generic_types/evaluation/cpp-vbench.cpp
===================================================================
--- doc/generic_types/evaluation/cpp-vbench.cpp	(revision 457013197df212effd5e36568f1d38ea6ca3704e)
+++ doc/generic_types/evaluation/cpp-vbench.cpp	(revision 79b8dc383bfab842e3790a2d71f85fb491db40e7)
@@ -1,5 +1,4 @@
 #include <algorithm>
 #include <fstream>
-#include <stdlib.h>
 #include "bench.hpp"
 #include "cpp-vstack.hpp"
@@ -9,58 +8,26 @@
 int main(int argc, char** argv) {
 	std::ofstream out{"cpp-vout.txt"};
-	srand(20171025);
+	stack s, t;
+	integer max{ 0 };
+	REPEAT_TIMED( "push_int", s.push( make<integer>( _i ) ); )
+	TIMED( "copy_int", t = s; )
+	TIMED( "clear_int", s.clear(); )
+	REPEAT_TIMED( "pop_int", max = std::max( max, t.pop()->as<integer>() ); /***/ )
+	print( out, max, c_string{"\n"} );
+	REPEAT_N_TIMED( "print_int", N/2, 
+		print( out, integer{_i}, c_string{":"}, integer{_i}, c_string{"\n"} ); )
 
-	stack s;
-	REPEAT_TIMED( "push_int",
-		s.push( std::make_unique<integer>( rand() ) );
-	)
-
-	stack t;
-	TIMED( "copy_int", 
-		t = s;
-	)
-
-	TIMED( "clear_int", 
-		s.clear();
-	)
-
-	integer max;
-	REPEAT_TIMED( "pop_int",
-		max = std::max( max, t.pop()->as<integer>() ); /***/
-	)
-	print( out, max, c_string{"\n"} );
-
-	REPEAT_N_TIMED( "print_int", N/2, 
-		print( out, integer{rand()}, c_string{":"}, integer{rand()}, c_string{"\n"} );
-	)
-
-	stack s2;
-	REPEAT_TIMED( "push_bool_char",
-		s2.push( std::make_unique<pair>( std::make_unique<boolean>( rand() & 0x1 ), 
-			std::make_unique<character>( rand() & 0x7F ) ) );
-	)
-
-	stack t2;
-	TIMED( "copy_bool_char", 
-		t2 = s2;
-	)
-
-	TIMED( "clear_bool_char", 
-		s2.clear();
-	)
-
-	auto max2 = std::make_unique<pair>( std::make_unique<boolean>(false), 
-		std::make_unique<character>('\0') );
+	stack s1, t1;
+	ptr<pair> max1 = make<pair>( make<boolean>(false), make<character>('\0') );
+	REPEAT_TIMED( "push_bool_char", 
+		s1.push( make<pair>( make<boolean>(_i & 1), make<character>(_i & 0x7F) ) ); )
+	TIMED( "copy_bool_char", t1 = s1; )
+	TIMED( "clear_bool_char", s1.clear(); )
 	REPEAT_TIMED( "pop_bool_char",
-		std::unique_ptr<pair> x = as_ptr<pair>( t2.pop() ); /***/
-		if ( *x > *max2 ) { max2 = std::move(x); }
-	)
-	print( out, *max2, c_string{"\n"} );
-
+		ptr<pair> x = as_ptr<pair>( t1.pop() ); /***/
+		if ( *x > *max1 ) { max1 = std::move(x); } )
+	print( out, *max1, c_string{"\n"} );
 	REPEAT_N_TIMED( "print_pair", N/2, 
-		print( out, pair{ std::make_unique<boolean>( rand() & 0x1 ), 
-			std::make_unique<character>( rand() & 0x7F ) }, c_string{":"}, 
-			pair{ std::make_unique<boolean>( rand() & 0x1 ), 
-			std::make_unique<character>( rand() & 0x7F ) }, c_string{"\n"} );
-	)
+		print( out, pair{ make<boolean>(_i & 1), make<character>(_i & 0x7F) }, c_string{":"}, 
+			pair{ make<boolean>(_i & 1), make<character>(_i & 0x7F) }, c_string{"\n"} ); )
 }
Index: doc/generic_types/evaluation/cpp-vstack.cpp
===================================================================
--- doc/generic_types/evaluation/cpp-vstack.cpp	(revision 457013197df212effd5e36568f1d38ea6ca3704e)
+++ doc/generic_types/evaluation/cpp-vstack.cpp	(revision 79b8dc383bfab842e3790a2d71f85fb491db40e7)
@@ -5,5 +5,5 @@
 stack::node::node( const object& v ) : value( v.new_copy() ), next( nullptr ) {}
 
-stack::node::node( std::unique_ptr<object>&& v, node* n ) : value( std::move(v) ), next( n ) {}
+stack::node::node( ptr<object>&& v, node* n ) : value( std::move(v) ), next( n ) {}
 
 void stack::copy(const stack& o) {
@@ -50,16 +50,12 @@
 }
 
-bool stack::empty() const {
-	return head == nullptr;
-}
+bool stack::empty() const { return head == nullptr; }
 
-void stack::push(std::unique_ptr<object>&& value) {
-	head = new node{ std::move(value), head }; /***/
-}
+void stack::push(ptr<object>&& value) { head = new node{ std::move(value), head }; /***/ }
 
-std::unique_ptr<object> stack::pop() {
+ptr<object> stack::pop() {
 	node* n = head;
 	head = n->next;
-	std::unique_ptr<object> x = std::move(n->value);
+	ptr<object> x = std::move(n->value);
 	delete n;
 	return x;
Index: doc/generic_types/evaluation/cpp-vstack.hpp
===================================================================
--- doc/generic_types/evaluation/cpp-vstack.hpp	(revision 457013197df212effd5e36568f1d38ea6ca3704e)
+++ doc/generic_types/evaluation/cpp-vstack.hpp	(revision 79b8dc383bfab842e3790a2d71f85fb491db40e7)
@@ -5,10 +5,10 @@
 class stack {
 	struct node {
-		std::unique_ptr<object> value;
+		ptr<object> value;
 		node* next;
 
 		node( const object& v );
 
-		node( std::unique_ptr<object>&& v, node* n );
+		node( ptr<object>&& v, node* n );
 	};
 
@@ -34,6 +34,6 @@
 	bool empty() const;
 
-	void push(std::unique_ptr<object>&& value);
+	void push(ptr<object>&& value);
 
-	std::unique_ptr<object> pop();
+	ptr<object> pop();
 };
Index: doc/generic_types/evaluation/object.hpp
===================================================================
--- doc/generic_types/evaluation/object.hpp	(revision 457013197df212effd5e36568f1d38ea6ca3704e)
+++ doc/generic_types/evaluation/object.hpp	(revision 79b8dc383bfab842e3790a2d71f85fb491db40e7)
@@ -25,4 +25,6 @@
 std::type_index class_of() { return { typeid(T) }; }
 
+template<typename T> using ptr = std::unique_ptr<T>;
+
 class object {
 public:
@@ -43,7 +45,7 @@
 	}
 
-	virtual std::unique_ptr<object> new_inst() const = 0;
-	
-	virtual std::unique_ptr<object> new_copy() const = 0;
+	virtual ptr<object> new_inst() const = 0;
+	
+	virtual ptr<object> new_copy() const = 0;
 	
 	virtual object& operator= (const object&) = 0;
@@ -52,8 +54,9 @@
 };
 
+template<typename T, typename... Args>
+static inline ptr<T> make(Args&&... args) { return std::make_unique<T>(std::forward<Args>(args)...); }
+
 template<typename To, typename From>
-std::unique_ptr<To> as_ptr( std::unique_ptr<From>&& p ) {
-	return std::unique_ptr<To>{ &p.release()->template as<To>() };
-}
+ptr<To> as_ptr( ptr<From>&& p ) { return ptr<To>{ &p.release()->template as<To>() }; }
 
 class ordered : public virtual object {
@@ -87,7 +90,7 @@
 	boolean(bool x) : x(x) {}
 
-	std::unique_ptr<object> new_inst() const override { return std::make_unique<boolean>(); }
-	
-	std::unique_ptr<object> new_copy() const override { return std::make_unique<boolean>(*this); }
+	ptr<object> new_inst() const override { return make<boolean>(); }
+	
+	ptr<object> new_copy() const override { return make<boolean>(*this); }
 
 	boolean& operator= (const boolean& that) {
@@ -115,7 +118,7 @@
 	character(char x) : x(x) {}
 
-	std::unique_ptr<object> new_inst() const override { return std::make_unique<character>(); }
-	
-	std::unique_ptr<object> new_copy() const override { return std::make_unique<character>(*this); }
+	ptr<object> new_inst() const override { return make<character>(); }
+	
+	ptr<object> new_copy() const override { return make<character>(*this); }
 
 	character& operator= (const character& that) {
@@ -146,7 +149,7 @@
 	integer(int x) : x(x) {}
 
-	std::unique_ptr<object> new_inst() const override { return std::make_unique<integer>(); }
-	
-	std::unique_ptr<object> new_copy() const override { return std::make_unique<integer>(*this); }
+	ptr<object> new_inst() const override { return make<integer>(); }
+	
+	ptr<object> new_copy() const override { return make<integer>(*this); }
 
 	integer& operator= (const integer& that) {
@@ -174,7 +177,7 @@
 	c_string(const char* s) : s(s) {}
 
-	std::unique_ptr<object> new_inst() const override { return std::make_unique<c_string>(); }
-
-	std::unique_ptr<object> new_copy() const override { return std::make_unique<c_string>(s); }
+	ptr<object> new_inst() const override { return make<c_string>(); }
+
+	ptr<object> new_copy() const override { return make<c_string>(s); }
 
 	c_string& operator= (const c_string& that) {
@@ -191,17 +194,16 @@
 
 class pair : public ordered, public printable {
-	std::unique_ptr<object> x;
-	std::unique_ptr<object> y;
+	ptr<object> x;
+	ptr<object> y;
 
 public:
 	pair() = default;
 
-	pair(std::unique_ptr<object>&& x, std::unique_ptr<object>&& y)
-		: x(std::move(x)), y(std::move(y)) {}
-	
-	std::unique_ptr<object> new_inst() const override { return std::make_unique<pair>(); }
-
-	std::unique_ptr<object> new_copy() const override {
-		return std::make_unique<pair>(x->new_copy(), y->new_copy());
+	pair(ptr<object>&& x, ptr<object>&& y) : x(std::move(x)), y(std::move(y)) {}
+	
+	ptr<object> new_inst() const override { return make<pair>(); }
+
+	ptr<object> new_copy() const override {
+		return make<pair>(x->new_copy(), y->new_copy());
 	}
 
