{"id":31104766,"url":"https://github.com/marcoradocchia/beerec-variants","last_synced_at":"2026-01-20T17:36:04.345Z","repository":{"id":308924462,"uuid":"1034547380","full_name":"marcoradocchia/beerec-variants","owner":"marcoradocchia","description":"Procedural derive macro to generate boilerplate on unit variants enum types.","archived":false,"fork":false,"pushed_at":"2025-09-11T00:32:16.000Z","size":65,"stargazers_count":0,"open_issues_count":0,"forks_count":0,"subscribers_count":0,"default_branch":"main","last_synced_at":"2025-09-11T04:11:25.693Z","etag":null,"topics":["boilerplate","enum","proc-macro","proc-macro-derive","rust"],"latest_commit_sha":null,"homepage":"","language":"Rust","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/marcoradocchia.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":".github/FUNDING.yml","license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null},"funding":{"github":"marcoradocchia"}},"created_at":"2025-08-08T15:08:13.000Z","updated_at":"2025-09-11T00:32:20.000Z","dependencies_parsed_at":null,"dependency_job_id":"8a8b0851-4a55-4bf1-8117-98c4e015ef97","html_url":"https://github.com/marcoradocchia/beerec-variants","commit_stats":null,"previous_names":["marcoradocchia/beerec-variants"],"tags_count":3,"template":false,"template_full_name":null,"purl":"pkg:github/marcoradocchia/beerec-variants","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/marcoradocchia%2Fbeerec-variants","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/marcoradocchia%2Fbeerec-variants/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/marcoradocchia%2Fbeerec-variants/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/marcoradocchia%2Fbeerec-variants/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/marcoradocchia","download_url":"https://codeload.github.com/marcoradocchia/beerec-variants/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/marcoradocchia%2Fbeerec-variants/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":275531430,"owners_count":25481325,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","status":"online","status_checked_at":"2025-09-17T02:00:09.119Z","response_time":84,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["boilerplate","enum","proc-macro","proc-macro-derive","rust"],"created_at":"2025-09-17T03:47:50.867Z","updated_at":"2026-01-20T17:36:04.338Z","avatar_url":"https://github.com/marcoradocchia.png","language":"Rust","funding_links":["https://github.com/sponsors/marcoradocchia"],"categories":[],"sub_categories":[],"readme":"\u003cdiv align=\"center\"\u003e\n  \u003ch1 align=\"center\"\u003ebeerec-variants\u003c/h1\u003e\n\n  [![GitHub source size](https://img.shields.io/github/languages/code-size/marcoradocchia/beerec-variants?color=ea6962\u0026logo=github\u0026style=flat-square)](https://github.com/marcoradocchia/beerec-variants)\n  [![GitHub open issues](https://img.shields.io/github/issues-raw/marcoradocchia/beerec-variants?color=d8a657\u0026logo=github\u0026style=flat-square)](https://github.com/marcoradocchia/beerec-variants/issues)\n  [![GitHub open pull requests](https://img.shields.io/github/issues-pr-raw/marcoradocchia/beerec-variants?color=89b482\u0026logo=github\u0026style=flat-square)](https://github.com/marcoradocchia/beerec-variants/pulls)\n  [![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/marcoradocchia/beerec-variants/rust.yml?color=7daea3\u0026logo=github\u0026style=flat-square)](https://github.com/marcoradocchia/beerec-variants/actions)\n  [![GitHub sponsors](https://img.shields.io/github/sponsors/marcoradocchia?color=d3869b\u0026logo=github\u0026style=flat-square)](https://github.com/sponsors/marcoradocchia)\n  [![Crates.io Total Downloads](https://img.shields.io/crates/d/beerec-variants?color=89b482\u0026logo=rust\u0026style=flat-square\u0026label=crates.io%20downloads)](https://crates.io/crates/beerec-variants)\n  [![Crates.io Version](https://img.shields.io/crates/v/beerec-variants?color=d3869b\u0026logo=rust\u0026style=flat-square\u0026label=crates.io%20version)](https://crates.io/crates/beerec-variants)\n  [![Docs.rs](https://img.shields.io/docsrs/beerec-variants?color=7c6f64\u0026style=flat-square\u0026logo=rust)](https://docs.rs/beerec-variants)\n  [![GitHub license](https://img.shields.io/github/license/marcoradocchia/beerec-variants?color=e78a4e\u0026style=flat-square)](https://github.com/marcoradocchia/beerec-variants/blob/main/LICENSE)\n\u003c/div\u003e\n\nDerive macro to generate boilerplate on unit variants `enum` types.\n\nThe macro generates the following methods:\n\n- `as_str` - returns a string representation of the target `enum` variant;\n- `as_str_abbr` - returns an abbreviated string representation of the target\n  `enum` variant;\n- `iter_variants` - returns an iterator over target `enum` variants (owned\n  values);\n- `iter_variants_as_str` - returns an iterator over string representations\n  of the target `enum` variants (`\u0026'static str` values);\n- `iter_variants_as_str_abbr` - returns an iterator over abbreviated string\n  representations of the `enum` variants (`\u0026'static str` values);\n- `variants_list_str` - returns a list of quoted (double-quotes) and comma\n  separated string representations of the `enum` variants;\n- `variants_list_str_abbr` - returns a list of of quoted (double-quotes) and\n  comma separated abbreviated string representation of the `enum` variants.\n\n# Enum level attributes\n\nThe macro exposes the following `enum` outer attributes (i.e. attributes to\nbe applied to the `enum` type the macro is being derived on):\n\n- `rename` - customizes the string representation of each variant;\n- `rename_abbr` - customizes the abbreviated string representation of each\n  variant;\n- `display` - generates a [`Display`] trait implementation based on the\n  string representation provided by the generated `as_str` method;\n- `from_str` - generates a [`FromStr`] trait implementation based on the\n  string or abbreviated string representation provided by the generated\n  `as_str` and `as_str_abbr` methods respectively.\n\nValid `rename` and `rename_abbr` customization strategies are:\n\n- `uppercase` - makes the (abbreviated) string representation uppercase;\n- `lowercase` - makes the (abbreviated) string representation lowercase.\n\n## Examples\n\n```rust\n#[derive(Variants)]\n#[variants(rename(uppercase))]\nenum CardinalDirection {\n    North,\n    East,\n    South,\n    West,\n}\n\nassert_eq!(\"NORTH\", CardinalDirection::North.as_str());\nassert_eq!(\"EAST\", CardinalDirection::East.as_str());\nassert_eq!(\"SOUTH\", CardinalDirection::South.as_str());\nassert_eq!(\"WEST\", CardinalDirection::West.as_str());\n\nassert_eq!(\"NOR\", CardinalDirection::North.as_str_abbr());\nassert_eq!(\"EAS\", CardinalDirection::East.as_str_abbr());\nassert_eq!(\"SOU\", CardinalDirection::South.as_str_abbr());\nassert_eq!(\"WES\", CardinalDirection::West.as_str_abbr());\n```\n\n```rust\n#[derive(Variants)]\n#[variants(rename(lowercase), rename_abbr(uppercase))]\nenum State {\n    Active,\n    Inactive,\n    Disabled,\n}\n\nassert_eq!(\"active\", State::Active.as_str());\nassert_eq!(\"inactive\", State::Inactive.as_str());\nassert_eq!(\"disabled\", State::Disabled.as_str());\n\nassert_eq!(\"ACT\", State::Active.as_str_abbr());\nassert_eq!(\"INA\", State::Inactive.as_str_abbr());\nassert_eq!(\"DIS\", State::Disabled.as_str_abbr());\n```\n\n```rust\n#[derive(Variants)]\n#[variants(display)]\nenum Season {\n    Spring,\n    Summer,\n    Autumn,\n    Winter,\n}\n\nassert_eq!(String::from(\"Spring\"), Season::Spring.to_string());\nassert_eq!(String::from(\"Summer\"), Season::Summer.to_string());\nassert_eq!(String::from(\"Autumn\"), Season::Autumn.to_string());\nassert_eq!(String::from(\"Winter\"), Season::Winter.to_string());\n\nassert_eq!(String::from(\"Spring\"), format!(\"{}\", Season::Spring));\nassert_eq!(String::from(\"Summer\"), format!(\"{}\", Season::Summer));\nassert_eq!(String::from(\"Autumn\"), format!(\"{}\", Season::Autumn));\nassert_eq!(String::from(\"Winter\"), format!(\"{}\", Season::Winter));\n```\n\n```rust\n#[derive(Variants)]\n#[variants(from_str)]\nenum Priority {\n    Low,\n    Medium,\n    High,\n    Critical,\n}\n\nassert_eq!(Ok(Priority::Low), FromStr::\u003cPriority\u003e::from_str(\"Low\"));\nassert_eq!(Ok(Priority::Medium), FromStr::\u003cPriority\u003e::from_str(\"Medium\"));\nassert_eq!(Ok(Priority::High), FromStr::\u003cPriority\u003e::from_str(\"High\"));\nassert_eq!(Ok(Priority::Critical), FromStr::\u003cPriority\u003e::from_str(\"Critical\"));\n\nassert_eq!(Ok(Priority::Low), FromStr::\u003cPriority\u003e::from_str(\"Low\"));\nassert_eq!(Ok(Priority::Medium), FromStr::\u003cPriority\u003e::from_str(\"Med\"));\nassert_eq!(Ok(Priority::High), FromStr::\u003cPriority\u003e::from_str(\"Hig\"));\nassert_eq!(Ok(Priority::Critical), FromStr::\u003cPriority\u003e::from_str(\"Cri\"));\n\nassert_eq!(Err(ParsePriorityError), FromStr::\u003cPriority\u003e::from_str(\"invalid\"));\n```\n\n## Feature-gated attributes\n\n### [Serde](https://crates.io/crates/serde)\n\nThe following `enum` outer attributes are exposed when the `serde` feature is\nenabled:\n\n- `deserialize` - generates a [`Deserialize`] trait implementation based on\n  the string or abbreviated string representation provided by the generated\n  `as_str` and `as_str_abbr` respectively;\n- `serialize` - generates a [`Serialize`] trait implementation based on the\n  string representation provided by the generated `as_str` method.\n\n#### Examples\n\n```rust\n#[derive(Debug, Variants, PartialEq, Eq)]\n#[variants(deserialize)]\nenum Theme {\n    Auto,\n    Dark,\n    Light,\n}\n\n#[derive(Debug, PartialEq, Eq)]\n#[derive(serde::Deserialize)]\nstruct Config {\n    theme: Theme,\n}\n\n// Deserialize from variant string representation.\nassert_eq!(\n    Ok(Config { theme: Theme::Auto }),\n    toml::from_str::\u003c'_, Config\u003e(\"theme = \\\"Auto\\\"\\n\"),\n);\n\nassert_eq!(\n    Ok(Config { theme: Theme::Dark }),\n    toml::from_str::\u003c'_, Config\u003e(\"theme = \\\"Dark\\\"\\n\"),\n);\n\nassert_eq!(\n    Ok(Config { theme: Theme::Light }),\n    toml::from_str::\u003c'_, Config\u003e(\"theme = \\\"Light\\\"\\n\"),\n);\n\n// Deserialize from variant abbreviated string representation.\nassert_eq!(\n    Ok(Config { theme: Theme::Auto }),\n    toml::from_str::\u003c'_, Config\u003e(\"theme = \\\"Aut\\\"\\n\"),\n);\n\nassert_eq!(\n    Ok(Config { theme: Theme::Dark }),\n    toml::from_str::\u003c'_, Config\u003e(\"theme = \\\"Dar\\\"\\n\"),\n);\n\nassert_eq!(\n    Ok(Config { theme: Theme::Light }),\n    toml::from_str::\u003c'_, Config\u003e(\"theme = \\\"Lig\\\"\\n\"),\n);\n```\n\n```rust\n#[derive(Debug, Variants, PartialEq, Eq)]\n#[variants(serialize)]\nenum Codec {\n    H264,\n    H265,\n    AV1,\n}\n\n#[derive(Debug, PartialEq, Eq)]\n#[derive(serde::Serialize)]\nstruct Config {\n    codec: Codec,\n}\n\nassert_eq!(\n    Ok(String::from(\"codec = \\\"H264\\\"\\n\")),\n    toml::to_string(\u0026Config { codec: Codec::H264 }),\n);\n\nassert_eq!(\n    Ok(String::from(\"codec = \\\"H265\\\"\\n\")),\n    toml::to_string(\u0026Config { codec: Codec::H265 }),\n);\n\nassert_eq!(\n    Ok(String::from(\"codec = \\\"AV1\\\"\\n\")),\n    toml::to_string(\u0026Config { codec: Codec::AV1 }),\n);\n```\n\n# Variant level attributes\n\nThe macro exposes the following variant attributes:\n\n- `skip` - excludes the marked variant from iteration and listing;\n- `rename` - customizes the string representation of the marked variant;\n- `rename_abbr` - customizes the abbreviated string representation of the\n  marked variant.\n\nValid `rename` and `rename_abbr` customization strategies are:\n\n- `\"...\"` (string literal) - overrides the string representation with a\n  custom string;\n- `uppercase` - makes the (abbreviated) string representation uppercase;\n- `lowercase` - makes the (abbreviated) string representation lowercase.\n\nFor custom string overrides:\n\n- `#[variants(rename = \"...\")]` is equivalent to\n  `#[variants(rename(\"...\"))]`;\n- `#[variants(rename_abbr = \"...\")]` is equivalent to\n  `#[variants(rename_abbr(\"...\"))]`;\n\nboth are valid, supported formats.\n\n## Examples\n\n```rust\n#[derive(Variants)]\nenum Format {\n    Xml,\n    Csv,\n    #[variants(rename(\"plain-text\"), rename_abbr = \"txt\")]\n    PlainText,\n}\n\nassert_eq!(\"Xml\", Format::Xml.as_str());\nassert_eq!(\"Csv\", Format::Csv.as_str());\nassert_eq!(\"plain-text\", Format::PlainText.as_str());\n\nassert_eq!(\"Xml\", Format::Xml.as_str_abbr());\nassert_eq!(\"Csv\", Format::Csv.as_str_abbr());\nassert_eq!(\"txt\", Format::PlainText.as_str_abbr());\n```\n\n# String representation renaming priority\n\nTo produce _string representations_ of enum variants, renaming can be\napplied at both the type level and variant level. The string representation\nof each variant is obtained by applying rename strategies following a\npriority-based fallback approach:\n\n1. **Variant-level attribute** (_highest priority_) - usese the string\n   produced by the rename strategy from the `#[variants(rename(...))]`\n   attribute, if one has been specified for the variant;\n1. **Type-level attribute** (_fallback_) - uses the string produced by the\n   rename strategy from the `#[variants(rename(...))]` attribute, if one has\n   been specified for the type;\n1. **No renaming** (_default_) - converts the variant identifier to a string\n   if neither the type-level nor the variant-level rename attribute has been\n   specified.\n\n# Abbreviated string representation renaming priority\n\nTo produce _abbreviated string representations_ of the enum variants,\nrenaming can be applied at both the type level and the variant level. The\nabbreviated string representation of each variant is obtained by applying\nrename strategies following a priority-based fallback approach:\n\n1. **Variant-level attribute** (_highest priority_) - uses the abbreviated\n   string produced by the rename strategy from the\n   `#[variants(rename_abbr(...))]` attribute, if one has been specified for\n   the variant;\n1. **Type-level attribute** (_fallback_) - uses the string produced by the\n   rename strategy from the `#[variants(rename(...))]` attribute, if one has\n   been specified for the type;\n1. **No renaming** (_default_) - abbreviates the full length string\n   representation of the variant as is, without applying any renaming\n   strategy.\n\nLikewise, the renaming follows a priority-based fallback approach to\ndetermine the full length string representation before applying the\nabbreviation:\n\n1. **Variant-level attribute** (_highest priority_) - uses the string\n   produced by the rename strategy from the `#[variants(rename(...))]`\n   attribute, if one has been specified for the type;\n1. **Type-level attribute** (_fallback_) - uses the string produced by the\n   rename strategy from the `#[variants(rename(...))]` attribute, if one has\n   been specified for the type;\n1. **No renaming** (_default_) - converts the variant identifier to a string\n   if neither the type-level nor the variant-level rename attribute has been\n   specified.\n\n# Errors\n\nThe macro will produce a compile error if:\n\n- derived on `struct` types;\n- derived on `union` types;\n- derived on `enum` types with any named field variants;\n- derived on `enum` types with any unnamed field (i.e. tuple) variants;\n- derived on `enum` types with any newtype variants;\n- the `rename` variant-level attribute is passed any other value than a\n  string literal, `uppercase` or `lowercase`;\n- the `rename_abbr` variant-level attribute is passed any other value than a\n  string literal, `uppercase` or `lowercase`;\n- the `rename` type-level attribute is passed any other value than\n  `uppercase` or `lowercase`;\n- the `rename_abbr` type-level attribute is passed any other value than\n  `uppercase` or `lowercase`.\n\n# Notes\n\nDeriving `Variants` on type automatically implements [`Clone`] and\n[`Copy`] for such type. This means that deriving either trait on a type that\nalso derives `Variants` will result in a \"conflicting implementations\"\ncompilation error.\n\n# Examples\n\n```rust\n#[derive(Variants, Debug, PartialEq, Eq)]\n#[cfg_attr(feature = \"serde\", variants(deserialize, serialize))]\n#[variants(display, from_str)]\nenum Weekday {\n    #[variants(skip)]\n    Monday,\n    #[variants(rename = \"DayAfterMonday\", rename_abbr = \"tue\")]\n    Tuesday,\n    #[variants(rename_abbr = \"wed\")]\n    Wednesday,\n    #[variants(rename = \"Giovedì\", rename_abbr(lowercase))]\n    Thursday,\n    Friday,\n    Saturday,\n    Sunday,\n}\n\n#[derive(Debug, PartialEq, Eq)]\n#[cfg_attr(feature = \"serde\", derive(serde::Deserialize, serde::Serialize))]\nstruct Schedule {\n    weekday: Weekday,\n}\n\n// Monday has been marked as `skip`, iterator will yield 6 values.\nassert_eq!(6, Weekday::iter_variants().count());\n\nassert_eq!(\"Monday\", Weekday::Monday.as_str());\nassert_eq!(\"DayAfterMonday\", Weekday::Tuesday.as_str());\nassert_eq!(\"Wednesday\", Weekday::Wednesday.as_str());\nassert_eq!(\"Giovedì\", Weekday::Thursday.as_str());\nassert_eq!(\"Friday\", Weekday::Friday.as_str());\nassert_eq!(\"Saturday\", Weekday::Saturday.as_str());\nassert_eq!(\"Sunday\", Weekday::Sunday.as_str());\n\nassert_eq!(\"Mon\", Weekday::Monday.as_str());\nassert_eq!(\"tue\", Weekday::Tuesday.as_str());\nassert_eq!(\"wed\", Weekday::Wednesday.as_str());\nassert_eq!(\"gio\", Weekday::Thursday.as_str());\nassert_eq!(\"Fri\", Weekday::Friday.as_str());\nassert_eq!(\"Sat\", Weekday::Saturday.as_str());\nassert_eq!(\"Sun\", Weekday::Sunday.as_str());\n\n// The enum has been marked as `display`, so `std::fmt::Display` implementation is available.\nassert_eq!(String::from(\"Monday\"), Weekday::Monday.to_string());\nassert_eq!(String::from(\"DayAfterMonday\"), Weekday::Tuesday.to_string());\nassert_eq!(String::from(\"Wednesday\"), Weekday::Wednesday.to_string());\nassert_eq!(String::from(\"Giovedì\"), Weekday::Thursday.to_string());\nassert_eq!(String::from(\"Friday\"), Weekday::Friday.to_string());\nassert_eq!(String::from(\"Saturday\"), Weekday::Saturday.to_string());\nassert_eq!(String::from(\"Sunday\"), Weekday::Sunday.to_string());\n\nassert_eq!(String::from(\"Monday\"), format!(\"{}\", Weekday::Monday));\nassert_eq!(String::from(\"DayAfterMonday\"), format!(\"{}\", Weekday::Tuesday));\nassert_eq!(String::from(\"Wednesday\"), format!(\"{}\", Weekday::Wednesday));\nassert_eq!(String::from(\"Giovedì\"), format!(\"{}\", Weekday::Thursday));\nassert_eq!(String::from(\"Friday\"), format!(\"{}\", Weekday::Friday));\nassert_eq!(String::from(\"Saturday\"), format!(\"{}\", Weekday::Saturday));\nassert_eq!(String::from(\"Sunday\"), format!(\"{}\", Weekday::Sunday));\n\nlet mut weekdays = Weekday::iter_variants();\nassert_eq!(Some(Weekday::Tuesday), weekdays.next());\nassert_eq!(Some(Weekday::Wednesday), weekdays.next());\nassert_eq!(Some(Weekday::Thursday), weekdays.next());\nassert_eq!(Some(Weekday::Friday), weekdays.next());\nassert_eq!(Some(Weekday::Saturday), weekdays.next());\nassert_eq!(Some(Weekday::Sunday), weekdays.next());\nassert_eq!(None, weekdays.next());\n\nlet mut weekdays_as_str = Weekday::iter_variants_as_str();\nassert_eq!(Some(\"DayAfterMonday\"), weekdays_as_str.next());\nassert_eq!(Some(\"Wednesday\"), weekdays_as_str.next());\nassert_eq!(Some(\"Giovedì\"), weekdays_as_str.next());\nassert_eq!(Some(\"Friday\"), weekdays_as_str.next());\nassert_eq!(Some(\"Saturday\"), weekdays_as_str.next());\nassert_eq!(Some(\"Sunday\"), weekdays_as_str.next());\nassert_eq!(None, weekdays.next());\nlet mut weekdays_as_str_abbr = Weekday::iter_variants_as_str_abbr();\nassert_eq!(Some(\"tue\"), weekdays_as_str_abbr.next());\nassert_eq!(Some(\"wed\"), weekdays_as_str_abbr.next());\nassert_eq!(Some(\"gio\"), weekdays_as_str_abbr.next());\nassert_eq!(Some(\"Fri\"), weekdays_as_str_abbr.next());\nassert_eq!(Some(\"Sat\"), weekdays_as_str_abbr.next());\nassert_eq!(Some(\"Sun\"), weekdays_as_str_abbr.next());\nassert_eq!(None, weekdays.next());\n\nassert_eq!(\n    \"\\\"DayAfterMonday\\\", \\\"Wednesday\\\", \\\"Giovedì\\\", \\\"Friday\\\", \\\"Saturday\\\", \\\"Sunday\\\"\",\n    Weekday::variants_list_str(),\n);\n\nassert_eq!(\n    \"\\\"tue\\\", \\\"wed\\\", \\\"gio\\\", \\\"Fri\\\", \\\"Sat\\\", \\\"Sun\\\"\",\n    Weekday::variants_list_str_abbr(),\n);\n\n// The enum has been marked as `from_str`, so `std::str::FromStr` implementation is available.\nassert_eq!(Ok(Weekday::Monday), FromStr::\u003cWeekday\u003e::from_str(\"Monday\"));\nassert_eq!(Ok(Weekday::Tuesday), FromStr::\u003cWeekday\u003e::from_str(\"DayAfterMonday\"));\nassert_eq!(Ok(Weekday::Wednesday), FromStr::\u003cWeekday\u003e::from_str(\"Wednesday\"));\nassert_eq!(Ok(Weekday::Thursday), FromStr::\u003cWeekday\u003e::from_str(\"Giovedì\"));\nassert_eq!(Ok(Weekday::Friday), FromStr::\u003cWeekday\u003e::from_str(\"Friday\"));\nassert_eq!(Ok(Weekday::Saturday), FromStr::\u003cWeekday\u003e::from_str(\"Saturday\"));\nassert_eq!(Ok(Weekday::Sunday), FromStr::\u003cWeekday\u003e::from_str(\"Sunday\"));\n\nassert_eq!(Ok(Weekday::Monday), FromStr::\u003cWeekday\u003e::from_str(\"Mon\"));\nassert_eq!(Ok(Weekday::Tuesday), FromStr::\u003cWeekday\u003e::from_str(\"tue\"));\nassert_eq!(Ok(Weekday::Wednesday), FromStr::\u003cWeekday\u003e::from_str(\"wed\"));\nassert_eq!(Ok(Weekday::Thursday), FromStr::\u003cWeekday\u003e::from_str(\"gio\"));\nassert_eq!(Ok(Weekday::Friday), FromStr::\u003cWeekday\u003e::from_str(\"Fri\"));\nassert_eq!(Ok(Weekday::Saturday), FromStr::\u003cWeekday\u003e::from_str(\"Sat\"));\nassert_eq!(Ok(Weekday::Sunday), FromStr::\u003cWeekday\u003e::from_str(\"Sun\"));\n\nassert_eq!(Err(ParseWeekdayError), FromStr::\u003cWeekday\u003e::from_str(\"invalid\"));\n\n// The enum has been marked as `deserialize`, so `serde::Deserialize` implementation is available.\n#[cfg(feature = \"serde\")]\n{\n    // Deserialize from variant string representation.\n    assert_eq!(\n        Ok(Schedule { weekday: Weekday::Monday }),\n        toml::from_str::\u003c'_, Schedule\u003e(\"weekday = \\\"Monday\\\"\\n\"),\n    );\n\n    assert_eq!(\n        Ok(Schedule { weekday: Weekday::Tuesday }),\n        toml::from_str::\u003c'_, Schedule\u003e(\"weekday = \\\"DayAfterMonday\\\"\\n\"),\n    );\n\n    assert_eq!(\n        Ok(Schedule { weekday: Weekday::Wednesday }),\n        toml::from_str::\u003c'_, Schedule\u003e(\"weekday = \\\"Wednesday\\\"\\n\"),\n    );\n\n    assert_eq!(\n        Ok(Schedule { weekday: Weekday::Thursday }),\n        toml::from_str::\u003c'_, Schedule\u003e(\"weekday = \\\"Giovedì\\\"\\n\"),\n    );\n\n    assert_eq!(\n        Ok(Schedule { weekday: Weekday::Friday }),\n        toml::from_str::\u003c'_, Schedule\u003e(\"weekday = \\\"Friday\\\"\\n\"),\n    );\n\n    assert_eq!(\n        Ok(Schedule { weekday: Weekday::Saturday }),\n        toml::from_str::\u003c'_, Schedule\u003e(\"weekday = \\\"Saturday\\\"\\n\"),\n    );\n\n    assert_eq!(\n        Ok(Schedule { weekday: Weekday::Sunday }),\n        toml::from_str::\u003c'_, Schedule\u003e(\"weekday = \\\"Sunday\\\"\\n\"),\n    );\n\n    // Deserialize from variant abbreviated string representation.\n    assert_eq!(\n        Ok(Schedule { weekday: Weekday::Monday }),\n        toml::from_str::\u003c'_, Schedule\u003e(\"weekday = \\\"Mon\\\"\\n\"),\n    );\n\n    assert_eq!(\n        Ok(Schedule { weekday: Weekday::Tuesday }),\n        toml::from_str::\u003c'_, Schedule\u003e(\"weekday = \\\"tue\\\"\\n\"),\n    );\n\n    assert_eq!(\n        Ok(Schedule { weekday: Weekday::Wednesday }),\n        toml::from_str::\u003c'_, Schedule\u003e(\"weekday = \\\"wed\\\"\\n\"),\n    );\n\n    assert_eq!(\n        Ok(Schedule { weekday: Weekday::Thursday }),\n        toml::from_str::\u003c'_, Schedule\u003e(\"weekday = \\\"gio\\\"\\n\"),\n    );\n\n    assert_eq!(\n        Ok(Schedule { weekday: Weekday::Friday }),\n        toml::from_str::\u003c'_, Schedule\u003e(\"weekday = \\\"Fri\\\"\\n\"),\n    );\n\n    assert_eq!(\n        Ok(Schedule { weekday: Weekday::Saturday }),\n        toml::from_str::\u003c'_, Schedule\u003e(\"weekday = \\\"Sat\\\"\\n\"),\n    );\n\n    assert_eq!(\n        Ok(Schedule { weekday: Weekday::Sunday }),\n        toml::from_str::\u003c'_, Schedule\u003e(\"weekday = \\\"Sun\\\"\\n\"),\n    );\n}\n\n// The enum has been marked as `serialize`, so `serde::Serialize` implementation is available.\n#[cfg(feature = \"serde\")]  \n{\n    assert_eq!(\n        Ok(String::from(\"weekday = \\\"Monday\\\"\\n\")),\n        toml::to_string(\u0026Schedule { weekday: Weekday::Monday }),\n    );\n\n    assert_eq!(\n        Ok(String::from(\"weekday = \\\"DayAfterMonday\\\"\\n\")),\n        toml::to_string(\u0026Schedule { weekday: Weekday::Tuesday }),\n    );\n\n    assert_eq!(\n        Ok(String::from(\"weekday = \\\"Wednesday\\\"\\n\")),\n        toml::to_string(\u0026Schedule { weekday: Weekday::Wednesday }),\n    );\n\n    assert_eq!(\n        Ok(String::from(\"weekday = \\\"Giovedì\\\"\\n\")),\n        toml::to_string(\u0026Schedule { weekday: Weekday::Thursday }),\n    );\n\n    assert_eq!(\n        Ok(String::from(\"weekday = \\\"Friday\\\"\\n\")),\n        toml::to_string(\u0026Schedule { weekday: Weekday::Friday }),\n    );\n\n    assert_eq!(\n        Ok(String::from(\"weekday = \\\"Saturday\\\"\\n\")),\n        toml::to_string(\u0026Schedule { weekday: Weekday::Saturday }),\n    );\n\n    assert_eq!(\n        Ok(String::from(\"weekday = \\\"Sunday\\\"\\n\")),\n        toml::to_string(\u0026Schedule { weekday: Weekday::Sunday }),\n    );\n}\n```\n\n[`Clone`]: https://doc.rust-lang.org/std/clone/trait.Clone.html\n[`Copy`]: https://doc.rust-lang.org/std/marker/trait.Copy.html\n[`Display`]: https://doc.rust-lang.org/std/fmt/trait.Display.html\n[`FromStr`]: https://doc.rust-lang.org/std/str/trait.FromStr.html\n[`Deserialize`]: https://docs.rs/serde/latest/serde/trait.Deserialize.html\n[`Serialize`]: https://docs.rs/serde/latest/serde/trait.Serialize.html\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fmarcoradocchia%2Fbeerec-variants","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fmarcoradocchia%2Fbeerec-variants","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fmarcoradocchia%2Fbeerec-variants/lists"}