Struct serde_dhall::Serializer
source · pub struct Serializer<'a, T, A> { /* private fields */ }
Expand description
Controls how a Dhall value is written.
This builder exposes the ability to configure how a value is serialized, and to set type annotations.
When using Serializer
, you’ll create it with serialize()
, then chain calls to methods
to set each option, then call to_string()
. This will give you a Result
containing the
input serialized to Dhall.
Note that if you do not provide a type annotation, some values may not be convertible to Dhall, like empty lists or enums.
Examples
Serializing without a type annotation:
use serde_dhall::serialize;
let string = serialize(&1i64).to_string()?;
assert_eq!(string, "+1".to_string());
Serializing with an automatic type annotation:
use serde_dhall::serialize;
let data: Option<u64> = None;
let string = serialize(&data).static_type_annotation().to_string()?;
assert_eq!(string, "None Natural".to_string());
Implementations§
source§impl<'a, T> Serializer<'a, T, NoAnnot>
impl<'a, T> Serializer<'a, T, NoAnnot>
sourcepub fn type_annotation<'ty>(
self,
ty: &'ty SimpleType
) -> Serializer<'a, T, ManualAnnot<'ty>>
pub fn type_annotation<'ty>(
self,
ty: &'ty SimpleType
) -> Serializer<'a, T, ManualAnnot<'ty>>
Provides a type to the serialization process. The provided value will be checked against that type, and the type will be used when Dhall needs it, like for empty lists or for unions.
In many cases the Dhall type that corresponds to a Rust type can be inferred automatically.
See the StaticType
trait and the static_type_annotation()
method for that.
Example
use serde_dhall::{serialize, from_str, SimpleType, SimpleValue};
let ty = from_str("< A | B: Bool >").parse()?;
let data = SimpleValue::Union("A".to_string(), None);
let string = serialize(&data)
.type_annotation(&ty)
.to_string()?;
assert_eq!(string, "< A | B: Bool >.A".to_string());
// Invalid data fails the type validation; serialization would have succeeded otherwise.
let ty = SimpleType::Integer;
assert!(
serialize(&Some(0u64))
.type_annotation(&ty)
.to_string()
.is_err()
);
sourcepub fn static_type_annotation(self) -> Serializer<'a, T, StaticAnnot>
pub fn static_type_annotation(self) -> Serializer<'a, T, StaticAnnot>
Uses the type of T
in the serialization process. This will be used when Dhall needs it,
like for empty lists or for unions.
T
must implement the StaticType
trait. If it doesn’t, you can use type_annotation()
Example
use serde::Serialize;
use serde_dhall::{serialize, StaticType};
#[derive(Serialize, StaticType)]
enum MyOption {
MyNone,
MySome(u64),
}
let data = MyOption::MySome(0);
let string = serialize(&data)
.static_type_annotation()
.to_string()?;
// The resulting Dhall string depends on the type annotation; it could not have been
// printed without it.
assert_eq!(string, "< MyNone | MySome: Natural >.MySome 0".to_string());
source§impl<'a, T, A> Serializer<'a, T, A>where
A: TypeAnnot,
impl<'a, T, A> Serializer<'a, T, A>where
A: TypeAnnot,
sourcepub fn to_string(&self) -> Result<String>where
T: ToDhall + HasAnnot<A>,
pub fn to_string(&self) -> Result<String>where
T: ToDhall + HasAnnot<A>,
Prints the chosen value with the options provided.
If you enabled static annotations, T
is required to implement StaticType
.
Note that if you do not provide a type annotation, some values may not be convertible to Dhall, like empty lists or enums.
Example
use serde_dhall::serialize;
let string = serialize(&1i64).static_type_annotation().to_string()?;
assert_eq!(string, "+1".to_string());