michael/lean2
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

chore(util): use && when appropriate

Browse source 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
This commit is contained in:
Leonardo de Moura 2013-11-21 12:48:04 -08:00
parent 63bbf07f64
commit df04dbe096
2 changed files with 14 additions and 14 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
src/util/list_fn.h
View file

@ -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>. \brief Given list <tt>(a_0, ..., a_k)</tt>, return list <tt>(f(a_0), ..., f(a_k))</tt>.
*/ */
template<typename T, typename F> 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, static_assert(std::is_same<typename std::result_of<F(T const &)>::type, T>::value,
"map: return type of f is not sxpr"); "map: return type of f is not sxpr");
if (is_nil(l)) { 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. list cells. The elements are compared using the predicate \c eq.
*/ */
template<typename T, typename F, typename Eq = std::equal_to<T>> 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)) { if (is_nil(l)) {
return l; return l;
} else { } 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>. \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> 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, 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: return type of f is not void");
typedef typename list<T>::cell cell; 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. \brief Compare two lists using the binary predicate p.
*/ */
template<typename T, typename 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, 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"); "compare: return type of f is not bool");
auto it1 = l1.begin(); auto it1 = l1.begin();

20
src/util/splay_tree.h
View file

@ -292,7 +292,7 @@ class splay_tree : public CMP {
} }
template<typename F, typename R> 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, 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"); "fold: return type of f(t : T, r : R) is not R");
if (n) { if (n) {
@ -305,7 +305,7 @@ class splay_tree : public CMP {
} }
template<typename F> 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, 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: return type of f is not void");
if (n) { if (n) {
@ -432,20 +432,20 @@ public:
<tt>a_0, a_1, ... a_k</tt> are the elements is stored in the splay tree. <tt>a_0, a_1, ... a_k</tt> are the elements is stored in the splay tree.
*/ */
template<typename F, typename R> 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, 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"); "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. \brief Apply \c f to each value stored in the splay tree.
*/ */
template<typename F> 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, 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: 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> 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> 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; } 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> 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, 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"); "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> 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, 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: return type of f is not void");
return t.for_each(f); return t.for_each(std::forward<F>(f));
} }
} }