Index: src/ResolvExpr/AlternativeFinder.cc
===================================================================
--- src/ResolvExpr/AlternativeFinder.cc	(revision a065f1ffe843ea0a3ceecdf36a1210abe07a2441)
+++ src/ResolvExpr/AlternativeFinder.cc	(revision 95dab9ec006307c04669f1d2832d144a7ff5a92f)
@@ -299,5 +299,5 @@
 				SemanticError( expr->location, stream.str() );
 			}
-			alternatives = move(pruned);
+			alternatives = std::move(pruned);
 			PRINT(
 				std::cerr << "there are " << oldsize << " alternatives before elimination" << std::endl;
@@ -573,6 +573,6 @@
 				unsigned tupleStart = 0, Cost cost = Cost::zero, unsigned nextExpl = 0,
 				unsigned explAlt = 0 )
-			: parent(parent), expr(expr->clone()), cost(cost), env(move(env)), need(move(need)),
-			  have(move(have)), openVars(move(openVars)), nextArg(nextArg), tupleStart(tupleStart),
+			: parent(parent), expr(expr->clone()), cost(cost), env(std::move(env)), need(std::move(need)),
+			  have(std::move(have)), openVars(std::move(openVars)), nextArg(nextArg), tupleStart(tupleStart),
 			  nextExpl(nextExpl), explAlt(explAlt) {}
 
@@ -580,5 +580,5 @@
 				OpenVarSet&& openVars, unsigned nextArg, Cost added )
 			: parent(o.parent), expr(o.expr ? o.expr->clone() : nullptr), cost(o.cost + added),
-			  env(move(env)), need(move(need)), have(move(have)), openVars(move(openVars)),
+			  env(std::move(env)), need(std::move(need)), have(std::move(have)), openVars(std::move(openVars)),
 			  nextArg(nextArg), tupleStart(o.tupleStart), nextExpl(0), explAlt(0) {}
 
@@ -707,5 +707,5 @@
 						if ( unify( ttype, argType, newResult.env, newResult.need, newResult.have,
 								newResult.openVars, indexer ) ) {
-							finalResults.push_back( move(newResult) );
+							finalResults.push_back( std::move(newResult) );
 						}
 
@@ -726,6 +726,6 @@
 						if ( expl.exprs.empty() ) {
 							results.emplace_back(
-								results[i], move(env), copy(results[i].need),
-								copy(results[i].have), move(openVars), nextArg + 1, expl.cost );
+								results[i], std::move(env), copy(results[i].need),
+								copy(results[i].have), std::move(openVars), nextArg + 1, expl.cost );
 
 							continue;
@@ -734,6 +734,6 @@
 						// add new result
 						results.emplace_back(
-							i, expl.exprs.front().get(), move(env), copy(results[i].need),
-							copy(results[i].have), move(openVars), nextArg + 1,
+							i, expl.exprs.front().get(), std::move(env), copy(results[i].need),
+							copy(results[i].have), std::move(openVars), nextArg + 1,
 							nTuples, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
 					}
@@ -747,5 +747,5 @@
 			// splice final results onto results
 			for ( std::size_t i = 0; i < finalResults.size(); ++i ) {
-				results.push_back( move(finalResults[i]) );
+				results.push_back( std::move(finalResults[i]) );
 			}
 			return ! finalResults.empty();
@@ -783,5 +783,5 @@
 
 					results.emplace_back(
-						i, expr, move(env), move(need), move(have), move(openVars), nextArg,
+						i, expr, std::move(env), std::move(need), std::move(have), std::move(openVars), nextArg,
 						nTuples, Cost::zero, nextExpl, results[i].explAlt );
 				}
@@ -801,6 +801,6 @@
 								indexer ) ) {
 							results.emplace_back(
-								i, new DefaultArgExpr( cnstExpr ), move(env), move(need), move(have),
-								move(openVars), nextArg, nTuples );
+								i, new DefaultArgExpr( cnstExpr ), std::move(env), std::move(need), std::move(have),
+								std::move(openVars), nextArg, nTuples );
 						}
 					}
@@ -824,5 +824,5 @@
 				if ( expl.exprs.empty() ) {
 					results.emplace_back(
-						results[i], move(env), move(need), move(have), move(openVars),
+						results[i], std::move(env), std::move(need), std::move(have), std::move(openVars),
 						nextArg + 1, expl.cost );
 
@@ -846,5 +846,5 @@
 					// add new result
 					results.emplace_back(
-						i, expr, move(env), move(need), move(have), move(openVars), nextArg + 1,
+						i, expr, std::move(env), std::move(need), std::move(have), std::move(openVars), nextArg + 1,
 						nTuples, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
 				}
@@ -962,6 +962,6 @@
 						if ( expl.exprs.empty() ) {
 							results.emplace_back(
-								results[i], move(env), copy(results[i].need),
-								copy(results[i].have), move(openVars), nextArg + 1, expl.cost );
+								results[i], std::move(env), copy(results[i].need),
+								copy(results[i].have), std::move(openVars), nextArg + 1, expl.cost );
 
 							continue;
@@ -970,6 +970,6 @@
 						// add new result
 						results.emplace_back(
-							i, expl.exprs.front().get(), move(env), copy(results[i].need),
-							copy(results[i].have), move(openVars), nextArg + 1, 0,
+							i, expl.exprs.front().get(), std::move(env), copy(results[i].need),
+							copy(results[i].have), std::move(openVars), nextArg + 1, 0,
 							expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
 					}
@@ -1067,5 +1067,5 @@
 				funcE.emplace_back( actual, indexer );
 			}
-			argExpansions.insert( argExpansions.begin(), move(funcE) );
+			argExpansions.insert( argExpansions.begin(), std::move(funcE) );
 
 			for ( AltList::iterator funcOp = funcOpFinder.alternatives.begin();
@@ -1116,5 +1116,5 @@
 		} // for
 
-		candidates = move(alternatives);
+		candidates = std::move(alternatives);
 
 		// use a new list so that alternatives are not examined by addAnonConversions twice.
Index: src/ResolvExpr/Unify.cc
===================================================================
--- src/ResolvExpr/Unify.cc	(revision a065f1ffe843ea0a3ceecdf36a1210abe07a2441)
+++ src/ResolvExpr/Unify.cc	(revision 95dab9ec006307c04669f1d2832d144a7ff5a92f)
@@ -727,5 +727,5 @@
 		};
 	}
-	
+
 	std::vector< ast::ptr< ast::Type > > flattenList(
 		const std::vector< ast::ptr< ast::Type > > & src, ast::TypeEnvironment & env
@@ -989,5 +989,5 @@
 				if ( isTuple && isTuple2 ) {
 					++it; ++jt;  // skip ttype parameters before break
-				} else if ( isTuple ) { 
+				} else if ( isTuple ) {
 					// bundle remaining params into tuple
 					pty2 = tupleFromExprs( param2, jt, params2.end(), pty->qualifiers );
@@ -1035,5 +1035,5 @@
 	private:
 		/// Creates a tuple type based on a list of Type
-		
+
 
 		static bool unifyList(
@@ -1207,5 +1207,5 @@
 			}
 
-		} else if ( common = commonType( t1, t2, env, need, have, open, widen, symtab )) {
+		} else if (( common = commonType( t1, t2, env, need, have, open, widen, symtab ))) {
 			// no exact unification, but common type
 			auto c = shallowCopy(common.get());