Index: src/ResolvExpr/AlternativeFinder.cc
===================================================================
--- src/ResolvExpr/AlternativeFinder.cc	(revision b5a8ef73c79284910b1246f953b8d0bd205dbf65)
+++ src/ResolvExpr/AlternativeFinder.cc	(revision 4b6ef7029b7327923c4ddf07c1f9b0f8d4d1af9f)
@@ -564,18 +564,18 @@
 	/// State to iteratively build a match of parameter expressions to arguments
 	struct ArgPack {
-		AltList actuals;      ///< Arguments included in this pack
-		TypeEnvironment env;  ///< Environment for this pack
-		AssertionSet need;    ///< Assertions outstanding for this pack
-		AssertionSet have;    ///< Assertions found for this pack
-		OpenVarSet openVars;  ///< Open variables for this pack
-		unsigned nextArg;     ///< Index of next argument in arguments list
-		
-		/// Number of elements included in current tuple element (nested appropriately)
-		std::vector<unsigned> tupleEls;
+		AltList actuals;                 ///< Arguments included in this pack
+		TypeEnvironment env;             ///< Environment for this pack
+		AssertionSet need;               ///< Assertions outstanding for this pack
+		AssertionSet have;               ///< Assertions found for this pack
+		OpenVarSet openVars;             ///< Open variables for this pack
+		unsigned nextArg;                ///< Index of next argument in arguments list
+		std::vector<Alternative> expls;  ///< Exploded actuals left over from last match
+		unsigned nextExpl;               ///< Index of next exploded alternative to use
+		std::vector<unsigned> tupleEls;  /// Number of elements in current tuple element(s)
 
 		ArgPack(const TypeEnvironment& env, const AssertionSet& need, const AssertionSet& have, 
 				const OpenVarSet& openVars)
 			: actuals(), env(env), need(need), have(have), openVars(openVars), nextArg(0),
-			  tupleEls() {}
+			  expls(), nextExpl(0), tupleEls() {}
 		
 		ArgPack(const ArgPack& old, Expression* actual, TypeEnvironment&& env, 
@@ -623,45 +623,12 @@
 			actuals.emplace_back( new TupleExpr( exprs ), this->env, cost );
 		}
+
+		/// Clones and adds an actual, returns this
+		ArgPack& withArg( Expression* expr ) {
+			actuals.emplace_back( expr->clone(), this->env, Cost::zero );
+			if ( ! tupleEls.empty() ) ++tupleEls.back();
+			return *this;
+		}
 	};
-
-	/// Iterates a result, exploding actuals as needed.
-	/// add is a function that takes the same parameters as this (with the exception of add)
-	template<typename F>
-	void addExplodedActual( ArgPack& result, Expression* expr, Cost cost, 
-			std::vector<ArgPack>& nextResults, F add ) {
-		Type* res = expr->get_result()->stripReferences();
-		if ( TupleType* tupleType = dynamic_cast<TupleType*>( res ) ) {
-			if ( TupleExpr* tupleExpr = dynamic_cast<TupleExpr*>( expr ) ) {
-				// recursively explode tuple
-				for ( Expression* sexpr : tupleExpr->get_exprs() ) {
-					addExplodedActual( result, sexpr, cost, nextResults, add );
-					cost = Cost::zero; // reset cost so not duplicated
-				}
-			} else {
-				// tuple type, but not tuple expr - recursively index into components.
-				// if expr type is reference, convert to value type
-				Expression* arg = expr->clone();
-				if ( Tuples::maybeImpureIgnoreUnique( arg ) ) {
-					// expressions which may contain side effects require a single unique instance of the expression.
-					arg = new UniqueExpr( arg );
-				}
-				// cast reference to value type to facilitate further explosion
-				if ( dynamic_cast<ReferenceType*>( arg->get_result() ) ) {
-					arg = new CastExpr( arg, tupleType->clone() );
-				}
-				// explode tuple by index
-				for ( unsigned i = 0; i < tupleType->size(); ++i ) {
-					TupleIndexExpr* idx = new TupleIndexExpr( arg->clone(), i );
-					addExplodedActual( result, idx, cost, nextResults, add );
-					cost = Cost::zero; // reset cost so not duplicated
-					delete idx;
-				}
-				delete arg;
-			}
-		} else {
-			// add non-tuple results directly
-			add( result, expr->clone(), cost, nextResults );
-		}
-	}
 
 	/// Instantiates an argument to match a formal, returns false if no results left
@@ -716,13 +683,18 @@
 					// add each possible next argument
 					for ( const Alternative& actual : args[result.nextArg] ) {
-						addExplodedActual( result, actual.expr, actual.cost, nextResults, 
-							[&actual]( ArgPack& result, Expression* expr, Cost cost, 
-									std::vector<ArgPack>& nextResults ) {
-								TypeEnvironment env{ result.env };
-								OpenVarSet openVars{ result.openVars };
-								env.addActual( actual.env, openVars );
-								nextResults.emplace_back( result, expr, std::move(env), 
-									std::move(openVars), cost );
-							} );
+						ArgPack aResult = result;  // copy to clone everything
+						// add details of actual to result
+						aResult.env.addActual( actual.env, aResult.openVars );
+		
+						// explode argument
+						std::vector<Alternative> exploded;
+						Tuples::explode( actual, indexer, back_inserter( exploded ) );
+						
+						// add exploded argument to tuple
+						for ( Alternative& aActual : exploded ) {
+							aResult.withArg( aActual.expr );
+						}
+						++aResult.nextArg;
+						nextResults.push_back( std::move(aResult) );
 					}
 				}
@@ -737,17 +709,35 @@
 		
 		// iterate each current subresult
-		for ( ArgPack& result : results ) {
-			if ( result.nextArg >= args.size() ) {
-				// If run out of actuals, handle default values
+		for ( unsigned iResult = 0; iResult < results.size(); ++iResult ) {
+			ArgPack& result = results[iResult];
+
+			if ( result.nextExpl < result.expls.size() ) {
+				// use remainder of exploded tuple if present
+				const Alternative& actual = result.expls[result.nextExpl];
+				result.env.addActual( actual.env, result.openVars );
+				Type* actualType = actual.expr->get_result();
+
+				PRINT(
+					std::cerr << "formal type is ";
+					formalType->print( std::cerr );
+					std::cerr << std::endl << "actual type is ";
+					actualType->print( std::cerr );
+					std::cerr << std::endl;
+				)
+				
+				if ( unify( formalType, actualType, result.env, result.need, result.have, 
+						result.openVars, indexer ) ) {
+					++result.nextExpl;
+					nextResults.push_back( std::move(result.withArg( actual.expr )) );
+				}
+
+				continue;
+			} else if ( result.nextArg >= args.size() ) {
+				// use default initializers if out of arguments
 				if ( ConstantExpr* cnstExpr = getDefaultValue( initializer ) ) {
 					if ( Constant* cnst = dynamic_cast<Constant*>( cnstExpr->get_constant() ) ) {
-						TypeEnvironment resultEnv = result.env;
-						AssertionSet resultNeed = result.need, resultHave = result.have;
-						if ( unify( formalType, cnst->get_type(), 
-								resultEnv, resultNeed, resultHave, result.openVars, 
-								indexer ) ) {
-							nextResults.emplace_back( result, cnstExpr->clone(), 
-								std::move(resultEnv), std::move(resultNeed), 
-								std::move(resultHave), OpenVarSet{ result.openVars } );
+						if ( unify( formalType, cnst->get_type(), result.env, result.need, 
+								result.have, result.openVars, indexer ) ) {
+							nextResults.push_back( std::move(result.withArg( cnstExpr )) );
 						}
 					}
@@ -758,30 +748,44 @@
 			// Check each possible next argument
 			for ( const Alternative& actual : args[result.nextArg] ) {
-				addExplodedActual( result, actual.expr, actual.cost, nextResults, 
-					[formalType,&indexer,&actual]( ArgPack& result, Expression* expr, Cost cost, 
-							std::vector<ArgPack>& nextResults ) {
-						// attempt to unify actual with parameter
-						TypeEnvironment resultEnv = result.env;
-						AssertionSet resultNeed = result.need, resultHave = result.have;
-						OpenVarSet resultOpenVars = result.openVars;
-						resultEnv.addActual( actual.env, resultOpenVars );
-						Type* actualType = expr->get_result();
-
-
-						PRINT(
-							std::cerr << "formal type is ";
-							formalType->print( std::cerr );
-							std::cerr << std::endl << "actual type is ";
-							actualType->print( std::cerr );
-							std::cerr << std::endl;
-						)
-
-						if ( unify( formalType, actualType, resultEnv, resultNeed, resultHave, 
-								resultOpenVars, indexer ) ) {
-							nextResults.emplace_back( result, expr->clone(), 
-								std::move(resultEnv), std::move(resultNeed), std::move(resultHave),
-								std::move(resultOpenVars), cost );
-						}
-					} );
+				ArgPack aResult = result;  // copy to clone everything
+				// add details of actual to result
+				aResult.env.addActual( actual.env, aResult.openVars );
+
+				// explode argument
+				std::vector<Alternative> exploded;
+				Tuples::explode( actual, indexer, back_inserter( exploded ) );
+				if ( exploded.empty() ) {
+					// skip empty tuple arguments
+					++aResult.nextArg;
+					results.push_back( std::move(aResult) );
+					continue;
+				}
+
+				// consider only first exploded actual
+				const Alternative& aActual = exploded.front();
+				Type* actualType = aActual.expr->get_result();
+
+				PRINT(
+					std::cerr << "formal type is ";
+					formalType->print( std::cerr );
+					std::cerr << std::endl << "actual type is ";
+					actualType->print( std::cerr );
+					std::cerr << std::endl;
+				)
+
+				// attempt to unify types
+				if ( unify( formalType, actualType, aResult.env, aResult.need, aResult.have, aResult.openVars, indexer ) ) {
+					// add argument
+					aResult.withArg( aActual.expr );
+					if ( exploded.size() == 1 ) {
+						// argument consumed
+						++aResult.nextArg;
+					} else {
+						// other parts of tuple left over
+						aResult.expls = std::move( exploded );
+						aResult.nextExpl = 1;
+					}
+					nextResults.push_back( std::move(aResult) );
+				}
 			}
 		}