// Copyright (C) 1998 by 
// Krzysztof Czarnecki (Czarnecki@acm.org) and
// Ulrich W. Eisenecker (Ulrich.Eisenecker@T-Online.de)
//
// METALISP.CPP contains a rudimentary LISP implementation as a template
// metaprogram. All the basic primitives and some convenience functions 
// are provided. You can use it to write functional programs interpreted by
// the compiler at compile time.
// This implementation uses member templates and has been tested with the
// Microsoft Visual C++ 5.0 compiler. Partial specialization and partial ordering of
// templates are not used. Some minor changes of the implementation might become
// necessary once the existing compilers conform to the upcoming C++
// standard.
// METACTRL is required.
// At some point, we will separate the examples from the header file.
/*
IMPORTANT NOTE FROM THE AUTHORS		
METALISP will be part of our upcoming book "Generative Programming -
Towards a New Paradigm of Software-Engineering" published by
Addison Wesley Longman.
Any suggestions for improvements and implementations of further LISP
functions are welcomed. If you have any problems with METALISP,
feel free to contact us for help or advice. If you find a bug in METALISP,
try first to fix it. If you are successful in fixing the bug, send us the bug
report along with the fix. If you are unable to fix it, please send us the bug
report including the detailed information about the compiler and the options you
use. We will see what we can do.
Feel free to extend METALISP in whatever way suits your needs.
However, PLEASE DO NOT RELEASE ENHANCED VERSIONS
WITHOUT CHECKING WITH US FIRST!!  We would like to be the clearing house
for new features added to METALISP. If you want to add features for your own
personal use, go ahead. But, if you want to distribute your enhanced version,
contact us first.
*/

#include <iostream>
#include <ios>
#include "metactrl"

namespace metalisp
{

	using namespace std;
	using namespace metactrl;

	// The functions which are not currently not available are documented
	// as comments. Many of them cannot be implemented, e.g. destructive
	// list functions or input during compile-time.

	// EVALUATION FUNCTIONS
	// EVAL	
	// APPLY
	// FUNCALL
	// QUOTE
	// FUNCTION	
	// BACKQUOTE
	// LAMBDA

	// SYMBOL FUNCTIONS
	// SET
	// SETQ
	// SETF
	// DEFUN
	// DEFMACRO
	// GENSYM
	// INTERN
	// MAKE-SYMBOL
	// SYMBOL-NAME
	// SYMBOL-VALUE
	// SYMBOL-PLIST
	// HASH

	// PROPERTY LIST FUNCTIONS
	// GET
	// PUTPROP
	// REMPROP

	// ARRAY FUNCTIONS
	// AREF
	// MAKE-ARRAY

	// LIST FUNCTIONS
	template <class List> struct CAR;
	template <class List> struct CDR;
	// CXXR
	// CXXXR
	// CXXXXR 
	template <class X1, class X2> struct CONS;
	template <class X1,class X2 = NILT> struct LIST;
	template <class X1,class X2> struct APPEND;
	template <class X> struct REVERSE;
	template <class X> struct LAST;
	// MEMBER
	// ASSOC
	// REMOVE
	template <class X> struct LENGTH;
	template <class X,int n> struct NTH;
	// NTHCDR
	// MAPC
	// MAPCAR
	// MAPL
	// MAPLIST
	// SUBST
	// SUBLIS

	// DESTRUCTIVE LIST FUNCTIONS [ ARE ALL NON-FUNCTIONAL AND HENCE CANNOT BE IMPLEMENTED! ]
	// RPLACA
	// RPLACD
	// NCONC
	// DELETE

	// PREDICATE FUNCTIONS
	template <class X> struct ATOM;
	template <class X> struct SYMBOLP;
	template <class X> struct NUMBERP;
	template <class X> struct NULLP; // ORIGINAL NAME IS NULL !
	template <class X> struct NOT;
	template <class X> struct LISTP;
	template <class X> struct CONSP;
	// BOUNDP
	// MINUSP
	// ZEROP
	// PLUSP
	// EVENP
	// ODDP
	template <class S1, class S2> struct EQ;
	template <class N1,class N2> struct EQL;
	template <class X1,class X2> struct EQUAL;

	// CONTROL CONSTRUCTS
	// COND
	// AND
	// OR
	// IF
	// CASE
	// LET
	// LET*
	// CATCH
	// THROW

	// LOOPING CONSTRUCTS
	// DO
	// DO*
	// DOLIST
	// DOTIMES
	
	// THE PROGRAM FEATURE [ CANNOT BE IMPLEMENTED ! ]
	// PROG
	// PROG*
	// GO
	// RETURN
	// PROG1
	// PROG2
	// PROGN

	// DEBUGGING AND ERROR-HANDLING [ CANNOT BE IMPLEMENTED ! ]
	// ERROR
	// CERROR
	// BREAK
	// CLEAN-UP
	// TOP-LEVEL
	// CONTINUE
	// ERRSET
	// BAKTRACE
	// EVALHOOK

	// ARITHMETIC FUNCTIONS
	// TRUNCATE
	// FLOAT
	template <class X1,class X2> struct ADD; // ORIGINAL NAME IS +
	template <class X1,class X2> struct SUBTRACT; // ORIGINAL NAME IS -
	template <class X1,class X2> struct MULTIPLY; // ORIGINAL NAME IS *
	template <class X1,class X2> struct DIVIDE; // ORIGINAL NAME IS /
	// 1+
	// 1-
	// REM
	// MIN
	// MAX
	// ABS
	// RANDOM
	// SIN
	// COS
	// TAN
	// EXPT
	// EXP
	// SQRT

	// BITWISE LOGICAL FUNCTIONS
	// LOGAND
	// LOGIOR
	// LOGXOR
	// LOGNOT

	// RELATIONAL FUNCTIONS
	// <
	// <=
	// =
	// /=
	// >=
	// >

	// STRING FUNCTIONS
	// CHAR
	// STRING
	// STRCAT
	// SUBSTR

	// INTPUT/OUTPUT FUNCTIONS
	// READ
	template <class X,class SINK = ostream> struct PRINT;
	// PRIN1
	// PRINC
	// TERPRI
	// FLATSIZE
	// FLATC

	// FILE I/O FUNCTIONS
	// OPENI
	// OPENO
	// CLOSE
	// READ-CHAR
	// PEEK-CHAR
	// WRITE-CHAR
	// READ-LINE

	// SYSTEM FUNCTIONS
	// LOAD
	// TRANSCRIPT
	// GC
	// EXPAND
	// ALLOC
	// MEM
	// TYPE-OF
	// PEEK
	// POKE
	// ADDRESS-OF
	// EXIT

// -----------------------------------------------------------------

	// T and NIL are implemented as const int's here.
	// Thus all predicate functions don't work on them!
	const int T = 1;	// value True in lisp
	const int NIL = 0;	// value False in lisp 

	struct NILT;
	typedef NILT LISTT; // LISTT is the empty list which is type NILT in lisp! It's called NILT since it would otherwise collide with NIL value

	//	Basic types: 
	//	- SEXPRESSIONT (for convenience of code sharing)
	//	- NUMBERT
	//	- SYMBOLT
	//	- LISTT (empty list, equals NILT)
	//	T stands for TYPE - These identifiers do not exist in Lisp.
	//						Otherwise we had conflicts with functions like LIST

	struct SEXPRESSIONT
	{
		enum {
				N_VAL = NIL,
				ID = NIL,
				IS_NUMBER = NIL,
				IS_SYMBOL = NIL,
				IS_ATOM = T,
				IS_LIST = NIL,
				IS_EMPTY = T,
			 };
		static const char* const name()
		{	return "SEXPRESSIONT";
		}
		static void print(ostream& os)
		{	os << name() << flush;
		}
		typedef NILT FIRST;	// required for termination of EQUAL<X1,X2>
		typedef NILT REST;	// required for termination of EQUAL<X1,X2>
	};

	namespace intimate
	{	template <class X1,class X2>
		struct SAME // not part of lisp
		{	enum { RET = X1::N_VAL == X2::N_VAL &&
						 X1::ID == X2::ID &&
						 X1::IS_NUMBER == X2::IS_NUMBER &&
						 X1::IS_SYMBOL == X2::IS_SYMBOL &&
						 X1::IS_ATOM == X2::IS_ATOM &&
						 X1::IS_LIST == X2::IS_LIST &&
						 X1::IS_EMPTY == X2::IS_EMPTY
				 };
		};

		template <class X,class Rev>
		struct _REVERSE;

	}; // end namespace intimate

	template <int value>
	struct NUMBERT : public SEXPRESSIONT
	{
		enum {
				IS_NUMBER=T,
				N_VAL = value
			 };
		typedef NUMBERT<value> RET;	// required for being treated as function
		static const char* const name()
		{	return "NUMBERT";
		}
		static void print(ostream& os)
		{	os << value << flush;
		}
	};

	template <class value,int SymbolID> // symbols are always bound here
	struct SYMBOLT : public SEXPRESSIONT
	{
		enum {
				IS_SYMBOL=T,
				ID = SymbolID // warning: it is not checked whether SymbolID is already in use
			 };
		typedef SYMBOLT<value,SymbolID> RET;	// required for being treated as function
		typedef value S_VAL;
		static const char* const name()
		{	return "SYMBOLT";
		}
		static void print(ostream& os)
		{	os << "'" << SymbolID << flush; // SymbolIDs are printed with a preceding quote
		}
	};

	struct NILT : public SEXPRESSIONT
	{
		enum {
				IS_LIST=T
			 };
		typedef NILT RET;	// required for being treated as function
		static const char* const name()
		{	return "NILT";
		}
		static void print(ostream& os)
		{	os << "NIL" << flush;
		}
	};

// List functions

	template <class List>
	struct CAR // return the CAR of a list node
	{
		typedef typename List::FIRST RET;
	};

	template <class List>
	struct CDR // return the CDR of a list node
	{
		typedef typename List::REST RET;
	};

	// CXXR, CXXXR, CXXXXR list functions are missing. 
	// The most simple way is to code them explicitly when required.

	template <class X1, class X2>
	struct CONS: public NILT // construct a new list node
	{
		enum 
			 { 
			   IS_EMPTY = NIL,
			   IS_ATOM = NIL
			 };
		typedef X1 FIRST;
		typedef X2 REST;
		typedef CONS<X1,X2> RET;
		static void print(ostream& os) // lists are printed with redundant parentheses
		{	os << "(";
			FIRST::print(os);
			os << " . ";
			REST::print(os);
			os << ")" << flush;
		}
	};

	template <class X1,class X2 = NILT>
	struct LIST: public CONS<X1,X2> // create a list of values
	{};

	template <class X>
	struct REVERSE	// reverse a list - different from standard lisp this implementation of
	{				// reverse works also on atoms; they are returned unchanged.
		typedef IF<ATOM<X>::RET,X,intimate::_REVERSE<X,NILT>::RET>::RET RET;
	};

// Predicate functions

	template <class X>
	struct NUMBERP // is X a list?
	{
		enum { RET = X::IS_NUMBER};
	};

	template <class X>
	struct SYMBOLP // is X a symbol?
	{
		enum { RET = X::IS_SYMBOL };
	};

	template <class X>
	struct LISTP // is X a list?
	{
		enum { RET = X::IS_LIST };
	};

	template <class X>
	struct NULLP // is X an empty list?
				 // usual name is NULL - had to be changed to NULLP due the
				 // presence of NULL in C++
	{
		enum { RET = X::IS_LIST && X::IS_EMPTY };
	};

	template <class X> // 
	struct NOT // returns T is X is NILT - for negating NIL C++ operator ! must be used
	{
		enum { RET = NIL };
	};

	template<>
	struct NOT<NILT>
	{
		enum { RET = T };
	};

	template<class X>
	struct CONSP // is this a non-empty list?
	{
		enum { RET = !NULLP<X>::RET };
	};

	template <class X>
	struct ATOM // is X an atom? - The answer is T also for empty lists
	{
		enum { RET = X::IS_ATOM };
	};

	template <class S1, class S2> // private
	struct EQ	// are S1 and S2 equal symbols?
	{			
		enum { RET = (SYMBOLP<S1>::RET && SYMBOLP<S2>::RET)?(S1::ID==S2::ID):0 };
	};

	template <class N1,class N2>
	struct EQL	// are N1 and N2 equal numbers? 
	{			// EQL normally works for strings too, but we don't have strings in this
		enum { RET = (NUMBERP<N1>::RET && NUMBERP<N2>::RET)?(N1::N_VAL == N2::N_VAL):0 };
	};

	template <class X1,class X2>
	struct EQUAL
	{
		enum { RET = (LISTP<X1>::RET && LISTP<X2>::RET)
						?	EQUAL<CAR<X1>::RET,
							CAR<X2>::RET>::RET && 
							EQUAL<CDR<X1>::RET,
							CDR<X2>::RET>::RET
						:	intimate::SAME<X1,X2>::RET
			 };
	};

	template<> 
	struct EQUAL<NILT,NILT> // terminate recursion of EQUAL
	{	
		enum { RET = T };
	};

	template <class X>
	struct LENGTH	// length of the list? (strings are not supported)
	{				// different from original lisp length can be applied
					// here also to numbers and symbols, for which it returns NIL
		enum { RET = ATOM<X>::RET
						? 0
						: LISTP<CDR<X>::RET>::RET
							? LENGTH<CDR<X>::RET>::RET + 1
							: 1
							 
			 };
	};

	template<>
	struct LENGTH<NILT> // terminate recursion of LENGTH
	{
		enum { RET = 0 };
	};

	template <class X,int n> // first node is node 0!
	struct NTH	// caution: strictly following the XLISP implementation is very hard 
	{			// in case of invalid n the last node is returned; if not applied to a list returns the object itself
		typedef IF<(LENGTH<X>::RET > 0 && n > 0),
					NTH<CDR<X>::RET,(n)?n-1:NIL>::RET,
					IF<(LENGTH<X>::RET == 0),X,CAR<X>::RET>::RET
				  >::RET RET;

	};

	template<>
	struct NTH<NILT,NIL>
	{
		typedef NILT RET;
	};

	template <class X>
	struct LAST // Return the last node of a list or, if not applied to a list, the object itself
	{
		typedef NTH<X,LENGTH<X>::RET>::RET RET;
	};

	// System functions
	// ---

// Arithmetic functions
	
	template <class X1,class X2>
	struct ADD // add two numbers, in original lisp +; other than in original lisp works on any type of element
	{	
		enum { 
				N1 = X1::N_VAL,
				N2 = X2::N_VAL
			 };
		typedef NUMBERT<N1 + N2> RET;
	};

	template <class X1,class X2>
	struct SUBTRACT // subtract two numbers, in original lisp -; other than in original lisp works on any type of element
	{	
		enum { 
				N1 = X1::N_VAL,
				N2 = X2::N_VAL
			 };
		typedef NUMBERT<N1 - N2> RET;
	};

	template <class X1,class X2>
	struct MULTIPLY // multiplies two numbers, in original lisp *; other than in original lisp works on any type of element
	{	
		enum { 
				N1 = X1::N_VAL,
				N2 = X2::N_VAL
			 };
		typedef NUMBERT<N1 * N2> RET;
	};

	template <class X1,class X2>
	struct DIVIDE // divides two numbers, in original lisp /; other than in original lisp works on any type of element
	{	
		enum { 
				N1 = X1::N_VAL,
				N2 = X2::N_VAL
			 };
		typedef NUMBERT<N1 / N2> RET;
	};

// Input/Output-Functions
	
	template <class X,class SINK = ostream> // 2 deviations from lisp: symbols are preded by a quote and lists print with redundant parentheses
	struct PRINT // prints X on SINK - must be called by EXEC() since RET can't have side effects
	{	static void EXEC(SINK& sink = cout)
		{	X::print(sink);
			sink << flush;
		}
	};

	template <class X1,class X2>
	struct APPEND
	{
		typedef IF<!ATOM<X1>::RET,
					 X1::FIRST,
					 X2::FIRST
				  >::RET N;
		typedef IF<ATOM<X1>::RET,
					 NILT,
					 X1::REST
				  >::RET N1;
		typedef IF<ATOM<X1>::RET,
					 X2::REST,
					 X2
				  >::RET N2;
		typedef IF<ATOM<X1>::RET && ATOM<X2>::RET,
					 NILT,
					 CONS<N,APPEND<N1,N2>::RET>::RET
				  >::RET RET;
	};

	template<> // terminate recursion of APPEND
	struct APPEND<NILT,NILT>
	{	typedef NILT RET;
	};

// Implementations

	namespace intimate
	{
		template <class X,class Rev>
		struct _REVERSE
		{	
			typedef CONS<X::FIRST,Rev> REV;

			typedef IF<(ATOM<X>::RET || ATOM<X::REST>::RET),
						 REV,
						 _REVERSE<IF<ATOM<X::REST>::RET,NILT,X::REST>::RET,
									 IF<ATOM<X::REST>::RET,NILT,REV>::RET>::RET
					  >::RET RET;
		};

		template<>
		struct _REVERSE<NILT,NILT> // terminate recursion of _REVERSE
		{	
			typedef NILT RET;
		};
	} // end namespace intimate

} // end namespace metalisp

// --------------------------------------------------------------------------

// Stuff for testing:

using namespace std;

void wait()
{	char c;
	cout << endl << "Press a key and Enter to continue ..." << flush;
	cin >> c;
	cout << endl;
}

using namespace metalisp;
using namespace metactrl;

template <class EXPR>
struct Test
{	static void print()
	{	cout << "N_VAL\t\t" << EXPR::N_VAL << endl
			 << "ID\t\t" << EXPR::ID << endl
			 << "IS_NUMBER\t" << bool(EXPR::IS_NUMBER) << endl
			 << "IS_SYMBOL\t" << bool(EXPR::IS_SYMBOL) << endl
			 <<	"IS_ATOM\t\t" << bool(EXPR::IS_ATOM) << endl
			 << "IS_LIST\t\t" << bool(EXPR::IS_LIST) << endl
			 << "IS_EMPTY\t" << bool(EXPR::IS_EMPTY) << endl;
		wait();
	}
	static void predicates()
	{	cout << "NUMBERP\t" << bool(NUMBERP<EXPR>::RET) << endl
			 << "SYMBOL\t" << bool(SYMBOLP<EXPR>::RET) << endl
			 << "LISTP\t" << bool(LISTP<EXPR>::RET) << endl
			 << "NULLP\t" << bool(NULLP<EXPR>::RET) << endl
			 << "ATOM\t" << bool(ATOM<EXPR>::RET) << endl;
		wait(); 
	}
	template <class X2>
	struct eq
	{	static void print()
		{	cout << "(EQ " << EXPR::name() << " " << X2::name() << ") -> " 
				 << bool(EQ<EXPR,X2>::RET) << endl;
		}
	};
	template <class X2>
	struct eql
	{	static void print()
		{	cout << "(EQL " << EXPR::name() << " " << X2::name() << ") -> " 
				 << bool(EQL<EXPR,X2>::RET) << endl;
		}
	};
	template <class X2>
	struct _equal
	{	static void print()
		{	cout << "(EQUAL " << EXPR::name() << " " << X2::name() << ") -> " 
				 << bool(EQUAL<EXPR,X2>::RET) << endl;
		}
	};
};

// some types

	typedef NUMBERT<99> number_99;
	typedef SYMBOLT<void,42> symbol_void_42;
	typedef LISTT empty_list;
	typedef CONS<number_99,symbol_void_42> cons_number_99_symbol_void_42;
	typedef CONS<CONS<NUMBERT<2>,SYMBOLT<void,2> >,CONS<SYMBOLT<int,3>,CONS<NUMBERT<3>,NUMBERT<4> > > > complex_cons;
	typedef CONS<NUMBERT<1>,CONS<NUMBERT<2>,CONS<NUMBERT<3>,NILT> > > pretty_list;
	typedef LIST<NUMBERT<1>,LIST<NUMBERT<2>,LIST<NUMBERT<3> > > > same_as_pretty_list;

// type mapping

template <int no>
struct type 
{};

template<>
struct type<0>
{	typedef number_99 RET;
};

template<>
struct type<1>
{	typedef symbol_void_42 RET;
};

template<>
struct type<2>
{	typedef empty_list RET;
};

template<>
struct type<3>
{	typedef cons_number_99_symbol_void_42 RET;
};

template<>
struct type<4>
{	typedef complex_cons RET;
};

// checking eq's

struct eq_check
{	template <int i>
	struct Code
	{	struct innerLoop
		{	template <int j>
			struct Code
			{	static void execute()
				{	Test<type<i>::RET>::eq<type<j>::RET>::print();
				}
			};
		};
		static void execute()
		{	FOR<0,Less,5,+1,innerLoop>::EXEC();
		}
	};
};
		
struct eql_check
{	template <int i>
	struct Code
	{	struct innerLoop
		{	template <int j>
			struct Code
			{	static void execute()
				{	Test<type<i>::RET>::eql<type<j>::RET>::print();
				}
			};
		};
		static void execute()
		{	FOR<0,Less,5,+1,innerLoop>::EXEC();
		}
	};
};
		
struct equal_check
{	template <int i>
	struct Code
	{	struct innerLoop
		{	template <int j>
			struct Code
			{	static void execute()
				{	Test<type<i>::RET>::_equal<type<j>::RET>::print();
				}
			};
		};
		static void execute()
		{	FOR<0,Less,5,+1,innerLoop>::EXEC();
		}
	};
};

struct length_check
{	template <int i>
	struct Code
	{	static void execute()
		{	cout << type<i>::RET::name() << '\t' << LENGTH<type<i>::RET>::RET << endl;
		}
	};
};

struct nth_check
{	template <int i>
	struct Code
	{	struct innerLoop
		{	template <int j>
			struct Code
			{	static void execute()
				{	cout << NTH<type<i>::RET,j>::RET::name() << '\t';
				}
			};
		};
		static void execute()
		{	FOR <0,Less,LENGTH<type<i>::RET>::RET+2,+1,innerLoop>::EXEC();
			cout << endl;
			wait();
		}
	};
};

struct last_check
{	template <int i>
	struct Code
	{	static void execute()
		{	cout << LAST<type<i>::RET>::RET::name() << endl;
		}
	};
};
				
struct print_check
{	template <int i>
	struct Code
	{	static void execute()
		{	PRINT<type<i>::RET>::EXEC();
			cout << endl;
		}
	};
};
				
struct reverse_check
{	template <int i>
	struct Code
	{	static void execute()
		{	PRINT<type<i>::RET>::EXEC();
			cout << " -> ";
			PRINT<REVERSE<type<i>::RET>::RET>::EXEC();
			cout << endl;
		}
	};
};
				
struct append_check
{	template <int i>
	struct Code
	{	struct innerLoop
		{	template <int j>
			struct Code
			{	static void execute()
				{	PRINT<type<i>::RET>::EXEC();
					cout << " + ";
					PRINT<type<j>::RET>::EXEC();
					cout << " -> ";
					PRINT<APPEND<type<i>::RET,type<j>::RET>::RET>::EXEC();
					cout << endl;
				}
			};
		};
		static void execute()
		{	FOR<0,Less,5,+1,innerLoop>::EXEC();
			wait();
		}
	};
};

struct consp_check
{	template <int i>
	struct Code
	{	static void execute()
		{	cout << "CONSP<";
			PRINT<type<i>::RET>::EXEC();
			cout << "> = " << CONSP<type<i>::RET>::RET << endl;
		}
	};
};
				
int main()
{	
	// Testing
	// The stuff for testing above and the tests below are in a terrible state.
	// They follow exactly the bootstrap process when developing the
	// basic types and then adding more and more functions.
	
	cout << boolalpha;

	cout << "SEXPRESSIONT" << endl;
	Test<SEXPRESSIONT>::print();
	
	cout << "number_99" << endl;
	Test<number_99>::print();
	
	cout << "symbol_void_42" << endl;
	Test<symbol_void_42>::print();
	
	cout << "empty_list" << endl;
	Test<empty_list>::print();

	cout << "cons_number_99_symbol_void_42" << endl;
	Test<cons_number_99_symbol_void_42>::print();

	cout << "CAR<cons_number_99_symbol_void_42>::RET" << endl;
	Test<CAR<cons_number_99_symbol_void_42>::RET>::print();

	cout << "CDR<cons_number_99_symbol_void_42>::RET" << endl;
	Test<CDR<cons_number_99_symbol_void_42>::RET>::print();

	cout << "Predicates for number_99" << endl;
	Test<number_99>::predicates();
	 
	cout << "Predicates for symbol_void_42" << endl;
	Test<symbol_void_42>::predicates();
	 
	cout << "Predicates for empty_list" << endl;
	Test<empty_list>::predicates();
	 
	cout << "Predicates for cons_number_99_symbol_void_42" << endl;
	Test<cons_number_99_symbol_void_42>::predicates();

	cout << "*EQ*" << endl;
	FOR<0,Less,5,+1,eq_check>::EXEC();
	wait();

	cout << "*EQL*" << endl;
	FOR<0,Less,5,+1,eql_check>::EXEC();
	wait();

	cout << "*EQUAL*" << endl;
	FOR<0,Less,5,+1,equal_check>::EXEC();
	wait();
 	
	cout << "*LENGTH*" << endl;
	FOR<0,Less,5,+1,length_check>::EXEC(); 
	wait();

	cout << "*NTH*" << endl;
	FOR<0,Less,5,+1,nth_check>::EXEC();
	wait();

	cout << "*LAST*" << endl;
	FOR<0,Less,5,+1,last_check>::EXEC();
	wait();

	cout << "*PRINT*" << endl;
	FOR<0,Less,5,+1,print_check>::EXEC();
	wait();

	cout << "*REVERSE*" << endl;
	FOR<0,Less,5,+1,reverse_check>::EXEC();
	wait();

	cout << "pretty_list" << endl;
	PRINT<pretty_list>::EXEC();
	cout << endl;

	cout << "same_as_pretty_list" << endl;
	PRINT<same_as_pretty_list>::EXEC();
	cout << endl;

	cout << "The two lists are really equal? " << EQUAL<pretty_list,same_as_pretty_list>::RET << endl;

	typedef REVERSE<pretty_list>::RET rev;
	PRINT<rev>::EXEC();
	cout << endl;

	cout << "*APPEND*" << endl;
	FOR<0,Less,5,+1,append_check>::EXEC();
	wait();
	
	typedef LIST<NUMBERT<1>,LIST<NUMBERT<2> > > A;
	typedef LIST<NUMBERT<3>,LIST<NUMBERT<4> > > B;
	PRINT<A>::EXEC();
	cout << endl;
	PRINT<B>::EXEC();
	cout << endl;
	PRINT<APPEND<A,B>::RET,ostream>::EXEC(cerr);
	cout << endl;

	cout << "*CONSP*" << endl;
	FOR<0,Less,5,+1,consp_check>::EXEC();
	wait();

	
	typedef NUMBERT<6> n1;
	typedef NUMBERT<2> n2;
	typedef NUMBERT<24> n3;

	cout << "6 + (2 + 24) = ";
	PRINT<ADD<n1,ADD<n2,n3>::RET>::RET>::EXEC();
	cout << endl;
	cout << "24 - (6 - 1) = ";
	PRINT<SUBTRACT<n3,SUBTRACT<n1,n2>::RET>::RET>::EXEC();
	cout << endl;
	cout << "6 * (2 * 24) = ";
	PRINT<MULTIPLY<n1,MULTIPLY<n2,n3>::RET>::RET>::EXEC();
	cout << endl; 
	cout << "24 / (6 / 2) = ";
	PRINT<DIVIDE<n3,DIVIDE<n1,n2>::RET>::RET>::EXEC();
	cout << endl;

	typedef LIST<SYMBOLT<bool,0>,LIST<SYMBOLT<char,1>,
	             LIST<SYMBOLT<int,2>,LIST<SYMBOLT<long,3> > > > > part_1;
	typedef LIST<SYMBOLT<float,4>,LIST<SYMBOLT<double,5> > > part_2;
	typedef APPEND<part_1,part_2>::RET all_types;

	PRINT<part_1>::EXEC();
	cout << " + ";
	PRINT<part_2>::EXEC();
	cout << " -> ";
	PRINT<all_types>::EXEC();
	cout << endl;		

	return 0;
}