diff --git a/include/boost/range/adaptor/transformed.hpp b/include/boost/range/adaptor/transformed.hpp
index 96d2dab..98c655e 100755
--- a/include/boost/range/adaptor/transformed.hpp
+++ b/include/boost/range/adaptor/transformed.hpp
@@ -41,20 +41,32 @@ namespace boost
             typedef F transform_fn_type;
             typedef R source_range_type;
 
+#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
             transformed_range( F f, R& r )
                 : base( boost::make_transform_iterator( boost::begin(r), f ),
                         boost::make_transform_iterator( boost::end(r), f ) )
 
-            { }
+            {
+            }
+#else
+            transformed_range(F&& f, R&& r)
+                : base(typename base::iterator(boost::begin(r), std::forward(f),
+                       typename base::iterator(boost::end(r), std::forward(f))))
+            {
+            }
+
+#endif
         };
 
         template< class T >
         struct transform_holder : holder<T>
         {
             transform_holder( T r ) : holder<T>(r)
-            { }
+            {
+            }
         };
 
+#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
         template< class InputRng, class UnaryFunction >
         inline transformed_range<UnaryFunction,InputRng>
         operator|( InputRng& r,
@@ -70,6 +82,16 @@ namespace boost
         {
            return transformed_range<UnaryFunction, const InputRng>( f.val, r );
         }
+#else
+        template<class InputRng, class UnaryFunction>
+        inline transformed_range<UnaryFunction,InputRng>
+        operator|(InputRng&& r,
+                  transform_holder<UnaryFunction>&& f)
+        {
+            return transformed_range<UnaryFunction, InputRng>(
+                        f.val, std::forward(r));
+        }
+#endif
 
     } // 'range_detail'
 
@@ -84,6 +106,7 @@ namespace boost
                       range_detail::forwarder<range_detail::transform_holder>();
         }
 
+#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
         template<class UnaryFunction, class InputRange>
         inline transformed_range<UnaryFunction, InputRange>
         transform(InputRange& rng, UnaryFunction fn)
@@ -97,6 +120,16 @@ namespace boost
         {
             return transformed_range<UnaryFunction, const InputRange>(fn, rng);
         }
+#else
+    template<typename UnaryFunction, typename InputRange>
+    inline transformed_range<UnaryFunction, InputRange>
+    transform(InputRange&& rng, UnaryFunction&& fn)
+    {
+        return transformed_range<UnaryFunction, InputRange>(
+                    std::forward(fn), std::forward(rng));
+    }
+
+#endif
     } // 'adaptors'
 
 }
diff --git a/test/adaptor_test/transformed.cpp b/test/adaptor_test/transformed.cpp
index 6b6121e..adadafc 100644
--- a/test/adaptor_test/transformed.cpp
+++ b/test/adaptor_test/transformed.cpp
@@ -14,6 +14,7 @@
 #include <boost/test/unit_test.hpp>
 
 #include <boost/assign.hpp>
+#include <boost/bind.hpp>
 #include <boost/range/algorithm_ext.hpp>
 
 #include <algorithm>
@@ -92,6 +93,29 @@ namespace boost
             transformed_test_impl< std::set< int > >();
             transformed_test_impl< std::multiset< int > >();
         }
+
+        struct foo_bind
+        {
+            int foo() const { return 7; }
+        };
+
+        void transformed_bind()
+        {
+            using namespace boost::adaptors;
+
+            std::vector<foo_bind> input(5);
+            std::vector<int> output;
+            boost::range::push_back(
+                    output,
+                    input | transformed(boost::bind(&foo_bind::foo, _1)));
+
+            BOOST_CHECK_EQUAL(output.size(), input.size());
+
+            std::vector<int> reference_output(5, 7);
+            BOOST_CHECK_EQUAL_COLLECTIONS(
+                        output.begin(), output.end(),
+                        reference_output.begin(), reference_output.end());
+        }
     }
 }
 
@@ -101,7 +125,8 @@ init_unit_test_suite(int argc, char* argv[])
     boost::unit_test::test_suite* test
         = BOOST_TEST_SUITE( "RangeTestSuite.adaptor.transformed" );
 
-    test->add( BOOST_TEST_CASE( &boost::transformed_test ) );
+    test->add(BOOST_TEST_CASE(&boost::transformed_test));
+    test->add(BOOST_TEST_CASE(&boost::transformed_bind));
 
     return test;
 }