Index: boost/units/lambda.hpp
===================================================================
--- boost/units/lambda.hpp	(Revision 48214)
+++ boost/units/lambda.hpp	(Arbeitskopie)
@@ -34,6 +34,7 @@
 
 #include <boost/lambda/lambda.hpp>
 #include <boost/units/units_fwd.hpp>
+#include <boost/units/detail/dimensionless_unit.hpp>
 #include <boost/units/operators.hpp>
 
 namespace boost {
@@ -318,6 +319,28 @@
     };
 
     /// Partial specialization of return type trait for action
+    /// quantity<dimensionless, X> + Y.
+    template<typename System, typename X, typename Y>
+    struct plain_return_type_2<arithmetic_action<plus_action>,
+                               boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), X>,
+                               Y> {
+        typedef typename boost::units::add_typeof_helper<
+            boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), X>,
+            Y>::type type;
+    };
+
+    /// Partial specialization of return type trait for action
+    /// X + quantity<dimensionless, Y>.
+    template<typename System, typename X, typename Y>
+    struct plain_return_type_2<arithmetic_action<plus_action>,
+                               X,
+                               boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y> > {
+        typedef typename boost::units::add_typeof_helper<
+            X,
+            boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y> >::type type;
+    };
+
+    /// Partial specialization of return type trait for action
     /// quantity<Unit1, X> - quantity<Unit2, Y>.
     template<typename Unit1, typename X, typename Unit2, typename Y>
     struct plain_return_type_2<arithmetic_action<minus_action>,
@@ -329,6 +352,28 @@
     };
 
     /// Partial specialization of return type trait for action
+    /// quantity<dimensionless, X> - Y.
+    template<typename System, typename X, typename Y>
+    struct plain_return_type_2<arithmetic_action<minus_action>,
+                               boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), X>,
+                               Y> {
+        typedef typename boost::units::subtract_typeof_helper<
+            boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), X>,
+            Y>::type type;
+    };
+
+    /// Partial specialization of return type trait for action
+    /// X - quantity<dimensionless, Y>.
+    template<typename System, typename X, typename Y>
+    struct plain_return_type_2<arithmetic_action<minus_action>,
+                               X,
+                               boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y> > {
+        typedef typename boost::units::subtract_typeof_helper<
+            X,
+            boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y> >::type type;
+    };
+
+    /// Partial specialization of return type trait for action
     /// quantity<Unit1, X> * quantity<Unit2, Y>.
     template<typename Unit1, typename X, typename Unit2, typename Y>
     struct plain_return_type_2<arithmetic_action<multiply_action>,
Index: libs/units/test/test_lambda.cpp
===================================================================
--- libs/units/test/test_lambda.cpp	(Revision 48214)
+++ libs/units/test/test_lambda.cpp	(Arbeitskopie)
@@ -142,9 +142,21 @@
     // quantity<Unit1, X> + quantity<Unit2, Y>
     BOOST_CHECK(((bl::_1 + bl::_2)(2.0 * bu::meter, 4.0 * bu::meter) == 6.0 * bu::meter));
 
+    // quantity<dimensionless, X> + Y
+    BOOST_CHECK(((bl::_1 + 1.0f)(bu::quantity<bu::dimensionless>(2.0)) == 3.0));
+
+    // X + quantity<dimensionless, Y>
+    BOOST_CHECK(((1.0f + bl::_1)(bu::quantity<bu::dimensionless>(1.0)) == 2.0));
+
     // quantity<Unit1, X> - quantity<Unit2, Y>
     BOOST_CHECK(((bl::_1 - bl::_2)(2.0 * bu::meter, 4.0 * bu::meter) == -2.0 * bu::meter));
 
+    // quantity<dimensionless, X> - Y
+    BOOST_CHECK(((bl::_1 - 2.0f)(bu::quantity<bu::dimensionless>(1.0)) == -1.0));
+
+    // X - quantity<dimensionless, Y>
+    BOOST_CHECK(((2.0f - bl::_1)(bu::quantity<bu::dimensionless>(1.0)) == 1.0));
+
     // quantity<Unit1, X> * quantity<Unit2, Y>
     BOOST_CHECK(((bl::_1 * bl::_2)(2.0 * bu::kilogram, 4.0 * bu::meter_per_second) == 8.0 * bu::kilogram * bu::meter_per_second));