Re: [boost] Boost.Convert+Boost.Parameter

Subject: Re: [boost] Boost.Convert+Boost.Parameter
From: Jeff Flinn (TriumphSprint2000_at_[hidden])
Date: 2009-02-28 09:54:35

Vladimir Batov wrote:
>> "Andrey Semashev" <andrey.semashev_at_[hidden]> wrote
>>   convert< string >((param1 = val1, param2 = val2, ...));
> 
> Andrey,
> 
> I started playing with your example integrating it in to the conversion 
> framework and managed to get it working. Thank you for the example and 
> that parameter_type extension. The whole thing seems to rely on that 
> facility. Well, the interface I am using (without Boost.Parameter) is
> 
>    int i = convert::to<int>(str);
>    int i = convert::from(str, -1);
> 
> (almost what I initially started from :-) ) I tried to get rid of 
> 'to&from' (several times) but in the end decided I needed to keep the 
> two variations as the 'from' deduces both (TypeIn, TypeOut) parameters 
> from the signature when the 'to' requires TypeOut explicitly specified. 
> Having both named convert() reads wrong for the 'to' specialization:
> 
>    int i = convert<int>(str);
> 
> and I could not stand it. Another option would be to ditch 'to' 
> altogether but I am not sure how it might be taken. Also I tried 
> deducing TypeOut parameter for 'to' as well via
> 
> template<class TypeIn>
> implementation
> {
>    template<class TypeOut> operator TypeOut()
> };
> 
> but did not get too far either.
> 
> Well, I digressed from my original post about Boost.Parameter as I did 
> not want us to get bogged down with convert::to and convert::from again 
> (and BTW you cannot shortcut them so they are very much like convert_to, 
> convert_from). OK. What I got working (thanks to your help) is
> 
>    int i = convert::to<int>(str, radix_ = 10);
>    int i = convert::from(str, default_ = -1);
>    int i = convert::from(str, (default_ = -1, radix_ = 10));
> 
> I understand the benefits of passing additional conversion parameters 
> like 'radix_ = 10' down to the conversion *implementation*. However, I 
> feel these parameters are of no value (and not accessible) to the 
> "casual" user (as opposed to the conversion implementer)... unlike I/O 
> Stream-based approach which allows the user to write his own manipulator 
> and deploy it like
> 
>    int i = convert::from(str, -1) >> my_special_formatter;
> 
> Is my understanding correct or you have some ideas of getting that 
> *user* extensibility with Boost.Parameter?
> 
> Secondly, I kinda like the explicitness of
> 
>    int i = convert::from(str, default_ = -1);
> 
> however, does it really add much (apart from verbosity) compared with
> 
>    int i = convert::from(str, -1);
> 
> I do not feel the above line is the trickiest in the whole Boost so that 
> we need to get out of our way to spell out every damn thing. What do you 
> think? That leads me to my question. Would that be sensible to have it 
> as follows:
> 
>    int i = convert::to<int>(str, (radix_ = 10, locale_= ...));
>    int i = convert::from(str, -1, (radix_ = 10, locale_= ...));
> 
> or you might have something else in mind?

Have you thought of making convert a class templated on the destination 
type which would allow a single function 'from', ala:

     int i = convert<int>::from(str, (radix_ = 10, locale_= ...));
     int i = convert<int>::from(str, -1, (radix_ = 10, locale_= ...));

Which reads more naturally to me in english, at least.

jeff