Macro ergo_std::convert_args []

macro_rules! convert_args {
    (
keys = $ kf : expr , $ macro_name : ident ! ( $ ( $ k : expr ) , * $ ( , ) * )
) => { ... };
    (
keys = $ kf : expr , values = $ vf : expr , $ macro_name : ident ! (
$ ( $ k : expr ) , * $ ( , ) * ) ) => { ... };
    (
keys = $ kf : expr , values = $ vf : expr , $ macro_name : ident ! (
$ ( $ k : expr => $ v : expr ) , * $ ( , ) * ) ) => { ... };
    (
keys = $ kf : expr , $ macro_name : ident ! ( $ ( $ rest : tt ) * ) ) => { ... };
    ( values = $ vf : expr , $ macro_name : ident ! ( $ ( $ rest : tt ) * ) ) => { ... };
    ( $ macro_name : ident ! $ ( $ rest : tt ) * ) => { ... };
}

Macro that converts the keys or key-value pairs passed to another maplit macro. The default conversion is to use the Into trait, if no custom conversion is passed.

The syntax is:

convert_args!( keys= function , values= function , macro_name !( [ key => value [, key => value ... ] ] ))

Here macro_name is any other maplit macro and either or both of the explicit keys= and values= parameters can be omitted.

Examples

#[macro_use] extern crate maplit;

use std::collections::HashMap;
use std::collections::BTreeSet;

// a. Use the default conversion with the Into trait.
// Here this converts both the key and value string literals to `String`,
// but we need to specify the map type exactly!

let map1: HashMap<String, String> = convert_args!(hashmap!(
    "a" => "b",
    "c" => "d",
));

// b. Specify an explicit custom conversion for the keys. If we don't specify
// a conversion for the values, they are not converted at all.

let map2 = convert_args!(keys=String::from, hashmap!(
    "a" => 1,
    "c" => 2,
));

// Note: map2 is a HashMap<String, i32>, but we didn't need to specify the type
let _: HashMap<String, i32> = map2;

// c. convert_args! works with all the maplit macros -- and macros from other
// crates that have the same "signature".
// For example, btreeset and conversion from &str to Vec<u8>.

let set: BTreeSet<Vec<u8>> = convert_args!(btreeset!(
    "a", "b", "c", "d", "a", "e", "f",
));
assert_eq!(set.len(), 6);