Index: polemy/eval.d
==================================================================
--- polemy/eval.d
+++ polemy/eval.d
@@ -258,34 +258,74 @@
 			this(Fun ast, Table defCtx) { this.ast=ast; this.defCtx=defCtx; }
 			override string toString() const
 				{ return sprintf!"(function:%x:%x)"(cast(void*)ast, cast(void*)defCtx); }
 			override int opCmp(Object rhs) {
 				if(auto r = cast(UserDefinedFunValue)rhs) {
-					auto a = cast(void*)this.ast;
-					auto b = cast(void*)r.ast;
-					if(a<b) return -1;
-					if(a>b) return +1; // [TODO] avoid using pointer value...
-					return this.defCtx.opCmp(r.defCtx);
+					if(auto c = typeid(void*).compare(cast(void*)ast, cast(void*)r.ast))
+						return c;
+					if(auto c = typeid(void*).compare(cast(void*)defCtx, cast(void*)r.defCtx))
+						return c;
+					return 0;// [TODO] avoid using pointer value...
 				}
 				if(auto r = cast(Value)rhs) return typeid(this).opCmp(typeid(r));
 				throw genex!RuntimeException("comparison with value and something other");
 			}
-			mixin SimpleToHash;
+			override hash_t toHash() {
+				return (cast(hash_t)cast(void*)ast) + (cast(hash_t)cast(void*)defCtx);
+			}
 
-			AST afterMacroAST;
+			AST macroCache;
+			static class MemokeyType
+			{
+				void* a; Layer b; Tuple!(string,Layer,Value)[] c;
+				hash_t toHash() {
+					hash_t h = structuralHash(a) + structuralHash(b);
+					foreach(e; c)
+						h += structuralHash(e[0])+structuralHash(e[1])+structuralHash(e[2]);
+					return h;
+				}
+				mixin SimpleToString;
+				mixin SimpleConstructor;
+				mixin SimpleCompareWithoutToHash;
+			}
+			static Tuple!(Value,int)[MemokeyType] memo;
+
 			override Value invoke(Layer lay, Table ctx, LexPosition pos)
 			{
 				if( isASTLayer(lay) )
 					return eval(ast.funbody, lay, ctx);
-				if( afterMacroAST is null )
+
+				auto nonMemoizedRun = (){
+					if( macroCache is null )
+					{
+						auto va = macroAndEval(e.funbody, lay, ctx);
+						macroCache = va[1];
+						return va[0];
+					}
+					else
+						return eval(macroCache, lay, ctx);
+				};
+
+				if( !isUserDefinedLayer(lay) )
+					return nonMemoizedRun();
+
+				MemokeyType memokey = new MemokeyType(cast(void*)ast, lay, ctx.direct_entries());
+
+				if(auto p = memokey in memo)
 				{
-					auto va = macroAndEval(e.funbody, lay, ctx);
-					afterMacroAST = va[1];
-					return va[0];
+					(*p)[1] ++;
+					return (*p)[0];
 				}
 				else
-					return eval(afterMacroAST, lay, ctx);
+					memo[memokey] = tuple(lift(new UndefinedValue, lay, ctx, pos), 0);
+
+				Value r = nonMemoizedRun();
+
+				int touched = memo[memokey][1];
+				memo[memokey] = tuple(r, 12345678);
+				//if(touched) {DBG("rerun :: ",r);r = nonMemoizedRun();} // twice!!
+				return r;
 			}
 		}
 		return new UserDefinedFunValue(e,ctx);
 	}
 
@@ -302,11 +342,13 @@
 			override int opCmp(Object rhs) {
 				if(auto r = cast(NativeFunValue)rhs) return typeid(typeof(dg)).compare(&dg,&r.dg);
 				if(auto r = cast(Value)rhs)          return typeid(this).opCmp(typeid(r));
 				throw genex!RuntimeException("comparison with value and something other");
 			}
-			mixin SimpleToHash;
+			override hash_t toHash() const {
+				return typeid(dg).getHash(&dg);
+			}
 
 			R delegate(T) dg;
 			Parameter[] params_data;
 
 			this(R delegate(T) dg)

Index: polemy/failure.d
==================================================================
--- polemy/failure.d
+++ polemy/failure.d
@@ -51,14 +51,14 @@
 	LexPosition pos;
 	this( LexPosition pos, string msg, string file=null, size_t line=0, Throwable next=null )
 	{
 		string fullmsg = pos is null ? sprintf!("\n[??] %s")(msg)
 		                             : sprintf!("\n[%s] %s")(pos, msg);
-		for(int i=0; i<callstack_pos.length || i<callstack_msg.length; ++i)
+		foreach_reverse(i,_; callstack_pos)
 		{
-			LexPosition p = (i<callstack_pos.length ? callstack_pos[i] : null);
-			string      m = (i<callstack_msg.length ? callstack_msg[i] : null);
+			LexPosition p = callstack_pos[i];
+			string      m = callstack_msg[i];
 			fullmsg ~= p is null ? sprintf!("\n[??] %s")(m)
 		                         : sprintf!("\n[%s] %s")(p, m);
 		}
 		super(fullmsg, file, line, next);
 		this.pos = pos;

Index: polemy/value.d
==================================================================
--- polemy/value.d
+++ polemy/value.d
@@ -20,13 +20,13 @@
 ///
 class IntValue : Value
 {
 	BigInt data;
 
-	this(bool n) { this.data = n?1:0; }
-	this(int n) { this.data = n; }
-	this(long n) { this.data = n; }
+	this(bool n)   { this.data = n?1:0; }
+	this(int n)    { this.data = n; }
+	this(long n)   { this.data = n; }
 	this(BigInt n) { this.data = n; }
 	this(string n) { this.data = BigInt(n); }
 	override string toString() const { return toDecimalString(cast(BigInt)data); }
 	override int opCmp(Object rhs) {
 		if(auto r = cast(IntValue)rhs) return data.opCmp(r.data);
@@ -81,26 +81,29 @@
 	enum Kind {PropagateSet, NotPropagateSet};
 
 	this( Table proto=null, Kind k = Kind.PropagateSet )
 		{ this.prototype = proto; this.kind = k; }
 
+	/// Set the value v to the index i of layer lay
 	void set(string i, Layer lay, Value v)
 	{
 		if( setIfExist(i, lay, v) )
 			return;
 		data[i][lay] = v;
 	}
 
+	/// True if index i has value in layer lay
 	bool has(string i, Layer lay) const
 	{
 		if( i in data )
 			return !!(lay in data[i]);
 		if( prototype is null )
 			return false;
 		return prototype.has(i, lay);
 	}
 	
+	/// Return the value of index i at layer lay. Throws if it is not set
 	Value get(string i, Layer lay, LexPosition pos=null)
 	{
 		if( i in data ) {
 			// [TODO] consider forwarding to proto also in this case
 			if( lay !in data[i] )
@@ -110,10 +113,12 @@
 		if( prototype is null )
 			throw genex!RuntimeException(pos, sprintf!"'%s' not found in %s layer"(i,lay));
 		return prototype.get(i, lay, pos);
 	}
 
+	/// t.access!T(lay,a,b,...) returns t.get(a,lay).get(b,lay).... if exists
+	/// and has type T. Returns null otherwise
 	T access(T,S...)( Layer lay, string path, S rest )
 	{
 		static if( rest.length == 0 )
 		{
 			if( this.has(path, lay) )
@@ -125,42 +130,10 @@
 				return next.access!T(lay,rest);
 		}
 		return null;
 	}
 
-	string toStringWithoutParen() const
-	{
-		string result;
-		bool first = true;
-		foreach(k, l2d; data)
-			foreach(l,d; l2d)
-			{
-				if(first) first=false; else result~=", ";
-				result ~= k;
-				if( l.empty )
-					result ~= "(emptylayer)";
-				else if( l != ValueLayer )
-					result ~= l;
-				result ~= ":";
-				result ~= text(cast(Value)d);
-			}
-		if( prototype !is null )
-		{
-			result ~= " / ";
-			result ~= prototype.toStringWithoutParen();
-		}
-		return result;
-	}
-
-	string toString()
-	{
-		if( isList() )
-			return text(toList());
-		return "{" ~ toStringWithoutParen() ~ "}";
-	}
-
-public:
 	/// Is this an empty table?
 	bool empty()
 	{
 		return data.length==0 && (prototype is null || prototype.empty);
 	}
@@ -192,15 +165,107 @@
 		}
 		if( t.empty )
 			return result;
 		throw genex!RuntimeException("this table is not a cons-list");
 	}	
+
+	/// Get the list of direct entries ignoring prototypes in sorted order
+	Tuple!(string,Layer,Value)[] direct_entries()
+	{
+		Tuple!(string,Layer,Value)[] arr;
+		foreach(k, l2d; data)
+			foreach(l,d; l2d)
+				arr ~= tuple(k,l,d);
+		arr.sort();
+		return arr;
+	}
+	
+	/// Get the whole list of observable entries in unspecified order
+	Tuple!(string,Layer,Value)[] entries()
+	{
+		bool[string] hidden;
+		Tuple!(string,Layer,Value)[] arr;
+		enumerateEntries(hidden, arr);
+		return arr;
+	}
+
+	private void enumerateEntries( ref bool[string] hidden, ref Tuple!(string,Layer,Value)[] arr )
+	{
+		foreach(k, l2d; data)
+			if( k !in hidden )
+			{
+				foreach(l,d; l2d)
+					arr ~= tuple(k,l,d);
+				hidden[k] = true;
+			}
+		if(prototype !is null)
+			prototype.enumerateEntries(hidden, arr);
+	}
+
+	override string toString()
+	{
+		if( isList() )
+			return text(toList());
+		return "{" ~ toStringWithoutParen() ~ "}";
+	}
+
+	override int opCmp(Object rhs)
+	{
+		if(auto r = cast(Table)rhs) {
+			Tuple!(string,Layer,Value)[] ls = this.entries();
+			Tuple!(string,Layer,Value)[] rs = r.entries();
+			if( ls.length != rs.length )
+				return (ls.length < rs.length ? -1 : +1);
+			ls.sort();
+			rs.sort();
+			foreach(i,_; ls)
+				if(auto c = ls[i].opCmp(rs[i]))
+					return c;
+			return 0;
+		}
+		if(auto r = cast(Value)rhs) return typeid(this).opCmp(typeid(r));
+		throw genex!RuntimeException("comparison with value and somithing other");
+	}
+
+	override hash_t toHash()
+	{
+		Tuple!(string,Layer,Value)[] ls = this.entries();
+		ls.sort();
+		hash_t h;
+		foreach(e; ls)
+			h += structuralHash(e[0])+structuralHash(e[1])+structuralHash(e[2]);
+		return h;
+	}
 
 private:
 	Table                prototype;
 	Kind                 kind;
 	Value[Layer][string] data;
+
+	string toStringWithoutParen() const
+	{
+		string result;
+		bool first = true;
+		foreach(k, l2d; data)
+			foreach(l,d; l2d)
+			{
+				if(first) first=false; else result~=", ";
+				result ~= k;
+				if( l.empty )
+					result ~= "(emptylayer)";
+				else if( l != ValueLayer )
+					result ~= l;
+				result ~= ":";
+				result ~= text(cast(Value)d);
+			}
+		if( prototype !is null )
+		{
+			result ~= " / ";
+			result ~= prototype.toStringWithoutParen();
+		}
+		return result;
+	}
 
 	bool setIfExist(string i, Layer lay, Value v)
 	{
 		if( i in data )
 		{

Index: sample/type.pmy
==================================================================
--- sample/type.pmy
+++ sample/type.pmy
@@ -22,5 +22,12 @@
 };
 
 @type "if" = fun(c,t,e) {@value(
  if(@type(c)=="int" ): mergeType(@type(t()), @type(e())) else : "error"
 )};
+
+def fib(x)
+{
+	if x<2 then 1 else fib(x-1) + fib(x-2)
+};
+
+print( @type(fib(10)) );

Index: tricks/tricks.d
==================================================================
--- tricks/tricks.d
+++ tricks/tricks.d
@@ -97,63 +97,96 @@
 	//   but it fails because Tomp takes (int,string,real).
 	assert( !__traits(compiles, {
 		class Tamp : Tomp { mixin SimpleConstructor; }
 	}) );
 }
+
+hash_t structuralHash(T)(T x)
+{
+	alias SC_Unqual!(T) UCT;
+
+	static if(is(UCT == class))
+		return (cast(UCT)x).toHash();
+	else
+	static if(SC_HasGoodHash!(UCT))
+		{ return typeid(UCT).getHash(&x); }
+	else
+	static if(is(UCT T == T[]))
+		{ hash_t h; foreach(e; x) h+=structuralHash(e); return h; }
+	else
+	static if(is(UCT == struct))
+		static if(__traits(compiles, std.bigint.BigInt))
+			static if(is(UCT == std.bigint.BigInt))
+				return cast(hash_t) x.toInt();
+			else
+				static assert(false, "should not use struct.toHash");
+		else
+			static assert(false, "should not use struct.toHash");
+	else
+		static assert(false, "nonhashable datatype "~UCT.stringof);
+}
+
+alias std.traits.Unqual SC_Unqual;
+
+template SC_HasGoodHash(T)
+{
+	enum SC_HasGoodHash =
+		is(T : bool) || isNumeric!(T) || isSomeString!(T) || isSomeChar!(T) || isPointer!(T);
+}
 
 /// Mixing-in the MOST-DERIVED-member-wise comparator for a class
+/// BE SURE THAT THIS IS CONSISTENT WITH opCmp and opEquals
 
 template SimpleToHash()
 {
 	override hash_t toHash() const /// member-by-member hash
 	{
 		hash_t h = 0;
 		foreach(mem; this.tupleof)
-			h += typeid(mem).getHash(&mem);
+			h += structuralHash(mem);
 		return h;
 	}
 }
 
 /// Mixing-in the MOST-DERIVED-member-wise comparator for a class
+
+template SimpleCompareWithoutToHash()
+{
+	override bool opEquals(Object rhs) const /// member-by-member equality
+	{
+		return opCmp(rhs) == 0;
+	}
+
+	override int opCmp(Object rhs_) const /// member-by-member compare
+	{
+		if( rhs_ is null )
+			return -1;
+		if( auto rhs = cast(typeof(this))rhs_ )
+		{
+			foreach(i,_; this.tupleof)
+			{
+				static if(is(typeof(_) == struct))
+					auto c = (cast(SC_Unqual!(typeof(_)))this.tupleof[i]).opCmp(rhs.tupleof[i]);
+				else
+					auto c = typeid(_).compare(&this.tupleof[i],&rhs.tupleof[i]);
+				if(c)
+					return c;
+			}
+			return 0;
+		}
+		return typeid(this).opCmp(typeid(rhs_));
+	}
+}
 
+/// Mixing-in the MOST-DERIVED-member-wise comparator for a class
+
 /*mixin*/
 template SimpleCompare()
 {
-	override bool opEquals(Object rhs_) const /// member-by-member equality
-	{
-		if( auto rhs = cast(typeof(this))rhs_ )
-		{
-			foreach(i,_; this.tupleof)
-				if( this.tupleof[i] != (cast(const)rhs).tupleof[i] )
-					return false;
-			return true;
-		}
-		assert(false, sprintf!"Cannot compare %s with %s"(typeid(this), typeid(rhs_)));
-	}
-
-	mixin SimpleToHash;
-
-	override int opCmp(Object rhs_) const /// member-by-member compare
-	{
-		if( auto rhs = cast(typeof(this))rhs_ )
-		{
-			foreach(i,_; this.tupleof)
-				if( this.tupleof[i] != (cast(const)rhs).tupleof[i] ) {
-					auto a = (cast(SC_Unqual!(typeof(this)))this).tupleof[i];
-					auto b =  rhs.tupleof[i];
-					return a < b ? -1 : +1;
-				}
-// not work well for structures???????
-//				if(auto c = typeid(_).compare(&this.tupleof[i],&rhs.tupleof[i]))
-//					return c;
-			return 0;
-		}
-		assert(false, sprintf!"Cannot compare %s with %s"(typeid(this), typeid(rhs_)));
-	}
+	mixin SimpleToHash;
+	mixin SimpleCompareWithoutToHash;
 }
-
-alias std.traits.Unqual SC_Unqual;
 
 unittest
 {
 	class Temp
 	{
@@ -175,12 +208,12 @@
 		int x;
 		string y;
 		mixin SimpleConstructor;
 		mixin SimpleCompare;
 	}
-	assert_throw!AssertError( new Temp(1,"foo") == new TempDummy(1,"foo") );
-	assert_throw!AssertError( new Temp(1,"foo") <= new TempDummy(1,"foo") );
+	assert_ne( new Temp(1,"foo"), new TempDummy(1,"foo") );
+	assert_nothrow( new Temp(1,"foo") <= new TempDummy(1,"foo") );
 }
 
 /// Mixing-in a simple toString method
 
 /*mixin*/
@@ -224,11 +257,11 @@
 	mixin SimpleConstructor;
 	mixin SimpleCompare;
 	mixin SimpleToString;
 }
 
-/// Will be used for dynamic overload resolution pattern
+/// Utility
 
 template firstParam(T)
 {
 	alias ParameterTypeTuple!(T)[0] firstParam;
 }