serializing enums with the default externally tagged serde option?

[divagant-martian]

as per the title.

To my surprise, this fails:

use serde::{self, Deserialize, Serialize};

#[derive(Deserialize, Debug, Serialize)]
struct Config {
    store: StoreKind,
}

#[derive(Deserialize, Debug, Serialize)]
enum StoreKind {
    File(FileConfig),
    Other,
}

#[derive(Deserialize, Debug, Serialize)]
struct FileConfig {
    path: String,
}

fn main() {
    let cfg = Config {
        store: StoreKind::File(FileConfig {
            path: "path/to/thing".into(),
        }),
    };
    let repr = basic_toml::to_string(&cfg).unwrap();
    println!("{repr}");
}

[oxalica]

Deserialization does not work either. I have a configuration type like this:

#[derive(Debug, serde::Deserialize)]
enum Listen {
    Address(String),
    Unix(String),
}

fn main() {
    let conf = r#"
Address = "localhost"
    "#;
    dbg!(basic_toml::from_str::<Listen>(conf));
    dbg!(toml::from_str::<Listen>(conf));
}

It gives:

[src/main.rs:11:5] basic_toml::from_str::<Listen>(conf) = Err(
    Error {
        kind: Custom,
        line: Some(
            0,
        ),
        col: 0,
        at: Some(
            0,
        ),
        message: "invalid type: map, expected enum Listen",
        key: [],
    },
)
[src/main.rs:12:5] toml::from_str::<Listen>(conf) = Ok(
    Address(
        "localhost",
    ),
)