anchor.diff:  struct tuple;
   
   template <typename Tuple, int N>
  -struct tuple_type;
  +struct tuple_element;
   
   template <typename Tuple, int N>
  -struct const_tuple_type;
  +struct const_tuple_element;
   
   template <typename T>
  -struct tuple_element {
  +struct tuple_type {
   	typedef T type;
  -	tuple_element(T& x) : _x(x) {}
  -	type& get() { return _x; }
  -	const type& get() const { return _x; }
  -private:
  -	type& _x;
  +	typedef T value_type;
  +	typedef T& reference;
  +	typedef const T& const_reference;
  +	typedef const T& transparent_reference;
   };
   
   template <typename T>
  -struct const_tuple_element {
  +struct tuple_type<T&> {
   	typedef T type;
  -	const_tuple_element(const T& x) : _x(x) {}
  -	const type& get() const { return _x; }
  -private:
  -	const type& _x;
  +	typedef T& value_type;
  +	typedef T& reference;
  +	typedef const T& const_reference;
  +	typedef T& transparent_reference;
  +};
  +
  +template <typename T>
  +struct tuple_type<const T&> {
  +	typedef T type;
  +	typedef T& value_type;
  +	typedef T& reference;
  +	typedef const T& const_reference;
  +	typedef const T& transparent_reference;
   };
   
   
   <%0.upto(GENERATION_LIMIT) {|i|%>
   <%0.upto(i) {|j|%>
   template <typename A0<%1.upto(i) {|k|%>, typename A<%=k%><%}%>>
  -struct tuple_type<tuple<A0<%1.upto(i) {|k|%>, A<%=k%><%}%>>, <%=j%>> : tuple_element<A<%=j%>> {
  -	tuple_type(tuple<A0<%1.upto(i) {|k|%>, A<%=k%> <%}%>>& x) : tuple_element<A<%=j%>>(x.a<%=j%>) {}
  +struct tuple_element<tuple<A0<%1.upto(i) {|k|%>, A<%=k%><%}%>>, <%=j%>> : tuple_type<A<%=j%>> {
  +	tuple_element(tuple<A0<%1.upto(i) {|k|%>, A<%=k%> <%}%>>& x) : _x(x.a<%=j%>) {}
  +	typename tuple_type<A<%=j%>>::reference get() { return _x; }
  +	typename tuple_type<A<%=j%>>::const_reference get() const { return _x; }
  +private:
  +	typename tuple_type<A<%=j%>>::reference _x;
   };
   <%}%>
   <%}%>
  
positive.code: <%0.upto(GENERATION_LIMIT) {|i|%>
  <%0.upto(i) {|j|%>
  template <typename A0<%1.upto(i) {|k|%>, typename A<%=k%><%}%>>
  struct const_tuple_type<tuple<A0<%1.upto(i) {|k|%>, A<%=k%><%}%>>, <%=j%>> : const_tuple_element<A<%=j%>> {
  	const_tuple_type(const tuple<A0<%1.upto(i) {|k|%>, A<%=k%><%}%>>& x) : const_tuple_element<A<%=j%>>(x.a<%=j%>) {}
  };
  <%}%>
  <%}%>
  
negative.code: 
  <%0.upto(GENERATION_LIMIT) {|i|%>
  template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
  tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_tuple(typename tuple_type<A0>::transparent_reference a0<%1.upto(i) {|j|%>, typename tuple_type<A<%=j%>>::transparent_reference a<%=j%><%}%>)
  {
  	return tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>);
  }
  