Index: src/Common/utility.h
===================================================================
--- src/Common/utility.h	(revision 2c1873785c86a3090205e2dd10829b87c86b12cd)
+++ src/Common/utility.h	(revision fbecee54da078ee561a27cf4314fabc5a3252a5a)
@@ -26,4 +26,5 @@
 #include <string>
 #include <type_traits>
+#include <utility>
 
 #include <cassert>
@@ -462,4 +463,38 @@
 std::pair<long long int, bool> eval(Expression * expr);
 
+// -----------------------------------------------------------------------------
+/// Reorders the input range in-place so that the minimal-value elements according to the 
+/// comparator are in front; 
+/// returns the iterator after the last minimal-value element.
+template<typename Iter, typename Compare>
+Iter sort_mins( Iter begin, Iter end, Compare& lt ) {
+	if ( begin == end ) return end;
+	
+	Iter min_pos = begin;
+	for ( Iter i = begin + 1; i != end; ++i ) {
+		if ( lt( *i, *min_pos ) ) {
+			// new minimum cost; swap into first position
+			min_pos = begin;
+			std::iter_swap( min_pos, i );
+		} else if ( ! lt( *min_pos, *i ) ) {
+			// duplicate minimum cost; swap into next minimum position
+			++min_pos;
+			std::iter_swap( min_pos, i );
+		}
+	}
+	return ++min_pos;
+}
+
+template<typename Iter, typename Compare>
+inline Iter sort_mins( Iter begin, Iter end, Compare&& lt ) {
+	return sort_mins( begin, end, lt );
+}
+
+/// sort_mins defaulted to use std::less
+template<typename Iter>
+inline Iter sort_mins( Iter begin, Iter end ) {
+	return sort_mins( begin, end, std::less<typename std::iterator_traits<Iter>::value_type>{} );
+}
+
 // Local Variables: //
 // tab-width: 4 //
Index: src/ResolvExpr/AlternativeFinder.cc
===================================================================
--- src/ResolvExpr/AlternativeFinder.cc	(revision 2c1873785c86a3090205e2dd10829b87c86b12cd)
+++ src/ResolvExpr/AlternativeFinder.cc	(revision fbecee54da078ee561a27cf4314fabc5a3252a5a)
@@ -254,6 +254,7 @@
 			SemanticError( expr, "No reasonable alternatives for expression " );
 		}
-		if ( mode.resolveAssns ) {
+		if ( mode.resolveAssns || mode.prune ) {
 			// trim candidates just to those where the assertions resolve
+			// - necessary pre-requisite to pruning
 			AltList candidates;
 			for ( unsigned i = 0; i < alternatives.size(); ++i ) {
Index: src/ResolvExpr/ResolveAssertions.cc
===================================================================
--- src/ResolvExpr/ResolveAssertions.cc	(revision 2c1873785c86a3090205e2dd10829b87c86b12cd)
+++ src/ResolvExpr/ResolveAssertions.cc	(revision fbecee54da078ee561a27cf4314fabc5a3252a5a)
@@ -18,4 +18,5 @@
 #include <cassert>                // for assertf
 #include <list>                   // for list
+#include <unordered_map>          // for unordered_map
 #include <utility>                // for move
 #include <vector>                 // for vector
@@ -23,4 +24,5 @@
 #include "Alternative.h"          // for Alternative, AssertionItem
 #include "Common/FilterCombos.h"  // for filterCombos
+#include "Common/utility.h"       // for sort_mins
 #include "SymTab/Indexer.h"       // for Indexer
 #include "TypeEnvironment.h"      // for TypeEnvironment, etc.
@@ -125,4 +127,36 @@
 	};
 
+	/// Comparator for CandidateEnvMerger outputs that sums their costs and caches the stored 
+	/// sums
+	struct CandidateCost {
+		using Element = CandidateEnvMerger::OutType;
+	private:
+		using Memo = std::unordered_map<const Element*, Cost>;
+		mutable Memo cache;              ///< cache of element costs
+		const SymTab::Indexer& indexer;  ///< Indexer for costing
+
+	public:
+		CandidateCost( const SymTab::Indexer& indexer ) : indexer(indexer) {}
+
+		/// reports the cost of an element
+		Cost get( const Element& x ) const {
+			Memo::const_iterator it = cache.find( &x );
+			if ( it == cache.end() ) {
+				Cost k = Cost::zero;
+				for ( const auto& assn : x.assns ) {
+					k += computeConversionCost( 
+						assn.match.adjType, assn.decl->get_type(), indexer, x.env );
+				}
+				it = cache.emplace_hint( it, &x, k );
+			}
+			return it->second;
+		}
+		
+		/// compares elements by cost
+		bool operator() ( const Element& a, const Element& b ) const {
+			return get( a ) < get( b );
+		}
+	};
+
 	/// Flag for state iteration
 	enum IterateFlag { IterateState };
@@ -275,10 +309,14 @@
 					}
 				} else {
-					// resolve deferred assertions by mutual compatibility
+					// resolve deferred assertions by mutual compatibility and sort by cost
 					std::vector<CandidateEnvMerger::OutType> compatible = filterCombos(
 						resn.deferred, 
 						CandidateEnvMerger{ resn.alt.env, resn.alt.openVars, resn.indexer } );
+					auto lmin = sort_mins( compatible.begin(), compatible.end(), 
+						CandidateCost{resn.indexer} );
 					
-					for ( auto& compat : compatible ) {
+					// for ( auto& compat : compatible ) {
+					for ( auto it = compatible.begin(); it != lmin ; ++it ) {
+						auto& compat = *it;
 						ResnState new_resn = resn;
 
Index: src/ResolvExpr/typeops.h
===================================================================
--- src/ResolvExpr/typeops.h	(revision 2c1873785c86a3090205e2dd10829b87c86b12cd)
+++ src/ResolvExpr/typeops.h	(revision fbecee54da078ee561a27cf4314fabc5a3252a5a)
@@ -72,4 +72,8 @@
 	Cost conversionCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env );
 
+	// in AlternativeFinder.cc
+	Cost computeConversionCost( Type *actualType, Type *formalType, 
+		const SymTab::Indexer &indexer, const TypeEnvironment &env );
+
 	// in PtrsAssignable.cc
 	int ptrsAssignable( Type *src, Type *dest, const TypeEnvironment &env );