Enum edn_rs::edn::Edn

pub enum Edn {
    Tagged(String, Box<Edn>),
    Vector(Vector),
    Set(Set),
    Map(Map),
    List(List),
    Key(String),
    Symbol(String),
    Str(String),
    Int(isize),
    UInt(usize),
    Double(Double),
    Rational(String),
    Char(char),
    Bool(bool),
    Inst(String),
    Uuid(String),
    NamespacedMap(String, Map),
    Nil,
    Empty,
}

EdnType is an Enum with possible values for an EDN type Symbol and Char are not yet implemented String implementation of Edn can be obtained with .to_string()

Variants

Tagged(String, Box<Edn>)

Tuple Fields

0: String

1: Box<Edn>

Vector(Vector)

Tuple Fields

0: Vector

Set(Set)

Tuple Fields

0: Set

Map(Map)

Tuple Fields

0: Map

List(List)

Tuple Fields

0: List

Key(String)

Tuple Fields

0: String

Symbol(String)

Tuple Fields

0: String

Str(String)

Tuple Fields

0: String

Int(isize)

Tuple Fields

0: isize

UInt(usize)

Tuple Fields

0: usize

Double(Double)

Tuple Fields

0: Double

Rational(String)

Tuple Fields

0: String

Char(char)

Tuple Fields

0: char

Bool(bool)

Tuple Fields

0: bool

Inst(String)

Tuple Fields

0: String

Uuid(String)

Tuple Fields

0: String

NamespacedMap(String, Map)

Tuple Fields

0: String

1: Map

Nil

Empty

Implementations

impl Edn

pub fn to_float(&self) -> Option<f64>

to_float takes an Edn and returns an Option<f64> with its value. Most types return None

use edn_rs::edn::{Edn, Vector};

let key = Edn::Key(String::from(":1234"));
let q = Edn::Rational(String::from("3/4"));
let i = Edn::Int(12isize);

assert_eq!(Edn::Vector(Vector::empty()).to_float(), None);
assert_eq!(key.to_float().unwrap(),1234f64);
assert_eq!(q.to_float().unwrap(), 0.75f64);
assert_eq!(i.to_float().unwrap(), 12f64);

pub fn to_int(&self) -> Option<isize>

to_int takes an Edn and returns an Option<isize> with its value. Most types return None

use edn_rs::edn::{Edn, Vector};

let key = Edn::Key(String::from(":1234"));
let q = Edn::Rational(String::from("3/4"));
let f = Edn::Double(12.3f64.into());

assert_eq!(Edn::Vector(Vector::empty()).to_float(), None);
assert_eq!(key.to_int().unwrap(),1234isize);
assert_eq!(q.to_int().unwrap(), 1isize);
assert_eq!(f.to_int().unwrap(), 12isize);

pub fn to_uint(&self) -> Option<usize>

Similar to to_int but returns an Option<usize>

pub fn to_bool(&self) -> Option<bool>

to_bool takes an Edn and returns an Option<bool> with its value. Most types return None

use edn_rs::edn::{Edn};

let b = Edn::Bool(true);
let s = Edn::Str("true".to_string());
let symbol = Edn::Symbol("false".to_string());

assert_eq!(b.to_bool().unwrap(),true);
assert_eq!(s.to_bool().unwrap(),true);
assert_eq!(symbol.to_bool().unwrap(),false);

pub fn to_char(&self) -> Option<char>

to_char takes an Edn and returns an Option<char> with its value. Most types return None

use edn_rs::edn::{Edn};

let c = Edn::Char('c');
let symbol = Edn::Symbol("false".to_string());

assert_eq!(c.to_char().unwrap(),'c');
assert_eq!(symbol.to_char(), None);

pub fn to_vec(&self) -> Option<Vec<String>>

to_vec converts Edn types Vector, List and Set into an Option<Vec<String>>. Type String was selected because it is the current way to mix floats, integers and Strings.

pub fn to_int_vec(&self) -> Option<Vec<isize>>

to_int_vec converts Edn types Vector List and Set into an Option<Vec<isize>>. All elements of this Edn structure should be of the same type

pub fn to_uint_vec(&self) -> Option<Vec<usize>>

to_uint_vec converts Edn types Vector List and Set into an Option<Vec<usize>>. All elements of this Edn structure should be of the same type

pub fn to_float_vec(&self) -> Option<Vec<f64>>

to_float_vec converts Edn types Vector List and Set into an Option<Vec<f64>>. All elements of this Edn structure should be of the same type

pub fn to_bool_vec(&self) -> Option<Vec<bool>>

to_bool_vec converts Edn types Vector List and Set into an Option<Vec<bool>>. All elements of this Edn structure should be of the same type

pub fn to_debug(&self) -> String

std::fmt::Debug to_debug is a wrapper of format!("{:?}", &self) for &Edn.

use edn_rs::edn::{Edn, Vector};

let edn = Edn::Vector(Vector::new(vec![Edn::Int(5), Edn::Int(6), Edn::Int(7)]));
let expected = "Vector(Vector([Int(5), Int(6), Int(7)]))";

assert_eq!(edn.to_debug(), expected);

While to_string returns a valid edn:

use edn_rs::edn::{Edn, Vector};

let edn = Edn::Vector(Vector::new(vec![Edn::Int(5), Edn::Int(6), Edn::Int(7)]));
let expected = "[5, 6, 7, ]";

assert_eq!(edn.to_string(), expected);

pub fn get<I: Index>(&self, index: I) -> Option<&Edn>

Index into a EDN vector, list, set or map. A string index can be used to access a value in a map, and a usize index can be used to access an element of a seqs.

Returns None if the type of self does not match the type of the index, for example if the index is a string and self is a seq or a number. Also returns None if the given key does not exist in the map or the given index is not within the bounds of the seq.

#[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.get(1).unwrap(), &edn!(1.2));
    assert_eq!(edn[3]["false"], edn!(:f));
    assert_eq!(edn[3].get("false").unwrap(), &Edn::Key(":f".to_string()));
}

pub fn get_mut<I: Index>(&mut self, index: I) -> Option<&mut Edn>

Mutably index into a EDN vector, set, list or map. A string index can be used to access a value in a map, and a usize index can be used to access an element of a seq.

Returns None if the type of self does not match the type of the index, for example if the index is a string and self is a seq or a number. Also returns None if the given key does not exist in the map or the given index is not within the bounds of the seq.

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

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

    assert_eq!(edn[1], edn!(1.2));
    assert_eq!(edn.get_mut(1).unwrap(), &edn!(1.2));
    assert_eq!(edn[3]["false"], edn!(:f));
    assert_eq!(edn[3].get_mut("false").unwrap(), &Edn::Key(":f".to_string()));
}

pub fn iter(&self) -> Option<Iter<'_, Edn>>

iter returns am Option<Iter<Edn>> with Some for types Edn::Vector and Edn::List Other types return None

use edn_rs::{Edn, Vector};

fn main() {
    let v = Edn::Vector(Vector::new(vec![Edn::Int(5), Edn::Int(6), Edn::Int(7)]));
    let sum = v.iter().unwrap().filter(|e| e.to_int().is_some()).map(|e| e.to_int().unwrap()).sum();

    assert_eq!(18isize, sum);
}

pub fn set_iter(&self) -> Option<Iter<'_, Edn>>

set_iter returns am Option<btree_set::Iter<Edn>> with Some for type Edn::Set Other types return None

pub fn map_iter(&self) -> Option<Iter<'_, String, Edn>>

map_iter returns am Option<btree_map::Iter<String, Edn>> with Some for type Edn::Map Other types return None

pub fn to_str_uuid(&self) -> Option<String>

to_str_uuid returns am Option<String> with Some containing the string representing the UUID for type Edn::Uuid Other types return None

pub fn to_str_inst(&self) -> Option<String>

to_str_INST returns am Option<String> with Some containing the string representing the instant for type Edn::Inst Other types return None

Trait Implementations

impl Clone for Edn

fn clone(&self) -> Edn

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Edn

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Edn

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromStr for Edn

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a &str that contains an Edn into Result<Edn, EdnError>

type Err = Error

The associated error which can be returned from parsing.

impl Hash for Edn

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<I> Index<I> for Edn where
    I: Index, 

type Output = Edn

The returned type after indexing.

fn index(&self, index: I) -> &Edn

Performs the indexing (container[index]) operation.

impl<I> IndexMut<I> for Edn where
    I: Index, 

fn index_mut(&mut self, index: I) -> &mut Edn

Performs the mutable indexing (container[index]) operation.

impl Ord for Edn

fn cmp(&self, other: &Edn) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl PartialEq<Edn> for Edn

fn eq(&self, other: &Edn) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Edn) -> bool

This method tests for !=.

impl PartialOrd<Edn> for Edn

fn partial_cmp(&self, other: &Edn) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for Edn

impl StructuralEq for Edn

impl StructuralPartialEq for Edn