---

more/gen/lambda.h

Go to the documentation of this file.

//  more/lambda.h -- expression templates for generating STL functionals
//  Copyright (C) 1998--2002  Petter Urkedal
//
//  This file is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This file is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//  As a special exception, you may use this file as part of a free
//  software library without restriction.  Specifically, if other files
//  instantiate templates or use macros or inline functions from this
//  file, or you compile this file and link it with other files to
//  produce an executable, this file does not by itself cause the
//  resulting executable to be covered by the GNU General Public
//  License.  This exception does not however invalidate any other
//  reasons why the executable file might be covered by the GNU General
//  Public License.
//
//  $Id: lambda.h,v 1.2 2002/08/24 13:54:41 petter_urkedal Exp $


#ifndef MORE_GEN_LAMBDA_H
#define MORE_GEN_LAMBDA_H

#include <iterator>
#include <more/gen/functional.h>

///\if bits
#define MORE_CR1(T) T // arguments to lambda-functionals
#define MORE_CR2(T) T // args and data of placeholder assignments
#define MORE_CR3(T) T // subexpressions of function expressions
#define MORE_CR4(T) T // expression-data of lambda functions
#define MORE_CR5(T) T // arguments to overloaded operators
///\endif

//  `#define MORE_CR1(T) const T&' is safe, since MORE_CR1 only
//  appears on arguments to `operator()'.
//
//  placeholder_assignments is never returned out of a context, so all
//  members and arguments can be const T& placeholder_assign is only
//  used in the former, so the same holds.  Thus, `#define MORE_CR2(T)
//  const T&' is safe.
//
//  `#define MORE_CR3(T) const T&' is unsafe since subexressions may
//  contain local data.  `#define MORE_CR4(T) const T&' violates
//  constness.


namespace more {
namespace gen {

  //  Since we are using some general templates for operators, we hide
  //  all definitions, except for placeholders and interfacing
  //  functions, and rely on Koenig lookup.
  ///\if bits
  namespace lambda_kns {

    using std::unary_function;
    using std::binary_function;

    template<typename Expression=void> struct expr {};
    struct derivable_void {};


    // ---   p l a c e h o l d e r   &   v a l u e h o l d e r  ---

    template<typename Placeholder>
      struct placeholder_assign {
          typedef typename Placeholder::result_type value_type;
          MORE_CR2(value_type) value;
          placeholder_assign(MORE_CR2(value_type) value_) : value(value_) {}
      };

    template<typename Placeholder, typename Rest=derivable_void>
      struct placeholder_assignments
          : placeholder_assign<Placeholder>, Rest {
          typedef typename Placeholder::result_type value_type;
          placeholder_assignments(MORE_CR2(value_type) value_)
              : placeholder_assign<Placeholder>(value_) {}
          placeholder_assignments(MORE_CR2(value_type) value_,
                                  const Rest& rest)
              : placeholder_assign<Placeholder>(value_), Rest(rest) {}
      };

    template<int Place, typename Type> struct placeholder_expr {};
    template<int Place, typename Type>
      struct expr< placeholder_expr<Place, Type> > {
          typedef Type result_type;
          expr() {}
          expr(placeholder_expr<Place, Type>) {}
          template<typename Assign>
            result_type operator()(const Assign& assign) const {
                return static_cast
                    <const placeholder_assign<expr>&>(assign).value;
          }
      };

    template<int Place, typename Type>
      struct placeholder
          : expr< placeholder_expr<Place, Type> > {};

    template<typename T> struct value_expr {};
    template<typename T>
      struct expr< value_expr<T> > {
          typedef T result_type;
          expr(const T& x_) : x(x_) {}
          template<typename Assign>
            const result_type& operator()(const Assign&) const { return x; }
          template<typename Assign>
            result_type& operator()(const Assign&) { return x; }
        private:
          result_type x;
      };

    template<typename T> struct valueref_expr {};
    template<typename T>
      struct expr< valueref_expr<T> > {
          typedef T& result_type;
          expr(T& x_) : x(x_) {}
          template<typename Assign>
            result_type operator()(const Assign&) const { return x; }
        private:
          result_type x;
      };



    // ---   l a m b d a   e x p r e s s i o n s   ---

    template<typename Expr>
      struct lambda_generator {
          typedef typename Expr::result_type result_type;
          lambda_generator() {}
          lambda_generator(const Expr& expr_) : expr(expr_) {}
          result_type operator()() {
              derivable_void vars;
              return expr(vars);
          }
          result_type operator()() const {
              derivable_void vars;
              return expr(vars);
          }
        private:
          MORE_CR4(Expr) expr;
      };

    template<typename Placeholder, typename Expr>
      struct unary_lambda_function
          : unary_function< typename Placeholder::result_type,
                            typename Expr::result_type > {
          typedef unary_function< typename Placeholder::result_type,
                                  typename Expr::result_type > base;
          typedef typename base::argument_type argument_type;
          typedef typename base::result_type result_type;
          unary_lambda_function() {}
          unary_lambda_function(const Expr& expr_) : expr(expr_) {}
          result_type operator()(MORE_CR1(argument_type) x) {
              typedef placeholder_assignments<Placeholder> asg1;
              return expr(asg1(x));
          }
          template<typename Assign>
            result_type operator()(const Assign& a,
                                   MORE_CR1(argument_type) x) {
                typedef placeholder_assignments<Placeholder, Assign> asg1;
                return expr(asg1(x, a));
          }
          result_type operator()(MORE_CR1(argument_type) x) const {
              typedef placeholder_assignments<Placeholder> asg1;
              return expr(asg1(x));
          }
          template<typename Assign>
            result_type operator()(const Assign& a,
                                   MORE_CR1(argument_type) x) const {
                typedef placeholder_assignments<Placeholder, Assign> asg1;
                return expr(asg1(x, a));
          }
        private:
          MORE_CR4(Expr) expr;
      };


    template< typename Placeholder1, typename Placeholder2,
              typename Expr >
      struct binary_lambda_function
          : binary_function< typename Placeholder1::result_type,
                             typename Placeholder2::result_type,
                             typename Expr::result_type > {
          typedef binary_function< typename Placeholder1::result_type,
                                   typename Placeholder2::result_type,
                                   typename Expr::result_type > base;
          typedef typename base::first_argument_type first_argument_type;
          typedef typename base::second_argument_type second_argument_type;
          typedef typename base::result_type result_type;
          binary_lambda_function() {}
          binary_lambda_function(const Expr& expr_) : expr(expr_) {}
          result_type operator()(MORE_CR1(first_argument_type) x,
                                 MORE_CR1(second_argument_type) y) {
              typedef placeholder_assignments<Placeholder2> asg2;
              typedef placeholder_assignments<Placeholder1, asg2> asg1;
              return expr(asg1(x, asg2(y)));
          }
          template<typename Assign>
            result_type operator()(const Assign& a,
                                   MORE_CR1(first_argument_type) x,
                                   MORE_CR1(second_argument_type) y) {
                typedef placeholder_assignments<Placeholder2, Assign> asg2;
                typedef placeholder_assignments<Placeholder1, asg2> asg1;
                return expr(asg1(x, asg2(y, a)));
          }
          result_type operator()(MORE_CR1(first_argument_type) x,
                                 MORE_CR1(second_argument_type) y) const {
              typedef placeholder_assignments<Placeholder2> asg2;
              typedef placeholder_assignments<Placeholder1, asg2> asg1;
              return expr(asg1(x, asg2(y)));
          }
          template<typename Assign>
            result_type operator()(const Assign& a,
                                   MORE_CR1(first_argument_type) x,
                                   MORE_CR1(second_argument_type) y) const {
                typedef placeholder_assignments<Placeholder2, Assign> asg2;
                typedef placeholder_assignments<Placeholder1, asg2> asg1;
                return expr(asg1(x, asg2(y, a)));
          }
        private:
          MORE_CR4(Expr) expr;
      };


    template< typename Placeholder1, typename Placeholder2,
              typename Placeholder3, typename Expr >
      struct ternary_lambda_function
          : ternary_function< typename Placeholder1::result_type,
                              typename Placeholder2::result_type,
                              typename Placeholder3::result_type,
                              typename Expr::result_type > {
          typedef ternary_function< typename Placeholder1::result_type,
                                    typename Placeholder2::result_type,
                                    typename Placeholder3::result_type,
                                    typename Expr::result_type > base;
          typedef typename base::first_argument_type first_argument_type;
          typedef typename base::second_argument_type second_argument_type;
          typedef typename base::third_argument_type third_argument_type;
          typedef typename base::result_type result_type;
          ternary_lambda_function() {}
          ternary_lambda_function(const Expr& expr_) : expr(expr_) {}
          result_type operator()(MORE_CR1(first_argument_type) x,
                                 MORE_CR1(second_argument_type) y,
                                 MORE_CR1(third_argument_type) z) {
              typedef placeholder_assignments< Placeholder3 > asg3;
              typedef placeholder_assignments< Placeholder2, asg3 > asg2;
              typedef placeholder_assignments< Placeholder1, asg2 > asg1;
              return expr(asg1(x, asg2(y, asg3(z))));
          }
          template<typename Assign>
            result_type operator()(const Assign& a,
                                   MORE_CR1(first_argument_type) x,
                                   MORE_CR1(second_argument_type) y,
                                   MORE_CR1(third_argument_type) z) {
                typedef placeholder_assignments< Placeholder3, Assign > asg3;
                typedef placeholder_assignments< Placeholder2, asg3 > asg2;
                typedef placeholder_assignments< Placeholder1, asg2 > asg1;
                return expr(asg1(x, asg2(y, asg3(z, a))));
          }
          result_type operator()(MORE_CR1(first_argument_type) x,
                                 MORE_CR1(second_argument_type) y,
                                 MORE_CR1(third_argument_type) z) const {
              typedef placeholder_assignments< Placeholder3 > asg3;
              typedef placeholder_assignments< Placeholder2, asg3 > asg2;
              typedef placeholder_assignments< Placeholder1, asg2 > asg1;
              return expr(asg1(x, asg2(y, asg3(z))));
          }
          template<typename Assign>
            result_type operator()(const Assign& a,
                                   MORE_CR1(first_argument_type) x,
                                   MORE_CR1(second_argument_type) y,
                                   MORE_CR1(third_argument_type) z) const {
                typedef placeholder_assignments< Placeholder3, Assign > asg3;
                typedef placeholder_assignments< Placeholder2, asg3 > asg2;
                typedef placeholder_assignments< Placeholder1, asg2 > asg1;
                return expr(asg1(x, asg2(y, asg3(z, a))));
          }
        private:
          MORE_CR4(Expr) expr;
      };


    template<typename Expr> inline
      lambda_generator<Expr> lambda(const Expr& a) {
          return lambda_generator<Expr>(a);
      }

    template<int Place, typename Type, typename Expr> inline
      unary_lambda_function< expr< placeholder_expr<Place, Type> >, Expr>
      lambda(const expr< placeholder_expr<Place, Type> >&, const Expr& a) {
          return unary_lambda_function
              < expr< placeholder_expr<Place, Type> >, Expr >(a);
      }

    template< int Place1, typename Type1,
              int Place2, typename Type2, typename Expr > inline
      binary_lambda_function
        < expr< placeholder_expr<Place1, Type1> >,
          expr< placeholder_expr<Place2, Type2> >, Expr >
      lambda(const expr< placeholder_expr<Place1, Type1> >&,
             const expr< placeholder_expr<Place2, Type2> >&,
             const Expr& a) {
        return binary_lambda_function
            < expr< placeholder_expr<Place1, Type1> >,
              expr< placeholder_expr<Place2, Type2> >, Expr >(a);
      }


    // ---   a p p l y   ---

    // --- metaprogram which reduces the number of
    //     function-templates for binary operators from 6 to 1 ---

    template<typename T> struct which_expr
        { typedef expr< value_expr<T> > eval; };
    template<int N, typename T> struct which_expr< placeholder<N, T> >
        { typedef expr< placeholder_expr<N, T> > eval; };
    template<typename Expr > struct which_expr< expr<Expr> >
        { typedef expr<Expr> eval; };

    template<typename E>
      struct which_expr< lambda_generator<E> >
        { typedef lambda_generator<E> eval; };
    template<typename P, typename E>
      struct which_expr< unary_lambda_function<P, E> >
        { typedef unary_lambda_function<P, E> eval; };
    template<typename P1, typename P2, typename E>
      struct which_expr< binary_lambda_function<P1, P2, E> >
        { typedef binary_lambda_function<P1, P2, E> eval; };


    template<typename Generator>
      struct generator_expr {};
    template<typename Generator>
      struct expr< generator_expr<Generator> > {
          typedef typename Generator::result_type result_tmp;
          typedef typename result_tmp::result_type result_type;
          result_type operator()() {
              return f(derivable_void())();
          }
          template<typename Assign>
            result_type operator()(const Assign& a) {
                return f(a)();
            }
          template<typename Assign>
            result_type operator()(const Assign& a) const {
                return f(a)();
            }
          expr(const Generator& f_) : f(f_) {};
        private:
          MORE_CR3(Generator) f;
      };

    template<typename Expr>
      struct expr< generator_expr< lambda_generator<Expr> > > {
          typedef lambda_generator<Expr> function_type;
          typedef typename function_type::result_type result_type;
          template<typename Assign>
            result_type operator()(const Assign& a) {
                return f(a);
            }
          template<typename Assign>
            result_type operator()(const Assign& a) const {
                return f(a);
            }
          expr(const function_type& f_) : f(f_) {};
        private:
          MORE_CR3(function_type) f;
      };

    template<typename UnaryFunction, typename Expr>
      struct unary_function_expr {};
    template<typename UnaryFunction, typename Expr>
      struct expr< unary_function_expr<UnaryFunction, Expr> > {
          typedef typename UnaryFunction::result_type result_tmp;
          typedef typename result_tmp::result_type result_type;
          result_type operator()() {
              return f(derivable_void())(x(derivable_void()));
          }
          template<typename Assign>
            result_type operator()(const Assign& a) {
                return f(a)(x(a));
            }
          template<typename Assign>
            result_type operator()(const Assign& a) const {
                return f(a)(x(a));
            }
          expr(const UnaryFunction& f_, const Expr& x_) : f(f_), x(x_) {};
        private:
          MORE_CR3(UnaryFunction) f;
          MORE_CR3(Expr) x;
      };

    template<typename Placeholder, typename SubExpr, typename Expr>
      struct expr< unary_function_expr
                    < unary_lambda_function<Placeholder, SubExpr>, Expr> > {
          typedef unary_lambda_function<Placeholder, SubExpr > function_type;
          typedef typename function_type::result_type result_type;
          template<typename Assign>
            result_type operator()(const Assign& a) {
                return f(a, x(a));
            }
          template<typename Assign>
            result_type operator()(const Assign& a) const {
                return f(a, x(a));
            }
          expr(const function_type& f_, const Expr& x_) : f(f_), x(x_) {};
        private:
          MORE_CR3(function_type) f;
          MORE_CR3(Expr) x;
      };

    template<typename BinaryFunction, typename Expr1, typename Expr2>
      struct binary_function_expr {};
    template<typename BinaryFunction, typename Expr1, typename Expr2>
      struct expr< binary_function_expr<BinaryFunction, Expr1, Expr2> > {
          typedef typename BinaryFunction::result_type result_tmp;
          typedef typename result_tmp::result_type result_type;
          result_type operator()() {
              return f(derivable_void())(x(derivable_void()),
                                         y(derivable_void()));
          }
          template<typename Assign>
            result_type operator()(const Assign& a) {
                return f(a)(x(a), y(a));
            }
          template<typename Assign>
            result_type operator()(const Assign& a) const {
                return f(a)(x(a), y(a));
            }
          expr(const BinaryFunction& f_, const Expr1& x_, const Expr2& y_)
              : f(f_), x(x_), y(y_) {}
        private:
          MORE_CR3(BinaryFunction) f;
          MORE_CR3(Expr1) x;
          MORE_CR3(Expr2) y;
      };

    template< typename Place1, typename Place2, typename SubExpr,
              typename Expr1, typename Expr2 >
      struct expr< binary_function_expr
                     < binary_lambda_function<Place1, Place2, SubExpr>,
                       Expr1, Expr2> > {
          typedef binary_lambda_function<Place1, Place2, SubExpr>
                  function_type;
          typedef typename function_type::result_type result_type;
          template<typename Assign>
            result_type operator()(const Assign& a) {
                return f(a, x(a), y(a));
            }
          template<typename Assign>
            result_type operator()(const Assign& a) const {
                return f(a, x(a), y(a));
            }
          expr(const function_type& f_, const Expr1& x_, const Expr2& y_)
              : f(f_), x(x_), y(y_) {}
        private:
          MORE_CR3(function_type) f;
          MORE_CR3(Expr1) x;
          MORE_CR3(Expr2) y;
      };


    template<typename Generator>
      inline expr< generator_expr< typename which_expr<Generator>::eval > >
      apply(const Generator& f) {
          return expr
              < generator_expr< typename which_expr<Generator>::eval> >(f);
      }

    template<typename UnaryFunction, typename T> inline
      expr< unary_function_expr < typename which_expr<UnaryFunction>::eval,
            typename which_expr<T>::eval > >
      apply(const UnaryFunction& f, const T& x) {
          typedef typename which_expr<UnaryFunction>::eval expr1;
          typedef typename which_expr<T>::eval expr2;
          return expr< unary_function_expr< expr1, expr2 > >(f, x);
      }

    template<typename BinaryFunction, typename T1, typename T2> inline
      expr< binary_function_expr
             < typename which_expr<BinaryFunction>::eval,
               typename which_expr<T1>::eval,
               typename which_expr<T2>::eval > >
      apply(const BinaryFunction& f, const T1& x1, const T2& x2) {
          return expr
              < binary_function_expr
                < typename which_expr<BinaryFunction>::eval,
                  typename which_expr<T1>::eval,
                  typename which_expr<T2>::eval > >(f, x1, x2);
      }

//     template< typename TernaryFunction,
//            typename T1, typename T2, typename T3 > inline
//     expr< ternary_function_expr
//              < TernaryFunction,
//             typename which_expr<T1>::eval,
//             typename which_expr<T2>::eval,
//             typename which_expr<T3>::eval > >
//     apply(const TernaryFunction& f,
//        const T1& x1, const T2& x2, const T3& x3) {
//      return expr
//          < ternary_function_expr
//              < TernaryFunction,
//                typename which_expr<T1>::eval,
//                typename which_expr<T2>::eval,
//                typename which_expr<T3> > >(f, x1, x2);
//     }




    // ---   e x p r e s s i o n s   ---

    // --- where ---

    template<typename Expr1, typename Expr2, typename Expr3>
      struct where_expr {};
    template<typename Expr1, typename Expr2, typename Expr3>
      struct expr< where_expr<Expr1, Expr2, Expr3> > {
          typedef typename Expr2::result_type result_type;
          template<typename Assign>
            result_type operator()(const Assign& a) {
                return cond(a)? pos(a) : neg(a);
            }
          template<typename Assign>
            result_type operator()(const Assign& a) const {
                return cond(a)? pos(a) : neg(a);
            }
          expr(const Expr1& x, const Expr2& y, const Expr3& z)
              : cond(x), pos(y), neg(z) {}
        private:
          Expr1 cond;
          Expr2 pos;
          Expr3 neg;
      };

    template<typename T1, typename T2, typename T3>
      inline
      expr< where_expr< typename which_expr<T1>::eval,
                        typename which_expr<T2>::eval,
                        typename which_expr<T3>::eval > >
      where(const T1& x, const T2& y, const T3& z) {
          return expr
              < where_expr< typename which_expr<T1>::eval,
                            typename which_expr<T2>::eval,
                            typename which_expr<T3>::eval > >(x, y, z);
      }


    // --- Unary operators ---

    template<typename Expr> struct not_expr {};
    template<typename Expr>
      struct expr< not_expr<Expr> > {
          typedef bool result_type;
          template<typename Assign>
            result_type operator()(const Assign& a) const {
                return !x(a);
            }
          explicit expr(const Expr& x_) : x(x_) {}
        private:
          Expr x;
      };

    template<typename Expr> inline
      expr< not_expr< expr<Expr> > > operator!(const expr<Expr>& x) {
          return expr< not_expr< expr<Expr> > >(x);
      }


    template<typename Expr> struct unary_minus_expr {};
    template<typename Expr>
      struct expr< unary_minus_expr<Expr> > {
          typedef typename Expr::result_type result_type;
          template<typename Assign>
            result_type operator()(const Assign& a) const {
                return -x(a);
            }
          explicit expr(const Expr& x_) : x(x_) {}
        private:
          Expr x;
      };

    template<typename Expr> inline
      expr< unary_minus_expr< expr<Expr> > >
      operator-(const expr<Expr>& x) {
          return expr< unary_minus_expr< expr<Expr> > >(x);
      }


    template<typename Expr> struct bitnot_expr {};
    template<typename Expr>
      struct expr< bitnot_expr<Expr> > {
          typedef typename Expr::result_type result_type;
          template<typename Assign>
            result_type operator()(const Assign& a) const {
                return ~x(a);
            }
          explicit expr(const Expr& x_) : x(x_) {}
        private:
          Expr x;
      };

    template<typename Expr> inline
      expr< bitnot_expr< expr<Expr> > > operator~(const expr<Expr>& x) {
          return expr< bitnot_expr< expr<Expr> > >(x);
      }

    template<typename Expr> struct dereference_expr {};
    template<typename Expr>
      struct expr< dereference_expr<Expr> > {
          typedef typename Expr::result_type argument_type;
          typedef typename std::iterator_traits<argument_type>::value_type
                  result_type;
          template<typename Assign>
            result_type operator()(const Assign& a) const {
                return *x(a);
            }
          explicit expr(const Expr& x_) : x(x_) {}
        private:
          Expr x;
      };
    template<typename Expr> inline
      expr< dereference_expr< expr<Expr> > >
      dereference(const expr<Expr>& x) {
          return expr< dereference_expr< expr<Expr> > >(x);
      }

  } // lambda_kns

#define MORE_DEF(OP, NAME, RESULT)\
  namespace lambda_kns {\
    template<typename Expr1, typename Expr2> struct NAME##_expr {};\
    template<typename Expr1, typename Expr2>\
      struct expr< NAME##_expr<Expr1, Expr2> > {\
          typedef typename Expr1::result_type first_argument_type;\
          typedef typename Expr2::result_type second_argument_type;\
          typedef RESULT result_type;\
          template<typename Assign>\
            result_type operator()(const Assign& a) const {\
                return x(a) OP y(a);\
            }\
          expr(MORE_CR5(Expr1) x_, MORE_CR5(Expr2) y_) : x(x_), y(y_) {}\
        private:\
          Expr1 x;\
          Expr2 y;\
      };\
    template<typename T1, typename T2>\
      inline\
      expr< NAME##_expr< typename which_expr<T1>::eval,\
                         typename which_expr<T2>::eval > >\
      operator OP(MORE_CR5(T1) x, MORE_CR5(T2) y) {\
          return expr\
                < NAME##_expr< typename which_expr<T1>::eval,\
                               typename which_expr<T2>::eval > >(x, y);\
      }\
  } // lambda_kns

  MORE_DEF(==, equal_to, bool)
  MORE_DEF(!=, not_equal_to, bool)
  MORE_DEF(<, less_than, bool)
  MORE_DEF(>, greater_than, bool)
  MORE_DEF(<=, less_or_equal_to, bool)
  MORE_DEF(>=, greater_or_equal_to, bool)
  MORE_DEF(&&, and, bool)
  MORE_DEF(||, or, bool)
#define MORE_COMMA ,
  MORE_DEF(MORE_COMMA, comma, second_argument_type)
#undef MORE_COMMA

  MORE_DEF(+, plus, first_argument_type)
  MORE_DEF(-, minus, first_argument_type)
  MORE_DEF(*, multiplies, first_argument_type)
  MORE_DEF(/, divides, first_argument_type)
  MORE_DEF(%, remainder, first_argument_type)
  MORE_DEF(&, bitand, first_argument_type)
  MORE_DEF(|, bitor, first_argument_type)
  MORE_DEF(^, bitxor, first_argument_type)
  MORE_DEF(<<, bitlshift, first_argument_type)
  MORE_DEF(>>, bitrshift, first_argument_type)
#undef MORE_DEF
  ///\endif bits

  using lambda_kns::placeholder;
  using lambda_kns::apply; // because of the generator-version
  using lambda_kns::lambda;
  using lambda_kns::where;

  /** Pass \a x by reference rather than by value in a lambda
   ** expression. */
  template<typename T>
    inline lambda_kns::expr< lambda_kns::valueref_expr<T> >
    refer(T& x) { return x; }

}} // more::gen

#undef MORE_CR1
#undef MORE_CR2
#undef MORE_CR3
#undef MORE_CR4

#endif

---