Unparsers
This commit is contained in:
parent
5c2d12971d
commit
aa1c983acc
|
@ -0,0 +1,11 @@
|
||||||
|
use crate::*;
|
||||||
|
use crate::syntax::block::Item;
|
||||||
|
use crate::syntax::block::constructors::*;
|
||||||
|
|
||||||
|
pub fn push_let(body: &mut Vec<Item>, name: Item, expr: Item) {
|
||||||
|
body.push(item(seq!["let ", name, " = ", expr, ";"]))
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn push_let_mut(body: &mut Vec<Item>, name: Item, expr: Item) {
|
||||||
|
body.push(item(seq!["let mut ", name, " = ", expr, ";"]))
|
||||||
|
}
|
|
@ -13,7 +13,6 @@ pub struct ModuleContext {
|
||||||
pub struct FunctionContext<'a> {
|
pub struct FunctionContext<'a> {
|
||||||
pub m: &'a mut ModuleContext,
|
pub m: &'a mut ModuleContext,
|
||||||
pub temp_counter: usize,
|
pub temp_counter: usize,
|
||||||
pub temps: Map<types::TDefinition, Vec<String>>,
|
|
||||||
pub captures: Vec<Capture>,
|
pub captures: Vec<Capture>,
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -52,7 +51,6 @@ impl<'a> FunctionContext<'a> {
|
||||||
FunctionContext {
|
FunctionContext {
|
||||||
m: m,
|
m: m,
|
||||||
temp_counter: 0,
|
temp_counter: 0,
|
||||||
temps: Map::new(),
|
|
||||||
captures: Vec::new(),
|
captures: Vec::new(),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -65,9 +63,27 @@ impl<'a> FunctionContext<'a> {
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
|
||||||
|
pub fn lookup_capture(&self, field_name: &str) -> &Capture {
|
||||||
|
for c in &self.captures {
|
||||||
|
if c.field_name == field_name {
|
||||||
|
return c;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
panic!("No capture for field {:?} available", field_name)
|
||||||
|
}
|
||||||
|
|
||||||
pub fn gentempname(&mut self) -> String {
|
pub fn gentempname(&mut self) -> String {
|
||||||
let i = self.temp_counter;
|
let i = self.temp_counter;
|
||||||
self.temp_counter += 1;
|
self.temp_counter += 1;
|
||||||
format!("_tmp{}", i)
|
format!("_tmp{}", i)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
pub fn branch<R, F: FnOnce(&mut Self) -> R>(&mut self, f: F) -> R {
|
||||||
|
let saved_temp_counter = self.temp_counter;
|
||||||
|
let saved_capture_count = self.captures.len();
|
||||||
|
let result = f(self);
|
||||||
|
self.temp_counter = saved_temp_counter;
|
||||||
|
self.captures.truncate(saved_capture_count);
|
||||||
|
result
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -2,6 +2,8 @@ pub mod types;
|
||||||
pub mod names;
|
pub mod names;
|
||||||
pub mod context;
|
pub mod context;
|
||||||
pub mod parsers;
|
pub mod parsers;
|
||||||
|
pub mod unparsers;
|
||||||
|
pub mod codegen;
|
||||||
|
|
||||||
use std::path::PathBuf;
|
use std::path::PathBuf;
|
||||||
use preserves::value::Map;
|
use preserves::value::Map;
|
||||||
|
@ -40,6 +42,7 @@ pub fn compile(config: &CompilerConfig) -> Result<(), std::io::Error> {
|
||||||
for (n, d) in &v.definitions.0 {
|
for (n, d) in &v.definitions.0 {
|
||||||
m.define_type(item(types::render_definition_type(n, &types::definition_type(d))));
|
m.define_type(item(types::render_definition_type(n, &types::definition_type(d))));
|
||||||
parsers::gen_definition_parser(&mut m, n, d);
|
parsers::gen_definition_parser(&mut m, n, d);
|
||||||
|
unparsers::gen_definition_unparser(&mut m, n, d);
|
||||||
}
|
}
|
||||||
|
|
||||||
//---------------------------------------------------------------------------
|
//---------------------------------------------------------------------------
|
||||||
|
|
|
@ -1,10 +1,12 @@
|
||||||
use crate::*;
|
use crate::*;
|
||||||
|
use crate::metaschema::*;
|
||||||
use crate::syntax::block::Item;
|
use crate::syntax::block::Item;
|
||||||
use crate::syntax::block::constructors::*;
|
use crate::syntax::block::constructors::*;
|
||||||
|
|
||||||
|
use super::codegen::*;
|
||||||
|
use super::context::{ModuleContext, FunctionContext};
|
||||||
use super::names;
|
use super::names;
|
||||||
use super::types::*;
|
use super::types::*;
|
||||||
use crate::metaschema::*;
|
|
||||||
use super::context::{ModuleContext, FunctionContext};
|
|
||||||
|
|
||||||
pub fn gen_definition_parser(m: &mut ModuleContext, n: &str, d: &Definition) {
|
pub fn gen_definition_parser(m: &mut ModuleContext, n: &str, d: &Definition) {
|
||||||
m.define_function(
|
m.define_function(
|
||||||
|
@ -23,7 +25,7 @@ pub fn gen_definition_parser(m: &mut ModuleContext, n: &str, d: &Definition) {
|
||||||
let mut body = Vec::new();
|
let mut body = Vec::new();
|
||||||
let dest = pattern_parser(&mut ctxt, pat, "value", None, &mut body);
|
let dest = pattern_parser(&mut ctxt, pat, "value", None, &mut body);
|
||||||
let dest = dest.as_ref().map(String::as_str);
|
let dest = dest.as_ref().map(String::as_str);
|
||||||
construct(&ctxt, ctorname, false, &TDefinition::Simple(pattern_type(pat)), dest, &mut body);
|
construct(&ctxt, ctorname, false, &pattern_type(pat), dest, &mut body);
|
||||||
item(seq!["fn ", fname.clone(), "(value: &preserves::value::IOValue) -> ",
|
item(seq!["fn ", fname.clone(), "(value: &preserves::value::IOValue) -> ",
|
||||||
"std::result::Result<", names::render_constructor(n), ", ()> ",
|
"std::result::Result<", names::render_constructor(n), ", ()> ",
|
||||||
block(body)])
|
block(body)])
|
||||||
|
@ -35,15 +37,15 @@ pub fn gen_definition_parser(m: &mut ModuleContext, n: &str, d: &Definition) {
|
||||||
Definition::And { pattern_0, pattern_1, pattern_n } => {
|
Definition::And { pattern_0, pattern_1, pattern_n } => {
|
||||||
let mut ps = vec![&**pattern_0, &**pattern_1];
|
let mut ps = vec![&**pattern_0, &**pattern_1];
|
||||||
ps.extend(pattern_n);
|
ps.extend(pattern_n);
|
||||||
for e in ps {
|
for e in &ps {
|
||||||
named_pattern_parser(&mut ctxt, e, "value", None, &mut body);
|
named_pattern_parser(&mut ctxt, e, "value", None, &mut body);
|
||||||
}
|
}
|
||||||
construct(&ctxt, item(names::render_constructor(n)), true, &definition_type(d), None, &mut body);
|
construct(&ctxt, item(names::render_constructor(n)), true, &record_type(&ps), None, &mut body);
|
||||||
}
|
}
|
||||||
Definition::Pattern(p) => {
|
Definition::Pattern(p) => {
|
||||||
let dest = pattern_parser(&mut ctxt, p, "value", None, &mut body);
|
let dest = pattern_parser(&mut ctxt, p, "value", None, &mut body);
|
||||||
let dest = dest.as_ref().map(String::as_str);
|
let dest = dest.as_ref().map(String::as_str);
|
||||||
construct(&ctxt, item(names::render_constructor(n)), true, &definition_type(d), dest, &mut body);
|
construct(&ctxt, item(names::render_constructor(n)), true, &pattern_type(p), dest, &mut body);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -60,16 +62,16 @@ fn construct(
|
||||||
ctxt: &FunctionContext,
|
ctxt: &FunctionContext,
|
||||||
ctorname: Item,
|
ctorname: Item,
|
||||||
is_struct: bool,
|
is_struct: bool,
|
||||||
ty: &TDefinition,
|
ty: &TSimple,
|
||||||
dest: Option<&str>,
|
dest: Option<&str>,
|
||||||
body: &mut Vec<Item>,
|
body: &mut Vec<Item>,
|
||||||
) {
|
) {
|
||||||
match ty {
|
match ty {
|
||||||
TDefinition::Simple(TSimple::Field(TField::Unit)) =>
|
TSimple::Field(TField::Unit) =>
|
||||||
body.push(item(seq!["Ok(", ctorname, ")"])),
|
body.push(item(seq!["Ok(", ctorname, ")"])),
|
||||||
TDefinition::Simple(TSimple::Field(fieldty)) =>
|
TSimple::Field(fieldty) =>
|
||||||
body.push(item(seq!["Ok(", ctorname, parens![store_wrap(is_struct, fieldty, dest.unwrap())], ")"])),
|
body.push(item(seq!["Ok(", ctorname, parens![store_wrap(is_struct, fieldty, dest.unwrap())], ")"])),
|
||||||
_ =>
|
TSimple::Record(_) =>
|
||||||
body.push(item(seq!["Ok(", ctorname, " ", braces(
|
body.push(item(seq!["Ok(", ctorname, " ", braces(
|
||||||
ctxt.captures.iter().map(
|
ctxt.captures.iter().map(
|
||||||
|c| item(seq![c.field_name.clone(), ": ", store_wrap(is_struct, &c.ty, &c.source_expr)])).collect()),
|
|c| item(seq![c.field_name.clone(), ": ", store_wrap(is_struct, &c.ty, &c.source_expr)])).collect()),
|
||||||
|
@ -93,14 +95,6 @@ fn store_wrap(is_struct: bool, ty: &TField, expr: &str) -> String {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn push_let(body: &mut Vec<Item>, name: &str, expr: Item) {
|
|
||||||
body.push(item(seq!["let ", name.to_owned(), " = ", expr, ";"]))
|
|
||||||
}
|
|
||||||
|
|
||||||
fn push_let_mut(body: &mut Vec<Item>, name: &str, expr: Item) {
|
|
||||||
body.push(item(seq!["let mut ", name.to_owned(), " = ", expr, ";"]))
|
|
||||||
}
|
|
||||||
|
|
||||||
fn simple_pattern_parser(
|
fn simple_pattern_parser(
|
||||||
ctxt: &mut FunctionContext,
|
ctxt: &mut FunctionContext,
|
||||||
p: &SimplePattern,
|
p: &SimplePattern,
|
||||||
|
@ -111,7 +105,7 @@ fn simple_pattern_parser(
|
||||||
let dest = ctxt.gentempname();
|
let dest = ctxt.gentempname();
|
||||||
match p {
|
match p {
|
||||||
SimplePattern::Any => {
|
SimplePattern::Any => {
|
||||||
push_let(body, &dest, item(src.to_owned()));
|
push_let(body, item(dest.to_owned()), item(src.to_owned()));
|
||||||
dest
|
dest
|
||||||
},
|
},
|
||||||
SimplePattern::Atom { atom_kind: k } => {
|
SimplePattern::Atom { atom_kind: k } => {
|
||||||
|
@ -124,17 +118,17 @@ fn simple_pattern_parser(
|
||||||
AtomKind::ByteString => "to_bytestring",
|
AtomKind::ByteString => "to_bytestring",
|
||||||
AtomKind::Symbol => "to_symbol",
|
AtomKind::Symbol => "to_symbol",
|
||||||
};
|
};
|
||||||
push_let(body, &dest, item(seq![src.to_owned(), ".value().", converter, "().map_err(|_| ())?"]));
|
push_let(body, item(dest.to_owned()), item(seq![src.to_owned(), ".value().", converter, "().map_err(|_| ())?"]));
|
||||||
dest
|
dest
|
||||||
},
|
},
|
||||||
SimplePattern::Embedded { .. } => {
|
SimplePattern::Embedded { .. } => {
|
||||||
push_let(body, &dest, item(seq![src.to_owned(), ".value().to_embedded().map_err(|_| ())?"]));
|
push_let(body, item(dest.to_owned()), item(seq![src.to_owned(), ".value().to_embedded().map_err(|_| ())?"]));
|
||||||
dest
|
dest
|
||||||
},
|
},
|
||||||
SimplePattern::Lit { value } => {
|
SimplePattern::Lit { value } => {
|
||||||
body.push(item(seq!["if ", src.to_owned(), " != ", ctxt.m.define_literal(value),
|
body.push(item(seq!["if ", src.to_owned(), " != ", ctxt.m.define_literal(value),
|
||||||
" { return Err(()); }"]));
|
" { return Err(()); }"]));
|
||||||
push_let(body, &dest, item("()"));
|
push_let(body, item(dest.to_owned()), item("()"));
|
||||||
dest
|
dest
|
||||||
},
|
},
|
||||||
SimplePattern::Seqof { pattern } => {
|
SimplePattern::Seqof { pattern } => {
|
||||||
|
@ -144,7 +138,7 @@ fn simple_pattern_parser(
|
||||||
let item_dest = simple_pattern_parser(ctxt, pattern, &tmp, None, &mut inner);
|
let item_dest = simple_pattern_parser(ctxt, pattern, &tmp, None, &mut inner);
|
||||||
inner.push(item(seq![dest.to_owned(), ".push(",
|
inner.push(item(seq![dest.to_owned(), ".push(",
|
||||||
store_wrap(true, &field_type(pattern), &item_dest), ");"]));
|
store_wrap(true, &field_type(pattern), &item_dest), ");"]));
|
||||||
push_let_mut(body, &dest, item("std::vec::Vec::new()"));
|
push_let_mut(body, item(dest.to_owned()), item("std::vec::Vec::new()"));
|
||||||
body.push(item(seq!["for ", tmp.to_owned(),
|
body.push(item(seq!["for ", tmp.to_owned(),
|
||||||
" in &", src.to_owned(), brackets![seq![n.to_string() , ".."]],
|
" in &", src.to_owned(), brackets![seq![n.to_string() , ".."]],
|
||||||
" ", block(inner)]));
|
" ", block(inner)]));
|
||||||
|
@ -156,7 +150,7 @@ fn simple_pattern_parser(
|
||||||
let item_dest = simple_pattern_parser(ctxt, pattern, &tmp, None, &mut inner);
|
let item_dest = simple_pattern_parser(ctxt, pattern, &tmp, None, &mut inner);
|
||||||
inner.push(item(seq![dest.to_owned(), ".insert(",
|
inner.push(item(seq![dest.to_owned(), ".insert(",
|
||||||
store_wrap(true, &field_type(pattern), &item_dest), ");"]));
|
store_wrap(true, &field_type(pattern), &item_dest), ");"]));
|
||||||
push_let_mut(body, &dest, item("preserves::value::Set::new()"));
|
push_let_mut(body, item(dest.to_owned()), item("preserves::value::Set::new()"));
|
||||||
body.push(item(seq!["for ", tmp.to_owned(),
|
body.push(item(seq!["for ", tmp.to_owned(),
|
||||||
" in ", src.to_owned(), ".value().to_set().map_err(|_| ())?",
|
" in ", src.to_owned(), ".value().to_set().map_err(|_| ())?",
|
||||||
" ", block(inner)]));
|
" ", block(inner)]));
|
||||||
|
@ -172,7 +166,7 @@ fn simple_pattern_parser(
|
||||||
dest.to_owned(), ".insert(",
|
dest.to_owned(), ".insert(",
|
||||||
store_wrap(true, &field_type(key), &key_dest), ", ",
|
store_wrap(true, &field_type(key), &key_dest), ", ",
|
||||||
store_wrap(true, &field_type(value), &value_dest), ");"]));
|
store_wrap(true, &field_type(value), &value_dest), ");"]));
|
||||||
push_let_mut(body, &dest, item("preserves::value::Map::new()"));
|
push_let_mut(body, item(dest.to_owned()), item("preserves::value::Map::new()"));
|
||||||
body.push(item(seq!["for (", tmp_key.to_owned(), ", ", tmp_value.to_owned(), ")",
|
body.push(item(seq!["for (", tmp_key.to_owned(), ", ", tmp_value.to_owned(), ")",
|
||||||
" in ", src.to_owned(), ".value().to_dictionary().map_err(|_| ())?",
|
" in ", src.to_owned(), ".value().to_dictionary().map_err(|_| ())?",
|
||||||
" ", block(inner)]));
|
" ", block(inner)]));
|
||||||
|
@ -183,9 +177,9 @@ fn simple_pattern_parser(
|
||||||
let mut mp = module.clone();
|
let mut mp = module.clone();
|
||||||
mp.push(name.to_owned());
|
mp.push(name.to_owned());
|
||||||
let tf = name![names::render_ref(mp), "try_from"];
|
let tf = name![names::render_ref(mp), "try_from"];
|
||||||
push_let(body, &dest, item(seq![tf,
|
push_let(body,
|
||||||
parens![src.to_owned()],
|
item(dest.to_owned()),
|
||||||
"?"]));
|
item(seq![tf, parens![src.to_owned()], "?"]));
|
||||||
dest
|
dest
|
||||||
},
|
},
|
||||||
}
|
}
|
||||||
|
@ -201,7 +195,9 @@ fn sequenceify(
|
||||||
Some(n) => (src.to_owned(), n),
|
Some(n) => (src.to_owned(), n),
|
||||||
None => {
|
None => {
|
||||||
let tmp = ctxt.gentempname();
|
let tmp = ctxt.gentempname();
|
||||||
push_let(body, &tmp, item(seq![src.to_owned(), ".value().to_sequence().map_err(|_| ())?"]));
|
push_let(body,
|
||||||
|
item(tmp.to_owned()),
|
||||||
|
item(seq![src.to_owned(), ".value().to_sequence().map_err(|_| ())?"]));
|
||||||
(tmp, 0)
|
(tmp, 0)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -257,7 +253,7 @@ fn pattern_parser(
|
||||||
match &**c {
|
match &**c {
|
||||||
CompoundPattern::Rec { label, fields } => {
|
CompoundPattern::Rec { label, fields } => {
|
||||||
let rtmp = ctxt.gentempname();
|
let rtmp = ctxt.gentempname();
|
||||||
push_let(body, &rtmp, item(seq![src.to_owned(), ".value().to_record(None).map_err(|_| ())?"]));
|
push_let(body, item(rtmp.to_owned()), item(seq![src.to_owned(), ".value().to_record(None).map_err(|_| ())?"]));
|
||||||
named_pattern_parser(ctxt, &**label, &format!("{}.label()", rtmp), None, body);
|
named_pattern_parser(ctxt, &**label, &format!("{}.label()", rtmp), None, body);
|
||||||
named_pattern_parser(ctxt, &**fields, &format!("{}.fields()", rtmp), Some(0), body);
|
named_pattern_parser(ctxt, &**fields, &format!("{}.fields()", rtmp), Some(0), body);
|
||||||
},
|
},
|
||||||
|
@ -268,14 +264,14 @@ fn pattern_parser(
|
||||||
CompoundPattern::TuplePrefix { fixed, variable } => {
|
CompoundPattern::TuplePrefix { fixed, variable } => {
|
||||||
let (src, n) = sequenceify(ctxt, src, sequence_base, body);
|
let (src, n) = sequenceify(ctxt, src, sequence_base, body);
|
||||||
fixed_sequence_parser(ctxt, n, fixed, &src, body);
|
fixed_sequence_parser(ctxt, n, fixed, &src, body);
|
||||||
named_pattern_parser(ctxt, &promote(&**variable), &src, Some(n + fixed.len()), body);
|
named_pattern_parser(ctxt, &promote(variable), &src, Some(n + fixed.len()), body);
|
||||||
},
|
},
|
||||||
CompoundPattern::Dict { entries } => {
|
CompoundPattern::Dict { entries } => {
|
||||||
let dtmp = ctxt.gentempname();
|
let dtmp = ctxt.gentempname();
|
||||||
push_let(body, &dtmp, item(seq![src.to_owned(), ".value().to_dictionary().map_err(|_| ())?"]));
|
push_let(body, item(dtmp.to_owned()), item(seq![src.to_owned(), ".value().to_dictionary().map_err(|_| ())?"]));
|
||||||
for (key_lit, value_pat) in entries.0.iter() {
|
for (key_lit, value_pat) in entries.0.iter() {
|
||||||
let vtmp = ctxt.gentempname();
|
let vtmp = ctxt.gentempname();
|
||||||
push_let(body, &vtmp, item(seq![
|
push_let(body, item(vtmp.to_owned()), item(seq![
|
||||||
dtmp.to_owned(), ".get", parens![ctxt.m.define_literal(key_lit)],
|
dtmp.to_owned(), ".get", parens![ctxt.m.define_literal(key_lit)],
|
||||||
".ok_or(())?"]));
|
".ok_or(())?"]));
|
||||||
named_pattern_parser(ctxt, &promote(value_pat), &vtmp, None, body);
|
named_pattern_parser(ctxt, &promote(value_pat), &vtmp, None, body);
|
||||||
|
|
|
@ -31,24 +31,39 @@ pub struct TRecord(pub Vec<(String, TField)>);
|
||||||
|
|
||||||
pub fn definition_type(d: &Definition) -> TDefinition {
|
pub fn definition_type(d: &Definition) -> TDefinition {
|
||||||
match d {
|
match d {
|
||||||
Definition::Or { pattern_0, pattern_1, pattern_n } => {
|
Definition::Or { pattern_0, pattern_1, pattern_n } =>
|
||||||
let mut entries = Vec::new();
|
TDefinition::Union(or_definition_type(pattern_0, pattern_1, pattern_n)),
|
||||||
entries.push((pattern_0.variant_label.to_owned(), pattern_type(&pattern_0.pattern)));
|
Definition::And { pattern_0, pattern_1, pattern_n } =>
|
||||||
entries.push((pattern_1.variant_label.to_owned(), pattern_type(&pattern_1.pattern)));
|
TDefinition::Simple(and_definition_type(pattern_0, pattern_1, pattern_n)),
|
||||||
for e in pattern_n {
|
Definition::Pattern(p) =>
|
||||||
entries.push((e.variant_label.to_owned(), pattern_type(&e.pattern)));
|
TDefinition::Simple(pattern_type(p)),
|
||||||
}
|
|
||||||
TDefinition::Union(entries)
|
|
||||||
},
|
|
||||||
Definition::And { pattern_0, pattern_1, pattern_n } => {
|
|
||||||
let mut arms = vec![&**pattern_0, &**pattern_1];
|
|
||||||
arms.extend(pattern_n);
|
|
||||||
TDefinition::Simple(record_type(&arms))
|
|
||||||
},
|
|
||||||
Definition::Pattern(p) => TDefinition::Simple(pattern_type(p)),
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
pub fn or_definition_type(
|
||||||
|
p0: &NamedAlternative,
|
||||||
|
p1: &NamedAlternative,
|
||||||
|
pn: &Vec<NamedAlternative>,
|
||||||
|
) -> Vec<(String, TSimple)> {
|
||||||
|
let mut entries = Vec::new();
|
||||||
|
entries.push((p0.variant_label.to_owned(), pattern_type(&p0.pattern)));
|
||||||
|
entries.push((p1.variant_label.to_owned(), pattern_type(&p1.pattern)));
|
||||||
|
for e in pn {
|
||||||
|
entries.push((e.variant_label.to_owned(), pattern_type(&e.pattern)));
|
||||||
|
}
|
||||||
|
entries
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn and_definition_type(
|
||||||
|
p0: &NamedPattern,
|
||||||
|
p1: &NamedPattern,
|
||||||
|
pn: &Vec<NamedPattern>,
|
||||||
|
) -> TSimple {
|
||||||
|
let mut arms = vec![p0, p1];
|
||||||
|
arms.extend(pn);
|
||||||
|
record_type(&arms)
|
||||||
|
}
|
||||||
|
|
||||||
pub fn pattern_type(p: &Pattern) -> TSimple {
|
pub fn pattern_type(p: &Pattern) -> TSimple {
|
||||||
match p {
|
match p {
|
||||||
Pattern::SimplePattern(p) =>
|
Pattern::SimplePattern(p) =>
|
||||||
|
|
|
@ -0,0 +1,287 @@
|
||||||
|
use crate::*;
|
||||||
|
use crate::metaschema::*;
|
||||||
|
use crate::syntax::block::constructors::*;
|
||||||
|
use crate::syntax::block::{Emittable, Item};
|
||||||
|
|
||||||
|
use std::cell::Cell;
|
||||||
|
use std::rc::Rc;
|
||||||
|
|
||||||
|
use super::codegen::*;
|
||||||
|
use super::context::{ModuleContext, FunctionContext};
|
||||||
|
use super::names;
|
||||||
|
use super::types::*;
|
||||||
|
|
||||||
|
type ValueSource = Option<String>;
|
||||||
|
|
||||||
|
#[derive(Clone)]
|
||||||
|
struct FieldsSink {
|
||||||
|
finish: Item,
|
||||||
|
vec_expr: Item,
|
||||||
|
body: Vec<Item>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Clone)]
|
||||||
|
enum ValueSink {
|
||||||
|
Normal,
|
||||||
|
Fields(Rc<Cell<Option<FieldsSink>>>),
|
||||||
|
}
|
||||||
|
|
||||||
|
impl std::fmt::Debug for ValueSink {
|
||||||
|
fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
|
||||||
|
match self {
|
||||||
|
ValueSink::Normal => write!(f, "ValueSink::Normal"),
|
||||||
|
ValueSink::Fields(_) => write!(f, "ValueSink::Normal"),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
struct ValueContext {
|
||||||
|
src: ValueSource,
|
||||||
|
sink: ValueSink,
|
||||||
|
is_struct: bool,
|
||||||
|
}
|
||||||
|
|
||||||
|
fn normal_none(is_struct: bool) -> ValueContext {
|
||||||
|
ValueContext { src: None, sink: ValueSink::Normal, is_struct: is_struct }
|
||||||
|
}
|
||||||
|
|
||||||
|
fn normal_src(src: String, is_struct: bool) -> ValueContext {
|
||||||
|
ValueContext { src: Some(src), sink: ValueSink::Normal, is_struct: is_struct }
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn gen_definition_unparser(m: &mut ModuleContext, n: &str, d: &Definition) {
|
||||||
|
m.define_function(
|
||||||
|
|mut ctxt| {
|
||||||
|
let mut body = Vec::new();
|
||||||
|
|
||||||
|
match d {
|
||||||
|
Definition::Or { pattern_0, pattern_1, pattern_n } => {
|
||||||
|
let mut ps = vec![&**pattern_0, &**pattern_1];
|
||||||
|
ps.extend(pattern_n);
|
||||||
|
body.push(item(seq!["match value ", block(ps.iter().map(
|
||||||
|
| NamedAlternative { variant_label: name, pattern: pat } | ctxt.branch(|ctxt| {
|
||||||
|
let ctorname = item(name![names::render_constructor(n), names::render_constructor(name)]);
|
||||||
|
let (patpat, vc) = destruct(ctxt, ctorname, false, &pattern_type(pat));
|
||||||
|
item(seq![patpat, " => ", pattern_unparser(ctxt, pat, &vc), ","])
|
||||||
|
})).collect())]));
|
||||||
|
}
|
||||||
|
Definition::And { pattern_0, pattern_1, pattern_n } => {
|
||||||
|
let mut ps = vec![&**pattern_0, &**pattern_1];
|
||||||
|
ps.extend(pattern_n);
|
||||||
|
let (patpat, vc) = destruct(&mut ctxt, item(names::render_constructor(n)), true, &record_type(&ps));
|
||||||
|
push_let(&mut body, item(patpat), item("value"));
|
||||||
|
body.push(item(seq!["preserves::value::merge(vec!", brackets(ps.iter().map(
|
||||||
|
|p| named_pattern_unparser(&mut ctxt, p, &vc)).collect()), ")"]));
|
||||||
|
}
|
||||||
|
Definition::Pattern(p) => {
|
||||||
|
let (patpat, vc) = destruct(&mut ctxt, item(names::render_constructor(n)), true, &pattern_type(p));
|
||||||
|
push_let(&mut body, item(patpat), item("value"));
|
||||||
|
body.push(pattern_unparser(&mut ctxt, p, &vc));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
item(seq!["impl std::convert::From", anglebrackets![seq!["&", names::render_constructor(n)]],
|
||||||
|
" for preserves::value::IOValue ", block![
|
||||||
|
seq!["fn from(value: &", names::render_constructor(n), ") -> Self ",
|
||||||
|
block(body)]]])
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
fn destruct(
|
||||||
|
ctxt: &mut FunctionContext,
|
||||||
|
ctorname: Item,
|
||||||
|
is_struct: bool,
|
||||||
|
ty: &TSimple,
|
||||||
|
) -> (impl Emittable, ValueContext) {
|
||||||
|
match ty {
|
||||||
|
TSimple::Field(TField::Unit) => (seq![ctorname], normal_none(is_struct)),
|
||||||
|
TSimple::Field(_) => {
|
||||||
|
let src = ctxt.gentempname();
|
||||||
|
(seq![ctorname, parens![src.to_owned()]], normal_src(src, is_struct))
|
||||||
|
}
|
||||||
|
TSimple::Record(TRecord(fs)) => {
|
||||||
|
for (fname, fty) in fs {
|
||||||
|
let fsrc = ctxt.gentempname();
|
||||||
|
ctxt.capture(names::render_fieldname(fname), fty.clone(), fsrc);
|
||||||
|
}
|
||||||
|
(seq![
|
||||||
|
ctorname, " ", braces(ctxt.captures.iter().map(
|
||||||
|
|c| item(seq![c.field_name.clone(), ": ", c.source_expr.clone()])).collect())],
|
||||||
|
normal_none(is_struct))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn simple_pattern_unparser(
|
||||||
|
ctxt: &mut FunctionContext,
|
||||||
|
p: &SimplePattern,
|
||||||
|
vc: &ValueContext,
|
||||||
|
) -> Item {
|
||||||
|
let src = &vc.src;
|
||||||
|
match p {
|
||||||
|
SimplePattern::Any =>
|
||||||
|
item(seq![src.as_ref().unwrap().to_owned(), ".clone()"]),
|
||||||
|
SimplePattern::Atom { atom_kind: k } => {
|
||||||
|
if let AtomKind::Symbol = &**k {
|
||||||
|
item(seq!["preserves::value::Value::symbol(", src.as_ref().unwrap().to_owned(), ").wrap()"])
|
||||||
|
} else {
|
||||||
|
item(seq!["preserves::value::Value::from(", src.as_ref().unwrap().to_owned(), ").wrap()"])
|
||||||
|
}
|
||||||
|
}
|
||||||
|
SimplePattern::Embedded { .. } =>
|
||||||
|
item(seq!["preserves::value::Value::Domain(", src.as_ref().unwrap().to_owned(), ").wrap()"]),
|
||||||
|
SimplePattern::Lit { value } =>
|
||||||
|
item(seq![parens![ctxt.m.define_literal(value)], ".clone()"]),
|
||||||
|
SimplePattern::Seqof { pattern } => {
|
||||||
|
let mut fields_sink = sequenceify(ctxt, vc);
|
||||||
|
let tmp = ctxt.gentempname();
|
||||||
|
fields_sink.body.push(item(seq![
|
||||||
|
"for ", tmp.to_owned(), " in ",
|
||||||
|
src.as_ref().unwrap().to_owned(), " ", block![
|
||||||
|
seq![fields_sink.vec_expr.clone(), ".push(",
|
||||||
|
simple_pattern_unparser(ctxt,
|
||||||
|
pattern,
|
||||||
|
&normal_src(tmp, true)), ");"]]]));
|
||||||
|
finish(fields_sink)
|
||||||
|
}
|
||||||
|
SimplePattern::Setof { pattern } => {
|
||||||
|
let tmp = ctxt.gentempname();
|
||||||
|
item(seq!["preserves::value::Value::Set(",
|
||||||
|
src.as_ref().unwrap().to_owned(), ".iter().map(|", tmp.to_owned(), "| ",
|
||||||
|
simple_pattern_unparser(ctxt, pattern, &normal_src(tmp, true)),
|
||||||
|
").collect()).wrap()"])
|
||||||
|
}
|
||||||
|
SimplePattern::Dictof { key, value } => {
|
||||||
|
let tmp_key = ctxt.gentempname();
|
||||||
|
let tmp_value = ctxt.gentempname();
|
||||||
|
item(seq!["preserves::value::Value::Dictionary(",
|
||||||
|
src.as_ref().unwrap().to_owned(),
|
||||||
|
".iter().map(|(", tmp_key.to_owned(), ", ", tmp_value.to_owned(), ")| ",
|
||||||
|
parens![simple_pattern_unparser(ctxt, key, &normal_src(tmp_key, true)),
|
||||||
|
simple_pattern_unparser(ctxt, value, &normal_src(tmp_value, true))],
|
||||||
|
").collect()).wrap()"])
|
||||||
|
}
|
||||||
|
SimplePattern::Ref(_r) =>
|
||||||
|
item(seq!["preserves::value::IOValue::from(", src.as_ref().unwrap().to_owned(),
|
||||||
|
if vc.is_struct { "" } else { ".as_ref()" },
|
||||||
|
")"]),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn named_pattern_unparser(
|
||||||
|
ctxt: &mut FunctionContext,
|
||||||
|
p: &NamedPattern,
|
||||||
|
vc: &ValueContext,
|
||||||
|
) -> Item {
|
||||||
|
match p {
|
||||||
|
NamedPattern::Anonymous(p) =>
|
||||||
|
pattern_unparser(ctxt, p, vc),
|
||||||
|
NamedPattern::Named(b) => {
|
||||||
|
let Binding { name, pattern} = &**b;
|
||||||
|
let src = ctxt.lookup_capture(&names::render_fieldname(name)).source_expr.to_owned();
|
||||||
|
simple_pattern_unparser(ctxt, pattern, &ValueContext {
|
||||||
|
src: Some(src),
|
||||||
|
sink: vc.sink.clone(),
|
||||||
|
is_struct: vc.is_struct,
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn pattern_unparser(
|
||||||
|
ctxt: &mut FunctionContext,
|
||||||
|
p: &Pattern,
|
||||||
|
vc: &ValueContext,
|
||||||
|
) -> Item {
|
||||||
|
match p {
|
||||||
|
Pattern::SimplePattern(s) =>
|
||||||
|
simple_pattern_unparser(ctxt, s, vc),
|
||||||
|
Pattern::CompoundPattern(c) => {
|
||||||
|
match &**c {
|
||||||
|
CompoundPattern::Rec { label, fields } => {
|
||||||
|
let rtmp = ctxt.gentempname();
|
||||||
|
let mut body = Vec::new();
|
||||||
|
push_let_mut(&mut body,
|
||||||
|
item(rtmp.to_owned()),
|
||||||
|
item(seq!["preserves::value::Record(vec![",
|
||||||
|
named_pattern_unparser(ctxt, label, &normal_none(vc.is_struct)),
|
||||||
|
"])"]));
|
||||||
|
named_pattern_unparser(ctxt, fields, &ValueContext {
|
||||||
|
src: None,
|
||||||
|
sink: ValueSink::Fields(Rc::new(Cell::new(Some(FieldsSink {
|
||||||
|
finish: item(seq![rtmp.clone(), ".finish().wrap()"]),
|
||||||
|
vec_expr: item(seq![rtmp.clone(), ".fields_vec_mut()"]),
|
||||||
|
body: body,
|
||||||
|
})))),
|
||||||
|
is_struct: vc.is_struct,
|
||||||
|
})
|
||||||
|
},
|
||||||
|
CompoundPattern::Tuple { patterns } => {
|
||||||
|
let mut fields_sink = sequenceify(ctxt, vc);
|
||||||
|
fixed_sequence_parser(ctxt, patterns, &mut fields_sink, vc.is_struct);
|
||||||
|
finish(fields_sink)
|
||||||
|
},
|
||||||
|
CompoundPattern::TuplePrefix { fixed, variable } => {
|
||||||
|
let mut fields_sink = sequenceify(ctxt, vc);
|
||||||
|
fixed_sequence_parser(ctxt, fixed, &mut fields_sink, vc.is_struct);
|
||||||
|
named_pattern_unparser(ctxt, &promote(variable), &ValueContext {
|
||||||
|
src: vc.src.clone(),
|
||||||
|
sink: ValueSink::Fields(Rc::new(Cell::new(Some(fields_sink)))),
|
||||||
|
is_struct: true,
|
||||||
|
})
|
||||||
|
},
|
||||||
|
CompoundPattern::Dict { entries } => {
|
||||||
|
let dtmp = item(ctxt.gentempname());
|
||||||
|
let mut body = Vec::new();
|
||||||
|
push_let_mut(&mut body, dtmp.clone(), item("preserves::value::Map::new()"));
|
||||||
|
for (key_lit, value_pat) in entries.0.iter() {
|
||||||
|
body.push(item(seq![dtmp.clone(), ".insert", parens![
|
||||||
|
seq![parens![ctxt.m.define_literal(key_lit)], ".clone()"],
|
||||||
|
named_pattern_unparser(ctxt, &promote(value_pat), &normal_none(vc.is_struct))], ";"]));
|
||||||
|
}
|
||||||
|
body.push(item(seq!["preserves::value::Value::Dictionary(", dtmp, ").wrap()"]));
|
||||||
|
item(block(body))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn sequenceify<'a>(
|
||||||
|
ctxt: &mut FunctionContext,
|
||||||
|
vc: &'a ValueContext,
|
||||||
|
) -> FieldsSink {
|
||||||
|
match vc {
|
||||||
|
ValueContext { sink: ValueSink::Fields(fields_sink), .. } =>
|
||||||
|
(**fields_sink).take().unwrap(),
|
||||||
|
_ => {
|
||||||
|
let rtmp = item(ctxt.gentempname());
|
||||||
|
let mut body = Vec::new();
|
||||||
|
push_let_mut(&mut body, rtmp.clone(), item("vec![]"));
|
||||||
|
FieldsSink {
|
||||||
|
finish: item(seq![
|
||||||
|
"preserves::value::Value::Sequence", parens![rtmp.clone()], ".wrap()"]),
|
||||||
|
vec_expr: rtmp,
|
||||||
|
body: body,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn finish(mut fields_sink: FieldsSink) -> Item {
|
||||||
|
fields_sink.body.push(fields_sink.finish);
|
||||||
|
item(block(fields_sink.body))
|
||||||
|
}
|
||||||
|
|
||||||
|
fn fixed_sequence_parser(
|
||||||
|
ctxt: &mut FunctionContext,
|
||||||
|
patterns: &Vec<NamedPattern>,
|
||||||
|
fields_sink: &mut FieldsSink,
|
||||||
|
is_struct: bool,
|
||||||
|
) {
|
||||||
|
for p in patterns {
|
||||||
|
fields_sink.body.push(item(seq![fields_sink.vec_expr.clone(), ".push", parens![
|
||||||
|
named_pattern_unparser(ctxt, p, &normal_none(is_struct))], ";"]));
|
||||||
|
}
|
||||||
|
}
|
|
@ -30,14 +30,15 @@ mod tests {
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn metaschema_parsing() -> Result<(), std::io::Error> {
|
fn metaschema_parsing() -> Result<(), std::io::Error> {
|
||||||
use preserves::value::Reader;
|
use preserves::value::{IOValue, Reader};
|
||||||
use std::convert::TryFrom;
|
use std::convert::TryFrom;
|
||||||
|
use std::convert::From;
|
||||||
|
|
||||||
let mut f = std::fs::File::open("../../../schema/schema.bin")?;
|
let mut f = std::fs::File::open("../../../schema/schema.bin")?;
|
||||||
let mut reader = preserves::value::PackedReader::decode_read(&mut f);
|
let mut reader = preserves::value::PackedReader::decode_read(&mut f);
|
||||||
let schema = reader.demand_next(false)?;
|
let schema = reader.demand_next(false)?;
|
||||||
println!("{:#?}", crate::metaschema::Schema::try_from(&schema));
|
let parsed = crate::metaschema::Schema::try_from(&schema).expect("successful parse");
|
||||||
|
assert_eq!(schema, IOValue::from(&parsed));
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -162,6 +162,20 @@ impl std::convert::TryFrom<&preserves::value::IOValue> for AtomKind {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
impl std::convert::From<&AtomKind> for preserves::value::IOValue {
|
||||||
|
fn from(value: &AtomKind) -> Self {
|
||||||
|
match value {
|
||||||
|
AtomKind::Boolean => (&*LIT0).clone(),
|
||||||
|
AtomKind::Float => (&*LIT1).clone(),
|
||||||
|
AtomKind::Double => (&*LIT2).clone(),
|
||||||
|
AtomKind::SignedInteger => (&*LIT3).clone(),
|
||||||
|
AtomKind::String => (&*LIT4).clone(),
|
||||||
|
AtomKind::ByteString => (&*LIT5).clone(),
|
||||||
|
AtomKind::Symbol => (&*LIT6).clone(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
impl std::convert::TryFrom<&preserves::value::IOValue> for Binding {
|
impl std::convert::TryFrom<&preserves::value::IOValue> for Binding {
|
||||||
type Error = ();
|
type Error = ();
|
||||||
fn try_from(value: &preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
|
fn try_from(value: &preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
|
||||||
|
@ -175,6 +189,18 @@ impl std::convert::TryFrom<&preserves::value::IOValue> for Binding {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
impl std::convert::From<&Binding> for preserves::value::IOValue {
|
||||||
|
fn from(value: &Binding) -> Self {
|
||||||
|
let Binding {name: _tmp0, pattern: _tmp1} = value;
|
||||||
|
{
|
||||||
|
let mut _tmp2 = preserves::value::Record(vec![(&*LIT7).clone()]);
|
||||||
|
_tmp2.fields_vec_mut().push(preserves::value::Value::symbol(_tmp0).wrap());
|
||||||
|
_tmp2.fields_vec_mut().push(preserves::value::IOValue::from(_tmp1));
|
||||||
|
_tmp2.finish().wrap()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
impl std::convert::TryFrom<&preserves::value::IOValue> for Bundle {
|
impl std::convert::TryFrom<&preserves::value::IOValue> for Bundle {
|
||||||
type Error = ();
|
type Error = ();
|
||||||
fn try_from(value: &preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
|
fn try_from(value: &preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
|
||||||
|
@ -187,6 +213,17 @@ impl std::convert::TryFrom<&preserves::value::IOValue> for Bundle {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
impl std::convert::From<&Bundle> for preserves::value::IOValue {
|
||||||
|
fn from(value: &Bundle) -> Self {
|
||||||
|
let Bundle {modules: _tmp0} = value;
|
||||||
|
{
|
||||||
|
let mut _tmp1 = preserves::value::Record(vec![(&*LIT8).clone()]);
|
||||||
|
_tmp1.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0));
|
||||||
|
_tmp1.finish().wrap()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
fn _parse_compound_pattern_rec(value: &preserves::value::IOValue) -> std::result::Result<CompoundPattern, ()> {
|
fn _parse_compound_pattern_rec(value: &preserves::value::IOValue) -> std::result::Result<CompoundPattern, ()> {
|
||||||
let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
|
let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
|
||||||
if _tmp0.label() != &*LIT9 { return Err(()); }
|
if _tmp0.label() != &*LIT9 { return Err(()); }
|
||||||
|
@ -240,6 +277,47 @@ impl std::convert::TryFrom<&preserves::value::IOValue> for CompoundPattern {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
impl std::convert::From<&CompoundPattern> for preserves::value::IOValue {
|
||||||
|
fn from(value: &CompoundPattern) -> Self {
|
||||||
|
match value {
|
||||||
|
CompoundPattern::Rec {label: _tmp0, fields: _tmp1} => {
|
||||||
|
let mut _tmp2 = preserves::value::Record(vec![(&*LIT9).clone()]);
|
||||||
|
_tmp2.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0.as_ref()));
|
||||||
|
_tmp2.fields_vec_mut().push(preserves::value::IOValue::from(_tmp1.as_ref()));
|
||||||
|
_tmp2.finish().wrap()
|
||||||
|
},
|
||||||
|
CompoundPattern::Tuple {patterns: _tmp0} => {
|
||||||
|
let mut _tmp1 = preserves::value::Record(vec![(&*LIT10).clone()]);
|
||||||
|
_tmp1.fields_vec_mut().push(
|
||||||
|
{
|
||||||
|
let mut _tmp2 = vec![];
|
||||||
|
for _tmp3 in _tmp0 {_tmp2.push(preserves::value::IOValue::from(_tmp3));}
|
||||||
|
preserves::value::Value::Sequence(_tmp2).wrap()
|
||||||
|
}
|
||||||
|
);
|
||||||
|
_tmp1.finish().wrap()
|
||||||
|
},
|
||||||
|
CompoundPattern::TuplePrefix {fixed: _tmp0, variable: _tmp1} => {
|
||||||
|
let mut _tmp2 = preserves::value::Record(vec![(&*LIT11).clone()]);
|
||||||
|
_tmp2.fields_vec_mut().push(
|
||||||
|
{
|
||||||
|
let mut _tmp3 = vec![];
|
||||||
|
for _tmp4 in _tmp0 {_tmp3.push(preserves::value::IOValue::from(_tmp4));}
|
||||||
|
preserves::value::Value::Sequence(_tmp3).wrap()
|
||||||
|
}
|
||||||
|
);
|
||||||
|
_tmp2.fields_vec_mut().push(preserves::value::IOValue::from(_tmp1.as_ref()));
|
||||||
|
_tmp2.finish().wrap()
|
||||||
|
},
|
||||||
|
CompoundPattern::Dict {entries: _tmp0} => {
|
||||||
|
let mut _tmp1 = preserves::value::Record(vec![(&*LIT12).clone()]);
|
||||||
|
_tmp1.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0.as_ref()));
|
||||||
|
_tmp1.finish().wrap()
|
||||||
|
},
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
fn _parse_definition_or(value: &preserves::value::IOValue) -> std::result::Result<Definition, ()> {
|
fn _parse_definition_or(value: &preserves::value::IOValue) -> std::result::Result<Definition, ()> {
|
||||||
let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
|
let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
|
||||||
if _tmp0.label() != &*LIT13 { return Err(()); }
|
if _tmp0.label() != &*LIT13 { return Err(()); }
|
||||||
|
@ -291,6 +369,40 @@ impl std::convert::TryFrom<&preserves::value::IOValue> for Definition {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
impl std::convert::From<&Definition> for preserves::value::IOValue {
|
||||||
|
fn from(value: &Definition) -> Self {
|
||||||
|
match value {
|
||||||
|
Definition::Or {pattern_0: _tmp0, pattern_1: _tmp1, pattern_n: _tmp2} => {
|
||||||
|
let mut _tmp3 = preserves::value::Record(vec![(&*LIT13).clone()]);
|
||||||
|
_tmp3.fields_vec_mut().push(
|
||||||
|
{
|
||||||
|
let mut _tmp4 = vec![];
|
||||||
|
_tmp4.push(preserves::value::IOValue::from(_tmp0.as_ref()));
|
||||||
|
_tmp4.push(preserves::value::IOValue::from(_tmp1.as_ref()));
|
||||||
|
for _tmp5 in _tmp2 {_tmp4.push(preserves::value::IOValue::from(_tmp5));}
|
||||||
|
preserves::value::Value::Sequence(_tmp4).wrap()
|
||||||
|
}
|
||||||
|
);
|
||||||
|
_tmp3.finish().wrap()
|
||||||
|
},
|
||||||
|
Definition::And {pattern_0: _tmp0, pattern_1: _tmp1, pattern_n: _tmp2} => {
|
||||||
|
let mut _tmp3 = preserves::value::Record(vec![(&*LIT14).clone()]);
|
||||||
|
_tmp3.fields_vec_mut().push(
|
||||||
|
{
|
||||||
|
let mut _tmp4 = vec![];
|
||||||
|
_tmp4.push(preserves::value::IOValue::from(_tmp0.as_ref()));
|
||||||
|
_tmp4.push(preserves::value::IOValue::from(_tmp1.as_ref()));
|
||||||
|
for _tmp5 in _tmp2 {_tmp4.push(preserves::value::IOValue::from(_tmp5));}
|
||||||
|
preserves::value::Value::Sequence(_tmp4).wrap()
|
||||||
|
}
|
||||||
|
);
|
||||||
|
_tmp3.finish().wrap()
|
||||||
|
},
|
||||||
|
Definition::Pattern(_tmp0) => preserves::value::IOValue::from(_tmp0.as_ref()),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
impl std::convert::TryFrom<&preserves::value::IOValue> for Definitions {
|
impl std::convert::TryFrom<&preserves::value::IOValue> for Definitions {
|
||||||
type Error = ();
|
type Error = ();
|
||||||
fn try_from(value: &preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
|
fn try_from(value: &preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
|
||||||
|
@ -304,6 +416,16 @@ impl std::convert::TryFrom<&preserves::value::IOValue> for Definitions {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
impl std::convert::From<&Definitions> for preserves::value::IOValue {
|
||||||
|
fn from(value: &Definitions) -> Self {
|
||||||
|
let Definitions(_tmp0) = value;
|
||||||
|
preserves::value::Value::Dictionary(_tmp0.iter().map(|(_tmp1, _tmp2)| (
|
||||||
|
preserves::value::Value::symbol(_tmp1).wrap(),
|
||||||
|
preserves::value::IOValue::from(_tmp2)
|
||||||
|
)).collect()).wrap()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
impl std::convert::TryFrom<&preserves::value::IOValue> for DictionaryEntries {
|
impl std::convert::TryFrom<&preserves::value::IOValue> for DictionaryEntries {
|
||||||
type Error = ();
|
type Error = ();
|
||||||
fn try_from(value: &preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
|
fn try_from(value: &preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
|
||||||
|
@ -317,6 +439,13 @@ impl std::convert::TryFrom<&preserves::value::IOValue> for DictionaryEntries {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
impl std::convert::From<&DictionaryEntries> for preserves::value::IOValue {
|
||||||
|
fn from(value: &DictionaryEntries) -> Self {
|
||||||
|
let DictionaryEntries(_tmp0) = value;
|
||||||
|
preserves::value::Value::Dictionary(_tmp0.iter().map(|(_tmp1, _tmp2)| (_tmp1.clone(), preserves::value::IOValue::from(_tmp2))).collect()).wrap()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
fn _parse_embedded_type_name_ref(value: &preserves::value::IOValue) -> std::result::Result<EmbeddedTypeName, ()> {
|
fn _parse_embedded_type_name_ref(value: &preserves::value::IOValue) -> std::result::Result<EmbeddedTypeName, ()> {
|
||||||
let _tmp0 = Ref::try_from(value)?;
|
let _tmp0 = Ref::try_from(value)?;
|
||||||
Ok(EmbeddedTypeName::Ref(std::boxed::Box::new(_tmp0)))
|
Ok(EmbeddedTypeName::Ref(std::boxed::Box::new(_tmp0)))
|
||||||
|
@ -337,6 +466,15 @@ impl std::convert::TryFrom<&preserves::value::IOValue> for EmbeddedTypeName {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
impl std::convert::From<&EmbeddedTypeName> for preserves::value::IOValue {
|
||||||
|
fn from(value: &EmbeddedTypeName) -> Self {
|
||||||
|
match value {
|
||||||
|
EmbeddedTypeName::Ref(_tmp0) => preserves::value::IOValue::from(_tmp0.as_ref()),
|
||||||
|
EmbeddedTypeName::False => (&*LIT15).clone(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
impl std::convert::TryFrom<&preserves::value::IOValue> for ModulePath {
|
impl std::convert::TryFrom<&preserves::value::IOValue> for ModulePath {
|
||||||
type Error = ();
|
type Error = ();
|
||||||
fn try_from(value: &preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
|
fn try_from(value: &preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
|
||||||
|
@ -350,6 +488,17 @@ impl std::convert::TryFrom<&preserves::value::IOValue> for ModulePath {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
impl std::convert::From<&ModulePath> for preserves::value::IOValue {
|
||||||
|
fn from(value: &ModulePath) -> Self {
|
||||||
|
let ModulePath(_tmp0) = value;
|
||||||
|
{
|
||||||
|
let mut _tmp1 = vec![];
|
||||||
|
for _tmp2 in _tmp0 {_tmp1.push(preserves::value::Value::symbol(_tmp2).wrap());}
|
||||||
|
preserves::value::Value::Sequence(_tmp1).wrap()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
impl std::convert::TryFrom<&preserves::value::IOValue> for Modules {
|
impl std::convert::TryFrom<&preserves::value::IOValue> for Modules {
|
||||||
type Error = ();
|
type Error = ();
|
||||||
fn try_from(value: &preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
|
fn try_from(value: &preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
|
||||||
|
@ -363,6 +512,13 @@ impl std::convert::TryFrom<&preserves::value::IOValue> for Modules {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
impl std::convert::From<&Modules> for preserves::value::IOValue {
|
||||||
|
fn from(value: &Modules) -> Self {
|
||||||
|
let Modules(_tmp0) = value;
|
||||||
|
preserves::value::Value::Dictionary(_tmp0.iter().map(|(_tmp1, _tmp2)| (preserves::value::IOValue::from(_tmp1), preserves::value::IOValue::from(_tmp2))).collect()).wrap()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
impl std::convert::TryFrom<&preserves::value::IOValue> for NamedAlternative {
|
impl std::convert::TryFrom<&preserves::value::IOValue> for NamedAlternative {
|
||||||
type Error = ();
|
type Error = ();
|
||||||
fn try_from(value: &preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
|
fn try_from(value: &preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
|
||||||
|
@ -374,6 +530,18 @@ impl std::convert::TryFrom<&preserves::value::IOValue> for NamedAlternative {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
impl std::convert::From<&NamedAlternative> for preserves::value::IOValue {
|
||||||
|
fn from(value: &NamedAlternative) -> Self {
|
||||||
|
let NamedAlternative {variant_label: _tmp0, pattern: _tmp1} = value;
|
||||||
|
{
|
||||||
|
let mut _tmp2 = vec![];
|
||||||
|
_tmp2.push(preserves::value::Value::from(_tmp0).wrap());
|
||||||
|
_tmp2.push(preserves::value::IOValue::from(_tmp1));
|
||||||
|
preserves::value::Value::Sequence(_tmp2).wrap()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
fn _parse_named_pattern_named(value: &preserves::value::IOValue) -> std::result::Result<NamedPattern, ()> {
|
fn _parse_named_pattern_named(value: &preserves::value::IOValue) -> std::result::Result<NamedPattern, ()> {
|
||||||
let _tmp0 = Binding::try_from(value)?;
|
let _tmp0 = Binding::try_from(value)?;
|
||||||
Ok(NamedPattern::Named(std::boxed::Box::new(_tmp0)))
|
Ok(NamedPattern::Named(std::boxed::Box::new(_tmp0)))
|
||||||
|
@ -393,6 +561,15 @@ impl std::convert::TryFrom<&preserves::value::IOValue> for NamedPattern {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
impl std::convert::From<&NamedPattern> for preserves::value::IOValue {
|
||||||
|
fn from(value: &NamedPattern) -> Self {
|
||||||
|
match value {
|
||||||
|
NamedPattern::Named(_tmp0) => preserves::value::IOValue::from(_tmp0.as_ref()),
|
||||||
|
NamedPattern::Anonymous(_tmp0) => preserves::value::IOValue::from(_tmp0.as_ref()),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
fn _parse_named_simple_pattern_named(value: &preserves::value::IOValue) -> std::result::Result<NamedSimplePattern, ()> {
|
fn _parse_named_simple_pattern_named(value: &preserves::value::IOValue) -> std::result::Result<NamedSimplePattern, ()> {
|
||||||
let _tmp0 = Binding::try_from(value)?;
|
let _tmp0 = Binding::try_from(value)?;
|
||||||
Ok(NamedSimplePattern::Named(std::boxed::Box::new(_tmp0)))
|
Ok(NamedSimplePattern::Named(std::boxed::Box::new(_tmp0)))
|
||||||
|
@ -412,6 +589,15 @@ impl std::convert::TryFrom<&preserves::value::IOValue> for NamedSimplePattern {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
impl std::convert::From<&NamedSimplePattern> for preserves::value::IOValue {
|
||||||
|
fn from(value: &NamedSimplePattern) -> Self {
|
||||||
|
match value {
|
||||||
|
NamedSimplePattern::Named(_tmp0) => preserves::value::IOValue::from(_tmp0.as_ref()),
|
||||||
|
NamedSimplePattern::Anonymous(_tmp0) => preserves::value::IOValue::from(_tmp0.as_ref()),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
fn _parse_pattern_simple_pattern(value: &preserves::value::IOValue) -> std::result::Result<Pattern, ()> {
|
fn _parse_pattern_simple_pattern(value: &preserves::value::IOValue) -> std::result::Result<Pattern, ()> {
|
||||||
let _tmp0 = SimplePattern::try_from(value)?;
|
let _tmp0 = SimplePattern::try_from(value)?;
|
||||||
Ok(Pattern::SimplePattern(std::boxed::Box::new(_tmp0)))
|
Ok(Pattern::SimplePattern(std::boxed::Box::new(_tmp0)))
|
||||||
|
@ -431,6 +617,15 @@ impl std::convert::TryFrom<&preserves::value::IOValue> for Pattern {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
impl std::convert::From<&Pattern> for preserves::value::IOValue {
|
||||||
|
fn from(value: &Pattern) -> Self {
|
||||||
|
match value {
|
||||||
|
Pattern::SimplePattern(_tmp0) => preserves::value::IOValue::from(_tmp0.as_ref()),
|
||||||
|
Pattern::CompoundPattern(_tmp0) => preserves::value::IOValue::from(_tmp0.as_ref()),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
impl std::convert::TryFrom<&preserves::value::IOValue> for Ref {
|
impl std::convert::TryFrom<&preserves::value::IOValue> for Ref {
|
||||||
type Error = ();
|
type Error = ();
|
||||||
fn try_from(value: &preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
|
fn try_from(value: &preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
|
||||||
|
@ -444,6 +639,18 @@ impl std::convert::TryFrom<&preserves::value::IOValue> for Ref {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
impl std::convert::From<&Ref> for preserves::value::IOValue {
|
||||||
|
fn from(value: &Ref) -> Self {
|
||||||
|
let Ref {module: _tmp0, name: _tmp1} = value;
|
||||||
|
{
|
||||||
|
let mut _tmp2 = preserves::value::Record(vec![(&*LIT16).clone()]);
|
||||||
|
_tmp2.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0));
|
||||||
|
_tmp2.fields_vec_mut().push(preserves::value::Value::symbol(_tmp1).wrap());
|
||||||
|
_tmp2.finish().wrap()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
impl std::convert::TryFrom<&preserves::value::IOValue> for Schema {
|
impl std::convert::TryFrom<&preserves::value::IOValue> for Schema {
|
||||||
type Error = ();
|
type Error = ();
|
||||||
fn try_from(value: &preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
|
fn try_from(value: &preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
|
||||||
|
@ -462,6 +669,25 @@ impl std::convert::TryFrom<&preserves::value::IOValue> for Schema {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
impl std::convert::From<&Schema> for preserves::value::IOValue {
|
||||||
|
fn from(value: &Schema) -> Self {
|
||||||
|
let Schema {definitions: _tmp0, embedded_type: _tmp1, version: _tmp2} = value;
|
||||||
|
{
|
||||||
|
let mut _tmp3 = preserves::value::Record(vec![(&*LIT17).clone()]);
|
||||||
|
_tmp3.fields_vec_mut().push(
|
||||||
|
{
|
||||||
|
let mut _tmp4 = preserves::value::Map::new();
|
||||||
|
_tmp4.insert((&*LIT18).clone(), preserves::value::IOValue::from(_tmp0));
|
||||||
|
_tmp4.insert((&*LIT19).clone(), preserves::value::IOValue::from(_tmp1));
|
||||||
|
_tmp4.insert((&*LIT20).clone(), preserves::value::IOValue::from(_tmp2));
|
||||||
|
preserves::value::Value::Dictionary(_tmp4).wrap()
|
||||||
|
}
|
||||||
|
);
|
||||||
|
_tmp3.finish().wrap()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
fn _parse_simple_pattern_any(value: &preserves::value::IOValue) -> std::result::Result<SimplePattern, ()> {if value != &*LIT21 { return Err(()); } let _tmp0 = (); Ok(SimplePattern::Any)}
|
fn _parse_simple_pattern_any(value: &preserves::value::IOValue) -> std::result::Result<SimplePattern, ()> {if value != &*LIT21 { return Err(()); } let _tmp0 = (); Ok(SimplePattern::Any)}
|
||||||
|
|
||||||
fn _parse_simple_pattern_atom(value: &preserves::value::IOValue) -> std::result::Result<SimplePattern, ()> {
|
fn _parse_simple_pattern_atom(value: &preserves::value::IOValue) -> std::result::Result<SimplePattern, ()> {
|
||||||
|
@ -539,8 +765,50 @@ impl std::convert::TryFrom<&preserves::value::IOValue> for SimplePattern {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
impl std::convert::From<&SimplePattern> for preserves::value::IOValue {
|
||||||
|
fn from(value: &SimplePattern) -> Self {
|
||||||
|
match value {
|
||||||
|
SimplePattern::Any => (&*LIT21).clone(),
|
||||||
|
SimplePattern::Atom {atom_kind: _tmp0} => {
|
||||||
|
let mut _tmp1 = preserves::value::Record(vec![(&*LIT22).clone()]);
|
||||||
|
_tmp1.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0.as_ref()));
|
||||||
|
_tmp1.finish().wrap()
|
||||||
|
},
|
||||||
|
SimplePattern::Embedded {interface: _tmp0} => {
|
||||||
|
let mut _tmp1 = preserves::value::Record(vec![(&*LIT23).clone()]);
|
||||||
|
_tmp1.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0.as_ref()));
|
||||||
|
_tmp1.finish().wrap()
|
||||||
|
},
|
||||||
|
SimplePattern::Lit {value: _tmp0} => {
|
||||||
|
let mut _tmp1 = preserves::value::Record(vec![(&*LIT24).clone()]);
|
||||||
|
_tmp1.fields_vec_mut().push(_tmp0.clone());
|
||||||
|
_tmp1.finish().wrap()
|
||||||
|
},
|
||||||
|
SimplePattern::Seqof {pattern: _tmp0} => {
|
||||||
|
let mut _tmp1 = preserves::value::Record(vec![(&*LIT25).clone()]);
|
||||||
|
_tmp1.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0.as_ref()));
|
||||||
|
_tmp1.finish().wrap()
|
||||||
|
},
|
||||||
|
SimplePattern::Setof {pattern: _tmp0} => {
|
||||||
|
let mut _tmp1 = preserves::value::Record(vec![(&*LIT26).clone()]);
|
||||||
|
_tmp1.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0.as_ref()));
|
||||||
|
_tmp1.finish().wrap()
|
||||||
|
},
|
||||||
|
SimplePattern::Dictof {key: _tmp0, value: _tmp1} => {
|
||||||
|
let mut _tmp2 = preserves::value::Record(vec![(&*LIT27).clone()]);
|
||||||
|
_tmp2.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0.as_ref()));
|
||||||
|
_tmp2.fields_vec_mut().push(preserves::value::IOValue::from(_tmp1.as_ref()));
|
||||||
|
_tmp2.finish().wrap()
|
||||||
|
},
|
||||||
|
SimplePattern::Ref(_tmp0) => preserves::value::IOValue::from(_tmp0.as_ref()),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
impl std::convert::TryFrom<&preserves::value::IOValue> for Version {
|
impl std::convert::TryFrom<&preserves::value::IOValue> for Version {
|
||||||
type Error = ();
|
type Error = ();
|
||||||
fn try_from(value: &preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {if value != &*LIT28 { return Err(()); } let _tmp0 = (); Ok(Version)}
|
fn try_from(value: &preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {if value != &*LIT28 { return Err(()); } let _tmp0 = (); Ok(Version)}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
impl std::convert::From<&Version> for preserves::value::IOValue {fn from(value: &Version) -> Self {let Version = value; (&*LIT28).clone()}}
|
||||||
|
|
||||||
|
|
|
@ -2,6 +2,7 @@ use num::bigint::BigInt;
|
||||||
use num::traits::cast::ToPrimitive;
|
use num::traits::cast::ToPrimitive;
|
||||||
use std::borrow::Cow;
|
use std::borrow::Cow;
|
||||||
use std::cmp::Ordering;
|
use std::cmp::Ordering;
|
||||||
|
use std::convert::From;
|
||||||
use std::convert::TryFrom;
|
use std::convert::TryFrom;
|
||||||
use std::convert::TryInto;
|
use std::convert::TryInto;
|
||||||
use std::fmt::Debug;
|
use std::fmt::Debug;
|
||||||
|
@ -217,9 +218,11 @@ impl<N: NestedValue<D>, D: Domain> From<i64> for Value<N, D> { fn from(v: i64) -
|
||||||
impl<N: NestedValue<D>, D: Domain> From<u128> for Value<N, D> { fn from(v: u128) -> Self { Value::SignedInteger(SignedInteger::from(v)) } }
|
impl<N: NestedValue<D>, D: Domain> From<u128> for Value<N, D> { fn from(v: u128) -> Self { Value::SignedInteger(SignedInteger::from(v)) } }
|
||||||
impl<N: NestedValue<D>, D: Domain> From<i128> for Value<N, D> { fn from(v: i128) -> Self { Value::SignedInteger(SignedInteger::from(v)) } }
|
impl<N: NestedValue<D>, D: Domain> From<i128> for Value<N, D> { fn from(v: i128) -> Self { Value::SignedInteger(SignedInteger::from(v)) } }
|
||||||
impl<N: NestedValue<D>, D: Domain> From<&BigInt> for Value<N, D> { fn from(v: &BigInt) -> Self { Value::SignedInteger(SignedInteger::from(Cow::Borrowed(v))) } }
|
impl<N: NestedValue<D>, D: Domain> From<&BigInt> for Value<N, D> { fn from(v: &BigInt) -> Self { Value::SignedInteger(SignedInteger::from(Cow::Borrowed(v))) } }
|
||||||
|
impl<N: NestedValue<D>, D: Domain> From<&SignedInteger> for Value<N, D> { fn from(v: &SignedInteger) -> Self { Value::SignedInteger(v.clone()) } }
|
||||||
|
|
||||||
impl<N: NestedValue<D>, D: Domain> From<&str> for Value<N, D> { fn from(v: &str) -> Self { Value::String(String::from(v)) } }
|
impl<N: NestedValue<D>, D: Domain> From<&str> for Value<N, D> { fn from(v: &str) -> Self { Value::String(String::from(v)) } }
|
||||||
impl<N: NestedValue<D>, D: Domain> From<String> for Value<N, D> { fn from(v: String) -> Self { Value::String(v) } }
|
impl<N: NestedValue<D>, D: Domain> From<String> for Value<N, D> { fn from(v: String) -> Self { Value::String(v) } }
|
||||||
|
impl<N: NestedValue<D>, D: Domain> From<&String> for Value<N, D> { fn from(v: &String) -> Self { Value::String(v.to_owned()) } }
|
||||||
|
|
||||||
impl<N: NestedValue<D>, D: Domain> From<&[u8]> for Value<N, D> { fn from(v: &[u8]) -> Self { Value::ByteString(Vec::from(v)) } }
|
impl<N: NestedValue<D>, D: Domain> From<&[u8]> for Value<N, D> { fn from(v: &[u8]) -> Self { Value::ByteString(Vec::from(v)) } }
|
||||||
// impl<N: NestedValue<D>, D: Domain> From<Vec<u8>> for Value<N, D> { fn from(v: Vec<u8>) -> Self { Value::ByteString(v) } }
|
// impl<N: NestedValue<D>, D: Domain> From<Vec<u8>> for Value<N, D> { fn from(v: Vec<u8>) -> Self { Value::ByteString(v) } }
|
||||||
|
|
Loading…
Reference in New Issue