@@ -322,7 +322,7 @@ RcppExport SEXP decomposeIsotopes(SEXP v_masses, SEXP v_abundances, SEXP s_error

 				transform(candidate_abundances.begin(),			// begin of source range

 					candidate_abundances.begin() + size,		// end of source range

 					candidate_abundances.begin(), 			// destination

-					bind2nd(multiplies<abundance_type>(), scale));	// operation (*scale)

+					[scale](abundance_type a) { return a * scale; }); // operation (*scale)

 			}

 		}

@@ -29,9 +29,9 @@ Alphabet::mass_type Alphabet::getMass(const name_type& name) const

 bool Alphabet::hasName(const name_type& name) const {

-	return std::find_if(elements.begin(), elements.end(),

-		compose_f_gx(std::bind2nd(std::equal_to<name_type>(), name),

-		std::mem_fun_ref(&element_type::getName))) < elements.end();

+        return std::find_if(elements.begin(), elements.end(), [name](const auto& elem) {

+	  return std::equal_to<name_type>()(elem.getName(), name);

+	}) != elements.end();

 }

@@ -68,11 +68,9 @@ Alphabet::masses_type Alphabet::getAverageMasses() const {

 void Alphabet::sortByNames() {

-	std::sort(elements.begin(), elements.end(),

-				compose_f_gx_hy(

-					std::less<name_type>(),

-					std::mem_fun_ref(&element_type::getName),

-					std::mem_fun_ref(&element_type::getName)));

+        std::sort(elements.begin(), elements.end(), [](const auto& lhs, const auto& rhs) {

+	  return std::less<name_type>()(lhs.getName(), rhs.getName());

+	});

 }

@@ -83,7 +83,7 @@ void LinearPointSetMatcher::swap(double& d1, double& d2) {

 std::unique_ptr<std::map<int,int> > LinearPointSetMatcher::getMapping() const {

 	if (results.mapping.get() == 0) {

-		return std::unique_ptr<std::map<int,int> >(0); // TODO throw sth. instead

+		return std::unique_ptr<std::map<int,int> >(new std::map<int,int>()); // TODO throw sth. instead

 	} else {

 		// aaargh, this syntax is awful, i hate it, hate it, hate it...

 		return std::unique_ptr<std::map<int,int> >(new std::map<int,int>(*(results.mapping)));

@@ -278,7 +278,7 @@ void LinearPointSetMatcher::countMatchesOneToOne(

 			#endif

 		}

-		std::unique_ptr<std::map<int,int> > mapping(0);

+		std::unique_ptr<std::map<int,int> > mapping(new std::map<int,int>());

 		// evaluate match matrix: count out score using...

 		if (!restrict_oneToOne) {

 			// ... greedy counting scheme

@@ -300,7 +300,7 @@ void LinearPointSetMatcher::countMatchesOneToOne(

 			results.centerB = j;

 			results.bestscale = (*p).scale;

 			results.besttranslation=-results.bestscale*a_first[i] + b_first[j] + diff;

-			results.mapping=mapping;

+			results.mapping=std::move(mapping);

 		}

 	}

 }

@@ -323,7 +323,7 @@ int LinearPointSetMatcher::match(RandomAccessIterator a_first, RandomAccessItera

 	if (oneToOne) {

 		results.mapping = std::unique_ptr<std::map<int,int> >(new std::map<int,int>);

 	} else {

-		results.mapping = std::unique_ptr<std::map<int,int> >(0);

+		results.mapping = std::unique_ptr<std::map<int,int> >(new std::map<int,int>());

 	}

 	#ifndef NDEBUG

@@ -29,7 +29,7 @@ ComposedElement::ComposedElement(const name_type& sequence, const Alphabet& alph

 	} else {

 		parser = std::unique_ptr<sequence_parser_type>(new MoleculeSequenceParser);

 	}

-	this->initializeElements(alphabet, parser);

+	this->initializeElements(alphabet, std::move(parser) );

 }

 ComposedElement::ComposedElement(const std::vector<unsigned int>& decomposition, 

@@ -71,14 +71,14 @@ template <typename T>

 std::vector<T> getPositiveNeighborhoodSet(T middle,

 					std::pair<T, T> minMaxElements, T range, T granularity) {

 	std::vector<T> valuesRange = getNeighborhoodSet(middle, minMaxElements, range, granularity);

-	valuesRange.erase(std::remove_if(valuesRange.begin(), valuesRange.end(), std::bind2nd(std::less<T>(), 0)), valuesRange.end());

+	valuesRange.erase(std::remove_if(valuesRange.begin(), valuesRange.end(), [](const T& x) { return x < 0; }, 0), valuesRange.end());

 	return valuesRange;

 }

 template <typename T>

 std::vector<T> getPositiveNeighborhoodSet(T middle, T range, T granularity) {

 	std::vector<T> valuesRange = getNeighborhoodSet(middle, range, granularity);

-	valuesRange.erase(std::remove_if(valuesRange.begin(), valuesRange.end(), std::bind2nd(std::less<T>(), 0)), valuesRange.end());

+	valuesRange.erase(std::remove_if(valuesRange.begin(), valuesRange.end(), [](const T& x) { return x < 0; }), valuesRange.end());

 	return valuesRange;

 }