Index: src/ResolvExpr/ConversionCost.cc
===================================================================
--- src/ResolvExpr/ConversionCost.cc	(revision a493682c6f60f330bbd63c42c5956da658ce185f)
+++ src/ResolvExpr/ConversionCost.cc	(revision b46e3bd5b2d8744c0e03f9a699c26f6faa6d35bb)
@@ -23,4 +23,8 @@
 	const Cost Cost::zero = Cost( 0, 0, 0 );
 	const Cost Cost::infinity = Cost( -1, -1, -1 );
+	const Cost Cost::unsafe = Cost( 1, 0, 0 );
+	const Cost Cost::poly = Cost( 0, 1, 0 );
+	const Cost Cost::safe = Cost( 0, 0, 1 );
+
 
 	Cost conversionCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
Index: src/ResolvExpr/Cost.h
===================================================================
--- src/ResolvExpr/Cost.h	(revision a493682c6f60f330bbd63c42c5956da658ce185f)
+++ src/ResolvExpr/Cost.h	(revision b46e3bd5b2d8744c0e03f9a699c26f6faa6d35bb)
@@ -5,5 +5,5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Cost.h -- 
+// Cost.h --
 //
 // Author           : Richard C. Bilson
@@ -23,10 +23,10 @@
 	  public:
 		Cost();
-		Cost( int unsafe, int poly, int safe );
-  
+		Cost( int unsafeCost, int polyCost, int safeCost );
+
 		void incUnsafe( int inc = 1 );
 		void incPoly( int inc = 1 );
 		void incSafe( int inc = 1 );
-  
+
 		Cost operator+( const Cost &other ) const;
 		Cost operator-( const Cost &other ) const;
@@ -36,70 +36,74 @@
 		bool operator!=( const Cost &other ) const;
 		friend std::ostream &operator<<( std::ostream &os, const Cost &cost );
-  
+
 		static const Cost zero;
 		static const Cost infinity;
+		static const Cost unsafe;
+		static const Cost poly;
+		static const Cost safe;
 	  private:
 		int compare( const Cost &other ) const;
 
-		int unsafe;
-		int poly;
-		int safe;
+		int unsafeCost;
+		int polyCost;
+		int safeCost;
 	};
 
-	inline Cost::Cost() : unsafe( 0 ), poly( 0 ), safe( 0 ) {}
+	inline Cost::Cost() : unsafeCost( 0 ), polyCost( 0 ), safeCost( 0 ) {}
 
-	inline Cost::Cost( int unsafe, int poly, int safe ) : unsafe( unsafe ), poly( poly ), safe( safe ) {}
+	inline Cost::Cost( int unsafeCost, int polyCost, int safeCost ) : unsafeCost( unsafeCost ), polyCost( polyCost ), safeCost( safeCost ) {}
 
 	inline void Cost::incUnsafe( int inc ) {
-		unsafe += inc;
+		unsafeCost += inc;
 	}
 
 	inline void Cost::incPoly( int inc ) {
-		poly += inc;
+		polyCost += inc;
 	}
 
 	inline void Cost::incSafe( int inc ) {
-		safe += inc;
+		safeCost += inc;
 	}
 
 	inline Cost Cost::operator+( const Cost &other ) const {
-		return Cost( unsafe + other.unsafe, poly + other.poly, safe + other.safe );
+		return Cost( unsafeCost + other.unsafeCost, polyCost + other.polyCost, safeCost + other.safeCost );
 	}
 
 	inline Cost Cost::operator-( const Cost &other ) const {
-		return Cost( unsafe - other.unsafe, poly - other.poly, safe - other.safe );
+		return Cost( unsafeCost - other.unsafeCost, polyCost - other.polyCost, safeCost - other.safeCost );
 	}
 
 	inline Cost &Cost::operator+=( const Cost &other ) {
-		unsafe += other.unsafe;
-		poly += other.poly;
-		safe += other.safe;
+		unsafeCost += other.unsafeCost;
+		polyCost += other.polyCost;
+		safeCost += other.safeCost;
 		return *this;
 	}
 
 	inline bool Cost::operator<( const Cost &other ) const {
-	    if ( *this == infinity ) return false;
-	    if ( other == infinity ) return true;
-	    if ( unsafe > other.unsafe ) {
+		if ( *this == infinity ) return false;
+		if ( other == infinity ) return true;
+
+		if ( unsafeCost > other.unsafeCost ) {
 			return false;
-	    } else if ( unsafe < other.unsafe ) {
+		} else if ( unsafeCost < other.unsafeCost ) {
 			return true;
-	    } else if ( poly > other.poly ) {
+		} else if ( polyCost > other.polyCost ) {
 			return false;
-	    } else if ( poly < other.poly ) {
+		} else if ( polyCost < other.polyCost ) {
 			return true;
-	    } else if ( safe > other.safe ) {
+		} else if ( safeCost > other.safeCost ) {
 			return false;
-	    } else if ( safe < other.safe ) {
+		} else if ( safeCost < other.safeCost ) {
 			return true;
-	    } else {
+		} else {
 			return false;
-	    } // if
+		} // if
 	}
 
 	inline bool Cost::operator==( const Cost &other ) const {
-		return unsafe == other.unsafe
-			&& poly == other.poly
-			&& safe == other.safe;
+		return unsafeCost == other.unsafeCost
+			&& polyCost == other.polyCost
+			&& safeCost == other.safeCost;
 	}
 
@@ -109,5 +113,5 @@
 
 	inline std::ostream &operator<<( std::ostream &os, const Cost &cost ) {
-		os << "( " << cost.unsafe << ", " << cost.poly << ", " << cost.safe << " )";
+		os << "( " << cost.unsafeCost << ", " << cost.polyCost << ", " << cost.safeCost << " )";
 		return os;
 	}