Override enum variants without using `#[serde(tag = "...")]`?

[watsaig]

This may be more of a feature request or question than a bug as I think the current behavior is expected. But I fell into a bit of trap which was to assume that when using merge, later values would necessarily override earlier values.

Basically, I use Figment to merge defaults, user-provided values from a file, and CLI overrides as the docs suggest.

But if my config contains an enum where the default variant is different from the one I specify in the file, then the default one is chosen regardless of the merging strategy -- unless I annotate the enum with #[serde(tag = "...")].

Is it even possible to implement a merging strategy that would allow overriding enum variants that are externally-tagged or untagged? And if so, any plans / desire to include this in Figment?

In case it's not clear, here is some minimal code to explain the situation:

Details

use figment::{
    Figment,
    providers::{Format, Serialized, Toml},
};
use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
//#[serde(untagged)]
//#[serde(tag = "type")]
enum Either {
    A(A),
    B(B),
}

impl Default for Either {
    fn default() -> Self {
        Either::A(A {
            alpha: "alpha".to_string(),
        })
    }
}

#[derive(Debug, Serialize, Deserialize)]
struct A {
    alpha: String,
}

#[derive(Debug, Serialize, Deserialize)]
struct B {
    beta: u32,
}

fn main() {
    // externally tagged (default)
    let toml_string = "b.beta = 42";
    // untagged
    //let toml_string = "beta = 42";
    // internally tagged
    //let toml_string = "type = 'b'\nbeta = 42";

    let config =
        Figment::from(Serialized::defaults(Either::default())).merge(Toml::string(toml_string));
    let config: Either = config.extract().unwrap();
    println!("{:?}", config);
    // output:
    // A(A { alpha: "alpha" })

}

[watsaig]

Looking at the docs closer, I thought this could be solved with different profiles:

A profile is selected when extracting, and the dictionary corresponding to that profile is deserialized into the requested type. If no profile is selected, the Default profile is used.

There are two built-in profiles: the aforementioned default profile and the Global profile. As the name implies, the default profile contains default values for all profiles. The global profile also contains values that correspond to all profiles, but those values supersede values of any other profile except the global profile, even when another source is merged.

Based on this I would expect a value set in the Global profile to be extracted first, but this doesn't seem to be the case.

Updating my example a little to set different profiles:

// (...rest of the code as above)

fn main() {
    let default_value = Either::A(A {
        alpha: "alpha".to_string(),
    });
    let toml_string = "b.beta = 42";

    let defaults = Figment::from(Serialized::defaults(default_value));
    let overrides = Toml::string(toml_string).profile(Profile::Global);

    let config = defaults.merge(overrides).select(Profile::Global);
    println!("{:#?}", config);
    let config: Either = config.extract().unwrap();
    println!("{:?}", config);
}

The output is still A(A { alpha: "alpha" }) despite the fact that the global profile is selected, and contains a valid value for the Either enum:

Figment {
    profile: Profile(
        Uncased {
            string: "global",
        },
    ),
    metadata: [.....]
    value: Ok(
        {
            Profile(
                Uncased {
                    string: "default",
                },
            ): {
                "a": Dict(
                    {
                        "alpha": String(
                            "alpha",
                        ),
                    },
                ),
            },
            Profile(
                Uncased {
                    string: "global",
                },
            ): {
                "b": Dict(
                    {
                        "beta": Num(
                            I64(
                                42,
                            ),
                        ),
                    },
                ),
            },
        },
    ),
}