From 352d8ba1b3cb90b3f1e58c3f79517e2f1a254fae Mon Sep 17 00:00:00 2001 From: Tony Garnock-Jones Date: Wed, 15 Sep 2021 10:43:31 +0200 Subject: [PATCH] Massive refactor to be more flexible around embedded types --- .../preserves-schema/src/compiler/context.rs | 157 ++- .../rust/preserves-schema/src/compiler/mod.rs | 203 ++-- .../preserves-schema/src/compiler/parsers.rs | 76 +- .../preserves-schema/src/compiler/readers.rs | 26 +- .../preserves-schema/src/compiler/types.rs | 186 ++- .../src/compiler/unparsers.rs | 65 +- .../rust/preserves-schema/src/gen/mod.rs | 74 +- .../rust/preserves-schema/src/gen/schema.rs | 1002 ++++++++--------- .../rust/preserves-schema/src/lib.rs | 9 +- .../rust/preserves-schema/src/support/mod.rs | 15 + .../rust/preserves-schema/src/syntax/block.rs | 151 ++- 11 files changed, 1171 insertions(+), 793 deletions(-) diff --git a/implementations/rust/preserves-schema/src/compiler/context.rs b/implementations/rust/preserves-schema/src/compiler/context.rs index a848464..9da8117 100644 --- a/implementations/rust/preserves-schema/src/compiler/context.rs +++ b/implementations/rust/preserves-schema/src/compiler/context.rs @@ -8,6 +8,7 @@ use convert_case::{Case, Casing}; use lazy_static::lazy_static; +use preserves::value::IOValue; use preserves::value::Map; use preserves::value::NestedValue; use preserves::value::Value; @@ -16,25 +17,31 @@ use super::CompilerConfig; use super::names; use super::types; -#[derive(Clone, Copy)] -pub enum ModuleContextMode { - TargetIOValue, - TargetAny, +pub struct BundleContext<'b> { + pub config: &'b CompilerConfig, + pub types: Map, + pub literals: Map, } -pub struct ModuleContext<'m> { +#[derive(Clone, Copy, PartialOrd, Ord, PartialEq, Eq)] +pub enum ModuleContextMode { + TargetModule, + TargetToplevel, + TargetGeneric, +} + +pub struct ModuleContext<'m, 'b> { + pub bundle: &'m mut BundleContext<'b>, pub module_path: ModulePath, - pub config: &'m CompilerConfig, - pub literals: Map<_Any, String>, + pub schema: &'m Schema, pub typedefs: Vec, pub functiondefs: Vec, - pub mode: Option, - pub schema: &'m Schema, + pub mode: ModuleContextMode, } -pub struct FunctionContext<'a, 'm> { +pub struct FunctionContext<'a, 'm, 'b> { pub error_context: String, - pub m: &'a mut ModuleContext<'m>, + pub m: &'a mut ModuleContext<'m, 'b>, pub temp_counter: usize, pub captures: Vec, pub capture_mode: CaptureMode, @@ -55,24 +62,22 @@ lazy_static! { static ref ID_RE: regex::Regex = regex::Regex::new(r"^[a-zA-Z][a-zA-Z_0-9]*$").unwrap(); } -impl<'m> ModuleContext<'m> { +impl<'b> BundleContext<'b> { pub fn new( - config: &'m CompilerConfig, - module_path: &ModulePath, - schema: &'m Schema, + config: &'b CompilerConfig, ) -> Self { - ModuleContext { - module_path: module_path.to_owned(), + BundleContext { config, + types: config.build_type_cache(), literals: Map::new(), - typedefs: Vec::new(), - functiondefs: Vec::new(), - mode: None, - schema, } } - pub fn define_literal(&mut self, v: &_Any) -> String { + pub fn type_for_name(&self, r: &Ref) -> &types::TDefinition { + self.types.get(r).unwrap_or_else(|| panic!("{:?} not found", r)) + } + + pub fn define_literal(&mut self, v: &IOValue) -> String { let prefix = format!("LIT_{}", self.literals.len()); let next_id = match v.value() { Value::Boolean(b) => prefix + "_" + &b.to_string(), @@ -82,7 +87,46 @@ impl<'m> ModuleContext<'m> { _ => prefix }; let next_id = next_id.to_case(Case::UpperSnake); - "&*".to_owned() + self.target_prefix() + "::" + self.literals.entry(v.clone()).or_insert(next_id) + format!("&_ctxt.{}", self.literals.entry(v.clone()).or_insert(next_id)) + } + + pub fn generate_module( + &mut self, + path: &Vec, + schema: &Schema, + mode: ModuleContextMode, + items: &mut Map>, + f: F, + ) { + let mut m = ModuleContext::new(self, &ModulePath(path.clone()), schema, mode); + f(&mut m); + items.entry(mode).or_default().extend(m.extract()); + } +} + +impl<'m, 'b> ModuleContext<'m, 'b> { + pub fn new( + bundle: &'m mut BundleContext<'b>, + module_path: &ModulePath, + schema: &'m Schema, + mode: ModuleContextMode, + ) -> Self { + ModuleContext { + bundle, + module_path: module_path.to_owned(), + schema, + typedefs: Vec::new(), + functiondefs: Vec::new(), + mode, + } + } + + pub fn reset_mode(&mut self) { + self.mode = ModuleContextMode::TargetToplevel; + } + + pub fn define_literal(&mut self, v: &IOValue) -> String { + self.bundle.define_literal(v) } pub fn define_type(&mut self, i: Item) { @@ -94,44 +138,79 @@ impl<'m> ModuleContext<'m> { self.functiondefs.push(i) } - pub fn render_ref(&self, r: &Ref) -> Item { - match self.config.module_aliases.get(&r.module.0) { + pub fn render_ref(&self, r: &Ref, with_generic_args: bool) -> Item { + let base = match self.bundle.config.module_aliases.get(&r.module.0) { None => if r.module.0.is_empty() { item(r.name.to_owned()) } else { let mut items = Vec::new(); - items.push(item(self.config.fully_qualified_module_prefix.to_owned())); + items.push(item(self.bundle.config.fully_qualified_module_prefix.to_owned())); for p in &r.module.0 { items.push(item(names::render_modname(p))) } items.push(item(r.name.to_owned())); item(name(items)) } Some(s) => item(name![s.to_owned(), r.name.to_owned()]) + }; + if with_generic_args && self.type_for_name(r).has_embedded(self) { + item(seq![base, anglebrackets!["_Any"]]) + } else { + base } } - pub fn mode(&self) -> ModuleContextMode { - self.mode.expect("defined ModuleContextMode") + pub fn any_type(&self) -> &'static str { + "_Any" } - pub fn target(&self) -> &'static str { - match self.mode() { - ModuleContextMode::TargetIOValue => "preserves::value::IOValue", - ModuleContextMode::TargetAny => "_Any", + pub fn qualify(&self, r: &Ref) -> Ref { + if r.module.0.is_empty() { + Ref { module: self.module_path.clone(), name: r.name.clone() } + } else { + r.clone() } } - pub fn target_prefix(&self) -> &'static str { - match self.mode() { - ModuleContextMode::TargetIOValue => "_io_", - ModuleContextMode::TargetAny => "_any_", - } + pub fn type_for_name(&self, r: &Ref) -> &types::TDefinition { + self.bundle.type_for_name(&self.qualify(r)) + } + + pub fn literals_generic_decls(&self) -> Item { + item(anglebrackets!["_Any: preserves::value::NestedValue"]) + } + + pub fn literals_generic_decls_with_defaults(&self) -> Item { + item(anglebrackets![ + seq!["_Any: preserves::value::NestedValue = ", + if self.schema.embedded_type == EmbeddedTypeName::False { + "preserves::value::IOValue" + } else { + "_Any" + }]]) + } + + pub fn literals_generic_arg(&self) -> Item { + item("<_Any>") + } + + pub fn literals_type(&self) -> Item { + item(seq!["&", self.literals_base_type(), self.literals_generic_arg()]) + } + + pub fn literals_base_type(&self) -> Item { + item(format!("{}::Literals", self.bundle.config.fully_qualified_module_prefix)) + } + + pub fn extract(&mut self) -> Vec { + let mut items = std::mem::take(&mut self.typedefs); + items.extend(std::mem::take(&mut self.functiondefs)); + items } } -impl<'a, 'm> FunctionContext<'a, 'm> { - pub fn new(m: &'a mut ModuleContext<'m>, error_context: &str) -> Self { +impl<'a, 'm, 'b> FunctionContext<'a, 'm, 'b> { + pub fn new(m: &'a mut ModuleContext<'m, 'b>, error_context: &str) -> Self { FunctionContext { error_context: error_context.to_owned(), m: m, diff --git a/implementations/rust/preserves-schema/src/compiler/mod.rs b/implementations/rust/preserves-schema/src/compiler/mod.rs index 9764104..730ca1a 100644 --- a/implementations/rust/preserves-schema/src/compiler/mod.rs +++ b/implementations/rust/preserves-schema/src/compiler/mod.rs @@ -6,8 +6,10 @@ pub mod types; pub mod unparsers; use crate::*; +use crate::compiler::context::*; +use crate::gen::Literals; use crate::gen::schema::*; -use crate::syntax::block::Formatter; +use crate::syntax::block::{Formatter, Item}; use crate::syntax::block::constructors::*; use glob::glob; @@ -15,13 +17,10 @@ use preserves::value::BinarySource; use preserves::value::IOBinarySource; use preserves::value::Map; use preserves::value::Reader; -use preserves::value::Set; -use std::convert::TryFrom; use std::fs::DirBuilder; use std::fs::File; use std::io; -use std::io::BufRead; use std::io::Read; use std::io::Write; use std::path::PathBuf; @@ -29,9 +28,11 @@ use std::path::PathBuf; pub type ModulePath = Vec; pub trait Plugin: std::fmt::Debug { - fn generate( + fn generate_module(&self, _module_ctxt: &mut ModuleContext) {} + + fn generate_definition( &self, - module_ctxt: &mut context::ModuleContext, + module_ctxt: &mut ModuleContext, definition_name: &str, definition: &Definition, ); @@ -73,8 +74,9 @@ impl CompilerConfig { let mut src = IOBinarySource::new(&mut f); let mut reader = src.packed_iovalues(); let blob = reader.demand_next(false)?; + let literals = Literals::default(); - if let Ok(s) = Schema::try_from(&blob) { + if let Ok(s) = Schema::parse(&literals, &blob) { let prefix = i.file_stem().ok_or_else( || io::Error::new(io::ErrorKind::InvalidData, format!("Bad schema file stem: {:?}", i)))? @@ -85,7 +87,7 @@ impl CompilerConfig { continue; } - if let Ok(Bundle { modules }) = Bundle::try_from(&blob) { + if let Ok(Bundle { modules }) = Bundle::parse(&literals, &blob) { for (ModulePath(k), v) in modules.0 { self.bundle.insert(k, v); } @@ -97,6 +99,31 @@ impl CompilerConfig { } Ok(()) } + + fn build_type_cache(&self) -> Map { + self.bundle.iter().flat_map( + |(modpath, s)| s.definitions.0.iter().map( + move |(name, def)| (Ref { module: ModulePath(modpath.clone()), name: name.clone() }, + types::definition_type(def)))) + .collect() + } + + fn generate_definition( + &self, + b: &mut BundleContext, + k: &ModulePath, + v: &Schema, + n: &str, + d: &Definition, + mode: ModuleContextMode, + generated: &mut Map>, + ) { + b.generate_module(k, v, mode, generated, |m| { + for plugin in self.plugins.iter() { + plugin.generate_definition(m, n, d); + } + }); + } } pub fn expand_inputs(globs: &Vec) -> io::Result> { @@ -130,6 +157,8 @@ impl Schema { } pub fn compile(config: &CompilerConfig) -> io::Result<()> { + let mut b = BundleContext::new(config); + for (k, v) in config.bundle.iter() { let mut output_path = config.output_dir.clone(); output_path.extend(k); @@ -137,102 +166,106 @@ pub fn compile(config: &CompilerConfig) -> io::Result<()> { let module_name = names::render_modname(&module_name); output_path.set_file_name(format!("{}.rs", module_name)); DirBuilder::new().recursive(true).create(output_path.parent().unwrap())?; - let mut m = context::ModuleContext::new(config, &ModulePath(k.clone()), v); - let mut modes: Vec = - vec![context::ModuleContextMode::TargetAny]; + //--------------------------------------------------------------------------- - match &v.embedded_type { - EmbeddedTypeName::False => { - m.define_type(item(seq!["pub type _Ptr = preserves::value::IOValue;"])); - m.define_type(item(seq!["pub type _Any = preserves::value::IOValue;"])); + let mut generated = Map::new(); + + b.generate_module(k, v, ModuleContextMode::TargetModule, &mut generated, |m| { + for plugin in config.plugins.iter() { + plugin.generate_module(m); } - EmbeddedTypeName::Ref(r) => { - modes.push(context::ModuleContextMode::TargetIOValue); - m.define_type(item(seq!["pub type _Dom = ", m.render_ref(&**r), ";"])); - m.define_type(item(seq!["pub type _Ptr = std::sync::Arc<_Dom>;"])); - m.define_type(item(seq!["pub type _Any = preserves::value::ArcValue<_Ptr>;"])); - } - } - - let modes = modes; // rebind as non-mutable + }); for (n, d) in &v.definitions.0 { - for plugin in config.plugins.iter() { - plugin.generate(&mut m, n, d); - } - for mode in &modes { - m.mode = Some(*mode); - for plugin in config.plugins.iter() { - plugin.generate(&mut m, n, d); - } - } - m.mode = None; + use ModuleContextMode::*; + config.generate_definition(&mut b, k, v, n, d, TargetToplevel, &mut generated); + config.generate_definition(&mut b, k, v, n, d, TargetGeneric, &mut generated); } //--------------------------------------------------------------------------- let mut lines: Vec = Vec::new(); - lines.push("#![allow(unused_parens)]".to_owned()); - lines.push("#![allow(unused_imports)]".to_owned()); - lines.push("".to_owned()); - lines.push("use std::convert::TryFrom;".to_owned()); - lines.push(format!("use {}::support as _support;", &config.support_crate)); - lines.push("use _support::Deserialize;".to_owned()); - lines.push("use _support::preserves;".to_owned()); - lines.push("use preserves::value::Domain;".to_owned()); - lines.push("use preserves::value::NestedValue;".to_owned()); - lines.push("".to_owned()); + lines.push(Formatter::to_string(vertical(false, seq![ + "#![allow(unused_parens)]", + "#![allow(unused_imports)]", + "", + "use std::convert::TryFrom;", + format!("use {}::support as _support;", &config.support_crate), + "use _support::Deserialize;", + "use _support::preserves;", + "use preserves::value::Domain;", + "use preserves::value::NestedValue;", + ""]))); - for mode in &modes { - m.mode = Some(*mode); - lines.push(format!("mod {} {{", m.target_prefix())); - lines.push(" use super::_Any;".to_owned()); - lines.push(format!(" use {}::support as _support;", &config.support_crate)); - lines.push(" _support::lazy_static! {".to_owned()); - for (value, name) in &m.literals { - let bs = preserves::value::PackedWriter::encode_iovalue(&value).unwrap(); - lines.push(format!( - " pub static ref {}: {} = /* {:?} */ _support::decode_lit(&vec!{:?}).unwrap();", - name, - m.target(), - value, - bs)); + let mut emit_items = |items: Vec| { + if !items.is_empty() { + lines.push(Formatter::to_string(vertical(true, seq(items)))); + lines.push("".to_owned()); } - lines.push(" }".to_owned()); - lines.push("}".to_owned()); - lines.push("".to_owned()); - } - m.mode = None; + }; + emit_items(generated.remove(&ModuleContextMode::TargetModule).unwrap()); + emit_items(generated.remove(&ModuleContextMode::TargetToplevel).unwrap()); + emit_items(generated.remove(&ModuleContextMode::TargetGeneric).unwrap()); - for i in m.typedefs { - lines.push(Formatter::to_string(i)); - lines.push("".to_owned()); - } - for i in m.functiondefs { - lines.push(Formatter::to_string(i)); - lines.push("".to_owned()); - } + // let mut generic_mod_items: Vec = vec![ + // item(vertical(false, seq![ + // format!("use {}::support as _support;", &config.support_crate), + // "use _support::Deserialize;", + // "use _support::preserves;"])), + // ]; + // generic_mod_items.extend(generated.remove(&ModuleContextMode::TargetGeneric).unwrap()); + // + // lines.push(Formatter::to_string(seq!["mod __ ", vertical(true, block(generic_mod_items))])); + // lines.push("".to_owned()); { let contents = lines.join("\n"); write_if_changed(&output_path, contents.as_bytes())?; } - - { - let mut mod_rs = output_path.clone(); - mod_rs.set_file_name("mod.rs"); - let mut lines = if !mod_rs.exists() { - Set::new() - } else { - io::BufReader::new(File::open(&mod_rs)?) - .lines().collect::, _>>()? - }; - lines.insert(format!("pub mod {};", &module_name)); - let contents = lines.into_iter().collect::>().join("\n"); - write_if_changed(&mod_rs, contents.as_bytes())?; - } } + + { + let mut mod_rs = config.output_dir.clone(); + mod_rs.extend(vec!["mod.rs"]); + let mut lines = Vec::new(); + + for modpath in config.bundle.keys() { + lines.push(format!("pub mod {};", names::render_modname(modpath.last().unwrap()))); + } + lines.push("".to_owned()); + + lines.push(format!("use {}::support as _support;", &config.support_crate)); + lines.push("use _support::preserves;".to_owned()); + lines.push("".to_owned()); + + lines.push("#[allow(non_snake_case)]".to_owned()); + lines.push(Formatter::to_string(item(seq![ + "pub struct Literals", anglebrackets!["N: preserves::value::NestedValue"], " ", + vertical(false, braces(b.literals.iter().map( + |(value, name)| item(format!("pub {}: N /* {:?} */", name, value))).collect())) + ]))); + lines.push("".to_owned()); + lines.push(Formatter::to_string(item(seq![ + "impl", anglebrackets!["N: preserves::value::NestedValue"], + " Default for Literals ", block![ + seq!["fn default() -> Self ", block![ + seq!["Literals ", vertical(false, braces(b.literals.iter().map(|(value, name)| { + let bs = preserves::value::PackedWriter::encode_iovalue(&value).unwrap(); + item(format!("{}: /* {:?} */ _support::decode_lit(&vec!{:?}).unwrap()", + name, + value, + bs)) + }).collect()))] + ]] + ] + ]))); + lines.push("".to_owned()); + + let contents = lines.join("\n"); + write_if_changed(&mod_rs, contents.as_bytes())?; + } + Ok(()) } diff --git a/implementations/rust/preserves-schema/src/compiler/parsers.rs b/implementations/rust/preserves-schema/src/compiler/parsers.rs index 56d64a3..b48708d 100644 --- a/implementations/rust/preserves-schema/src/compiler/parsers.rs +++ b/implementations/rust/preserves-schema/src/compiler/parsers.rs @@ -11,14 +11,16 @@ use super::types::*; pub struct ParserPlugin; impl compiler::Plugin for ParserPlugin { - fn generate(&self, module_ctxt: &mut ModuleContext, definition_name: &str, definition: &Definition) { - if module_ctxt.mode.is_some() { + fn generate_definition(&self, module_ctxt: &mut ModuleContext, definition_name: &str, definition: &Definition) { + if let ModuleContextMode::TargetGeneric = module_ctxt.mode { gen_definition_parser(module_ctxt, definition_name, definition) } } } pub fn gen_definition_parser(m: &mut ModuleContext, n: &str, d: &Definition) { + let ty = definition_type(d); + m.define_function( n, |mut ctxt| { @@ -29,8 +31,7 @@ pub fn gen_definition_parser(m: &mut ModuleContext, n: &str, d: &Definition) { let mut ps = vec![&**pattern_0, &**pattern_1]; ps.extend(pattern_n); for NamedAlternative { variant_label: name, pattern: pat } in ps { - let fname = seq![ctxt.m.target_prefix(), "parse_", - names::render_fieldname(n), "_", names::render_fieldname(name)]; + let fname = seq!["parse_", names::render_fieldname(n), "_", names::render_fieldname(name)]; let ctorname = item(name![names::render_constructor(n), names::render_constructor(name)]); ctxt.m.define_function( &(n.to_owned() + "::" + name), @@ -39,11 +40,14 @@ pub fn gen_definition_parser(m: &mut ModuleContext, n: &str, d: &Definition) { let dest = pattern_parser(&mut ctxt, pat, "value", None, &mut body); let dest = dest.as_ref().map(String::as_str); construct(&ctxt, ctorname, false, &pattern_type(pat), dest, &mut body); - item(seq!["fn ", fname.clone(), "(value: &", ctxt.m.target(), ") -> ", - "std::result::Result<", names::render_constructor(n), ", _support::ParseError> ", - block(body)]) + item(seq!["fn ", fname.clone(), ctxt.m.literals_generic_decls(), + "(_ctxt: ", ctxt.m.literals_type(), ", value: &", ctxt.m.any_type(), ") -> ", + "std::result::Result<", + names::render_constructor(n), ty.generic_arg(ctxt.m), + ", _support::ParseError> ", + codeblock(body)]) }); - body.push(item(seq!["if let Ok(r) = ", fname, "(value) { return Ok(r); }"])); + body.push(item(seq!["if let Ok(r) = ", fname, "(_ctxt, value) { return Ok(r); }"])); } body.push(item(seq![ctxt.err_code()])); } @@ -62,13 +66,36 @@ pub fn gen_definition_parser(m: &mut ModuleContext, n: &str, d: &Definition) { } } - item(seq!["impl std::convert::TryFrom", anglebrackets![seq!["&", ctxt.m.target()]], " for ", - names::render_constructor(n), " ", block![ - seq!["type Error = _support::ParseError;"], - seq!["fn try_from(value: &", ctxt.m.target(), ") -> ", + let (topdecl, innerdecl) = if ty.has_embedded(ctxt.m) { + (ctxt.m.literals_generic_decls(), item("")) + } else { + (item(""), ctxt.m.literals_generic_decls()) + }; + + item(seq!["impl", topdecl, " ", + names::render_constructor(n), ty.generic_arg(ctxt.m), " ", + block![ + seq!["pub fn parse", innerdecl, "(_ctxt: ", ctxt.m.literals_type(), + ", value: &", ctxt.m.any_type(), ") -> ", "std::result::Result ", - block(body)]]]) + codeblock(body)]]]) }); + + // m.define_function( + // n, + // |ctxt| { + // item(seq!["impl", ctxt.m.literals_generic_decls(), + // " std::convert::TryFrom", anglebrackets![seq!["&", ctxt.m.any_type()]], " for ", + // names::render_constructor(n), ty.generic_arg(ctxt.m), " ", + // block![ + // seq!["type Error = _support::ParseError;"], + // seq!["fn try_from(value: &", ctxt.m.any_type(), ") -> ", + // "std::result::Result ", + // codeblock![ + // seq!["Self::parse(", + // ctxt.m.literals_base_type(), "::default()", + // ", value)"]]]]]) + // }); } fn construct( @@ -118,12 +145,7 @@ fn simple_pattern_parser( let dest = ctxt.gentempname(); match p { SimplePattern::Any => { - match ctxt.m.mode() { - ModuleContextMode::TargetIOValue => - ctxt.define_atom(body, &dest, item(seq!["_support::decode_embedded", parens![src.to_owned()], "?"])), - ModuleContextMode::TargetAny => - ctxt.define_atom(body, &dest, item(src.to_owned())), - } + ctxt.define_atom(body, &dest, item(src.to_owned())); dest }, SimplePattern::Atom { atom_kind: k } => { @@ -140,16 +162,8 @@ fn simple_pattern_parser( dest }, SimplePattern::Embedded { .. } => { - match ctxt.m.mode() { - ModuleContextMode::TargetIOValue => - ctxt.define_atom(body, &dest, item(seq![ - "std::sync::Arc::new(_Dom::try_from", - parens![seq![src.to_owned(), ".value().to_embedded()?"]], - "?)"])), - ModuleContextMode::TargetAny => - ctxt.define_atom(body, &dest, item(seq![ - parens![seq![src.to_owned(), ".value().to_embedded()?"]]])), - } + ctxt.define_atom(body, &dest, item(seq![ + parens![seq![src.to_owned(), ".value().to_embedded()?"]]])); dest }, SimplePattern::Lit { value } => { @@ -200,10 +214,10 @@ fn simple_pattern_parser( dest }, SimplePattern::Ref(r) => { - let tf = name![ctxt.m.render_ref(&**r), "try_from"]; + let tf = name![ctxt.m.render_ref(&**r, false), "parse"]; ctxt.define_atom(body, &dest, - item(seq![tf, parens![seq![src.to_owned()]], "?"])); + item(seq![tf, parens!["_ctxt", src.to_owned()], "?"])); dest }, } diff --git a/implementations/rust/preserves-schema/src/compiler/readers.rs b/implementations/rust/preserves-schema/src/compiler/readers.rs index cf02c71..83d565a 100644 --- a/implementations/rust/preserves-schema/src/compiler/readers.rs +++ b/implementations/rust/preserves-schema/src/compiler/readers.rs @@ -7,10 +7,11 @@ use crate::syntax::block::constructors::*; use preserves::value::AtomClass; use preserves::value::CompoundClass; +use preserves::value::IOValue; use preserves::value::NestedValue; use preserves::value::ValueClass; -use super::context::{ModuleContext, FunctionContext}; +use super::context::{ModuleContextMode, ModuleContext, FunctionContext}; use super::names; use super::types::*; @@ -18,8 +19,8 @@ use super::types::*; pub struct ReaderPlugin; impl compiler::Plugin for ReaderPlugin { - fn generate(&self, module_ctxt: &mut ModuleContext, definition_name: &str, definition: &Definition) { - if module_ctxt.mode.is_none() { + fn generate_definition(&self, module_ctxt: &mut ModuleContext, definition_name: &str, definition: &Definition) { + if let ModuleContextMode::TargetGeneric = module_ctxt.mode { gen_definition_reader(module_ctxt, definition_name, definition) } } @@ -74,6 +75,8 @@ impl BoundaryTracker { } pub fn gen_definition_reader(m: &mut ModuleContext, n: &str, d: &Definition) { + let ty = definition_type(d); + m.define_function( n, |mut ctxt| { @@ -97,9 +100,12 @@ pub fn gen_definition_reader(m: &mut ModuleContext, n: &str, d: &Definition) { item(seq![ "fn ", fname.clone(), anglebrackets![ "'de", + "_Any: preserves::value::NestedValue", "R: _support::Reader<'de, _Any>"], "(r: &mut R) -> ", - "std::result::Result<", names::render_constructor(n), ", _support::ParseError> ", + "std::result::Result<", + names::render_constructor(n), ty.generic_arg(ctxt.m), + ", _support::ParseError> ", block(body)]) }); body.push(item(seq![ @@ -132,9 +138,11 @@ pub fn gen_definition_reader(m: &mut ModuleContext, n: &str, d: &Definition) { } item(seq![ - "impl", anglebrackets!["'de", "R: _support::Reader<'de, _Any>"], " ", + "impl", anglebrackets!["'de", + "_Any: preserves::value::NestedValue", + "R: _support::Reader<'de, _Any>"], " ", "_support::Deserialize", anglebrackets!["'de", "_Any", "R"], " ", - "for ", names::render_constructor(n), " ", block![ + "for ", names::render_constructor(n), ty.generic_arg(ctxt.m), " ", block![ seq!["fn deserialize(r: &mut R) -> ", "std::result::Result ", block(body)]]]) @@ -207,8 +215,8 @@ where } type LiteralContinuation = Box) -> ()>; -type LiteralCases = Vec<(_Any, LiteralContinuation)>; -type LiteralSeqCases = Vec<(Vec<_Any>, LiteralContinuation)>; +type LiteralCases = Vec<(IOValue, LiteralContinuation)>; +type LiteralSeqCases = Vec<(Vec, LiteralContinuation)>; fn read_expected_literal_seqs( ctxt: &mut FunctionContext, @@ -418,7 +426,7 @@ fn simple_pattern_reader( dest }, SimplePattern::Ref(r) => { - let tf = name![ctxt.m.render_ref(&**r), "deserialize"]; + let tf = name![ctxt.m.render_ref(&**r, false), "deserialize"]; ctxt.define_atom(body, &dest, item(seq![tf, "(r)?"])); dest }, diff --git a/implementations/rust/preserves-schema/src/compiler/types.rs b/implementations/rust/preserves-schema/src/compiler/types.rs index a8272a3..4171282 100644 --- a/implementations/rust/preserves-schema/src/compiler/types.rs +++ b/implementations/rust/preserves-schema/src/compiler/types.rs @@ -1,9 +1,11 @@ use crate::*; -use crate::syntax::block::Emittable; +use crate::syntax::block::{Item, Emittable}; use crate::syntax::block::constructors::*; use crate::gen::schema::*; -use super::context::ModuleContext; +use preserves::value::Set; + +use super::context::{ModuleContextMode, ModuleContext}; use super::names; #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone)] @@ -37,11 +39,23 @@ pub struct TRecord(pub Vec<(String, TField)>); pub struct TypePlugin; impl compiler::Plugin for TypePlugin { - fn generate(&self, m: &mut ModuleContext, n: &str, d: &Definition) { - if m.mode.is_none() { - m.define_type(item(render_definition_type(m, n, &definition_type(d)))); + fn generate_module(&self, m: &mut ModuleContext) { + if let EmbeddedTypeName::Ref(r) = &m.schema.embedded_type { + m.define_type(item(vertical(false, seq![ + seq!["pub type _Dom = ", m.render_ref(&*r, true), ";"], + seq!["pub type _Ptr = std::sync::Arc<_Dom>;"], + seq!["pub type _Any = preserves::value::ArcValue<_Ptr>;"] + ]))); + } + } + + fn generate_definition(&self, m: &mut ModuleContext, n: &str, d: &Definition) { + if let ModuleContextMode::TargetGeneric = m.mode { + let ty = definition_type(d); + m.define_type(item(ty.render(m, n))); m.define_type(item(seq![ - "impl preserves::value::Domain for ", names::render_constructor(n), " {}"])); + "impl", ty.generic_decl(m), " preserves::value::Domain for ", + names::render_constructor(n), ty.generic_arg(m), " {}"])); } } } @@ -165,59 +179,119 @@ pub fn field_type(p: &SimplePattern) -> TField { } } -pub fn render_field_type( - ctxt: &ModuleContext, - box_needed: bool, - t: &TField, -) -> impl Emittable { - match t { - TField::Unit => seq!["()"], - TField::Any => seq!["_Any"], - TField::Embedded => seq!["_Ptr"], - TField::Array(t) => seq!["std::vec::Vec<", render_field_type(ctxt, false, t), ">"], - TField::Set(t) => seq!["preserves::value::Set<", render_field_type(ctxt, false, t), ">"], - TField::Map(k, v) => seq!["preserves::value::Map", - anglebrackets![render_field_type(ctxt, false, k), - render_field_type(ctxt, false, v)]], - TField::Ref(r) => - if box_needed { - seq!["std::boxed::Box", anglebrackets![ctxt.render_ref(r)]] - } else { - seq![ctxt.render_ref(r)] - }, - TField::Base(n) => seq![n.to_owned()], +impl TField { + fn render(&self, ctxt: &ModuleContext, box_needed: bool) -> impl Emittable { + match self { + TField::Unit => seq!["()"], + TField::Any => seq!["_Any"], + TField::Embedded => seq!["_Ptr"], + TField::Array(t) => seq!["std::vec::Vec<", t.render(ctxt, false), ">"], + TField::Set(t) => seq!["preserves::value::Set<", t.render(ctxt, false), ">"], + TField::Map(k, v) => seq!["preserves::value::Map", + anglebrackets![k.render(ctxt, false), + v.render(ctxt, false)]], + TField::Ref(r) => + if box_needed { + seq!["std::boxed::Box", anglebrackets![ctxt.render_ref(r, true)]] + } else { + seq![ctxt.render_ref(r, true)] + }, + TField::Base(n) => seq![n.to_owned()], + } + } + + pub fn has_embedded(&self, ctxt: &ModuleContext, seen: &mut Set) -> bool { + match self { + TField::Unit => false, + TField::Any => true, // at least potentially true + TField::Embedded => true, + TField::Array(f) => f.has_embedded(ctxt, seen), + TField::Set(f) => f.has_embedded(ctxt, seen), + TField::Map(k, v) => k.has_embedded(ctxt, seen) || v.has_embedded(ctxt, seen), + TField::Ref(r) => { + let r = ctxt.qualify(r); + if seen.contains(&r) { + false + } else { + seen.insert(r.clone()); + ctxt.type_for_name(&r)._has_embedded(ctxt, seen) + } + } + TField::Base(_) => false, + } } } -pub fn render_recordlike_type( - ctxt: &ModuleContext, - is_struct: bool, - n: &str, - d: &TSimple, -) -> impl Emittable { - let semi = if is_struct { seq![";"] } else { seq![] }; - let ppub = if is_struct { "pub " } else { "" }; - seq![names::render_constructor(n), match d { - TSimple::Record(TRecord(fs)) => seq![" ", braces( - fs.iter().map(|(n, d)| item( - seq![ppub, names::render_fieldname(n), ": ", render_field_type(ctxt, !is_struct, d)] - )).collect())], - TSimple::Field(TField::Unit) => semi, - TSimple::Field(t) => seq![parens![seq![ppub, render_field_type(ctxt, !is_struct, t)]], semi], - }] +impl TSimple { + pub fn render(&self, ctxt: &ModuleContext, ptr: Item, is_struct: bool, n: &str) -> impl Emittable { + let semi = if is_struct { seq![";"] } else { seq![] }; + let ppub = if is_struct { "pub " } else { "" }; + seq![names::render_constructor(n), ptr.to_owned(), + match self { + TSimple::Record(TRecord(fs)) => seq![" ", vertical(false, braces( + fs.iter().map(|(n, d)| item( + seq![ppub, names::render_fieldname(n), ": ", d.render(ctxt, !is_struct)] + )).collect()))], + TSimple::Field(TField::Unit) => semi, + TSimple::Field(t) => seq![parens![seq![ppub, t.render(ctxt, !is_struct)]], semi], + }] + } + + pub fn has_embedded(&self, ctxt: &ModuleContext, seen: &mut Set) -> bool { + match self { + TSimple::Field(f) => f.has_embedded(ctxt, seen), + TSimple::Record(TRecord(fs)) => fs.iter().any(|(_k, v)| v.has_embedded(ctxt, seen)), + } + } } -pub fn render_definition_type( - ctxt: &ModuleContext, - n: &str, - t: &TDefinition, -) -> impl Emittable { - seq!["#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]\n", - match t { - TDefinition::Union(items) => - seq!["pub enum ", names::render_constructor(n), " ", braces( - items.iter().map(|(n, d)| item(render_recordlike_type(ctxt, false, n, d))).collect())], - TDefinition::Simple(s) => - seq!["pub struct ", render_recordlike_type(ctxt, true, n, s)], - }] +impl TDefinition { + pub fn generic_decl(&self, ctxt: &ModuleContext) -> Item { + if self.has_embedded(ctxt) { + ctxt.literals_generic_decls() + } else { + item("") + } + } + + pub fn generic_decl_with_defaults(&self, ctxt: &ModuleContext) -> Item { + if self.has_embedded(ctxt) { + ctxt.literals_generic_decls_with_defaults() + } else { + item("") + } + } + + pub fn generic_arg(&self, ctxt: &ModuleContext) -> Item { + if self.has_embedded(ctxt) { + ctxt.literals_generic_arg() + } else { + item("") + } + } + + pub fn render(&self, ctxt: &ModuleContext, n: &str) -> impl Emittable { + vertical(false, seq![ + "#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]", + match self { + TDefinition::Union(items) => + seq!["pub enum ", + names::render_constructor(n), self.generic_decl_with_defaults(ctxt), " ", + vertical(false, braces(items.iter().map( + |(n, d)| item(d.render(ctxt, item(""), false, n))).collect()))], + TDefinition::Simple(s) => + seq!["pub struct ", s.render(ctxt, self.generic_decl_with_defaults(ctxt), true, n)], + }]) + } + + pub fn has_embedded(&self, ctxt: &ModuleContext) -> bool { + self._has_embedded(ctxt, &mut Set::new()) + } + + fn _has_embedded(&self, ctxt: &ModuleContext, seen: &mut Set) -> bool { + match self { + TDefinition::Union(entries) => entries.iter().any(|(_k, v)| v.has_embedded(ctxt, seen)), + TDefinition::Simple(t) => t.has_embedded(ctxt, seen), + } + } } diff --git a/implementations/rust/preserves-schema/src/compiler/unparsers.rs b/implementations/rust/preserves-schema/src/compiler/unparsers.rs index dfcb040..a765f92 100644 --- a/implementations/rust/preserves-schema/src/compiler/unparsers.rs +++ b/implementations/rust/preserves-schema/src/compiler/unparsers.rs @@ -14,8 +14,8 @@ use super::types::*; pub struct UnparserPlugin; impl compiler::Plugin for UnparserPlugin { - fn generate(&self, module_ctxt: &mut ModuleContext, definition_name: &str, definition: &Definition) { - if module_ctxt.mode.is_some() { + fn generate_definition(&self, module_ctxt: &mut ModuleContext, definition_name: &str, definition: &Definition) { + if let ModuleContextMode::TargetGeneric = module_ctxt.mode { gen_definition_unparser(module_ctxt, definition_name, definition) } } @@ -61,6 +61,8 @@ fn normal_src(src: String, is_struct: bool) -> ValueContext { } pub fn gen_definition_unparser(m: &mut ModuleContext, n: &str, d: &Definition) { + let ty = definition_type(d); + m.define_function( n, |mut ctxt| { @@ -70,7 +72,7 @@ pub fn gen_definition_unparser(m: &mut ModuleContext, n: &str, d: &Definition) { 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( + body.push(item(seq!["match self ", 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)); @@ -81,7 +83,7 @@ pub fn gen_definition_unparser(m: &mut ModuleContext, n: &str, d: &Definition) { 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)); - body.push(item(seq!["let ", patpat, " = value;"])); + body.push(item(seq!["let ", patpat, " = self;"])); body.push(item(seq![ "preserves::value::merge(vec!", brackets(ps.iter().map( |p| named_pattern_unparser(&mut ctxt, p, &vc)).collect() @@ -90,16 +92,37 @@ pub fn gen_definition_unparser(m: &mut ModuleContext, n: &str, d: &Definition) { } Definition::Pattern(p) => { let (patpat, vc) = destruct(&mut ctxt, item(names::render_constructor(n)), true, &pattern_type(p)); - body.push(item(seq!["let ", patpat, " = value;"])); + body.push(item(seq!["let ", patpat, " = self;"])); body.push(pattern_unparser(&mut ctxt, p, &vc)); } } - item(seq!["impl std::convert::From", anglebrackets![seq!["&", names::render_constructor(n)]], - " for ", ctxt.m.target(), " ", block![ - seq!["fn from(value: &", names::render_constructor(n), ") -> Self ", - block(body)]]]) + let (topdecl, innerdecl) = if ty.has_embedded(ctxt.m) { + (ctxt.m.literals_generic_decls(), item("")) + } else { + (item(""), ctxt.m.literals_generic_decls()) + }; + + item(seq!["impl", topdecl, " ", + names::render_constructor(n), ty.generic_arg(ctxt.m), " ", block![ + seq!["pub fn unparse", innerdecl, + "(&self, _ctxt: ", ctxt.m.literals_type(), ") -> ", + ctxt.m.any_type(), " ", block(body)]]]) }); + + // m.define_function( + // n, + // |ctxt| { + // let ty_arg = item(seq![names::render_constructor(n), ty.generic_arg(ctxt.m)]); + // item(seq!["impl", ctxt.m.literals_generic_decls(), + // " std::convert::From", anglebrackets![seq!["&", ty_arg.clone()]], + // " for ", ctxt.m.any_type(), " ", block![ + // seq!["fn from(value: &", ty_arg, ") -> Self ", + // codeblock![ + // seq!["Self::unparse(", + // ctxt.m.literals_base_type(), "::default()", + // ", value)"]]]]]) + // }); } fn destruct( @@ -134,14 +157,8 @@ fn simple_pattern_unparser( ) -> Item { let src = &vc.src; match p { - SimplePattern::Any => { - match ctxt.m.mode() { - ModuleContextMode::TargetIOValue => - item(seq!["_support::encode_embedded", parens![src.as_ref().unwrap().to_owned()]]), - ModuleContextMode::TargetAny => - item(seq![src.as_ref().unwrap().to_owned(), ".clone()"]), - } - } + SimplePattern::Any => + item(seq![src.as_ref().unwrap().to_owned(), ".clone()"]), SimplePattern::Atom { atom_kind: k } => { match &**k { AtomKind::Symbol => @@ -152,14 +169,8 @@ fn simple_pattern_unparser( item(seq!["preserves::value::Value::from(", src.as_ref().unwrap().to_owned(), ").wrap()"]) } } - SimplePattern::Embedded { .. } => { - match ctxt.m.mode() { - ModuleContextMode::TargetIOValue => - item(seq!["preserves::value::Value::Embedded(preserves::value::IOValue::from(&**", src.as_ref().unwrap().to_owned(), ")).wrap()"]), - ModuleContextMode::TargetAny => - item(seq!["preserves::value::Value::Embedded(", src.as_ref().unwrap().to_owned(), ".clone()).wrap()"]), - } - } + SimplePattern::Embedded { .. } => + item(seq!["preserves::value::Value::Embedded(", src.as_ref().unwrap().to_owned(), ".clone()).wrap()"]), SimplePattern::Lit { value } => item(seq![parens![ctxt.m.define_literal(value)], ".clone()"]), SimplePattern::Seqof { pattern } => { @@ -192,9 +203,9 @@ fn simple_pattern_unparser( ").collect()).wrap()"]) } SimplePattern::Ref(_r) => - item(seq![ctxt.m.target(), "::from(", src.as_ref().unwrap().to_owned(), + item(seq![src.as_ref().unwrap().to_owned(), if vc.is_struct { "" } else { ".as_ref()" }, - ")"]), + ".unparse(_ctxt)"]), } } diff --git a/implementations/rust/preserves-schema/src/gen/mod.rs b/implementations/rust/preserves-schema/src/gen/mod.rs index 7a50786..0354d33 100644 --- a/implementations/rust/preserves-schema/src/gen/mod.rs +++ b/implementations/rust/preserves-schema/src/gen/mod.rs @@ -1 +1,73 @@ -pub mod schema; \ No newline at end of file +pub mod schema; + +use crate::support as _support; +use _support::preserves; + +#[allow(non_snake_case)] +pub struct Literals { + pub LIT_15_FALSE: N /* #f */, + pub LIT_28_1: N /* 1 */, + pub LIT_0_BOOLEAN: N /* Boolean */, + pub LIT_5_BYTE_STRING: N /* ByteString */, + pub LIT_2_DOUBLE: N /* Double */, + pub LIT_1_FLOAT: N /* Float */, + pub LIT_3_SIGNED_INTEGER: N /* SignedInteger */, + pub LIT_4_STRING: N /* String */, + pub LIT_6_SYMBOL: N /* Symbol */, + pub LIT_14_AND: N /* and */, + pub LIT_21_ANY: N /* any */, + pub LIT_22_ATOM: N /* atom */, + pub LIT_8_BUNDLE: N /* bundle */, + pub LIT_18_DEFINITIONS: N /* definitions */, + pub LIT_12_DICT: N /* dict */, + pub LIT_27_DICTOF: N /* dictof */, + pub LIT_23_EMBEDDED: N /* embedded */, + pub LIT_19_EMBEDDED_TYPE: N /* embeddedType */, + pub LIT_24_LIT: N /* lit */, + pub LIT_7_NAMED: N /* named */, + pub LIT_13_OR: N /* or */, + pub LIT_9_REC: N /* rec */, + pub LIT_16_REF: N /* ref */, + pub LIT_17_SCHEMA: N /* schema */, + pub LIT_25_SEQOF: N /* seqof */, + pub LIT_26_SETOF: N /* setof */, + pub LIT_10_TUPLE: N /* tuple */, + pub LIT_11_TUPLE_PREFIX: N /* tuplePrefix */, + pub LIT_20_VERSION: N /* version */ +} + +impl Default for Literals { + fn default() -> Self { + Literals { + LIT_15_FALSE: /* #f */ _support::decode_lit(&vec![128]).unwrap(), + LIT_28_1: /* 1 */ _support::decode_lit(&vec![145]).unwrap(), + LIT_0_BOOLEAN: /* Boolean */ _support::decode_lit(&vec![179, 7, 66, 111, 111, 108, 101, 97, 110]).unwrap(), + LIT_5_BYTE_STRING: /* ByteString */ _support::decode_lit(&vec![179, 10, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103]).unwrap(), + LIT_2_DOUBLE: /* Double */ _support::decode_lit(&vec![179, 6, 68, 111, 117, 98, 108, 101]).unwrap(), + LIT_1_FLOAT: /* Float */ _support::decode_lit(&vec![179, 5, 70, 108, 111, 97, 116]).unwrap(), + LIT_3_SIGNED_INTEGER: /* SignedInteger */ _support::decode_lit(&vec![179, 13, 83, 105, 103, 110, 101, 100, 73, 110, 116, 101, 103, 101, 114]).unwrap(), + LIT_4_STRING: /* String */ _support::decode_lit(&vec![179, 6, 83, 116, 114, 105, 110, 103]).unwrap(), + LIT_6_SYMBOL: /* Symbol */ _support::decode_lit(&vec![179, 6, 83, 121, 109, 98, 111, 108]).unwrap(), + LIT_14_AND: /* and */ _support::decode_lit(&vec![179, 3, 97, 110, 100]).unwrap(), + LIT_21_ANY: /* any */ _support::decode_lit(&vec![179, 3, 97, 110, 121]).unwrap(), + LIT_22_ATOM: /* atom */ _support::decode_lit(&vec![179, 4, 97, 116, 111, 109]).unwrap(), + LIT_8_BUNDLE: /* bundle */ _support::decode_lit(&vec![179, 6, 98, 117, 110, 100, 108, 101]).unwrap(), + LIT_18_DEFINITIONS: /* definitions */ _support::decode_lit(&vec![179, 11, 100, 101, 102, 105, 110, 105, 116, 105, 111, 110, 115]).unwrap(), + LIT_12_DICT: /* dict */ _support::decode_lit(&vec![179, 4, 100, 105, 99, 116]).unwrap(), + LIT_27_DICTOF: /* dictof */ _support::decode_lit(&vec![179, 6, 100, 105, 99, 116, 111, 102]).unwrap(), + LIT_23_EMBEDDED: /* embedded */ _support::decode_lit(&vec![179, 8, 101, 109, 98, 101, 100, 100, 101, 100]).unwrap(), + LIT_19_EMBEDDED_TYPE: /* embeddedType */ _support::decode_lit(&vec![179, 12, 101, 109, 98, 101, 100, 100, 101, 100, 84, 121, 112, 101]).unwrap(), + LIT_24_LIT: /* lit */ _support::decode_lit(&vec![179, 3, 108, 105, 116]).unwrap(), + LIT_7_NAMED: /* named */ _support::decode_lit(&vec![179, 5, 110, 97, 109, 101, 100]).unwrap(), + LIT_13_OR: /* or */ _support::decode_lit(&vec![179, 2, 111, 114]).unwrap(), + LIT_9_REC: /* rec */ _support::decode_lit(&vec![179, 3, 114, 101, 99]).unwrap(), + LIT_16_REF: /* ref */ _support::decode_lit(&vec![179, 3, 114, 101, 102]).unwrap(), + LIT_17_SCHEMA: /* schema */ _support::decode_lit(&vec![179, 6, 115, 99, 104, 101, 109, 97]).unwrap(), + LIT_25_SEQOF: /* seqof */ _support::decode_lit(&vec![179, 5, 115, 101, 113, 111, 102]).unwrap(), + LIT_26_SETOF: /* setof */ _support::decode_lit(&vec![179, 5, 115, 101, 116, 111, 102]).unwrap(), + LIT_10_TUPLE: /* tuple */ _support::decode_lit(&vec![179, 5, 116, 117, 112, 108, 101]).unwrap(), + LIT_11_TUPLE_PREFIX: /* tuplePrefix */ _support::decode_lit(&vec![179, 11, 116, 117, 112, 108, 101, 80, 114, 101, 102, 105, 120]).unwrap(), + LIT_20_VERSION: /* version */ _support::decode_lit(&vec![179, 7, 118, 101, 114, 115, 105, 111, 110]).unwrap() + } + } +} diff --git a/implementations/rust/preserves-schema/src/gen/schema.rs b/implementations/rust/preserves-schema/src/gen/schema.rs index 3212449..efda883 100644 --- a/implementations/rust/preserves-schema/src/gen/schema.rs +++ b/implementations/rust/preserves-schema/src/gen/schema.rs @@ -8,173 +8,20 @@ use _support::preserves; use preserves::value::Domain; use preserves::value::NestedValue; -mod _any_ { - use super::_Any; - use crate::support as _support; - _support::lazy_static! { - pub static ref LIT_15_FALSE: _Any = /* #f */ _support::decode_lit(&vec![128]).unwrap(); - pub static ref LIT_28_1: _Any = /* 1 */ _support::decode_lit(&vec![145]).unwrap(); - pub static ref LIT_0_BOOLEAN: _Any = /* Boolean */ _support::decode_lit(&vec![179, 7, 66, 111, 111, 108, 101, 97, 110]).unwrap(); - pub static ref LIT_5_BYTE_STRING: _Any = /* ByteString */ _support::decode_lit(&vec![179, 10, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103]).unwrap(); - pub static ref LIT_2_DOUBLE: _Any = /* Double */ _support::decode_lit(&vec![179, 6, 68, 111, 117, 98, 108, 101]).unwrap(); - pub static ref LIT_1_FLOAT: _Any = /* Float */ _support::decode_lit(&vec![179, 5, 70, 108, 111, 97, 116]).unwrap(); - pub static ref LIT_3_SIGNED_INTEGER: _Any = /* SignedInteger */ _support::decode_lit(&vec![179, 13, 83, 105, 103, 110, 101, 100, 73, 110, 116, 101, 103, 101, 114]).unwrap(); - pub static ref LIT_4_STRING: _Any = /* String */ _support::decode_lit(&vec![179, 6, 83, 116, 114, 105, 110, 103]).unwrap(); - pub static ref LIT_6_SYMBOL: _Any = /* Symbol */ _support::decode_lit(&vec![179, 6, 83, 121, 109, 98, 111, 108]).unwrap(); - pub static ref LIT_14_AND: _Any = /* and */ _support::decode_lit(&vec![179, 3, 97, 110, 100]).unwrap(); - pub static ref LIT_21_ANY: _Any = /* any */ _support::decode_lit(&vec![179, 3, 97, 110, 121]).unwrap(); - pub static ref LIT_22_ATOM: _Any = /* atom */ _support::decode_lit(&vec![179, 4, 97, 116, 111, 109]).unwrap(); - pub static ref LIT_8_BUNDLE: _Any = /* bundle */ _support::decode_lit(&vec![179, 6, 98, 117, 110, 100, 108, 101]).unwrap(); - pub static ref LIT_18_DEFINITIONS: _Any = /* definitions */ _support::decode_lit(&vec![179, 11, 100, 101, 102, 105, 110, 105, 116, 105, 111, 110, 115]).unwrap(); - pub static ref LIT_12_DICT: _Any = /* dict */ _support::decode_lit(&vec![179, 4, 100, 105, 99, 116]).unwrap(); - pub static ref LIT_27_DICTOF: _Any = /* dictof */ _support::decode_lit(&vec![179, 6, 100, 105, 99, 116, 111, 102]).unwrap(); - pub static ref LIT_23_EMBEDDED: _Any = /* embedded */ _support::decode_lit(&vec![179, 8, 101, 109, 98, 101, 100, 100, 101, 100]).unwrap(); - pub static ref LIT_19_EMBEDDED_TYPE: _Any = /* embeddedType */ _support::decode_lit(&vec![179, 12, 101, 109, 98, 101, 100, 100, 101, 100, 84, 121, 112, 101]).unwrap(); - pub static ref LIT_24_LIT: _Any = /* lit */ _support::decode_lit(&vec![179, 3, 108, 105, 116]).unwrap(); - pub static ref LIT_7_NAMED: _Any = /* named */ _support::decode_lit(&vec![179, 5, 110, 97, 109, 101, 100]).unwrap(); - pub static ref LIT_13_OR: _Any = /* or */ _support::decode_lit(&vec![179, 2, 111, 114]).unwrap(); - pub static ref LIT_9_REC: _Any = /* rec */ _support::decode_lit(&vec![179, 3, 114, 101, 99]).unwrap(); - pub static ref LIT_16_REF: _Any = /* ref */ _support::decode_lit(&vec![179, 3, 114, 101, 102]).unwrap(); - pub static ref LIT_17_SCHEMA: _Any = /* schema */ _support::decode_lit(&vec![179, 6, 115, 99, 104, 101, 109, 97]).unwrap(); - pub static ref LIT_25_SEQOF: _Any = /* seqof */ _support::decode_lit(&vec![179, 5, 115, 101, 113, 111, 102]).unwrap(); - pub static ref LIT_26_SETOF: _Any = /* setof */ _support::decode_lit(&vec![179, 5, 115, 101, 116, 111, 102]).unwrap(); - pub static ref LIT_10_TUPLE: _Any = /* tuple */ _support::decode_lit(&vec![179, 5, 116, 117, 112, 108, 101]).unwrap(); - pub static ref LIT_11_TUPLE_PREFIX: _Any = /* tuplePrefix */ _support::decode_lit(&vec![179, 11, 116, 117, 112, 108, 101, 80, 114, 101, 102, 105, 120]).unwrap(); - pub static ref LIT_20_VERSION: _Any = /* version */ _support::decode_lit(&vec![179, 7, 118, 101, 114, 115, 105, 111, 110]).unwrap(); - } -} - -pub type _Ptr = preserves::value::IOValue; - -pub type _Any = preserves::value::IOValue; - #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] -pub enum AtomKind {Boolean, Float, Double, SignedInteger, String, ByteString, Symbol} +pub enum AtomKind { + Boolean, + Float, + Double, + SignedInteger, + String, + ByteString, + Symbol +} impl preserves::value::Domain for AtomKind {} -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] -pub struct Binding {pub name: std::string::String, pub pattern: SimplePattern} - -impl preserves::value::Domain for Binding {} - -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] -pub struct Bundle {pub modules: Modules} - -impl preserves::value::Domain for Bundle {} - -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] -pub enum CompoundPattern { - Rec {label: std::boxed::Box, fields: std::boxed::Box}, - Tuple {patterns: std::vec::Vec}, - TuplePrefix { - fixed: std::vec::Vec, - variable: std::boxed::Box - }, - Dict {entries: std::boxed::Box} -} - -impl preserves::value::Domain for CompoundPattern {} - -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] -pub enum Definition { - Or { - pattern_0: std::boxed::Box, - pattern_1: std::boxed::Box, - pattern_n: std::vec::Vec - }, - And { - pattern_0: std::boxed::Box, - pattern_1: std::boxed::Box, - pattern_n: std::vec::Vec - }, - Pattern(std::boxed::Box) -} - -impl preserves::value::Domain for Definition {} - -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] -pub struct Definitions(pub preserves::value::Map); - -impl preserves::value::Domain for Definitions {} - -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] -pub struct DictionaryEntries(pub preserves::value::Map<_Any, NamedSimplePattern>); - -impl preserves::value::Domain for DictionaryEntries {} - -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] -pub enum EmbeddedTypeName {Ref(std::boxed::Box), False} - -impl preserves::value::Domain for EmbeddedTypeName {} - -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] -pub struct ModulePath(pub std::vec::Vec); - -impl preserves::value::Domain for ModulePath {} - -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] -pub struct Modules(pub preserves::value::Map); - -impl preserves::value::Domain for Modules {} - -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] -pub struct NamedAlternative {pub variant_label: std::string::String, pub pattern: Pattern} - -impl preserves::value::Domain for NamedAlternative {} - -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] -pub enum NamedPattern {Named(std::boxed::Box), Anonymous(std::boxed::Box)} - -impl preserves::value::Domain for NamedPattern {} - -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] -pub enum NamedSimplePattern {Named(std::boxed::Box), Anonymous(std::boxed::Box)} - -impl preserves::value::Domain for NamedSimplePattern {} - -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] -pub enum Pattern { - SimplePattern(std::boxed::Box), - CompoundPattern(std::boxed::Box) -} - -impl preserves::value::Domain for Pattern {} - -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] -pub struct Ref {pub module: ModulePath, pub name: std::string::String} - -impl preserves::value::Domain for Ref {} - -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] -pub struct Schema { - pub definitions: Definitions, - pub embedded_type: EmbeddedTypeName, - pub version: Version -} - -impl preserves::value::Domain for Schema {} - -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] -pub enum SimplePattern { - Any, - Atom {atom_kind: std::boxed::Box}, - Embedded {interface: std::boxed::Box}, - Lit {value: _Any}, - Seqof {pattern: std::boxed::Box}, - Setof {pattern: std::boxed::Box}, - Dictof {key: std::boxed::Box, value: std::boxed::Box}, - Ref(std::boxed::Box) -} - -impl preserves::value::Domain for SimplePattern {} - -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] -pub struct Version; - -impl preserves::value::Domain for Version {} - -fn read_atom_kind_boolean<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { +fn read_atom_kind_boolean<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "Boolean" => {} @@ -186,7 +33,7 @@ fn read_atom_kind_boolean<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std Ok(AtomKind::Boolean) } -fn read_atom_kind_float<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { +fn read_atom_kind_float<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "Float" => {} @@ -198,7 +45,7 @@ fn read_atom_kind_float<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std:: Ok(AtomKind::Float) } -fn read_atom_kind_double<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { +fn read_atom_kind_double<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "Double" => {} @@ -210,7 +57,7 @@ fn read_atom_kind_double<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std: Ok(AtomKind::Double) } -fn read_atom_kind_signed_integer<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { +fn read_atom_kind_signed_integer<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "SignedInteger" => {} @@ -222,7 +69,7 @@ fn read_atom_kind_signed_integer<'de, R: _support::Reader<'de, _Any>>(r: &mut R) Ok(AtomKind::SignedInteger) } -fn read_atom_kind_string<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { +fn read_atom_kind_string<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "String" => {} @@ -234,7 +81,7 @@ fn read_atom_kind_string<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std: Ok(AtomKind::String) } -fn read_atom_kind_byte_string<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { +fn read_atom_kind_byte_string<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "ByteString" => {} @@ -246,7 +93,7 @@ fn read_atom_kind_byte_string<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> Ok(AtomKind::ByteString) } -fn read_atom_kind_symbol<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { +fn read_atom_kind_symbol<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "Symbol" => {} @@ -258,7 +105,7 @@ fn read_atom_kind_symbol<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std: Ok(AtomKind::Symbol) } -impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for AtomKind { +impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for AtomKind { fn deserialize(r: &mut R) -> std::result::Result { let _mark = r.mark()?; match read_atom_kind_boolean(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result } @@ -272,77 +119,84 @@ impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> fo } } -fn _any_parse_atom_kind_boolean(value: &_Any) -> std::result::Result { - if value != &*_any_::LIT_0_BOOLEAN { return Err(_support::ParseError::conformance_error("schema.AtomKind::Boolean")); } +fn parse_atom_kind_boolean<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result { + if value != &_ctxt.LIT_0_BOOLEAN { return Err(_support::ParseError::conformance_error("schema.AtomKind::Boolean")); } let _tmp0 = (); Ok(AtomKind::Boolean) } -fn _any_parse_atom_kind_float(value: &_Any) -> std::result::Result { - if value != &*_any_::LIT_1_FLOAT { return Err(_support::ParseError::conformance_error("schema.AtomKind::Float")); } +fn parse_atom_kind_float<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result { + if value != &_ctxt.LIT_1_FLOAT { return Err(_support::ParseError::conformance_error("schema.AtomKind::Float")); } let _tmp0 = (); Ok(AtomKind::Float) } -fn _any_parse_atom_kind_double(value: &_Any) -> std::result::Result { - if value != &*_any_::LIT_2_DOUBLE { return Err(_support::ParseError::conformance_error("schema.AtomKind::Double")); } +fn parse_atom_kind_double<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result { + if value != &_ctxt.LIT_2_DOUBLE { return Err(_support::ParseError::conformance_error("schema.AtomKind::Double")); } let _tmp0 = (); Ok(AtomKind::Double) } -fn _any_parse_atom_kind_signed_integer(value: &_Any) -> std::result::Result { - if value != &*_any_::LIT_3_SIGNED_INTEGER { return Err(_support::ParseError::conformance_error("schema.AtomKind::SignedInteger")); } +fn parse_atom_kind_signed_integer<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result { + if value != &_ctxt.LIT_3_SIGNED_INTEGER { return Err(_support::ParseError::conformance_error("schema.AtomKind::SignedInteger")); } let _tmp0 = (); Ok(AtomKind::SignedInteger) } -fn _any_parse_atom_kind_string(value: &_Any) -> std::result::Result { - if value != &*_any_::LIT_4_STRING { return Err(_support::ParseError::conformance_error("schema.AtomKind::String")); } +fn parse_atom_kind_string<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result { + if value != &_ctxt.LIT_4_STRING { return Err(_support::ParseError::conformance_error("schema.AtomKind::String")); } let _tmp0 = (); Ok(AtomKind::String) } -fn _any_parse_atom_kind_byte_string(value: &_Any) -> std::result::Result { - if value != &*_any_::LIT_5_BYTE_STRING { return Err(_support::ParseError::conformance_error("schema.AtomKind::ByteString")); } +fn parse_atom_kind_byte_string<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result { + if value != &_ctxt.LIT_5_BYTE_STRING { return Err(_support::ParseError::conformance_error("schema.AtomKind::ByteString")); } let _tmp0 = (); Ok(AtomKind::ByteString) } -fn _any_parse_atom_kind_symbol(value: &_Any) -> std::result::Result { - if value != &*_any_::LIT_6_SYMBOL { return Err(_support::ParseError::conformance_error("schema.AtomKind::Symbol")); } +fn parse_atom_kind_symbol<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result { + if value != &_ctxt.LIT_6_SYMBOL { return Err(_support::ParseError::conformance_error("schema.AtomKind::Symbol")); } let _tmp0 = (); Ok(AtomKind::Symbol) } -impl std::convert::TryFrom<&_Any> for AtomKind { - type Error = _support::ParseError; - fn try_from(value: &_Any) -> std::result::Result { - if let Ok(r) = _any_parse_atom_kind_boolean(value) { return Ok(r); } - if let Ok(r) = _any_parse_atom_kind_float(value) { return Ok(r); } - if let Ok(r) = _any_parse_atom_kind_double(value) { return Ok(r); } - if let Ok(r) = _any_parse_atom_kind_signed_integer(value) { return Ok(r); } - if let Ok(r) = _any_parse_atom_kind_string(value) { return Ok(r); } - if let Ok(r) = _any_parse_atom_kind_byte_string(value) { return Ok(r); } - if let Ok(r) = _any_parse_atom_kind_symbol(value) { return Ok(r); } +impl AtomKind { + pub fn parse<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result { + if let Ok(r) = parse_atom_kind_boolean(_ctxt, value) { return Ok(r); } + if let Ok(r) = parse_atom_kind_float(_ctxt, value) { return Ok(r); } + if let Ok(r) = parse_atom_kind_double(_ctxt, value) { return Ok(r); } + if let Ok(r) = parse_atom_kind_signed_integer(_ctxt, value) { return Ok(r); } + if let Ok(r) = parse_atom_kind_string(_ctxt, value) { return Ok(r); } + if let Ok(r) = parse_atom_kind_byte_string(_ctxt, value) { return Ok(r); } + if let Ok(r) = parse_atom_kind_symbol(_ctxt, value) { return Ok(r); } Err(_support::ParseError::conformance_error("schema.AtomKind")) } } -impl std::convert::From<&AtomKind> for _Any { - fn from(value: &AtomKind) -> Self { - match value { - AtomKind::Boolean => (&*_any_::LIT_0_BOOLEAN).clone(), - AtomKind::Float => (&*_any_::LIT_1_FLOAT).clone(), - AtomKind::Double => (&*_any_::LIT_2_DOUBLE).clone(), - AtomKind::SignedInteger => (&*_any_::LIT_3_SIGNED_INTEGER).clone(), - AtomKind::String => (&*_any_::LIT_4_STRING).clone(), - AtomKind::ByteString => (&*_any_::LIT_5_BYTE_STRING).clone(), - AtomKind::Symbol => (&*_any_::LIT_6_SYMBOL).clone(), +impl AtomKind { + pub fn unparse<_Any: preserves::value::NestedValue>(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any { + match self { + AtomKind::Boolean => (&_ctxt.LIT_0_BOOLEAN).clone(), + AtomKind::Float => (&_ctxt.LIT_1_FLOAT).clone(), + AtomKind::Double => (&_ctxt.LIT_2_DOUBLE).clone(), + AtomKind::SignedInteger => (&_ctxt.LIT_3_SIGNED_INTEGER).clone(), + AtomKind::String => (&_ctxt.LIT_4_STRING).clone(), + AtomKind::ByteString => (&_ctxt.LIT_5_BYTE_STRING).clone(), + AtomKind::Symbol => (&_ctxt.LIT_6_SYMBOL).clone(), } } } -impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Binding { +#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] +pub struct Binding<_Any: preserves::value::NestedValue = preserves::value::IOValue> { + pub name: std::string::String, + pub pattern: SimplePattern<_Any> +} + +impl<_Any: preserves::value::NestedValue> preserves::value::Domain for Binding<_Any> {} + +impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Binding<_Any> { fn deserialize(r: &mut R) -> std::result::Result { r.open_record(None)?; let mut _tmp0 = _support::B::Type::default(); @@ -367,32 +221,38 @@ impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> fo } } -impl std::convert::TryFrom<&_Any> for Binding { - type Error = _support::ParseError; - fn try_from(value: &_Any) -> std::result::Result { +impl<_Any: preserves::value::NestedValue> Binding<_Any> { + pub fn parse(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result { let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*_any_::LIT_7_NAMED { return Err(_support::ParseError::conformance_error("schema.Binding")); } + if _tmp0.label() != &_ctxt.LIT_7_NAMED { return Err(_support::ParseError::conformance_error("schema.Binding")); } let _tmp1 = (); if _tmp0.fields().len() < 2 { return Err(_support::ParseError::conformance_error("schema.Binding")); } let _tmp2 = (&_tmp0.fields()[0]).value().to_symbol()?; - let _tmp3 = SimplePattern::try_from((&_tmp0.fields()[1]))?; + let _tmp3 = SimplePattern::parse(_ctxt, (&_tmp0.fields()[1]))?; Ok(Binding {name: _tmp2.clone(), pattern: _tmp3}) } } -impl std::convert::From<&Binding> for _Any { - fn from(value: &Binding) -> Self { - let Binding {name: _tmp0, pattern: _tmp1} = value; +impl<_Any: preserves::value::NestedValue> Binding<_Any> { + pub fn unparse(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any { + let Binding {name: _tmp0, pattern: _tmp1} = self; { - let mut _tmp2 = preserves::value::Record(vec![(&*_any_::LIT_7_NAMED).clone()]); + let mut _tmp2 = preserves::value::Record(vec![(&_ctxt.LIT_7_NAMED).clone()]); _tmp2.fields_vec_mut().push(preserves::value::Value::symbol(_tmp0).wrap()); - _tmp2.fields_vec_mut().push(_Any::from(_tmp1)); + _tmp2.fields_vec_mut().push(_tmp1.unparse(_ctxt)); _tmp2.finish().wrap() } } } -impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Bundle { +#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] +pub struct Bundle<_Any: preserves::value::NestedValue = preserves::value::IOValue> { + pub modules: Modules<_Any> +} + +impl<_Any: preserves::value::NestedValue> preserves::value::Domain for Bundle<_Any> {} + +impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Bundle<_Any> { fn deserialize(r: &mut R) -> std::result::Result { r.open_record(None)?; let mut _tmp0 = _support::B::Type::default(); @@ -414,30 +274,49 @@ impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> fo } } -impl std::convert::TryFrom<&_Any> for Bundle { - type Error = _support::ParseError; - fn try_from(value: &_Any) -> std::result::Result { +impl<_Any: preserves::value::NestedValue> Bundle<_Any> { + pub fn parse(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result { let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*_any_::LIT_8_BUNDLE { return Err(_support::ParseError::conformance_error("schema.Bundle")); } + if _tmp0.label() != &_ctxt.LIT_8_BUNDLE { return Err(_support::ParseError::conformance_error("schema.Bundle")); } let _tmp1 = (); if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.Bundle")); } - let _tmp2 = Modules::try_from((&_tmp0.fields()[0]))?; + let _tmp2 = Modules::parse(_ctxt, (&_tmp0.fields()[0]))?; Ok(Bundle {modules: _tmp2}) } } -impl std::convert::From<&Bundle> for _Any { - fn from(value: &Bundle) -> Self { - let Bundle {modules: _tmp0} = value; +impl<_Any: preserves::value::NestedValue> Bundle<_Any> { + pub fn unparse(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any { + let Bundle {modules: _tmp0} = self; { - let mut _tmp1 = preserves::value::Record(vec![(&*_any_::LIT_8_BUNDLE).clone()]); - _tmp1.fields_vec_mut().push(_Any::from(_tmp0)); + let mut _tmp1 = preserves::value::Record(vec![(&_ctxt.LIT_8_BUNDLE).clone()]); + _tmp1.fields_vec_mut().push(_tmp0.unparse(_ctxt)); _tmp1.finish().wrap() } } } -fn read_compound_pattern_rec<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { +#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] +pub enum CompoundPattern<_Any: preserves::value::NestedValue = preserves::value::IOValue> { + Rec { + label: std::boxed::Box>, + fields: std::boxed::Box> + }, + Tuple { + patterns: std::vec::Vec> + }, + TuplePrefix { + fixed: std::vec::Vec>, + variable: std::boxed::Box> + }, + Dict { + entries: std::boxed::Box> + } +} + +impl<_Any: preserves::value::NestedValue> preserves::value::Domain for CompoundPattern<_Any> {} + +fn read_compound_pattern_rec<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result, _support::ParseError> { r.open_record(None)?; let mut _tmp0 = _support::B::Type::default(); _tmp0.shift(Some(_support::B::Item::RecordLabel)); @@ -460,7 +339,7 @@ fn read_compound_pattern_rec<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> Ok(CompoundPattern::Rec {label: std::boxed::Box::new(_tmp2), fields: std::boxed::Box::new(_tmp3)}) } -fn read_compound_pattern_tuple<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { +fn read_compound_pattern_tuple<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result, _support::ParseError> { r.open_record(None)?; let mut _tmp0 = _support::B::Type::default(); _tmp0.shift(Some(_support::B::Item::RecordLabel)); @@ -489,7 +368,7 @@ fn read_compound_pattern_tuple<'de, R: _support::Reader<'de, _Any>>(r: &mut R) - Ok(CompoundPattern::Tuple {patterns: _tmp2}) } -fn read_compound_pattern_tuple_prefix<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { +fn read_compound_pattern_tuple_prefix<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result, _support::ParseError> { r.open_record(None)?; let mut _tmp0 = _support::B::Type::default(); _tmp0.shift(Some(_support::B::Item::RecordLabel)); @@ -521,7 +400,7 @@ fn read_compound_pattern_tuple_prefix<'de, R: _support::Reader<'de, _Any>>(r: &m Ok(CompoundPattern::TuplePrefix {fixed: _tmp2, variable: std::boxed::Box::new(_tmp6)}) } -fn read_compound_pattern_dict<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { +fn read_compound_pattern_dict<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result, _support::ParseError> { r.open_record(None)?; let mut _tmp0 = _support::B::Type::default(); _tmp0.shift(Some(_support::B::Item::RecordLabel)); @@ -541,7 +420,7 @@ fn read_compound_pattern_dict<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> Ok(CompoundPattern::Dict {entries: std::boxed::Box::new(_tmp2)}) } -impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for CompoundPattern { +impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for CompoundPattern<_Any> { fn deserialize(r: &mut R) -> std::result::Result { let _mark = r.mark()?; match read_compound_pattern_rec(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result } @@ -552,101 +431,117 @@ impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> fo } } -fn _any_parse_compound_pattern_rec(value: &_Any) -> std::result::Result { +fn parse_compound_pattern_rec<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result, _support::ParseError> { let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*_any_::LIT_9_REC { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::rec")); } + if _tmp0.label() != &_ctxt.LIT_9_REC { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::rec")); } let _tmp1 = (); if _tmp0.fields().len() < 2 { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::rec")); } - let _tmp2 = NamedPattern::try_from((&_tmp0.fields()[0]))?; - let _tmp3 = NamedPattern::try_from((&_tmp0.fields()[1]))?; + let _tmp2 = NamedPattern::parse(_ctxt, (&_tmp0.fields()[0]))?; + let _tmp3 = NamedPattern::parse(_ctxt, (&_tmp0.fields()[1]))?; Ok(CompoundPattern::Rec {label: std::boxed::Box::new(_tmp2), fields: std::boxed::Box::new(_tmp3)}) } -fn _any_parse_compound_pattern_tuple(value: &_Any) -> std::result::Result { +fn parse_compound_pattern_tuple<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result, _support::ParseError> { let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*_any_::LIT_10_TUPLE { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::tuple")); } + if _tmp0.label() != &_ctxt.LIT_10_TUPLE { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::tuple")); } let _tmp1 = (); if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::tuple")); } let _tmp3 = (&_tmp0.fields()[0]).value().to_sequence()?; let mut _tmp2 = std::vec::Vec::new(); - for _tmp4 in &_tmp3[0..] {let _tmp5 = NamedPattern::try_from(_tmp4)?; _tmp2.push(_tmp5);} + for _tmp4 in &_tmp3[0..] {let _tmp5 = NamedPattern::parse(_ctxt, _tmp4)?; _tmp2.push(_tmp5);} Ok(CompoundPattern::Tuple {patterns: _tmp2}) } -fn _any_parse_compound_pattern_tuple_prefix(value: &_Any) -> std::result::Result { +fn parse_compound_pattern_tuple_prefix<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result, _support::ParseError> { let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*_any_::LIT_11_TUPLE_PREFIX { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::tuplePrefix")); } + if _tmp0.label() != &_ctxt.LIT_11_TUPLE_PREFIX { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::tuplePrefix")); } let _tmp1 = (); if _tmp0.fields().len() < 2 { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::tuplePrefix")); } let _tmp3 = (&_tmp0.fields()[0]).value().to_sequence()?; let mut _tmp2 = std::vec::Vec::new(); - for _tmp4 in &_tmp3[0..] {let _tmp5 = NamedPattern::try_from(_tmp4)?; _tmp2.push(_tmp5);} - let _tmp6 = NamedSimplePattern::try_from((&_tmp0.fields()[1]))?; + for _tmp4 in &_tmp3[0..] {let _tmp5 = NamedPattern::parse(_ctxt, _tmp4)?; _tmp2.push(_tmp5);} + let _tmp6 = NamedSimplePattern::parse(_ctxt, (&_tmp0.fields()[1]))?; Ok(CompoundPattern::TuplePrefix {fixed: _tmp2, variable: std::boxed::Box::new(_tmp6)}) } -fn _any_parse_compound_pattern_dict(value: &_Any) -> std::result::Result { +fn parse_compound_pattern_dict<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result, _support::ParseError> { let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*_any_::LIT_12_DICT { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::dict")); } + if _tmp0.label() != &_ctxt.LIT_12_DICT { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::dict")); } let _tmp1 = (); if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::dict")); } - let _tmp2 = DictionaryEntries::try_from((&_tmp0.fields()[0]))?; + let _tmp2 = DictionaryEntries::parse(_ctxt, (&_tmp0.fields()[0]))?; Ok(CompoundPattern::Dict {entries: std::boxed::Box::new(_tmp2)}) } -impl std::convert::TryFrom<&_Any> for CompoundPattern { - type Error = _support::ParseError; - fn try_from(value: &_Any) -> std::result::Result { - if let Ok(r) = _any_parse_compound_pattern_rec(value) { return Ok(r); } - if let Ok(r) = _any_parse_compound_pattern_tuple(value) { return Ok(r); } - if let Ok(r) = _any_parse_compound_pattern_tuple_prefix(value) { return Ok(r); } - if let Ok(r) = _any_parse_compound_pattern_dict(value) { return Ok(r); } +impl<_Any: preserves::value::NestedValue> CompoundPattern<_Any> { + pub fn parse(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result { + if let Ok(r) = parse_compound_pattern_rec(_ctxt, value) { return Ok(r); } + if let Ok(r) = parse_compound_pattern_tuple(_ctxt, value) { return Ok(r); } + if let Ok(r) = parse_compound_pattern_tuple_prefix(_ctxt, value) { return Ok(r); } + if let Ok(r) = parse_compound_pattern_dict(_ctxt, value) { return Ok(r); } Err(_support::ParseError::conformance_error("schema.CompoundPattern")) } } -impl std::convert::From<&CompoundPattern> for _Any { - fn from(value: &CompoundPattern) -> Self { - match value { +impl<_Any: preserves::value::NestedValue> CompoundPattern<_Any> { + pub fn unparse(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any { + match self { CompoundPattern::Rec {label: _tmp0, fields: _tmp1} => { - let mut _tmp2 = preserves::value::Record(vec![(&*_any_::LIT_9_REC).clone()]); - _tmp2.fields_vec_mut().push(_Any::from(_tmp0.as_ref())); - _tmp2.fields_vec_mut().push(_Any::from(_tmp1.as_ref())); + let mut _tmp2 = preserves::value::Record(vec![(&_ctxt.LIT_9_REC).clone()]); + _tmp2.fields_vec_mut().push(_tmp0.as_ref().unparse(_ctxt)); + _tmp2.fields_vec_mut().push(_tmp1.as_ref().unparse(_ctxt)); _tmp2.finish().wrap() }, CompoundPattern::Tuple {patterns: _tmp0} => { - let mut _tmp1 = preserves::value::Record(vec![(&*_any_::LIT_10_TUPLE).clone()]); + let mut _tmp1 = preserves::value::Record(vec![(&_ctxt.LIT_10_TUPLE).clone()]); _tmp1.fields_vec_mut().push( { let mut _tmp2 = std::vec::Vec::new(); - for _tmp3 in _tmp0 {_tmp2.push(_Any::from(_tmp3));} + for _tmp3 in _tmp0 {_tmp2.push(_tmp3.unparse(_ctxt));} preserves::value::Value::Sequence(_tmp2).wrap() } ); _tmp1.finish().wrap() }, CompoundPattern::TuplePrefix {fixed: _tmp0, variable: _tmp1} => { - let mut _tmp2 = preserves::value::Record(vec![(&*_any_::LIT_11_TUPLE_PREFIX).clone()]); + let mut _tmp2 = preserves::value::Record(vec![(&_ctxt.LIT_11_TUPLE_PREFIX).clone()]); _tmp2.fields_vec_mut().push( { let mut _tmp3 = std::vec::Vec::new(); - for _tmp4 in _tmp0 {_tmp3.push(_Any::from(_tmp4));} + for _tmp4 in _tmp0 {_tmp3.push(_tmp4.unparse(_ctxt));} preserves::value::Value::Sequence(_tmp3).wrap() } ); - _tmp2.fields_vec_mut().push(_Any::from(_tmp1.as_ref())); + _tmp2.fields_vec_mut().push(_tmp1.as_ref().unparse(_ctxt)); _tmp2.finish().wrap() }, CompoundPattern::Dict {entries: _tmp0} => { - let mut _tmp1 = preserves::value::Record(vec![(&*_any_::LIT_12_DICT).clone()]); - _tmp1.fields_vec_mut().push(_Any::from(_tmp0.as_ref())); + let mut _tmp1 = preserves::value::Record(vec![(&_ctxt.LIT_12_DICT).clone()]); + _tmp1.fields_vec_mut().push(_tmp0.as_ref().unparse(_ctxt)); _tmp1.finish().wrap() }, } } } -fn read_definition_or<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { +#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] +pub enum Definition<_Any: preserves::value::NestedValue = preserves::value::IOValue> { + Or { + pattern_0: std::boxed::Box>, + pattern_1: std::boxed::Box>, + pattern_n: std::vec::Vec> + }, + And { + pattern_0: std::boxed::Box>, + pattern_1: std::boxed::Box>, + pattern_n: std::vec::Vec> + }, + Pattern(std::boxed::Box>) +} + +impl<_Any: preserves::value::NestedValue> preserves::value::Domain for Definition<_Any> {} + +fn read_definition_or<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result, _support::ParseError> { r.open_record(None)?; let mut _tmp0 = _support::B::Type::default(); _tmp0.shift(Some(_support::B::Item::RecordLabel)); @@ -685,7 +580,7 @@ fn read_definition_or<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::re }) } -fn read_definition_and<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { +fn read_definition_and<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result, _support::ParseError> { r.open_record(None)?; let mut _tmp0 = _support::B::Type::default(); _tmp0.shift(Some(_support::B::Item::RecordLabel)); @@ -724,12 +619,12 @@ fn read_definition_and<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::r }) } -fn read_definition_pattern<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { +fn read_definition_pattern<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result, _support::ParseError> { let _tmp0 = Pattern::deserialize(r)?; Ok(Definition::Pattern(std::boxed::Box::new(_tmp0))) } -impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Definition { +impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Definition<_Any> { fn deserialize(r: &mut R) -> std::result::Result { let _mark = r.mark()?; match read_definition_or(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result } @@ -739,17 +634,17 @@ impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> fo } } -fn _any_parse_definition_or(value: &_Any) -> std::result::Result { +fn parse_definition_or<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result, _support::ParseError> { let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*_any_::LIT_13_OR { return Err(_support::ParseError::conformance_error("schema.Definition::or")); } + if _tmp0.label() != &_ctxt.LIT_13_OR { return Err(_support::ParseError::conformance_error("schema.Definition::or")); } let _tmp1 = (); if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.Definition::or")); } let _tmp2 = (&_tmp0.fields()[0]).value().to_sequence()?; if _tmp2.len() < 2 { return Err(_support::ParseError::conformance_error("schema.Definition::or")); } - let _tmp3 = NamedAlternative::try_from((&_tmp2[0]))?; - let _tmp4 = NamedAlternative::try_from((&_tmp2[1]))?; + let _tmp3 = NamedAlternative::parse(_ctxt, (&_tmp2[0]))?; + let _tmp4 = NamedAlternative::parse(_ctxt, (&_tmp2[1]))?; let mut _tmp5 = std::vec::Vec::new(); - for _tmp6 in &_tmp2[2..] {let _tmp7 = NamedAlternative::try_from(_tmp6)?; _tmp5.push(_tmp7);} + for _tmp6 in &_tmp2[2..] {let _tmp7 = NamedAlternative::parse(_ctxt, _tmp6)?; _tmp5.push(_tmp7);} Ok(Definition::Or { pattern_0: std::boxed::Box::new(_tmp3), pattern_1: std::boxed::Box::new(_tmp4), @@ -757,17 +652,17 @@ fn _any_parse_definition_or(value: &_Any) -> std::result::Result std::result::Result { +fn parse_definition_and<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result, _support::ParseError> { let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*_any_::LIT_14_AND { return Err(_support::ParseError::conformance_error("schema.Definition::and")); } + if _tmp0.label() != &_ctxt.LIT_14_AND { return Err(_support::ParseError::conformance_error("schema.Definition::and")); } let _tmp1 = (); if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.Definition::and")); } let _tmp2 = (&_tmp0.fields()[0]).value().to_sequence()?; if _tmp2.len() < 2 { return Err(_support::ParseError::conformance_error("schema.Definition::and")); } - let _tmp3 = NamedPattern::try_from((&_tmp2[0]))?; - let _tmp4 = NamedPattern::try_from((&_tmp2[1]))?; + let _tmp3 = NamedPattern::parse(_ctxt, (&_tmp2[0]))?; + let _tmp4 = NamedPattern::parse(_ctxt, (&_tmp2[1]))?; let mut _tmp5 = std::vec::Vec::new(); - for _tmp6 in &_tmp2[2..] {let _tmp7 = NamedPattern::try_from(_tmp6)?; _tmp5.push(_tmp7);} + for _tmp6 in &_tmp2[2..] {let _tmp7 = NamedPattern::parse(_ctxt, _tmp6)?; _tmp5.push(_tmp7);} Ok(Definition::And { pattern_0: std::boxed::Box::new(_tmp3), pattern_1: std::boxed::Box::new(_tmp4), @@ -775,56 +670,60 @@ fn _any_parse_definition_and(value: &_Any) -> std::result::Result std::result::Result { - let _tmp0 = Pattern::try_from(value)?; +fn parse_definition_pattern<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result, _support::ParseError> { + let _tmp0 = Pattern::parse(_ctxt, value)?; Ok(Definition::Pattern(std::boxed::Box::new(_tmp0))) } -impl std::convert::TryFrom<&_Any> for Definition { - type Error = _support::ParseError; - fn try_from(value: &_Any) -> std::result::Result { - if let Ok(r) = _any_parse_definition_or(value) { return Ok(r); } - if let Ok(r) = _any_parse_definition_and(value) { return Ok(r); } - if let Ok(r) = _any_parse_definition_pattern(value) { return Ok(r); } +impl<_Any: preserves::value::NestedValue> Definition<_Any> { + pub fn parse(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result { + if let Ok(r) = parse_definition_or(_ctxt, value) { return Ok(r); } + if let Ok(r) = parse_definition_and(_ctxt, value) { return Ok(r); } + if let Ok(r) = parse_definition_pattern(_ctxt, value) { return Ok(r); } Err(_support::ParseError::conformance_error("schema.Definition")) } } -impl std::convert::From<&Definition> for _Any { - fn from(value: &Definition) -> Self { - match value { +impl<_Any: preserves::value::NestedValue> Definition<_Any> { + pub fn unparse(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any { + match self { Definition::Or {pattern_0: _tmp0, pattern_1: _tmp1, pattern_n: _tmp2} => { - let mut _tmp3 = preserves::value::Record(vec![(&*_any_::LIT_13_OR).clone()]); + let mut _tmp3 = preserves::value::Record(vec![(&_ctxt.LIT_13_OR).clone()]); _tmp3.fields_vec_mut().push( { let mut _tmp4 = std::vec::Vec::new(); - _tmp4.push(_Any::from(_tmp0.as_ref())); - _tmp4.push(_Any::from(_tmp1.as_ref())); - for _tmp5 in _tmp2 {_tmp4.push(_Any::from(_tmp5));} + _tmp4.push(_tmp0.as_ref().unparse(_ctxt)); + _tmp4.push(_tmp1.as_ref().unparse(_ctxt)); + for _tmp5 in _tmp2 {_tmp4.push(_tmp5.unparse(_ctxt));} 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![(&*_any_::LIT_14_AND).clone()]); + let mut _tmp3 = preserves::value::Record(vec![(&_ctxt.LIT_14_AND).clone()]); _tmp3.fields_vec_mut().push( { let mut _tmp4 = std::vec::Vec::new(); - _tmp4.push(_Any::from(_tmp0.as_ref())); - _tmp4.push(_Any::from(_tmp1.as_ref())); - for _tmp5 in _tmp2 {_tmp4.push(_Any::from(_tmp5));} + _tmp4.push(_tmp0.as_ref().unparse(_ctxt)); + _tmp4.push(_tmp1.as_ref().unparse(_ctxt)); + for _tmp5 in _tmp2 {_tmp4.push(_tmp5.unparse(_ctxt));} preserves::value::Value::Sequence(_tmp4).wrap() } ); _tmp3.finish().wrap() }, - Definition::Pattern(_tmp0) => _Any::from(_tmp0.as_ref()), + Definition::Pattern(_tmp0) => _tmp0.as_ref().unparse(_ctxt), } } } -impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Definitions { +#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] +pub struct Definitions<_Any: preserves::value::NestedValue = preserves::value::IOValue>(pub preserves::value::Map>); + +impl<_Any: preserves::value::NestedValue> preserves::value::Domain for Definitions<_Any> {} + +impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Definitions<_Any> { fn deserialize(r: &mut R) -> std::result::Result { r.open_dictionary()?; let mut _tmp2 = _support::B::Type::default(); @@ -843,27 +742,31 @@ impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> fo } } -impl std::convert::TryFrom<&_Any> for Definitions { - type Error = _support::ParseError; - fn try_from(value: &_Any) -> std::result::Result { +impl<_Any: preserves::value::NestedValue> Definitions<_Any> { + pub fn parse(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result { let mut _tmp0 = preserves::value::Map::new(); for (_tmp1, _tmp2) in value.value().to_dictionary()? { let _tmp3 = _tmp1.value().to_symbol()?; - let _tmp4 = Definition::try_from(_tmp2)?; + let _tmp4 = Definition::parse(_ctxt, _tmp2)?; _tmp0.insert(_tmp3.clone(), _tmp4); } Ok(Definitions(_tmp0)) } } -impl std::convert::From<&Definitions> for _Any { - fn from(value: &Definitions) -> Self { - let Definitions(_tmp0) = value; - preserves::value::Value::Dictionary(_tmp0.iter().map(|(_tmp1, _tmp2)| (preserves::value::Value::symbol(_tmp1).wrap(), _Any::from(_tmp2))).collect()).wrap() +impl<_Any: preserves::value::NestedValue> Definitions<_Any> { + pub fn unparse(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any { + let Definitions(_tmp0) = self; + preserves::value::Value::Dictionary(_tmp0.iter().map(|(_tmp1, _tmp2)| (preserves::value::Value::symbol(_tmp1).wrap(), _tmp2.unparse(_ctxt))).collect()).wrap() } } -impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for DictionaryEntries { +#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] +pub struct DictionaryEntries<_Any: preserves::value::NestedValue = preserves::value::IOValue>(pub preserves::value::Map<_Any, NamedSimplePattern<_Any>>); + +impl<_Any: preserves::value::NestedValue> preserves::value::Domain for DictionaryEntries<_Any> {} + +impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for DictionaryEntries<_Any> { fn deserialize(r: &mut R) -> std::result::Result { r.open_dictionary()?; let mut _tmp2 = _support::B::Type::default(); @@ -882,32 +785,39 @@ impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> fo } } -impl std::convert::TryFrom<&_Any> for DictionaryEntries { - type Error = _support::ParseError; - fn try_from(value: &_Any) -> std::result::Result { +impl<_Any: preserves::value::NestedValue> DictionaryEntries<_Any> { + pub fn parse(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result { let mut _tmp0 = preserves::value::Map::new(); for (_tmp1, _tmp2) in value.value().to_dictionary()? { let _tmp3 = _tmp1; - let _tmp4 = NamedSimplePattern::try_from(_tmp2)?; + let _tmp4 = NamedSimplePattern::parse(_ctxt, _tmp2)?; _tmp0.insert(_tmp3.clone(), _tmp4); } Ok(DictionaryEntries(_tmp0)) } } -impl std::convert::From<&DictionaryEntries> for _Any { - fn from(value: &DictionaryEntries) -> Self { - let DictionaryEntries(_tmp0) = value; - preserves::value::Value::Dictionary(_tmp0.iter().map(|(_tmp1, _tmp2)| (_tmp1.clone(), _Any::from(_tmp2))).collect()).wrap() +impl<_Any: preserves::value::NestedValue> DictionaryEntries<_Any> { + pub fn unparse(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any { + let DictionaryEntries(_tmp0) = self; + preserves::value::Value::Dictionary(_tmp0.iter().map(|(_tmp1, _tmp2)| (_tmp1.clone(), _tmp2.unparse(_ctxt))).collect()).wrap() } } -fn read_embedded_type_name_ref<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { +#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] +pub enum EmbeddedTypeName { + Ref(std::boxed::Box), + False +} + +impl preserves::value::Domain for EmbeddedTypeName {} + +fn read_embedded_type_name_ref<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { let _tmp0 = Ref::deserialize(r)?; Ok(EmbeddedTypeName::Ref(std::boxed::Box::new(_tmp0))) } -fn read_embedded_type_name_false<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { +fn read_embedded_type_name_false<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Boolean(w) if !*w => {} @@ -919,7 +829,7 @@ fn read_embedded_type_name_false<'de, R: _support::Reader<'de, _Any>>(r: &mut R) Ok(EmbeddedTypeName::False) } -impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for EmbeddedTypeName { +impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for EmbeddedTypeName { fn deserialize(r: &mut R) -> std::result::Result { let _mark = r.mark()?; match read_embedded_type_name_ref(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result } @@ -928,36 +838,40 @@ impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> fo } } -fn _any_parse_embedded_type_name_ref(value: &_Any) -> std::result::Result { - let _tmp0 = Ref::try_from(value)?; +fn parse_embedded_type_name_ref<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result { + let _tmp0 = Ref::parse(_ctxt, value)?; Ok(EmbeddedTypeName::Ref(std::boxed::Box::new(_tmp0))) } -fn _any_parse_embedded_type_name_false(value: &_Any) -> std::result::Result { - if value != &*_any_::LIT_15_FALSE { return Err(_support::ParseError::conformance_error("schema.EmbeddedTypeName::false")); } +fn parse_embedded_type_name_false<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result { + if value != &_ctxt.LIT_15_FALSE { return Err(_support::ParseError::conformance_error("schema.EmbeddedTypeName::false")); } let _tmp0 = (); Ok(EmbeddedTypeName::False) } -impl std::convert::TryFrom<&_Any> for EmbeddedTypeName { - type Error = _support::ParseError; - fn try_from(value: &_Any) -> std::result::Result { - if let Ok(r) = _any_parse_embedded_type_name_ref(value) { return Ok(r); } - if let Ok(r) = _any_parse_embedded_type_name_false(value) { return Ok(r); } +impl EmbeddedTypeName { + pub fn parse<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result { + if let Ok(r) = parse_embedded_type_name_ref(_ctxt, value) { return Ok(r); } + if let Ok(r) = parse_embedded_type_name_false(_ctxt, value) { return Ok(r); } Err(_support::ParseError::conformance_error("schema.EmbeddedTypeName")) } } -impl std::convert::From<&EmbeddedTypeName> for _Any { - fn from(value: &EmbeddedTypeName) -> Self { - match value { - EmbeddedTypeName::Ref(_tmp0) => _Any::from(_tmp0.as_ref()), - EmbeddedTypeName::False => (&*_any_::LIT_15_FALSE).clone(), +impl EmbeddedTypeName { + pub fn unparse<_Any: preserves::value::NestedValue>(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any { + match self { + EmbeddedTypeName::Ref(_tmp0) => _tmp0.as_ref().unparse(_ctxt), + EmbeddedTypeName::False => (&_ctxt.LIT_15_FALSE).clone(), } } } -impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for ModulePath { +#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] +pub struct ModulePath(pub std::vec::Vec); + +impl preserves::value::Domain for ModulePath {} + +impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for ModulePath { fn deserialize(r: &mut R) -> std::result::Result { r.open_sequence()?; let mut _tmp2 = _support::B::Type::default(); @@ -973,9 +887,8 @@ impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> fo } } -impl std::convert::TryFrom<&_Any> for ModulePath { - type Error = _support::ParseError; - fn try_from(value: &_Any) -> std::result::Result { +impl ModulePath { + pub fn parse<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result { let _tmp1 = value.value().to_sequence()?; let mut _tmp0 = std::vec::Vec::new(); for _tmp2 in &_tmp1[0..] {let _tmp3 = _tmp2.value().to_symbol()?; _tmp0.push(_tmp3.clone());} @@ -983,9 +896,9 @@ impl std::convert::TryFrom<&_Any> for ModulePath { } } -impl std::convert::From<&ModulePath> for _Any { - fn from(value: &ModulePath) -> Self { - let ModulePath(_tmp0) = value; +impl ModulePath { + pub fn unparse<_Any: preserves::value::NestedValue>(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any { + let ModulePath(_tmp0) = self; { let mut _tmp1 = std::vec::Vec::new(); for _tmp2 in _tmp0 {_tmp1.push(preserves::value::Value::symbol(_tmp2).wrap());} @@ -994,7 +907,12 @@ impl std::convert::From<&ModulePath> for _Any { } } -impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Modules { +#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] +pub struct Modules<_Any: preserves::value::NestedValue = preserves::value::IOValue>(pub preserves::value::Map>); + +impl<_Any: preserves::value::NestedValue> preserves::value::Domain for Modules<_Any> {} + +impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Modules<_Any> { fn deserialize(r: &mut R) -> std::result::Result { r.open_dictionary()?; let mut _tmp2 = _support::B::Type::default(); @@ -1013,27 +931,34 @@ impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> fo } } -impl std::convert::TryFrom<&_Any> for Modules { - type Error = _support::ParseError; - fn try_from(value: &_Any) -> std::result::Result { +impl<_Any: preserves::value::NestedValue> Modules<_Any> { + pub fn parse(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result { let mut _tmp0 = preserves::value::Map::new(); for (_tmp1, _tmp2) in value.value().to_dictionary()? { - let _tmp3 = ModulePath::try_from(_tmp1)?; - let _tmp4 = Schema::try_from(_tmp2)?; + let _tmp3 = ModulePath::parse(_ctxt, _tmp1)?; + let _tmp4 = Schema::parse(_ctxt, _tmp2)?; _tmp0.insert(_tmp3, _tmp4); } Ok(Modules(_tmp0)) } } -impl std::convert::From<&Modules> for _Any { - fn from(value: &Modules) -> Self { - let Modules(_tmp0) = value; - preserves::value::Value::Dictionary(_tmp0.iter().map(|(_tmp1, _tmp2)| (_Any::from(_tmp1), _Any::from(_tmp2))).collect()).wrap() +impl<_Any: preserves::value::NestedValue> Modules<_Any> { + pub fn unparse(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any { + let Modules(_tmp0) = self; + preserves::value::Value::Dictionary(_tmp0.iter().map(|(_tmp1, _tmp2)| (_tmp1.unparse(_ctxt), _tmp2.unparse(_ctxt))).collect()).wrap() } } -impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for NamedAlternative { +#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] +pub struct NamedAlternative<_Any: preserves::value::NestedValue = preserves::value::IOValue> { + pub variant_label: std::string::String, + pub pattern: Pattern<_Any> +} + +impl<_Any: preserves::value::NestedValue> preserves::value::Domain for NamedAlternative<_Any> {} + +impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for NamedAlternative<_Any> { fn deserialize(r: &mut R) -> std::result::Result { r.open_sequence()?; let mut _tmp0 = _support::B::Type::default(); @@ -1048,40 +973,47 @@ impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> fo } } -impl std::convert::TryFrom<&_Any> for NamedAlternative { - type Error = _support::ParseError; - fn try_from(value: &_Any) -> std::result::Result { +impl<_Any: preserves::value::NestedValue> NamedAlternative<_Any> { + pub fn parse(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result { let _tmp0 = value.value().to_sequence()?; if _tmp0.len() < 2 { return Err(_support::ParseError::conformance_error("schema.NamedAlternative")); } let _tmp1 = (&_tmp0[0]).value().to_string()?; - let _tmp2 = Pattern::try_from((&_tmp0[1]))?; + let _tmp2 = Pattern::parse(_ctxt, (&_tmp0[1]))?; Ok(NamedAlternative {variant_label: _tmp1.clone(), pattern: _tmp2}) } } -impl std::convert::From<&NamedAlternative> for _Any { - fn from(value: &NamedAlternative) -> Self { - let NamedAlternative {variant_label: _tmp0, pattern: _tmp1} = value; +impl<_Any: preserves::value::NestedValue> NamedAlternative<_Any> { + pub fn unparse(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any { + let NamedAlternative {variant_label: _tmp0, pattern: _tmp1} = self; { let mut _tmp2 = std::vec::Vec::new(); _tmp2.push(preserves::value::Value::from(_tmp0).wrap()); - _tmp2.push(_Any::from(_tmp1)); + _tmp2.push(_tmp1.unparse(_ctxt)); preserves::value::Value::Sequence(_tmp2).wrap() } } } -fn read_named_pattern_named<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { +#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] +pub enum NamedPattern<_Any: preserves::value::NestedValue = preserves::value::IOValue> { + Named(std::boxed::Box>), + Anonymous(std::boxed::Box>) +} + +impl<_Any: preserves::value::NestedValue> preserves::value::Domain for NamedPattern<_Any> {} + +fn read_named_pattern_named<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result, _support::ParseError> { let _tmp0 = Binding::deserialize(r)?; Ok(NamedPattern::Named(std::boxed::Box::new(_tmp0))) } -fn read_named_pattern_anonymous<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { +fn read_named_pattern_anonymous<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result, _support::ParseError> { let _tmp0 = Pattern::deserialize(r)?; Ok(NamedPattern::Anonymous(std::boxed::Box::new(_tmp0))) } -impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for NamedPattern { +impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for NamedPattern<_Any> { fn deserialize(r: &mut R) -> std::result::Result { let _mark = r.mark()?; match read_named_pattern_named(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result } @@ -1090,45 +1022,52 @@ impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> fo } } -fn _any_parse_named_pattern_named(value: &_Any) -> std::result::Result { - let _tmp0 = Binding::try_from(value)?; +fn parse_named_pattern_named<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result, _support::ParseError> { + let _tmp0 = Binding::parse(_ctxt, value)?; Ok(NamedPattern::Named(std::boxed::Box::new(_tmp0))) } -fn _any_parse_named_pattern_anonymous(value: &_Any) -> std::result::Result { - let _tmp0 = Pattern::try_from(value)?; +fn parse_named_pattern_anonymous<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result, _support::ParseError> { + let _tmp0 = Pattern::parse(_ctxt, value)?; Ok(NamedPattern::Anonymous(std::boxed::Box::new(_tmp0))) } -impl std::convert::TryFrom<&_Any> for NamedPattern { - type Error = _support::ParseError; - fn try_from(value: &_Any) -> std::result::Result { - if let Ok(r) = _any_parse_named_pattern_named(value) { return Ok(r); } - if let Ok(r) = _any_parse_named_pattern_anonymous(value) { return Ok(r); } +impl<_Any: preserves::value::NestedValue> NamedPattern<_Any> { + pub fn parse(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result { + if let Ok(r) = parse_named_pattern_named(_ctxt, value) { return Ok(r); } + if let Ok(r) = parse_named_pattern_anonymous(_ctxt, value) { return Ok(r); } Err(_support::ParseError::conformance_error("schema.NamedPattern")) } } -impl std::convert::From<&NamedPattern> for _Any { - fn from(value: &NamedPattern) -> Self { - match value { - NamedPattern::Named(_tmp0) => _Any::from(_tmp0.as_ref()), - NamedPattern::Anonymous(_tmp0) => _Any::from(_tmp0.as_ref()), +impl<_Any: preserves::value::NestedValue> NamedPattern<_Any> { + pub fn unparse(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any { + match self { + NamedPattern::Named(_tmp0) => _tmp0.as_ref().unparse(_ctxt), + NamedPattern::Anonymous(_tmp0) => _tmp0.as_ref().unparse(_ctxt), } } } -fn read_named_simple_pattern_named<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { +#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] +pub enum NamedSimplePattern<_Any: preserves::value::NestedValue = preserves::value::IOValue> { + Named(std::boxed::Box>), + Anonymous(std::boxed::Box>) +} + +impl<_Any: preserves::value::NestedValue> preserves::value::Domain for NamedSimplePattern<_Any> {} + +fn read_named_simple_pattern_named<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result, _support::ParseError> { let _tmp0 = Binding::deserialize(r)?; Ok(NamedSimplePattern::Named(std::boxed::Box::new(_tmp0))) } -fn read_named_simple_pattern_anonymous<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { +fn read_named_simple_pattern_anonymous<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result, _support::ParseError> { let _tmp0 = SimplePattern::deserialize(r)?; Ok(NamedSimplePattern::Anonymous(std::boxed::Box::new(_tmp0))) } -impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for NamedSimplePattern { +impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for NamedSimplePattern<_Any> { fn deserialize(r: &mut R) -> std::result::Result { let _mark = r.mark()?; match read_named_simple_pattern_named(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result } @@ -1137,45 +1076,52 @@ impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> fo } } -fn _any_parse_named_simple_pattern_named(value: &_Any) -> std::result::Result { - let _tmp0 = Binding::try_from(value)?; +fn parse_named_simple_pattern_named<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result, _support::ParseError> { + let _tmp0 = Binding::parse(_ctxt, value)?; Ok(NamedSimplePattern::Named(std::boxed::Box::new(_tmp0))) } -fn _any_parse_named_simple_pattern_anonymous(value: &_Any) -> std::result::Result { - let _tmp0 = SimplePattern::try_from(value)?; +fn parse_named_simple_pattern_anonymous<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result, _support::ParseError> { + let _tmp0 = SimplePattern::parse(_ctxt, value)?; Ok(NamedSimplePattern::Anonymous(std::boxed::Box::new(_tmp0))) } -impl std::convert::TryFrom<&_Any> for NamedSimplePattern { - type Error = _support::ParseError; - fn try_from(value: &_Any) -> std::result::Result { - if let Ok(r) = _any_parse_named_simple_pattern_named(value) { return Ok(r); } - if let Ok(r) = _any_parse_named_simple_pattern_anonymous(value) { return Ok(r); } +impl<_Any: preserves::value::NestedValue> NamedSimplePattern<_Any> { + pub fn parse(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result { + if let Ok(r) = parse_named_simple_pattern_named(_ctxt, value) { return Ok(r); } + if let Ok(r) = parse_named_simple_pattern_anonymous(_ctxt, value) { return Ok(r); } Err(_support::ParseError::conformance_error("schema.NamedSimplePattern")) } } -impl std::convert::From<&NamedSimplePattern> for _Any { - fn from(value: &NamedSimplePattern) -> Self { - match value { - NamedSimplePattern::Named(_tmp0) => _Any::from(_tmp0.as_ref()), - NamedSimplePattern::Anonymous(_tmp0) => _Any::from(_tmp0.as_ref()), +impl<_Any: preserves::value::NestedValue> NamedSimplePattern<_Any> { + pub fn unparse(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any { + match self { + NamedSimplePattern::Named(_tmp0) => _tmp0.as_ref().unparse(_ctxt), + NamedSimplePattern::Anonymous(_tmp0) => _tmp0.as_ref().unparse(_ctxt), } } } -fn read_pattern_simple_pattern<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { +#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] +pub enum Pattern<_Any: preserves::value::NestedValue = preserves::value::IOValue> { + SimplePattern(std::boxed::Box>), + CompoundPattern(std::boxed::Box>) +} + +impl<_Any: preserves::value::NestedValue> preserves::value::Domain for Pattern<_Any> {} + +fn read_pattern_simple_pattern<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result, _support::ParseError> { let _tmp0 = SimplePattern::deserialize(r)?; Ok(Pattern::SimplePattern(std::boxed::Box::new(_tmp0))) } -fn read_pattern_compound_pattern<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { +fn read_pattern_compound_pattern<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result, _support::ParseError> { let _tmp0 = CompoundPattern::deserialize(r)?; Ok(Pattern::CompoundPattern(std::boxed::Box::new(_tmp0))) } -impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Pattern { +impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Pattern<_Any> { fn deserialize(r: &mut R) -> std::result::Result { let _mark = r.mark()?; match read_pattern_simple_pattern(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result } @@ -1184,35 +1130,42 @@ impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> fo } } -fn _any_parse_pattern_simple_pattern(value: &_Any) -> std::result::Result { - let _tmp0 = SimplePattern::try_from(value)?; +fn parse_pattern_simple_pattern<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result, _support::ParseError> { + let _tmp0 = SimplePattern::parse(_ctxt, value)?; Ok(Pattern::SimplePattern(std::boxed::Box::new(_tmp0))) } -fn _any_parse_pattern_compound_pattern(value: &_Any) -> std::result::Result { - let _tmp0 = CompoundPattern::try_from(value)?; +fn parse_pattern_compound_pattern<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result, _support::ParseError> { + let _tmp0 = CompoundPattern::parse(_ctxt, value)?; Ok(Pattern::CompoundPattern(std::boxed::Box::new(_tmp0))) } -impl std::convert::TryFrom<&_Any> for Pattern { - type Error = _support::ParseError; - fn try_from(value: &_Any) -> std::result::Result { - if let Ok(r) = _any_parse_pattern_simple_pattern(value) { return Ok(r); } - if let Ok(r) = _any_parse_pattern_compound_pattern(value) { return Ok(r); } +impl<_Any: preserves::value::NestedValue> Pattern<_Any> { + pub fn parse(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result { + if let Ok(r) = parse_pattern_simple_pattern(_ctxt, value) { return Ok(r); } + if let Ok(r) = parse_pattern_compound_pattern(_ctxt, value) { return Ok(r); } Err(_support::ParseError::conformance_error("schema.Pattern")) } } -impl std::convert::From<&Pattern> for _Any { - fn from(value: &Pattern) -> Self { - match value { - Pattern::SimplePattern(_tmp0) => _Any::from(_tmp0.as_ref()), - Pattern::CompoundPattern(_tmp0) => _Any::from(_tmp0.as_ref()), +impl<_Any: preserves::value::NestedValue> Pattern<_Any> { + pub fn unparse(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any { + match self { + Pattern::SimplePattern(_tmp0) => _tmp0.as_ref().unparse(_ctxt), + Pattern::CompoundPattern(_tmp0) => _tmp0.as_ref().unparse(_ctxt), } } } -impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Ref { +#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] +pub struct Ref { + pub module: ModulePath, + pub name: std::string::String +} + +impl preserves::value::Domain for Ref {} + +impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Ref { fn deserialize(r: &mut R) -> std::result::Result { r.open_record(None)?; let mut _tmp0 = _support::B::Type::default(); @@ -1237,32 +1190,40 @@ impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> fo } } -impl std::convert::TryFrom<&_Any> for Ref { - type Error = _support::ParseError; - fn try_from(value: &_Any) -> std::result::Result { +impl Ref { + pub fn parse<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result { let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*_any_::LIT_16_REF { return Err(_support::ParseError::conformance_error("schema.Ref")); } + if _tmp0.label() != &_ctxt.LIT_16_REF { return Err(_support::ParseError::conformance_error("schema.Ref")); } let _tmp1 = (); if _tmp0.fields().len() < 2 { return Err(_support::ParseError::conformance_error("schema.Ref")); } - let _tmp2 = ModulePath::try_from((&_tmp0.fields()[0]))?; + let _tmp2 = ModulePath::parse(_ctxt, (&_tmp0.fields()[0]))?; let _tmp3 = (&_tmp0.fields()[1]).value().to_symbol()?; Ok(Ref {module: _tmp2, name: _tmp3.clone()}) } } -impl std::convert::From<&Ref> for _Any { - fn from(value: &Ref) -> Self { - let Ref {module: _tmp0, name: _tmp1} = value; +impl Ref { + pub fn unparse<_Any: preserves::value::NestedValue>(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any { + let Ref {module: _tmp0, name: _tmp1} = self; { - let mut _tmp2 = preserves::value::Record(vec![(&*_any_::LIT_16_REF).clone()]); - _tmp2.fields_vec_mut().push(_Any::from(_tmp0)); + let mut _tmp2 = preserves::value::Record(vec![(&_ctxt.LIT_16_REF).clone()]); + _tmp2.fields_vec_mut().push(_tmp0.unparse(_ctxt)); _tmp2.fields_vec_mut().push(preserves::value::Value::symbol(_tmp1).wrap()); _tmp2.finish().wrap() } } } -impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Schema { +#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] +pub struct Schema<_Any: preserves::value::NestedValue = preserves::value::IOValue> { + pub definitions: Definitions<_Any>, + pub embedded_type: EmbeddedTypeName, + pub version: Version +} + +impl<_Any: preserves::value::NestedValue> preserves::value::Domain for Schema<_Any> {} + +impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Schema<_Any> { fn deserialize(r: &mut R) -> std::result::Result { r.open_record(None)?; let mut _tmp0 = _support::B::Type::default(); @@ -1320,35 +1281,34 @@ impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> fo } } -impl std::convert::TryFrom<&_Any> for Schema { - type Error = _support::ParseError; - fn try_from(value: &_Any) -> std::result::Result { +impl<_Any: preserves::value::NestedValue> Schema<_Any> { + pub fn parse(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result { let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*_any_::LIT_17_SCHEMA { return Err(_support::ParseError::conformance_error("schema.Schema")); } + if _tmp0.label() != &_ctxt.LIT_17_SCHEMA { return Err(_support::ParseError::conformance_error("schema.Schema")); } let _tmp1 = (); if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.Schema")); } let _tmp2 = (&_tmp0.fields()[0]).value().to_dictionary()?; - let _tmp3 = _tmp2.get(&*_any_::LIT_18_DEFINITIONS).ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?; - let _tmp4 = Definitions::try_from(_tmp3)?; - let _tmp5 = _tmp2.get(&*_any_::LIT_19_EMBEDDED_TYPE).ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?; - let _tmp6 = EmbeddedTypeName::try_from(_tmp5)?; - let _tmp7 = _tmp2.get(&*_any_::LIT_20_VERSION).ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?; - let _tmp8 = Version::try_from(_tmp7)?; + let _tmp3 = _tmp2.get(&_ctxt.LIT_18_DEFINITIONS).ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?; + let _tmp4 = Definitions::parse(_ctxt, _tmp3)?; + let _tmp5 = _tmp2.get(&_ctxt.LIT_19_EMBEDDED_TYPE).ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?; + let _tmp6 = EmbeddedTypeName::parse(_ctxt, _tmp5)?; + let _tmp7 = _tmp2.get(&_ctxt.LIT_20_VERSION).ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?; + let _tmp8 = Version::parse(_ctxt, _tmp7)?; Ok(Schema {definitions: _tmp4, embedded_type: _tmp6, version: _tmp8}) } } -impl std::convert::From<&Schema> for _Any { - fn from(value: &Schema) -> Self { - let Schema {definitions: _tmp0, embedded_type: _tmp1, version: _tmp2} = value; +impl<_Any: preserves::value::NestedValue> Schema<_Any> { + pub fn unparse(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any { + let Schema {definitions: _tmp0, embedded_type: _tmp1, version: _tmp2} = self; { - let mut _tmp3 = preserves::value::Record(vec![(&*_any_::LIT_17_SCHEMA).clone()]); + let mut _tmp3 = preserves::value::Record(vec![(&_ctxt.LIT_17_SCHEMA).clone()]); _tmp3.fields_vec_mut().push( { let mut _tmp4 = preserves::value::Map::new(); - _tmp4.insert((&*_any_::LIT_18_DEFINITIONS).clone(), _Any::from(_tmp0)); - _tmp4.insert((&*_any_::LIT_19_EMBEDDED_TYPE).clone(), _Any::from(_tmp1)); - _tmp4.insert((&*_any_::LIT_20_VERSION).clone(), _Any::from(_tmp2)); + _tmp4.insert((&_ctxt.LIT_18_DEFINITIONS).clone(), _tmp0.unparse(_ctxt)); + _tmp4.insert((&_ctxt.LIT_19_EMBEDDED_TYPE).clone(), _tmp1.unparse(_ctxt)); + _tmp4.insert((&_ctxt.LIT_20_VERSION).clone(), _tmp2.unparse(_ctxt)); preserves::value::Value::Dictionary(_tmp4).wrap() } ); @@ -1357,7 +1317,34 @@ impl std::convert::From<&Schema> for _Any { } } -fn read_simple_pattern_any<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { +#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] +pub enum SimplePattern<_Any: preserves::value::NestedValue = preserves::value::IOValue> { + Any, + Atom { + atom_kind: std::boxed::Box + }, + Embedded { + interface: std::boxed::Box> + }, + Lit { + value: _Any + }, + Seqof { + pattern: std::boxed::Box> + }, + Setof { + pattern: std::boxed::Box> + }, + Dictof { + key: std::boxed::Box>, + value: std::boxed::Box> + }, + Ref(std::boxed::Box) +} + +impl<_Any: preserves::value::NestedValue> preserves::value::Domain for SimplePattern<_Any> {} + +fn read_simple_pattern_any<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result, _support::ParseError> { match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "any" => {} @@ -1369,7 +1356,7 @@ fn read_simple_pattern_any<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> st Ok(SimplePattern::Any) } -fn read_simple_pattern_atom<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { +fn read_simple_pattern_atom<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result, _support::ParseError> { r.open_record(None)?; let mut _tmp0 = _support::B::Type::default(); _tmp0.shift(Some(_support::B::Item::RecordLabel)); @@ -1389,7 +1376,7 @@ fn read_simple_pattern_atom<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> s Ok(SimplePattern::Atom {atom_kind: std::boxed::Box::new(_tmp2)}) } -fn read_simple_pattern_embedded<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { +fn read_simple_pattern_embedded<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result, _support::ParseError> { r.open_record(None)?; let mut _tmp0 = _support::B::Type::default(); _tmp0.shift(Some(_support::B::Item::RecordLabel)); @@ -1409,7 +1396,7 @@ fn read_simple_pattern_embedded<'de, R: _support::Reader<'de, _Any>>(r: &mut R) Ok(SimplePattern::Embedded {interface: std::boxed::Box::new(_tmp2)}) } -fn read_simple_pattern_lit<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { +fn read_simple_pattern_lit<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result, _support::ParseError> { r.open_record(None)?; let mut _tmp0 = _support::B::Type::default(); _tmp0.shift(Some(_support::B::Item::RecordLabel)); @@ -1429,7 +1416,7 @@ fn read_simple_pattern_lit<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> st Ok(SimplePattern::Lit {value: _tmp2}) } -fn read_simple_pattern_seqof<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { +fn read_simple_pattern_seqof<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result, _support::ParseError> { r.open_record(None)?; let mut _tmp0 = _support::B::Type::default(); _tmp0.shift(Some(_support::B::Item::RecordLabel)); @@ -1449,7 +1436,7 @@ fn read_simple_pattern_seqof<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> Ok(SimplePattern::Seqof {pattern: std::boxed::Box::new(_tmp2)}) } -fn read_simple_pattern_setof<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { +fn read_simple_pattern_setof<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result, _support::ParseError> { r.open_record(None)?; let mut _tmp0 = _support::B::Type::default(); _tmp0.shift(Some(_support::B::Item::RecordLabel)); @@ -1469,7 +1456,7 @@ fn read_simple_pattern_setof<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> Ok(SimplePattern::Setof {pattern: std::boxed::Box::new(_tmp2)}) } -fn read_simple_pattern_dictof<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { +fn read_simple_pattern_dictof<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result, _support::ParseError> { r.open_record(None)?; let mut _tmp0 = _support::B::Type::default(); _tmp0.shift(Some(_support::B::Item::RecordLabel)); @@ -1492,12 +1479,12 @@ fn read_simple_pattern_dictof<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> Ok(SimplePattern::Dictof {key: std::boxed::Box::new(_tmp2), value: std::boxed::Box::new(_tmp3)}) } -fn read_simple_pattern_ref<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { +fn read_simple_pattern_ref<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result, _support::ParseError> { let _tmp0 = Ref::deserialize(r)?; Ok(SimplePattern::Ref(std::boxed::Box::new(_tmp0))) } -impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for SimplePattern { +impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for SimplePattern<_Any> { fn deserialize(r: &mut R) -> std::result::Result { let _mark = r.mark()?; match read_simple_pattern_any(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result } @@ -1512,128 +1499,132 @@ impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> fo } } -fn _any_parse_simple_pattern_any(value: &_Any) -> std::result::Result { - if value != &*_any_::LIT_21_ANY { return Err(_support::ParseError::conformance_error("schema.SimplePattern::any")); } +fn parse_simple_pattern_any<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result, _support::ParseError> { + if value != &_ctxt.LIT_21_ANY { return Err(_support::ParseError::conformance_error("schema.SimplePattern::any")); } let _tmp0 = (); Ok(SimplePattern::Any) } -fn _any_parse_simple_pattern_atom(value: &_Any) -> std::result::Result { +fn parse_simple_pattern_atom<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result, _support::ParseError> { let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*_any_::LIT_22_ATOM { return Err(_support::ParseError::conformance_error("schema.SimplePattern::atom")); } + if _tmp0.label() != &_ctxt.LIT_22_ATOM { return Err(_support::ParseError::conformance_error("schema.SimplePattern::atom")); } let _tmp1 = (); if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.SimplePattern::atom")); } - let _tmp2 = AtomKind::try_from((&_tmp0.fields()[0]))?; + let _tmp2 = AtomKind::parse(_ctxt, (&_tmp0.fields()[0]))?; Ok(SimplePattern::Atom {atom_kind: std::boxed::Box::new(_tmp2)}) } -fn _any_parse_simple_pattern_embedded(value: &_Any) -> std::result::Result { +fn parse_simple_pattern_embedded<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result, _support::ParseError> { let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*_any_::LIT_23_EMBEDDED { return Err(_support::ParseError::conformance_error("schema.SimplePattern::embedded")); } + if _tmp0.label() != &_ctxt.LIT_23_EMBEDDED { return Err(_support::ParseError::conformance_error("schema.SimplePattern::embedded")); } let _tmp1 = (); if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.SimplePattern::embedded")); } - let _tmp2 = SimplePattern::try_from((&_tmp0.fields()[0]))?; + let _tmp2 = SimplePattern::parse(_ctxt, (&_tmp0.fields()[0]))?; Ok(SimplePattern::Embedded {interface: std::boxed::Box::new(_tmp2)}) } -fn _any_parse_simple_pattern_lit(value: &_Any) -> std::result::Result { +fn parse_simple_pattern_lit<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result, _support::ParseError> { let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*_any_::LIT_24_LIT { return Err(_support::ParseError::conformance_error("schema.SimplePattern::lit")); } + if _tmp0.label() != &_ctxt.LIT_24_LIT { return Err(_support::ParseError::conformance_error("schema.SimplePattern::lit")); } let _tmp1 = (); if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.SimplePattern::lit")); } let _tmp2 = (&_tmp0.fields()[0]); Ok(SimplePattern::Lit {value: _tmp2.clone()}) } -fn _any_parse_simple_pattern_seqof(value: &_Any) -> std::result::Result { +fn parse_simple_pattern_seqof<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result, _support::ParseError> { let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*_any_::LIT_25_SEQOF { return Err(_support::ParseError::conformance_error("schema.SimplePattern::seqof")); } + if _tmp0.label() != &_ctxt.LIT_25_SEQOF { return Err(_support::ParseError::conformance_error("schema.SimplePattern::seqof")); } let _tmp1 = (); if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.SimplePattern::seqof")); } - let _tmp2 = SimplePattern::try_from((&_tmp0.fields()[0]))?; + let _tmp2 = SimplePattern::parse(_ctxt, (&_tmp0.fields()[0]))?; Ok(SimplePattern::Seqof {pattern: std::boxed::Box::new(_tmp2)}) } -fn _any_parse_simple_pattern_setof(value: &_Any) -> std::result::Result { +fn parse_simple_pattern_setof<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result, _support::ParseError> { let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*_any_::LIT_26_SETOF { return Err(_support::ParseError::conformance_error("schema.SimplePattern::setof")); } + if _tmp0.label() != &_ctxt.LIT_26_SETOF { return Err(_support::ParseError::conformance_error("schema.SimplePattern::setof")); } let _tmp1 = (); if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.SimplePattern::setof")); } - let _tmp2 = SimplePattern::try_from((&_tmp0.fields()[0]))?; + let _tmp2 = SimplePattern::parse(_ctxt, (&_tmp0.fields()[0]))?; Ok(SimplePattern::Setof {pattern: std::boxed::Box::new(_tmp2)}) } -fn _any_parse_simple_pattern_dictof(value: &_Any) -> std::result::Result { +fn parse_simple_pattern_dictof<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result, _support::ParseError> { let _tmp0 = value.value().to_record(None)?; - if _tmp0.label() != &*_any_::LIT_27_DICTOF { return Err(_support::ParseError::conformance_error("schema.SimplePattern::dictof")); } + if _tmp0.label() != &_ctxt.LIT_27_DICTOF { return Err(_support::ParseError::conformance_error("schema.SimplePattern::dictof")); } let _tmp1 = (); if _tmp0.fields().len() < 2 { return Err(_support::ParseError::conformance_error("schema.SimplePattern::dictof")); } - let _tmp2 = SimplePattern::try_from((&_tmp0.fields()[0]))?; - let _tmp3 = SimplePattern::try_from((&_tmp0.fields()[1]))?; + let _tmp2 = SimplePattern::parse(_ctxt, (&_tmp0.fields()[0]))?; + let _tmp3 = SimplePattern::parse(_ctxt, (&_tmp0.fields()[1]))?; Ok(SimplePattern::Dictof {key: std::boxed::Box::new(_tmp2), value: std::boxed::Box::new(_tmp3)}) } -fn _any_parse_simple_pattern_ref(value: &_Any) -> std::result::Result { - let _tmp0 = Ref::try_from(value)?; +fn parse_simple_pattern_ref<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result, _support::ParseError> { + let _tmp0 = Ref::parse(_ctxt, value)?; Ok(SimplePattern::Ref(std::boxed::Box::new(_tmp0))) } -impl std::convert::TryFrom<&_Any> for SimplePattern { - type Error = _support::ParseError; - fn try_from(value: &_Any) -> std::result::Result { - if let Ok(r) = _any_parse_simple_pattern_any(value) { return Ok(r); } - if let Ok(r) = _any_parse_simple_pattern_atom(value) { return Ok(r); } - if let Ok(r) = _any_parse_simple_pattern_embedded(value) { return Ok(r); } - if let Ok(r) = _any_parse_simple_pattern_lit(value) { return Ok(r); } - if let Ok(r) = _any_parse_simple_pattern_seqof(value) { return Ok(r); } - if let Ok(r) = _any_parse_simple_pattern_setof(value) { return Ok(r); } - if let Ok(r) = _any_parse_simple_pattern_dictof(value) { return Ok(r); } - if let Ok(r) = _any_parse_simple_pattern_ref(value) { return Ok(r); } +impl<_Any: preserves::value::NestedValue> SimplePattern<_Any> { + pub fn parse(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result { + if let Ok(r) = parse_simple_pattern_any(_ctxt, value) { return Ok(r); } + if let Ok(r) = parse_simple_pattern_atom(_ctxt, value) { return Ok(r); } + if let Ok(r) = parse_simple_pattern_embedded(_ctxt, value) { return Ok(r); } + if let Ok(r) = parse_simple_pattern_lit(_ctxt, value) { return Ok(r); } + if let Ok(r) = parse_simple_pattern_seqof(_ctxt, value) { return Ok(r); } + if let Ok(r) = parse_simple_pattern_setof(_ctxt, value) { return Ok(r); } + if let Ok(r) = parse_simple_pattern_dictof(_ctxt, value) { return Ok(r); } + if let Ok(r) = parse_simple_pattern_ref(_ctxt, value) { return Ok(r); } Err(_support::ParseError::conformance_error("schema.SimplePattern")) } } -impl std::convert::From<&SimplePattern> for _Any { - fn from(value: &SimplePattern) -> Self { - match value { - SimplePattern::Any => (&*_any_::LIT_21_ANY).clone(), +impl<_Any: preserves::value::NestedValue> SimplePattern<_Any> { + pub fn unparse(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any { + match self { + SimplePattern::Any => (&_ctxt.LIT_21_ANY).clone(), SimplePattern::Atom {atom_kind: _tmp0} => { - let mut _tmp1 = preserves::value::Record(vec![(&*_any_::LIT_22_ATOM).clone()]); - _tmp1.fields_vec_mut().push(_Any::from(_tmp0.as_ref())); + let mut _tmp1 = preserves::value::Record(vec![(&_ctxt.LIT_22_ATOM).clone()]); + _tmp1.fields_vec_mut().push(_tmp0.as_ref().unparse(_ctxt)); _tmp1.finish().wrap() }, SimplePattern::Embedded {interface: _tmp0} => { - let mut _tmp1 = preserves::value::Record(vec![(&*_any_::LIT_23_EMBEDDED).clone()]); - _tmp1.fields_vec_mut().push(_Any::from(_tmp0.as_ref())); + let mut _tmp1 = preserves::value::Record(vec![(&_ctxt.LIT_23_EMBEDDED).clone()]); + _tmp1.fields_vec_mut().push(_tmp0.as_ref().unparse(_ctxt)); _tmp1.finish().wrap() }, SimplePattern::Lit {value: _tmp0} => { - let mut _tmp1 = preserves::value::Record(vec![(&*_any_::LIT_24_LIT).clone()]); + let mut _tmp1 = preserves::value::Record(vec![(&_ctxt.LIT_24_LIT).clone()]); _tmp1.fields_vec_mut().push(_tmp0.clone()); _tmp1.finish().wrap() }, SimplePattern::Seqof {pattern: _tmp0} => { - let mut _tmp1 = preserves::value::Record(vec![(&*_any_::LIT_25_SEQOF).clone()]); - _tmp1.fields_vec_mut().push(_Any::from(_tmp0.as_ref())); + let mut _tmp1 = preserves::value::Record(vec![(&_ctxt.LIT_25_SEQOF).clone()]); + _tmp1.fields_vec_mut().push(_tmp0.as_ref().unparse(_ctxt)); _tmp1.finish().wrap() }, SimplePattern::Setof {pattern: _tmp0} => { - let mut _tmp1 = preserves::value::Record(vec![(&*_any_::LIT_26_SETOF).clone()]); - _tmp1.fields_vec_mut().push(_Any::from(_tmp0.as_ref())); + let mut _tmp1 = preserves::value::Record(vec![(&_ctxt.LIT_26_SETOF).clone()]); + _tmp1.fields_vec_mut().push(_tmp0.as_ref().unparse(_ctxt)); _tmp1.finish().wrap() }, SimplePattern::Dictof {key: _tmp0, value: _tmp1} => { - let mut _tmp2 = preserves::value::Record(vec![(&*_any_::LIT_27_DICTOF).clone()]); - _tmp2.fields_vec_mut().push(_Any::from(_tmp0.as_ref())); - _tmp2.fields_vec_mut().push(_Any::from(_tmp1.as_ref())); + let mut _tmp2 = preserves::value::Record(vec![(&_ctxt.LIT_27_DICTOF).clone()]); + _tmp2.fields_vec_mut().push(_tmp0.as_ref().unparse(_ctxt)); + _tmp2.fields_vec_mut().push(_tmp1.as_ref().unparse(_ctxt)); _tmp2.finish().wrap() }, - SimplePattern::Ref(_tmp0) => _Any::from(_tmp0.as_ref()), + SimplePattern::Ref(_tmp0) => _tmp0.as_ref().unparse(_ctxt), } } } -impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Version { +#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] +pub struct Version; + +impl preserves::value::Domain for Version {} + +impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Version { fn deserialize(r: &mut R) -> std::result::Result { match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { @@ -1647,15 +1638,14 @@ impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> fo } } -impl std::convert::TryFrom<&_Any> for Version { - type Error = _support::ParseError; - fn try_from(value: &_Any) -> std::result::Result { - if value != &*_any_::LIT_28_1 { return Err(_support::ParseError::conformance_error("schema.Version")); } +impl Version { + pub fn parse<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result { + if value != &_ctxt.LIT_28_1 { return Err(_support::ParseError::conformance_error("schema.Version")); } let _tmp0 = (); Ok(Version) } } -impl std::convert::From<&Version> for _Any { - fn from(value: &Version) -> Self {let Version = value; (&*_any_::LIT_28_1).clone()} +impl Version { + pub fn unparse<_Any: preserves::value::NestedValue>(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any {let Version = self; (&_ctxt.LIT_28_1).clone()} } diff --git a/implementations/rust/preserves-schema/src/lib.rs b/implementations/rust/preserves-schema/src/lib.rs index 6519734..0101030 100644 --- a/implementations/rust/preserves-schema/src/lib.rs +++ b/implementations/rust/preserves-schema/src/lib.rs @@ -31,17 +31,16 @@ mod tests { #[test] fn metaschema_parsing() -> Result<(), std::io::Error> { - use preserves::value::{BinarySource, IOBinarySource, IOValue, Reader}; - use std::convert::TryFrom; - use std::convert::From; + use preserves::value::{BinarySource, IOBinarySource, Reader}; use crate::gen::schema::*; let mut f = std::fs::File::open("../../../schema/schema.bin")?; let mut src = IOBinarySource::new(&mut f); let mut reader = src.packed_iovalues(); let schema = reader.demand_next(false)?; - let parsed = Schema::try_from(&schema).expect("successful parse"); - assert_eq!(schema, IOValue::from(&parsed)); + let literals = crate::gen::Literals::default(); + let parsed = Schema::parse(&literals, &schema).expect("successful parse"); + assert_eq!(schema, parsed.unparse(&literals)); Ok(()) } } diff --git a/implementations/rust/preserves-schema/src/support/mod.rs b/implementations/rust/preserves-schema/src/support/mod.rs index 21fd398..6e406d1 100644 --- a/implementations/rust/preserves-schema/src/support/mod.rs +++ b/implementations/rust/preserves-schema/src/support/mod.rs @@ -14,10 +14,25 @@ use preserves::value::Value; use std::convert::From; use std::convert::TryFrom; use std::io; +use std::marker::PhantomData; use std::sync::Arc; use thiserror::Error; +pub struct Codec { + pub literals: L, + phantom: PhantomData, +} + +impl Codec { + pub fn new() -> Self { + Codec { + literals: L::default(), + phantom: PhantomData, + } + } +} + pub trait Deserialize<'de, N: NestedValue, R: Reader<'de, N>> where Self: Sized diff --git a/implementations/rust/preserves-schema/src/syntax/block.rs b/implementations/rust/preserves-schema/src/syntax/block.rs index f5f58a0..580f90b 100644 --- a/implementations/rust/preserves-schema/src/syntax/block.rs +++ b/implementations/rust/preserves-schema/src/syntax/block.rs @@ -7,11 +7,24 @@ pub trait Emittable: std::fmt::Debug { fn write_on(&self, f: &mut Formatter); } +#[derive(Clone, PartialEq, Eq)] +pub enum VerticalMode { + Variable, + Normal, + ExtraNewline, +} + +pub trait Vertical { + fn set_vertical_mode(&mut self, mode: VerticalMode); + fn write_vertically_on(&self, f: &mut Formatter); +} + pub type Item = std::rc::Rc; #[derive(Clone)] pub struct Sequence { pub items: Vec, + pub vertical_mode: VerticalMode, pub separator: &'static str, pub terminator: &'static str, } @@ -80,6 +93,12 @@ impl Formatter { } } +impl Default for VerticalMode { + fn default() -> Self { + Self::Variable + } +} + //--------------------------------------------------------------------------- impl Emittable for &str { @@ -104,48 +123,86 @@ impl<'a, E: Emittable> Emittable for &'a Vec where &'a E: Emittable { impl Emittable for Sequence { fn write_on(&self, f: &mut Formatter) { - let mut need_sep = false; - for e in self.items.iter() { - if need_sep { - self.separator.write_on(f) - } else { - need_sep = true + if self.vertical_mode != VerticalMode::Variable { + self.write_vertically_on(f) + } else { + let mut need_sep = false; + for e in self.items.iter() { + if need_sep { + self.separator.write_on(f) + } else { + need_sep = true + } + e.write_on(f) + } + if !self.items.is_empty() { + self.terminator.write_on(f) } - e.write_on(f) } - self.terminator.write_on(f) + } +} + +impl Vertical for Sequence { + fn set_vertical_mode(&mut self, vertical_mode: VerticalMode) { + self.vertical_mode = vertical_mode; + } + + fn write_vertically_on(&self, f: &mut Formatter) { + let mut i = self.items.len(); + let mut first = true; + for e in self.items.iter() { + if !first { + if self.vertical_mode == VerticalMode::ExtraNewline { + f.write("\n"); + } + f.newline(); + } + first = false; + e.write_on(f); + let delim = if i == 1 { self.terminator } else { self.separator }; + delim.trim_end_matches(|c: char| c.is_whitespace() && c != '\n').write_on(f); + i = i - 1; + } } } impl Emittable for Grouping { fn write_on(&self, f: &mut Formatter) { - let mut g = f.copy_empty(); - self.open.write_on(&mut g); - g.write(&self.sequence); - self.close.write_on(&mut g); - let s = g.buffer; - if s.len() <= f.width { - f.write(&s) + if self.sequence.vertical_mode != VerticalMode::Variable { + self.write_vertically_on(f) } else { - self.open.write_on(f); - if !self.sequence.items.is_empty() { - f.with_indent(|f| { - let mut i = self.sequence.items.len(); - for e in self.sequence.items.iter() { - f.newline(); - e.write_on(f); - let delim = if i == 1 { self.sequence.terminator } else { self.sequence.separator }; - delim.trim_end().write_on(f); - i = i - 1; - } - }); - f.newline() + let mut g = f.copy_empty(); + self.open.write_on(&mut g); + g.write(&self.sequence); + self.close.write_on(&mut g); + let s = g.buffer; + if s.len() <= f.width { + f.write(&s) + } else { + self.write_vertically_on(f) } - self.close.write_on(f); } } } +impl Vertical for Grouping { + fn set_vertical_mode(&mut self, vertical_mode: VerticalMode) { + self.sequence.set_vertical_mode(vertical_mode); + } + + fn write_vertically_on(&self, f: &mut Formatter) { + self.open.write_on(f); + if !self.sequence.items.is_empty() { + f.with_indent(|f| { + f.newline(); + self.sequence.write_vertically_on(f) + }); + f.newline() + } + self.close.write_on(f); + } +} + impl<'a, E: Emittable> Emittable for &'a E { fn write_on(&self, f: &mut Formatter) { (*self).write_on(f) @@ -210,21 +267,23 @@ pub mod constructors { use super::Grouping; use super::Item; use super::Emittable; + use super::VerticalMode; + use super::Vertical; pub fn item(i: E) -> Item { std::rc::Rc::new(i) } pub fn name(pieces: Vec) -> Sequence { - Sequence { items: pieces, separator: "::", terminator: "" } + Sequence { items: pieces, vertical_mode: VerticalMode::default(), separator: "::", terminator: "" } } pub fn seq(items: Vec) -> Sequence { - Sequence { items: items, separator: "", terminator: "" } + Sequence { items: items, vertical_mode: VerticalMode::default(), separator: "", terminator: "" } } pub fn commas(items: Vec) -> Sequence { - Sequence { items: items, separator: ", ", terminator: "" } + Sequence { items: items, vertical_mode: VerticalMode::default(), separator: ", ", terminator: "" } } pub fn parens(items: Vec) -> Grouping { @@ -245,19 +304,38 @@ pub mod constructors { pub fn block(items: Vec) -> Grouping { Grouping { - sequence: Sequence { items: items, separator: " ", terminator: "" }, + sequence: Sequence { + items: items, + vertical_mode: VerticalMode::default(), + separator: " ", + terminator: "", + }, open: "{", close: "}", } } + pub fn codeblock(items: Vec) -> Grouping { + vertical(false, block(items)) + } + pub fn semiblock(items: Vec) -> Grouping { Grouping { - sequence: Sequence { items: items, separator: "; ", terminator: "" }, + sequence: Sequence { + items: items, + vertical_mode: VerticalMode::default(), + separator: "; ", + terminator: "", + }, open: "{", close: "}", } } + + pub fn vertical(spaced: bool, mut v: V) -> V { + v.set_vertical_mode(if spaced { VerticalMode::ExtraNewline } else { VerticalMode::Normal }); + v + } } pub mod macros { @@ -301,6 +379,11 @@ pub mod macros { ($($item:expr),*) => {crate::syntax::block::constructors::block(vec![$(std::rc::Rc::new($item)),*])} } + #[macro_export] + macro_rules! codeblock { + ($($item:expr),*) => {crate::syntax::block::constructors::codeblock(vec![$(std::rc::Rc::new($item)),*])} + } + #[macro_export] macro_rules! semiblock { ($($item:expr),*) => {crate::syntax::block::constructors::semiblock(vec![$(std::rc::Rc::new($item)),*])}