Macro edn_rs::edn

macro_rules! edn {
    ($($edn:tt)+) => { ... };
}

Macro to parse EDN into Rust Spec:

#![recursion_limit="512"] //recomended recursion size

#[macro_use]
extern crate edn_rs;

use edn_rs::edn::{Edn, List, Set, Map};

fn main() {
    let list = edn!((1 1.2 3 false :f nil 3/4));
    let expected = Edn::List(
            List::new(
                vec![
                    Edn::Int(1),
                    Edn::Double(1.2.into()),
                    Edn::Int(3),
                    Edn::Bool(false),
                    Edn::Key(":f".to_string()),
                    Edn::Nil,
                    Edn::Rational("3/4".to_string())
                ]
            )
        );

    assert_eq!(list, expected);

    let set = edn!(#{1 1.2 3 false :f nil 3/4});
    let expected = Edn::Set(
    Set::new(
        set!{
            Edn::Int(1),
            Edn::Double(1.2.into()),
            Edn::Int(3),
            Edn::Bool(false),
            Edn::Key(":f".to_string()),
            Edn::Nil,
            Edn::Rational("3/4".to_string())
            }
        )
    );

    assert_eq!(set, expected);
    let map = edn!({1.2 false, :b 3/4});
    let expected = Edn::Map(
        Map::new(
            map!{
                String::from("1.2") => Edn::Bool(false),
                // Note `:b` becomes `b`
                String::from(":b") => Edn::Rational(String::from("3/4"))
            }
        )
    );

    assert_eq!(map, expected);
}

A more complete exemple:

#[macro_use]
extern crate edn_rs;

use edn_rs::edn::{Edn, List, Vector, Map};
fn main() {
    let expected = Edn::List(
    List::new(
        vec![
            Edn::Int(1),
            Edn::Double(1.2.into()),
            Edn::Int(3),
            Edn::Map(
                Map::new( map![
                    String::from("false") => Edn::Map(
                        Map::new( map![
                            String::from(":f") => Edn::Key(String::from(":b"))
                        ])),
                    String::from("nil") => Edn::Vector(
                        Vector::new( vec![
                            Edn::Rational("3/4".to_string()),
                            Edn::Int(1isize)
                        ]))
            ]))
        ]
    )
    );

    assert_eq!(edn!(( 1 1.2 3 {false {:f :b} nil [3/4 1]})), expected);
}

To navigate through Edn data you can just use get and get_mut:

#[macro_use]
extern crate edn_rs;
use edn_rs::edn::{Edn, Map, Vector};

fn main() {
    let edn = edn!([ 1 1.2 3 {false :f nil 3/4}]);

    assert_eq!(edn[1], edn!(1.2));
    assert_eq!(edn[1], Edn::Double(1.2f64.into()));
    assert_eq!(edn[3]["false"], edn!(:f));
    assert_eq!(edn[3]["false"], Edn::Key(":f".to_string()));
}

Internal implementation is hidden, please look at source.