bon/
collections.rs

1/// Same as [`std::vec!`] but converts each element with [`Into`].
2///
3/// **WARNING:** it's not recommended to import this macro into scope. Reference it
4/// using the full path (`bon::vec![]`) to avoid confusion with the [`std::vec!`] macro.
5///
6/// A good example of the use case for this macro is when you want to create a
7/// [`Vec<String>`] where part of the items are hard-coded string literals of type
8/// `&str` and the other part is made of dynamic [`String`] values.
9///
10/// ```
11/// fn convert_media(input_extension: &str, output_extension: &str) -> std::io::Result<()> {
12///     let ffmpeg_args: Vec<String> = bon::vec![
13///         "-i",
14///         format!("input.{input_extension}"),
15///         "-y",
16///         format!("output.{output_extension}"),
17///     ];
18///
19///     std::process::Command::new("ffmpeg").args(ffmpeg_args).output()?;
20///
21///     Ok(())
22/// }
23/// ```
24///
25/// This macro doesn't support `vec![expr; N]` syntax, since it's simpler to
26/// just write `vec![expr.into(); N]` using [`std::vec!`] instead.
27#[macro_export]
28#[cfg(feature = "alloc")]
29#[cfg_attr(docsrs, doc(cfg(any(feature = "std", feature = "alloc"))))]
30#[allow(edition_2024_expr_fragment_specifier)]
31macro_rules! vec {
32    () => ($crate::__::alloc::vec::Vec::new());
33    ($($item:expr),+ $(,)?) => ($crate::__::alloc::vec![$(::core::convert::Into::into($item)),+ ]);
34}
35
36/// Creates a fixed-size array literal with each element converted with [`Into`].
37///
38/// You'll probably need a hint for the target type of items in the array if the
39/// compiler can't infer it from its usage.
40///
41/// This is similar in spirit to the [`bon::vec!`] macro, but it's for arrays.
42/// See [`bon::vec!`] docs for details.
43///
44/// Same example as in [`bon::vec!`], but using this macro. It works with array
45/// as well because [`Command::args`] accepts any value that implements [`IntoIterator`]:
46///
47/// ```
48/// fn convert_media(input_extension: &str, output_extension: &str) -> std::io::Result<()> {
49///     let ffmpeg_args: [String; 4] = bon::arr![
50///         "-i",
51///         format!("input.{input_extension}"),
52///         "-y",
53///         format!("output.{output_extension}"),
54///     ];
55///
56///     std::process::Command::new("ffmpeg").args(ffmpeg_args).output()?;
57///
58///     Ok(())
59/// }
60/// ```
61///
62/// This macro doesn't support `[expr; N]` syntax, since it's simpler to
63/// just write `[expr.into(); N]` instead.
64///
65/// [`Command::args`]: std::process::Command::args
66/// [`bon::vec!`]: crate::vec
67#[macro_export]
68#[allow(edition_2024_expr_fragment_specifier)]
69macro_rules! arr {
70    () => ([]);
71    ($($item:expr),+ $(,)?) => ([$(::core::convert::Into::into($item)),+]);
72}
73
74#[cfg(test)]
75mod tests {
76    // It's okay to use indexing in tests for conciseness.
77    #![allow(clippy::indexing_slicing)]
78
79    #[cfg(feature = "alloc")]
80    use crate::__::alloc::{string::String, vec::Vec};
81    use core::num::NonZeroU8;
82
83    #[cfg(feature = "alloc")]
84    #[test]
85    fn arr_of_strings() {
86        let actual: [String; 3] = crate::arr!["foo", "bar", "baz"];
87        assert_eq!(actual, ["foo", "bar", "baz"]);
88
89        let actual: [String; 0] = crate::arr![];
90        assert!(actual.is_empty());
91    }
92
93    #[test]
94    fn arr_of_numbers() {
95        let actual: [u8; 2] = crate::arr![NonZeroU8::new(1).unwrap(), NonZeroU8::new(2).unwrap()];
96        assert_eq!(actual, [1, 2]);
97
98        let actual: [u8; 0] = crate::arr![];
99        assert!(actual.is_empty());
100    }
101
102    #[cfg(feature = "alloc")]
103    #[test]
104    fn vec_smoke() {
105        let actual: Vec<String> = crate::vec!["foo", "bar", "baz"];
106        assert_eq!(actual, ["foo", "bar", "baz"]);
107
108        let actual: Vec<String> = crate::vec![];
109        assert!(actual.is_empty());
110    }
111
112    #[cfg(feature = "std")]
113    #[test]
114    fn map_smoke() {
115        use std::collections::{BTreeMap, HashMap};
116
117        let hash_strings: HashMap<String, String> = crate::map! {
118            "Hello": "World",
119            "Goodbye": "Mars",
120        };
121
122        assert_eq!(hash_strings["Hello"], "World");
123        assert_eq!(hash_strings["Goodbye"], "Mars");
124
125        let tree_strings: BTreeMap<String, String> = crate::map! {
126            "Hello": "World",
127            "Goodbye": "Mars",
128        };
129
130        assert_eq!(tree_strings["Hello"], "World");
131        assert_eq!(tree_strings["Goodbye"], "Mars");
132    }
133
134    #[cfg(feature = "std")]
135    #[test]
136    fn set_smoke() {
137        use std::collections::BTreeSet;
138        use std::collections::HashSet;
139
140        let hash_strings: HashSet<String> = crate::set!["Hello", "World", "Goodbye", "Mars"];
141
142        assert!(hash_strings.contains("Hello"));
143        assert!(hash_strings.contains("World"));
144        assert!(hash_strings.contains("Goodbye"));
145        assert!(hash_strings.contains("Mars"));
146
147        let tree_strings: BTreeSet<String> = crate::set!["Hello", "World", "Goodbye", "Mars"];
148
149        assert!(tree_strings.contains("Hello"));
150        assert!(tree_strings.contains("World"));
151        assert!(tree_strings.contains("Goodbye"));
152        assert!(tree_strings.contains("Mars"));
153    }
154}
bon/collections.rs

bon/
collections.rs
