Enum edn_rs::edn::Edn

#[non_exhaustive]
pub enum Edn {
    Tagged(String, Box<Edn>),
    Vector(Vector),
    Set(Set),
    Map(Map),
    List(List),
    Key(String),
    Symbol(String),
    Str(String),
    Int(i64),
    UInt(u64),
    Double(Double),
    Rational(String),
    Char(char),
    Bool(bool),
    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 (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Tagged(String, Box<Edn>)

Vector(Vector)

Set(Set)

Map(Map)

List(List)

Key(String)

Symbol(String)

Str(String)

Int(i64)

UInt(u64)

Double(Double)

Rational(String)

Char(char)

Bool(bool)

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(12i64);

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<i64>

to_int takes an Edn and returns an Option<i64> 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(),1234i64);
assert_eq!(q.to_int().unwrap(), 1i64);
assert_eq!(f.to_int().unwrap(), 12i64);

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

Similar to to_int but returns an Option<u64>

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 const 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<i64>>

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

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

to_uint_vec converts Edn types Vector List and Set into an Option<Vec<u64>>. 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<&Self>

Index into a EDN vector, list, set or map. A string index can be used to access a value in a map, and a u64 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 Self>

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 u64 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_some(&self) -> Option<Iter<'_, Self>>

iter_some returns an 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_some().unwrap().filter(|e| e.to_int().is_some()).map(|e| e.to_int().unwrap()).sum();

    assert_eq!(18i64, sum);
}

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

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, Self>>

map_iter returns am Option<btree_map::Iter<String, Edn>> with Some for type Edn::Map 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<I> Index<I> for Edn

where I: Index,

type Output = Edn

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<I> IndexMut<I> for Edn

where I: Index,

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

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq 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: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd 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 StructuralPartialEq for Edn