Enum serde_dhall::SimpleType

pub enum SimpleType {
    Bool,
    Natural,
    Integer,
    Double,
    Text,
    Optional(Box<SimpleType>),
    List(Box<SimpleType>),
    Record(HashMap<String, SimpleType>),
    Union(HashMap<String, Option<SimpleType>>),
}

The type of a value that can be decoded by serde_dhall, e.g. { x: Bool, y: List Natural }.

A SimpleType is used when deserializing values to ensure they are of the expected type. Rather than letting serde handle potential type mismatches, this uses the type-checking capabilities of Dhall to catch errors early and cleanly indicate in the user's code where the mismatch happened.

You would typically not manipulate SimpleTypes by hand but rather let Rust infer it for your datatype by deriving the StaticType trait, and using Deserializer::static_type_annotation. If you need to supply a SimpleType manually, you can either deserialize it like any other Dhall value, or construct it manually.

Examples

use serde_dhall::{SimpleType, StaticType};

#[derive(StaticType)]
struct Foo {
    x: bool,
    y: Vec<u64>,
}

let ty: SimpleType =
    serde_dhall::from_str("{ x: Bool, y: List Natural }").parse()?;

assert_eq!(Foo::static_type(), ty);

use std::collections::HashMap;
use serde_dhall::SimpleType;

let ty: SimpleType =
    serde_dhall::from_str("{ x: Natural, y: Natural }").parse()?;

let mut map = HashMap::new();
map.insert("x".to_string(), SimpleType::Natural);
map.insert("y".to_string(), SimpleType::Natural);
assert_eq!(ty, SimpleType::Record(map));

Variants

Bool

Corresponds to the Dhall type Bool

Natural

Corresponds to the Dhall type Natural

Integer

Corresponds to the Dhall type Integer

Double

Corresponds to the Dhall type Double

Text

Corresponds to the Dhall type Text

Optional(Box<SimpleType>)

Corresponds to the Dhall type Optional T

List(Box<SimpleType>)

Corresponds to the Dhall type List T

Record(HashMap<String, SimpleType>)

Corresponds to the Dhall type { x : T, y : U }

Union(HashMap<String, Option<SimpleType>>)

Corresponds to the Dhall type < x : T | y : U >

Trait Implementations

impl Clone for SimpleType

fn clone(&self) -> SimpleType

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SimpleType

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

Formats the value using the given formatter.

impl Eq for SimpleType

impl FromDhall for SimpleType

fn from_dhall(v: &Value) -> Result<Self>

impl PartialEq<SimpleType> for SimpleType

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

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

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

This method tests for !=.

impl StructuralEq for SimpleType

impl StructuralPartialEq for SimpleType