45c45
< # pragma warning(disable: 4512) // assignment � could not be generated
---
> # pragma warning(disable: 4512) // assignment operator could not be generated
1171,1326d1170
< // operator+
< template <typename R>
< struct left_addition
< {
< 	left_addition (const R & value) : m_value (value) {}
< 	
<     template<class V> V operator()(V const & v) const { return m_value + v; }
< 
< private:
< 	R m_value;
< };
< 
< template <typename R>
< struct right_addition
< {
< 	right_addition (const R & value) : m_value (value) {}
< 	
<     template<class V> V operator()(V const & v) const { return v+m_value; }
< 
< private:
< 	R m_value;
< };
< 
< template<class R, class F, class L>
<     bind_t< R, left_addition<R>, list1< bind_t<R, F, L> > >
<     operator+ (R const & value, bind_t<R, F, L> const & f)
< {
<     typedef list1< bind_t<R, F, L> > list_type;
<     return bind_t<R, left_addition<R>, list_type> (left_addition<R> (value), list_type(f));
< }
< 
< template<class R, class F, class L>
<     bind_t< R, right_addition<R>, list1< bind_t<R, F, L> > >
<     operator+ (bind_t<R, F, L> const & f, R const & value)
< {
<     typedef list1< bind_t<R, F, L> > list_type;
<     return bind_t<R, right_addition<R>, list_type> (right_addition<R> (value), list_type(f));
< }
< 
< // operator-
< template <typename R>
< struct left_substraction
< {
< 	left_substraction (const R & value) : m_value (value) {}
< 	
<     template<class V> V operator()(V const & v) const { return m_value - v; }
< 
< private:
< 	R m_value;
< };
< 
< template <typename R>
< struct right_substraction
< {
< 	right_substraction (const R & value) : m_value (value) {}
< 	
<     template<class V> V operator()(V const & v) const { return v - m_value; }
< 
< private:
< 	R m_value;
< };
< 
< template<class R, class F, class L>
<     bind_t< R, left_substraction<R>, list1< bind_t<R, F, L> > >
<     operator- (R const & value, bind_t<R, F, L> const & f)
< {
<     typedef list1< bind_t<R, F, L> > list_type;
<     return bind_t<R, left_substraction<R>, list_type> (left_substraction<R> (value), list_type(f));
< }
< 
< template<class R, class F, class L>
<     bind_t< R, right_substraction<R>, list1< bind_t<R, F, L> > >
<     operator- (bind_t<R, F, L> const & f, R const & value)
< {
<     typedef list1< bind_t<R, F, L> > list_type;
<     return bind_t<R, right_substraction<R>, list_type> (right_substraction<R> (value), list_type(f));
< }
< 
< // operator*
< template <typename R>
< struct left_multiplication
< {
< 	left_multiplication (const R & value) : m_value (value) {}
< 	
<     template<class V> V operator()(V const & v) const { return m_value * v; }
< 
< private:
< 	R m_value;
< };
< 
< template <typename R>
< struct right_multiplication
< {
< 	right_multiplication (const R & value) : m_value (value) {}
< 	
<     template<class V> V operator()(V const & v) const { return v * m_value; }
< 
< private:
< 	R m_value;
< };
< 
< template<class R, class F, class L>
<     bind_t< R, left_multiplication<R>, list1< bind_t<R, F, L> > >
<     operator* (R const & value, bind_t<R, F, L> const & f)
< {
<     typedef list1< bind_t<R, F, L> > list_type;
<     return bind_t<R, left_multiplication<R>, list_type> (left_multiplication<R> (value), list_type(f));
< }
< 
< template<class R, class F, class L>
<     bind_t< R, right_multiplication<R>, list1< bind_t<R, F, L> > >
<     operator* (bind_t<R, F, L> const & f, R const & value)
< {
<     typedef list1< bind_t<R, F, L> > list_type;
<     return bind_t<R, right_multiplication<R>, list_type> (right_multiplication<R> (value), list_type(f));
< }
< 
< // operator/
< template <typename R>
< struct left_division
< {
< 	left_division (const R & value) : m_value (value) {}
< 	
<     template<class V> V operator()(V const & v) const { return m_value / v; }
< 
< private:
< 	R m_value;
< };
< 
< template <typename R>
< struct right_division
< {
< 	right_division (const R & value) : m_value (value) {}
< 	
<     template<class V> V operator()(V const & v) const { return v / m_value; }
< 
< private:
< 	R m_value;
< };
< 
< template<class R, class F, class L>
<     bind_t< R, left_division<R>, list1< bind_t<R, F, L> > >
<     operator/ (R const & value, bind_t<R, F, L> const & f)
< {
<     typedef list1< bind_t<R, F, L> > list_type;
<     return bind_t<R, left_division<R>, list_type> (left_division<R> (value), list_type(f));
< }
< 
< template<class R, class F, class L>
<     bind_t< R, right_division<R>, list1< bind_t<R, F, L> > >
<     operator/ (bind_t<R, F, L> const & f, R const & value)
< {
<     typedef list1< bind_t<R, F, L> > list_type;
<     return bind_t<R, right_division<R>, list_type> (right_division<R> (value), list_type(f));
< }
< 
