Enum serde_dhall::SimpleValue

pub enum SimpleValue {
    Num(NumKind),
    Text(String),
    Optional(Option<Box<SimpleValue>>),
    List(Vec<SimpleValue>),
    Record(BTreeMap<String, SimpleValue>),
    Union(String, Option<Box<SimpleValue>>),
}

A value of the kind that can be decoded by serde_dhall, e.g. { x = True, y = [1, 2, 3] }. This can be obtained with from_str() or from_file(). It can also be deserialized into Rust types with from_simple_value().

Examples

use std::collections::BTreeMap;
use serde::Deserialize;
use serde_dhall::{from_simple_value, NumKind, SimpleValue};

#[derive(Debug, PartialEq, Eq, Deserialize)]
struct Foo {
    x: bool,
    y: Vec<u64>,
}

let value: SimpleValue =
    serde_dhall::from_str("{ x = True, y = [1, 2, 3] }").parse()?;

assert_eq!(
    value,
    SimpleValue::Record({
        let mut r = BTreeMap::new();
        r.insert(
            "x".to_string(),
            SimpleValue::Num(NumKind::Bool(true))
        );
        r.insert(
            "y".to_string(),
            SimpleValue::List(vec![
                SimpleValue::Num(NumKind::Natural(1)),
                SimpleValue::Num(NumKind::Natural(2)),
                SimpleValue::Num(NumKind::Natural(3)),
            ])
        );
        r
    })
);

let foo: Foo = from_simple_value(value)?;

assert_eq!(
    foo,
    Foo {
        x: true,
        y: vec![1, 2, 3]
    }
);

use std::collections::BTreeMap;
use serde_dhall::{NumKind, SimpleValue};

let value: SimpleValue =
    serde_dhall::from_str("{ x = 1, y = 2 }").parse()?;

let mut map = BTreeMap::new();
map.insert("x".to_string(), SimpleValue::Num(NumKind::Natural(1)));
map.insert("y".to_string(), SimpleValue::Num(NumKind::Natural(2)));
assert_eq!(value, SimpleValue::Record(map));

Variants

Num(NumKind)

Numbers and booleans - True, 1, +2, 3.24

Text(String)

A string of text - "Hello world!"

Optional(Option<Box<SimpleValue>>)

An optional value - Some e, None

List(Vec<SimpleValue>)

A list of values - [a, b, c, d, e]

Record(BTreeMap<String, SimpleValue>)

A record value - { k1 = v1, k2 = v2 }

Union(String, Option<Box<SimpleValue>>)

A union value (both the name of the variant and the variant’s value) - Left e

Trait Implementations

impl Clone for SimpleValue

fn clone(&self) -> SimpleValue

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SimpleValue

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SimpleValue

fn deserialize<D>(deserializer: D) -> Result<SimpleValue, D::Error>where
    D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq<SimpleValue> for SimpleValue

fn eq(&self, other: &SimpleValue) -> 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 Serialize for SimpleValue

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>where
    S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for SimpleValue

impl StructuralEq for SimpleValue

impl StructuralPartialEq for SimpleValue