trait TryInto for FieldValue

[alllel]

The traits TryInto<> for FiledValue is implemented on value, not on reference. That means that value (of type FieldValue) must be consumed during conversion. I think it is not quite convenient.

One more inconvenience arises from the fact that the method get of FieldTable returns a borrowed reference to FieldValue.
Such value cannot be directly converted via try_into(). Instead one must do .clone() before .try_into().

Of course implementing this trait for reference means that this cloning will take place inside of the try_into() method.
But, for example, for conversion to bool, this will mean implicit cloning of bool instead of explicit cloning of FieldValue.

Is such a change possible? Desirable? Will it break some existing code?
Maybe it is possible to implement both variants from value and from reference?

[gftea]

TryInto trait contract is to consume the type, for type safety, cannot use reference
get is not supposed to return reference, user need to clone it explictly, which is better than implicitly doing clone at cost internally

[alllel]

Yes, I see the point that explicit clone is better than implicit.

But what about bool (and, probably, other types implementing Copy)?
For such types implicit clone is the desired behavior!
BTW: there could be similar conversions to various int and float values, but only bool and String are currently implemented.

[alllel]

What do you say about the following implementation?

impl<'a> TryInto<&'a LongStr> for &'a FieldValue {
    type Error = crate::Error;

    fn try_into(self) -> Result<&'a LongStr, Self::Error> {
        match self {
            FieldValue::S(v) => Ok(v),
            _ => Err(crate::Error::Message("not a LongStr".to_string())),
        }
    }
}

Here we have no implicit clone.
User has possibility to clone only string but not the whole container.

[gftea]

I agree this is a good idea to add, please submit a PR. Thanks!

What do you say about the following implementation?

impl<'a> TryInto<&'a LongStr> for &'a FieldValue {
    type Error = crate::Error;

    fn try_into(self) -> Result<&'a LongStr, Self::Error> {
        match self {
            FieldValue::S(v) => Ok(v),
            _ => Err(crate::Error::Message("not a LongStr".to_string())),
        }
    }
}

Here we have no implicit clone. User has possibility to clone only string but not the whole container.