## Alternative Interface

> "It's not a question of happiness, it's a requirement. Consider the alternative” Doug Horton

As it was indicated previously `boost::optional` is the actual type returned by the `boost::convert()` main interface:

    boost::optional<TypeOut> boost::convert(TypeIn const&, Converter const&);

The signature is functionally-complete and routinely elided during compilation. Still, the following alternative (and arguably more traditional) interface might be potentially more suitable for certain deployment scenarios (or due to personal preferences):

    TypeOut convert(TypeIn const&, Converter const&, TypeOut const& fallback_value);
    TypeOut convert(TypeIn const&, Converter const&, Functor const& fallback_func);
    TypeOut convert(TypeIn const&, Converter const&, boost::throw_on_failure);

The interface still provides unambiguous behavior and readability, full support for various program flows and various degrees of conversion-failure detection and processing. It can be deployed in a similar fashion as follows:

    struct fallback_func
    {
        int operator()() const { log("Failed to convert"); return 42; }
    };

    // Error-processing behavior are specified unambiguously and uniformly.
    // a) i1: Returns the provided fallback value;
    // b) i2: Calls the provided failure-processing function;
    // c) i3: Throws an exception.

    int i1 = convert<int>(str, cnv, fallback_value);
    int i2 = convert<int>(str, cnv, fallback_func());

    try
    {
        // Throwing behavior specified explicitly rather than implied.
        int i3 = convert<int>(str, cnv, boost::throw_on_failure);
    }
    catch (boost::bad_optional_access const&)
    {
      // Handle failed conversion.
    }

Still, the described interfaces are convenience wrappers around the main interface which provides the described behavior with:

    int m1 = convert<int>(str, cnv).value_or(fallback_value);
    int m2 = convert<int>(str, cnv).value_or_eval(fallback_func());
    int m3 = convert<int>(str, cnv).value();