On Tue, Oct 19, 2010 at 3:34 AM, Matt Calabrese <rivorus@gmail.com> wrote:
All of these details can be worked out after I submit it for review, and at that point, pending it even gets accepted, if there is a strong opinion in one direction I will make changes, but as of right now I'd rather just get back to focusing on functionality.
Alright, I have an interesting way to handle checking arbitrary expression requirements for the automatically deduced result type, but I'm not sure it's standard.:It's actually kind of nasty, but I think it would work and it also has the side-effect of allowing users to pass a series of statements, including declarations, to "try" and "continue try", instead of a preprocessor sequence of expressions (though compilers can't handle it yet). For a macro invocation such as this: template< class T > BOOST_AUTO_FUNCTION( (foo( T arg )) , ( continue try some_required_function( _result_() ); some_other_function( _result_() ); ) , ( return arg + 1; ) ) It would generate code where something such as the following would appear at some point in the return type, for purposes of SFINAE: decltype( [&]( decltype( [&]{ return arg; }() ) (*_result_)() ){ some_required_function( _result_() )); some_other_function( _result_() );; } ) That's a mouthful, I know, but essentially what's happening is I'm creating a lambda that has a function pointer parameter called "_result_" with a return type that matches that of the "auto function", and in the body of that lamda function it simply repeats the arguments passed to "continue try". The reason why _result_ is a function pointer that is invoked as opposed to simply a parameter whose type is a reference to the result type is because doing that would force the value to be an lvalue when used in expressions. By making _result_ a function pointer to be called, we can be certain that its use in tested expressions has exactly the properties as that of using the result type of the "auto function". If the user wishes to test the result as if it were an lvalue, he'd either create a declaration, or I could simply add a second parameter to the lambda function called "_lvalue_result_" whose type is a reference to the result type of the "auto function". It's pretty gross, but I think it might be standard. It won't be implemented for a while though, as I have no way to test it. -- -Matt Calabrese