From df04dbe096dfcc958a19430365be21cf08342973 Mon Sep 17 00:00:00 2001
From: Leonardo de Moura <leonardo@microsoft.com>
Date: Thu, 21 Nov 2013 12:48:04 -0800
Subject: [PATCH] chore(util): use && when appropriate

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
---
 src/util/list_fn.h    |  8 ++++----
 src/util/splay_tree.h | 20 ++++++++++----------
 2 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/src/util/list_fn.h b/src/util/list_fn.h
index 0b937861a9..3c0e6aec41 100644
--- a/src/util/list_fn.h
+++ b/src/util/list_fn.h
@@ -138,7 +138,7 @@ list<T> append(list<T> const & l1, list<T> const & l2) {
    \brief Given list <tt>(a_0, ..., a_k)</tt>, return list <tt>(f(a_0), ..., f(a_k))</tt>.
 */
 template<typename T, typename F>
-list<T> map(list<T> const & l, F f) {
+list<T> map(list<T> const & l, F && f) {
     static_assert(std::is_same<typename std::result_of<F(T const &)>::type, T>::value,
                   "map: return type of f is not sxpr");
     if (is_nil(l)) {
@@ -161,7 +161,7 @@ list<T> map(list<T> const & l, F f) {
    list cells. The elements are compared using the predicate \c eq.
 */
 template<typename T, typename F, typename Eq = std::equal_to<T>>
-list<T> map_reuse(list<T> const & l, F f, Eq const & eq = Eq()) {
+list<T> map_reuse(list<T> const & l, F && f, Eq const & eq = Eq()) {
     if (is_nil(l)) {
         return l;
     } else {
@@ -191,7 +191,7 @@ list<T> map_reuse(list<T> const & l, F f, Eq const & eq = Eq()) {
    \brief Given list <tt>(a_0, ..., a_k)</tt>, exec f(a_0); f(a_1); ... f(a_k)</tt>.
 */
 template<typename T, typename F>
-void for_each(list<T> const & l, F f) {
+void for_each(list<T> const & l, F && f) {
     static_assert(std::is_same<typename std::result_of<F(T const &)>::type, void>::value,
                   "for_each: return type of f is not void");
     typedef typename list<T>::cell cell;
@@ -206,7 +206,7 @@ void for_each(list<T> const & l, F f) {
    \brief Compare two lists using the binary predicate p.
 */
 template<typename T, typename P>
-bool compare(list<T> const & l1, list<T> const & l2, P p) {
+bool compare(list<T> const & l1, list<T> const & l2, P && p) {
     static_assert(std::is_same<typename std::result_of<P(T const &, T const &)>::type, bool>::value,
                   "compare: return type of f is not bool");
     auto it1 = l1.begin();
diff --git a/src/util/splay_tree.h b/src/util/splay_tree.h
index 0814f6ae93..b9d5feec00 100644
--- a/src/util/splay_tree.h
+++ b/src/util/splay_tree.h
@@ -292,7 +292,7 @@ class splay_tree : public CMP {
     }
 
     template<typename F, typename R>
-    static R fold(node const * n, F & f, R r) {
+    static R fold(node const * n, F && f, R r) {
         static_assert(std::is_same<typename std::result_of<F(T const &, R)>::type, R>::value,
                       "fold: return type of f(t : T, r : R) is not R");
         if (n) {
@@ -305,7 +305,7 @@ class splay_tree : public CMP {
     }
 
     template<typename F>
-    static void for_each(node const * n, F & f) {
+    static void for_each(node const * n, F && f) {
         static_assert(std::is_same<typename std::result_of<F(T const &)>::type, void>::value,
                       "for_each: return type of f is not void");
         if (n) {
@@ -432,20 +432,20 @@ public:
        <tt>a_0, a_1, ... a_k</tt> are the elements is stored in the splay tree.
     */
     template<typename F, typename R>
-    R fold(F f, R r) const {
+    R fold(F && f, R r) const {
         static_assert(std::is_same<typename std::result_of<F(T const &, R)>::type, R>::value,
                       "fold: return type of f(t : T, r : R) is not R");
-        return fold(m_ptr, f, r);
+        return fold(m_ptr, std::forward<F>(f), r);
     }
 
     /**
        \brief Apply \c f to each value stored in the splay tree.
     */
     template<typename F>
-    void for_each(F f) const {
+    void for_each(F && f) const {
         static_assert(std::is_same<typename std::result_of<F(T const &)>::type, void>::value,
                       "for_each: return type of f is not void");
-        for_each(m_ptr, f);
+        for_each(m_ptr, std::forward<F>(f));
     }
 };
 template<typename T, typename CMP>
@@ -453,15 +453,15 @@ splay_tree<T, CMP> insert(splay_tree<T, CMP> & t, T const & v) { splay_tree<T, C
 template<typename T, typename CMP>
 splay_tree<T, CMP> erase(splay_tree<T, CMP> & t, T const & v) { splay_tree<T, CMP> r(t); r.erase(v); return r; }
 template<typename T, typename CMP, typename F, typename R>
-R fold(splay_tree<T, CMP> const & t, F f, R r) {
+R fold(splay_tree<T, CMP> const & t, F && f, R r) {
     static_assert(std::is_same<typename std::result_of<F(T const &, R)>::type, R>::value,
                   "fold: return type of f(t : T, r : R) is not R");
-    return t.fold(f, r);
+    return t.fold(std::forward<F>(f), r);
 }
 template<typename T, typename CMP, typename F>
-void for_each(splay_tree<T, CMP> const & t, F f) {
+void for_each(splay_tree<T, CMP> const & t, F && f) {
     static_assert(std::is_same<typename std::result_of<F(T const &)>::type, void>::value,
                   "for_each: return type of f is not void");
-    return t.for_each(f);
+    return t.for_each(std::forward<F>(f));
 }
 }