use std::collections::LinkedList;
use std::collections::HashMap;
use std::convert::From;
use std::iter::FromIterator;
use std::iter::IntoIterator;

#[derive(Debug)]
pub enum Element {
	IntegerElem(i32),
        DoubleElem(f64),
	StringElem(String),
	ListElem(LinkedList<Element>),
	MapElem(HashMap<String,Element>)
}

impl From<i32> for Element {
	fn from(x: i32) -> Element {
		Element::IntegerElem(x)
	}
}

impl From<f64> for Element {
	fn from(x: f64) -> Element {
		Element::DoubleElem(x)
	}
}

impl<'a> From<&'a str> for Element {
	fn from(x: &str) -> Element {
		Element::StringElem(x.to_string())
	}
}

impl<T: Into<Element>> FromIterator<T> for Element {
	fn from_iter<U>(iterator: U) -> Self
		where U: IntoIterator<Item=T>
	{
		let x = iterator.into_iter().map(|y| { y.into() });
		Element::ListElem(x.collect())
	}
}

impl<'a, V: Into<Element>> From<HashMap<&'a str, V>> for Element {
        fn from(mut input: HashMap<&str, V>) -> Self
        {
            let mut map : HashMap<String,Element> = HashMap::new();
            while input.len() > 0 {
                let key = input.keys().next().unwrap().clone();
                let val = input.remove(key).unwrap();
                let elem = val.into();
                map.insert(key.to_string(), elem);
            }
            Element::MapElem(map)
        }
}

fn main () {
	let five = Element::IntegerElem(5);
	let foo : Element = "Foo".into();
	let bar = Element::from("Bar");
	let mut list = LinkedList::new();
	list.push_back(five);
	list.push_back(foo);
	list.push_back(bar);
	println!("{:?}", list);
	let listelem = Element::from_iter(list);
	println!("{:?}", listelem);

	let integers = vec![1,3,5];
	let element = Element::from_iter(integers);
	println!("{:?}", element);

        let mut int_map : HashMap<&str,i32> = HashMap::new();
        int_map.insert("1", 1);
        int_map.insert("2", 2);
        let int_map_elem = Element::from(int_map);
	println!("{:?}", int_map_elem);
}