From 31561806019943c3a1690c5c7a2b7f5811722d96 Mon Sep 17 00:00:00 2001 From: Tony Garnock-Jones Date: Wed, 30 Jun 2021 09:53:32 +0200 Subject: [PATCH] IOValue -> _Any = ArcValue<_Ptr> --- .../preserves-schema/src/compiler/context.rs | 8 +- .../rust/preserves-schema/src/compiler/mod.rs | 12 +- .../preserves-schema/src/compiler/parsers.rs | 10 +- .../preserves-schema/src/compiler/types.rs | 4 +- .../src/compiler/unparsers.rs | 4 +- .../rust/preserves-schema/src/gen/schema.rs | 443 +++++++++--------- .../rust/preserves-schema/src/lib.rs | 9 +- 7 files changed, 257 insertions(+), 233 deletions(-) diff --git a/implementations/rust/preserves-schema/src/compiler/context.rs b/implementations/rust/preserves-schema/src/compiler/context.rs index 673fd9d..cbf0d2d 100644 --- a/implementations/rust/preserves-schema/src/compiler/context.rs +++ b/implementations/rust/preserves-schema/src/compiler/context.rs @@ -1,16 +1,16 @@ -use preserves::value::{Map, IOValue}; - use crate::*; use crate::syntax::block::Item; use crate::syntax::block::constructors::*; use crate::gen::schema::*; +use preserves::value::Map; + use super::CompilerConfig; use super::types; pub struct ModuleContext<'m> { pub config: &'m CompilerConfig, - pub literals: Map, + pub literals: Map<_Any, String>, pub typedefs: Vec, pub functiondefs: Vec, } @@ -37,7 +37,7 @@ impl<'m> ModuleContext<'m> { } } - pub fn define_literal(&mut self, v: &IOValue) -> String { + pub fn define_literal(&mut self, v: &_Any) -> String { let next_id = format!("LIT{}", self.literals.len()); "&*".to_owned() + self.literals.entry(v.clone()).or_insert(next_id) } diff --git a/implementations/rust/preserves-schema/src/compiler/mod.rs b/implementations/rust/preserves-schema/src/compiler/mod.rs index 8655828..ab4d8a3 100644 --- a/implementations/rust/preserves-schema/src/compiler/mod.rs +++ b/implementations/rust/preserves-schema/src/compiler/mod.rs @@ -12,6 +12,7 @@ use crate::syntax::block::constructors::*; use glob::glob; use preserves::value::Map; +use preserves::value::NestedValue; use preserves::value::PackedReader; use preserves::value::Reader; use preserves::value::Set; @@ -55,9 +56,9 @@ impl CompilerConfig { for i in inputs { let mut f = File::open(&i)?; let mut reader = PackedReader::decode_read(&mut f); - let blob = reader.demand_next(false)?; + let blob = _Any::from_io_value(&reader.demand_next(false)?)?; - if let Ok(s) = Schema::try_from(&blob) { + if let Ok(s) = Schema::try_from(blob.clone()) { let prefix = i.file_stem().ok_or_else( || Error::new(ErrorKind::InvalidData, format!("Bad schema file stem: {:?}", i)))? .to_str().ok_or_else( @@ -66,7 +67,7 @@ impl CompilerConfig { return Ok(()); } - if let Ok(Bundle { modules }) = Bundle::try_from(&blob) { + if let Ok(Bundle { modules }) = Bundle::try_from(blob) { for (ModulePath(k), v) in modules.0 { self.bundle.insert(k, v); } @@ -103,6 +104,7 @@ pub fn compile(config: &CompilerConfig) -> Result<(), std::io::Error> { EmbeddedTypeName::False => item("preserves::value::IOValue".to_owned()), EmbeddedTypeName::Ref(r) => m.render_ref(&**r), }, ";"])); + m.define_type(item(seq!["pub type _Any = preserves::value::ArcValue<_Ptr>;"])); for (n, d) in &v.definitions.0 { m.define_type(item(types::render_definition_type(&m, n, &types::definition_type(d)))); @@ -123,8 +125,8 @@ pub fn compile(config: &CompilerConfig) -> Result<(), std::io::Error> { lines.push("lazy_static! {".to_owned()); for (value, name) in m.literals { - let bs = preserves::value::PackedWriter::encode(&value).unwrap(); - lines.push(format!(" pub static ref {}: preserves::value::IOValue = /* {:?} */ preserves::value::packed::from_bytes(&vec!{:?}).unwrap();", + let bs = preserves::value::PackedWriter::encode(&value.to_io_value()).unwrap(); + lines.push(format!(" pub static ref {}: _Any = /* {:?} */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec!{:?}).unwrap()).unwrap();", name, value, bs)); diff --git a/implementations/rust/preserves-schema/src/compiler/parsers.rs b/implementations/rust/preserves-schema/src/compiler/parsers.rs index 2f81299..f61fe89 100644 --- a/implementations/rust/preserves-schema/src/compiler/parsers.rs +++ b/implementations/rust/preserves-schema/src/compiler/parsers.rs @@ -11,7 +11,7 @@ use super::types::*; pub fn gen_definition_parser(m: &mut ModuleContext, n: &str, d: &Definition) { m.define_function( |mut ctxt| { - let mut body = Vec::new(); + let mut body = vec![item("let value = &value;")]; match d { Definition::Or { pattern_0, pattern_1, pattern_n } => { @@ -26,7 +26,7 @@ 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: &preserves::value::IOValue) -> ", + item(seq!["fn ", fname.clone(), "(value: &_Any) -> ", "std::result::Result<", names::render_constructor(n), ", ()> ", block(body)]) }); @@ -49,10 +49,10 @@ pub fn gen_definition_parser(m: &mut ModuleContext, n: &str, d: &Definition) { } } - item(seq!["impl std::convert::TryFrom", anglebrackets!["&preserves::value::IOValue"], " for ", + item(seq!["impl std::convert::TryFrom", anglebrackets!["_Any"], " for ", names::render_constructor(n), " ", block![ seq!["type Error = ();"], - seq!["fn try_from(value: &preserves::value::IOValue) -> ", + seq!["fn try_from(value: _Any) -> ", "std::result::Result ", block(body)]]]) }); @@ -176,7 +176,7 @@ fn simple_pattern_parser( let tf = name![ctxt.m.render_ref(&**r), "try_from"]; push_let(body, item(dest.to_owned()), - item(seq![tf, parens![src.to_owned()], "?"])); + item(seq![tf, parens![seq![src.to_owned(), ".clone()"]], "?"])); dest }, } diff --git a/implementations/rust/preserves-schema/src/compiler/types.rs b/implementations/rust/preserves-schema/src/compiler/types.rs index 5e0d32f..bc774bd 100644 --- a/implementations/rust/preserves-schema/src/compiler/types.rs +++ b/implementations/rust/preserves-schema/src/compiler/types.rs @@ -129,7 +129,7 @@ pub fn promote(p: &NamedSimplePattern) -> NamedPattern { pub fn field_type(p: &SimplePattern) -> TField { match p { - SimplePattern::Any => TField::Base("preserves::value::IOValue".to_owned()), + SimplePattern::Any => TField::Base("_Any".to_owned()), SimplePattern::Atom { atom_kind: k } => match **k { AtomKind::Boolean => TField::Base("bool".to_owned()), @@ -195,7 +195,7 @@ pub fn render_definition_type( n: &str, t: &TDefinition, ) -> impl Emittable { - seq!["#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone)]\n", + seq!["#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]\n", match t { TDefinition::Union(items) => seq!["pub enum ", names::render_constructor(n), " ", braces( diff --git a/implementations/rust/preserves-schema/src/compiler/unparsers.rs b/implementations/rust/preserves-schema/src/compiler/unparsers.rs index 1566c97..f2839d1 100644 --- a/implementations/rust/preserves-schema/src/compiler/unparsers.rs +++ b/implementations/rust/preserves-schema/src/compiler/unparsers.rs @@ -82,7 +82,7 @@ pub fn gen_definition_unparser(m: &mut ModuleContext, n: &str, d: &Definition) { } item(seq!["impl std::convert::From", anglebrackets![seq!["&", names::render_constructor(n)]], - " for preserves::value::IOValue ", block![ + " for _Any ", block![ seq!["fn from(value: &", names::render_constructor(n), ") -> Self ", block(body)]]]) }); @@ -166,7 +166,7 @@ fn simple_pattern_unparser( ").collect()).wrap()"]) } SimplePattern::Ref(_r) => - item(seq!["preserves::value::IOValue::from(", src.as_ref().unwrap().to_owned(), + item(seq!["_Any::from(", src.as_ref().unwrap().to_owned(), if vc.is_struct { "" } else { ".as_ref()" }, ")"]), } diff --git a/implementations/rust/preserves-schema/src/gen/schema.rs b/implementations/rust/preserves-schema/src/gen/schema.rs index ea894ed..c41ae09 100644 --- a/implementations/rust/preserves-schema/src/gen/schema.rs +++ b/implementations/rust/preserves-schema/src/gen/schema.rs @@ -5,49 +5,51 @@ use preserves::value::NestedValue; use crate::support::*; lazy_static! { - pub static ref LIT15: preserves::value::IOValue = /* #f */ preserves::value::packed::from_bytes(&vec![128]).unwrap(); - pub static ref LIT28: preserves::value::IOValue = /* 1 */ preserves::value::packed::from_bytes(&vec![145]).unwrap(); - pub static ref LIT0: preserves::value::IOValue = /* Boolean */ preserves::value::packed::from_bytes(&vec![179, 7, 66, 111, 111, 108, 101, 97, 110]).unwrap(); - pub static ref LIT5: preserves::value::IOValue = /* ByteString */ preserves::value::packed::from_bytes(&vec![179, 10, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103]).unwrap(); - pub static ref LIT2: preserves::value::IOValue = /* Double */ preserves::value::packed::from_bytes(&vec![179, 6, 68, 111, 117, 98, 108, 101]).unwrap(); - pub static ref LIT1: preserves::value::IOValue = /* Float */ preserves::value::packed::from_bytes(&vec![179, 5, 70, 108, 111, 97, 116]).unwrap(); - pub static ref LIT3: preserves::value::IOValue = /* SignedInteger */ preserves::value::packed::from_bytes(&vec![179, 13, 83, 105, 103, 110, 101, 100, 73, 110, 116, 101, 103, 101, 114]).unwrap(); - pub static ref LIT4: preserves::value::IOValue = /* String */ preserves::value::packed::from_bytes(&vec![179, 6, 83, 116, 114, 105, 110, 103]).unwrap(); - pub static ref LIT6: preserves::value::IOValue = /* Symbol */ preserves::value::packed::from_bytes(&vec![179, 6, 83, 121, 109, 98, 111, 108]).unwrap(); - pub static ref LIT14: preserves::value::IOValue = /* and */ preserves::value::packed::from_bytes(&vec![179, 3, 97, 110, 100]).unwrap(); - pub static ref LIT21: preserves::value::IOValue = /* any */ preserves::value::packed::from_bytes(&vec![179, 3, 97, 110, 121]).unwrap(); - pub static ref LIT22: preserves::value::IOValue = /* atom */ preserves::value::packed::from_bytes(&vec![179, 4, 97, 116, 111, 109]).unwrap(); - pub static ref LIT8: preserves::value::IOValue = /* bundle */ preserves::value::packed::from_bytes(&vec![179, 6, 98, 117, 110, 100, 108, 101]).unwrap(); - pub static ref LIT18: preserves::value::IOValue = /* definitions */ preserves::value::packed::from_bytes(&vec![179, 11, 100, 101, 102, 105, 110, 105, 116, 105, 111, 110, 115]).unwrap(); - pub static ref LIT12: preserves::value::IOValue = /* dict */ preserves::value::packed::from_bytes(&vec![179, 4, 100, 105, 99, 116]).unwrap(); - pub static ref LIT27: preserves::value::IOValue = /* dictof */ preserves::value::packed::from_bytes(&vec![179, 6, 100, 105, 99, 116, 111, 102]).unwrap(); - pub static ref LIT23: preserves::value::IOValue = /* embedded */ preserves::value::packed::from_bytes(&vec![179, 8, 101, 109, 98, 101, 100, 100, 101, 100]).unwrap(); - pub static ref LIT19: preserves::value::IOValue = /* embeddedType */ preserves::value::packed::from_bytes(&vec![179, 12, 101, 109, 98, 101, 100, 100, 101, 100, 84, 121, 112, 101]).unwrap(); - pub static ref LIT24: preserves::value::IOValue = /* lit */ preserves::value::packed::from_bytes(&vec![179, 3, 108, 105, 116]).unwrap(); - pub static ref LIT7: preserves::value::IOValue = /* named */ preserves::value::packed::from_bytes(&vec![179, 5, 110, 97, 109, 101, 100]).unwrap(); - pub static ref LIT13: preserves::value::IOValue = /* or */ preserves::value::packed::from_bytes(&vec![179, 2, 111, 114]).unwrap(); - pub static ref LIT9: preserves::value::IOValue = /* rec */ preserves::value::packed::from_bytes(&vec![179, 3, 114, 101, 99]).unwrap(); - pub static ref LIT16: preserves::value::IOValue = /* ref */ preserves::value::packed::from_bytes(&vec![179, 3, 114, 101, 102]).unwrap(); - pub static ref LIT17: preserves::value::IOValue = /* schema */ preserves::value::packed::from_bytes(&vec![179, 6, 115, 99, 104, 101, 109, 97]).unwrap(); - pub static ref LIT25: preserves::value::IOValue = /* seqof */ preserves::value::packed::from_bytes(&vec![179, 5, 115, 101, 113, 111, 102]).unwrap(); - pub static ref LIT26: preserves::value::IOValue = /* setof */ preserves::value::packed::from_bytes(&vec![179, 5, 115, 101, 116, 111, 102]).unwrap(); - pub static ref LIT10: preserves::value::IOValue = /* tuple */ preserves::value::packed::from_bytes(&vec![179, 5, 116, 117, 112, 108, 101]).unwrap(); - pub static ref LIT11: preserves::value::IOValue = /* tuplePrefix */ preserves::value::packed::from_bytes(&vec![179, 11, 116, 117, 112, 108, 101, 80, 114, 101, 102, 105, 120]).unwrap(); - pub static ref LIT20: preserves::value::IOValue = /* version */ preserves::value::packed::from_bytes(&vec![179, 7, 118, 101, 114, 115, 105, 111, 110]).unwrap(); + pub static ref LIT15: _Any = /* #f */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![128]).unwrap()).unwrap(); + pub static ref LIT28: _Any = /* 1 */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![145]).unwrap()).unwrap(); + pub static ref LIT0: _Any = /* Boolean */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 7, 66, 111, 111, 108, 101, 97, 110]).unwrap()).unwrap(); + pub static ref LIT5: _Any = /* ByteString */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 10, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103]).unwrap()).unwrap(); + pub static ref LIT2: _Any = /* Double */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 6, 68, 111, 117, 98, 108, 101]).unwrap()).unwrap(); + pub static ref LIT1: _Any = /* Float */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 5, 70, 108, 111, 97, 116]).unwrap()).unwrap(); + pub static ref LIT3: _Any = /* SignedInteger */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 13, 83, 105, 103, 110, 101, 100, 73, 110, 116, 101, 103, 101, 114]).unwrap()).unwrap(); + pub static ref LIT4: _Any = /* String */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 6, 83, 116, 114, 105, 110, 103]).unwrap()).unwrap(); + pub static ref LIT6: _Any = /* Symbol */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 6, 83, 121, 109, 98, 111, 108]).unwrap()).unwrap(); + pub static ref LIT14: _Any = /* and */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 3, 97, 110, 100]).unwrap()).unwrap(); + pub static ref LIT21: _Any = /* any */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 3, 97, 110, 121]).unwrap()).unwrap(); + pub static ref LIT22: _Any = /* atom */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 4, 97, 116, 111, 109]).unwrap()).unwrap(); + pub static ref LIT8: _Any = /* bundle */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 6, 98, 117, 110, 100, 108, 101]).unwrap()).unwrap(); + pub static ref LIT18: _Any = /* definitions */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 11, 100, 101, 102, 105, 110, 105, 116, 105, 111, 110, 115]).unwrap()).unwrap(); + pub static ref LIT12: _Any = /* dict */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 4, 100, 105, 99, 116]).unwrap()).unwrap(); + pub static ref LIT27: _Any = /* dictof */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 6, 100, 105, 99, 116, 111, 102]).unwrap()).unwrap(); + pub static ref LIT23: _Any = /* embedded */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 8, 101, 109, 98, 101, 100, 100, 101, 100]).unwrap()).unwrap(); + pub static ref LIT19: _Any = /* embeddedType */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 12, 101, 109, 98, 101, 100, 100, 101, 100, 84, 121, 112, 101]).unwrap()).unwrap(); + pub static ref LIT24: _Any = /* lit */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 3, 108, 105, 116]).unwrap()).unwrap(); + pub static ref LIT7: _Any = /* named */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 5, 110, 97, 109, 101, 100]).unwrap()).unwrap(); + pub static ref LIT13: _Any = /* or */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 2, 111, 114]).unwrap()).unwrap(); + pub static ref LIT9: _Any = /* rec */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 3, 114, 101, 99]).unwrap()).unwrap(); + pub static ref LIT16: _Any = /* ref */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 3, 114, 101, 102]).unwrap()).unwrap(); + pub static ref LIT17: _Any = /* schema */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 6, 115, 99, 104, 101, 109, 97]).unwrap()).unwrap(); + pub static ref LIT25: _Any = /* seqof */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 5, 115, 101, 113, 111, 102]).unwrap()).unwrap(); + pub static ref LIT26: _Any = /* setof */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 5, 115, 101, 116, 111, 102]).unwrap()).unwrap(); + pub static ref LIT10: _Any = /* tuple */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 5, 116, 117, 112, 108, 101]).unwrap()).unwrap(); + pub static ref LIT11: _Any = /* tuplePrefix */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 11, 116, 117, 112, 108, 101, 80, 114, 101, 102, 105, 120]).unwrap()).unwrap(); + pub static ref LIT20: _Any = /* version */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 7, 118, 101, 114, 115, 105, 111, 110]).unwrap()).unwrap(); } pub type _Ptr = preserves::value::IOValue; -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone)] +pub type _Any = preserves::value::ArcValue<_Ptr>; + +#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] pub enum AtomKind {Boolean, Float, Double, SignedInteger, String, ByteString, Symbol} -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone)] +#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] pub struct Binding {pub name: std::string::String, pub pattern: SimplePattern} -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone)] +#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] pub struct Bundle {pub modules: Modules} -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone)] +#[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}, @@ -58,7 +60,7 @@ pub enum CompoundPattern { Dict {entries: std::boxed::Box} } -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone)] +#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] pub enum Definition { Or { pattern_0: std::boxed::Box, @@ -73,86 +75,87 @@ pub enum Definition { Pattern(std::boxed::Box) } -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone)] +#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] pub struct Definitions(pub preserves::value::Map); -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone)] -pub struct DictionaryEntries(pub preserves::value::Map); +#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] +pub struct DictionaryEntries(pub preserves::value::Map<_Any, NamedSimplePattern>); -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone)] +#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] pub enum EmbeddedTypeName {Ref(std::boxed::Box), False} -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone)] +#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] pub struct ModulePath(pub std::vec::Vec); -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone)] +#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] pub struct Modules(pub preserves::value::Map); -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone)] +#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] pub struct NamedAlternative {pub variant_label: std::string::String, pub pattern: Pattern} -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone)] +#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] pub enum NamedPattern {Named(std::boxed::Box), Anonymous(std::boxed::Box)} -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone)] +#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] pub enum NamedSimplePattern {Named(std::boxed::Box), Anonymous(std::boxed::Box)} -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone)] +#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] pub enum Pattern { SimplePattern(std::boxed::Box), CompoundPattern(std::boxed::Box) } -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone)] +#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] pub struct Ref {pub module: ModulePath, pub name: std::string::String} -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone)] +#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] pub struct Schema { pub definitions: Definitions, pub embedded_type: EmbeddedTypeName, pub version: Version } -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone)] +#[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: preserves::value::IOValue}, + 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) } -#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone)] +#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)] pub struct Version; -fn _parse_atom_kind_boolean(value: &preserves::value::IOValue) -> std::result::Result {if value != &*LIT0 { return Err(()); } let _tmp0 = (); Ok(AtomKind::Boolean)} +fn _parse_atom_kind_boolean(value: &_Any) -> std::result::Result {if value != &*LIT0 { return Err(()); } let _tmp0 = (); Ok(AtomKind::Boolean)} -fn _parse_atom_kind_float(value: &preserves::value::IOValue) -> std::result::Result {if value != &*LIT1 { return Err(()); } let _tmp0 = (); Ok(AtomKind::Float)} +fn _parse_atom_kind_float(value: &_Any) -> std::result::Result {if value != &*LIT1 { return Err(()); } let _tmp0 = (); Ok(AtomKind::Float)} -fn _parse_atom_kind_double(value: &preserves::value::IOValue) -> std::result::Result {if value != &*LIT2 { return Err(()); } let _tmp0 = (); Ok(AtomKind::Double)} +fn _parse_atom_kind_double(value: &_Any) -> std::result::Result {if value != &*LIT2 { return Err(()); } let _tmp0 = (); Ok(AtomKind::Double)} -fn _parse_atom_kind_signed_integer(value: &preserves::value::IOValue) -> std::result::Result { +fn _parse_atom_kind_signed_integer(value: &_Any) -> std::result::Result { if value != &*LIT3 { return Err(()); } let _tmp0 = (); Ok(AtomKind::SignedInteger) } -fn _parse_atom_kind_string(value: &preserves::value::IOValue) -> std::result::Result {if value != &*LIT4 { return Err(()); } let _tmp0 = (); Ok(AtomKind::String)} +fn _parse_atom_kind_string(value: &_Any) -> std::result::Result {if value != &*LIT4 { return Err(()); } let _tmp0 = (); Ok(AtomKind::String)} -fn _parse_atom_kind_byte_string(value: &preserves::value::IOValue) -> std::result::Result { +fn _parse_atom_kind_byte_string(value: &_Any) -> std::result::Result { if value != &*LIT5 { return Err(()); } let _tmp0 = (); Ok(AtomKind::ByteString) } -fn _parse_atom_kind_symbol(value: &preserves::value::IOValue) -> std::result::Result {if value != &*LIT6 { return Err(()); } let _tmp0 = (); Ok(AtomKind::Symbol)} +fn _parse_atom_kind_symbol(value: &_Any) -> std::result::Result {if value != &*LIT6 { return Err(()); } let _tmp0 = (); Ok(AtomKind::Symbol)} -impl std::convert::TryFrom<&preserves::value::IOValue> for AtomKind { +impl std::convert::TryFrom<_Any> for AtomKind { type Error = (); - fn try_from(value: &preserves::value::IOValue) -> std::result::Result { + fn try_from(value: _Any) -> std::result::Result { + let value = &value; if let Ok(r) = _parse_atom_kind_boolean(value) { return Ok(r); } if let Ok(r) = _parse_atom_kind_float(value) { return Ok(r); } if let Ok(r) = _parse_atom_kind_double(value) { return Ok(r); } @@ -164,7 +167,7 @@ impl std::convert::TryFrom<&preserves::value::IOValue> for AtomKind { } } -impl std::convert::From<&AtomKind> for preserves::value::IOValue { +impl std::convert::From<&AtomKind> for _Any { fn from(value: &AtomKind) -> Self { match value { AtomKind::Boolean => (&*LIT0).clone(), @@ -178,99 +181,102 @@ impl std::convert::From<&AtomKind> for preserves::value::IOValue { } } -impl std::convert::TryFrom<&preserves::value::IOValue> for Binding { +impl std::convert::TryFrom<_Any> for Binding { type Error = (); - fn try_from(value: &preserves::value::IOValue) -> std::result::Result { + fn try_from(value: _Any) -> std::result::Result { + let value = &value; let _tmp0 = value.value().to_record(None).map_err(|_| ())?; if _tmp0.label() != &*LIT7 { return Err(()); } let _tmp1 = (); if _tmp0.fields().len() - 0 < 2 { return Err(()); } let _tmp2 = (&_tmp0.fields()[0]).value().to_symbol().map_err(|_| ())?; - let _tmp3 = SimplePattern::try_from((&_tmp0.fields()[1]))?; + let _tmp3 = SimplePattern::try_from((&_tmp0.fields()[1]).clone())?; Ok(Binding {name: _tmp2.clone(), pattern: _tmp3}) } } -impl std::convert::From<&Binding> for preserves::value::IOValue { +impl std::convert::From<&Binding> for _Any { fn from(value: &Binding) -> Self { let Binding {name: _tmp0, pattern: _tmp1} = value; { let mut _tmp2 = preserves::value::Record(vec![(&*LIT7).clone()]); _tmp2.fields_vec_mut().push(preserves::value::Value::symbol(_tmp0).wrap()); - _tmp2.fields_vec_mut().push(preserves::value::IOValue::from(_tmp1)); + _tmp2.fields_vec_mut().push(_Any::from(_tmp1)); _tmp2.finish().wrap() } } } -impl std::convert::TryFrom<&preserves::value::IOValue> for Bundle { +impl std::convert::TryFrom<_Any> for Bundle { type Error = (); - fn try_from(value: &preserves::value::IOValue) -> std::result::Result { + fn try_from(value: _Any) -> std::result::Result { + let value = &value; let _tmp0 = value.value().to_record(None).map_err(|_| ())?; if _tmp0.label() != &*LIT8 { return Err(()); } let _tmp1 = (); if _tmp0.fields().len() - 0 < 1 { return Err(()); } - let _tmp2 = Modules::try_from((&_tmp0.fields()[0]))?; + let _tmp2 = Modules::try_from((&_tmp0.fields()[0]).clone())?; Ok(Bundle {modules: _tmp2}) } } -impl std::convert::From<&Bundle> for preserves::value::IOValue { +impl std::convert::From<&Bundle> for _Any { fn from(value: &Bundle) -> Self { let Bundle {modules: _tmp0} = value; { let mut _tmp1 = preserves::value::Record(vec![(&*LIT8).clone()]); - _tmp1.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0)); + _tmp1.fields_vec_mut().push(_Any::from(_tmp0)); _tmp1.finish().wrap() } } } -fn _parse_compound_pattern_rec(value: &preserves::value::IOValue) -> std::result::Result { +fn _parse_compound_pattern_rec(value: &_Any) -> std::result::Result { let _tmp0 = value.value().to_record(None).map_err(|_| ())?; if _tmp0.label() != &*LIT9 { return Err(()); } let _tmp1 = (); if _tmp0.fields().len() - 0 < 2 { return Err(()); } - let _tmp2 = NamedPattern::try_from((&_tmp0.fields()[0]))?; - let _tmp3 = NamedPattern::try_from((&_tmp0.fields()[1]))?; + let _tmp2 = NamedPattern::try_from((&_tmp0.fields()[0]).clone())?; + let _tmp3 = NamedPattern::try_from((&_tmp0.fields()[1]).clone())?; Ok(CompoundPattern::Rec {label: std::boxed::Box::new(_tmp2), fields: std::boxed::Box::new(_tmp3)}) } -fn _parse_compound_pattern_tuple(value: &preserves::value::IOValue) -> std::result::Result { +fn _parse_compound_pattern_tuple(value: &_Any) -> std::result::Result { let _tmp0 = value.value().to_record(None).map_err(|_| ())?; if _tmp0.label() != &*LIT10 { return Err(()); } let _tmp1 = (); if _tmp0.fields().len() - 0 < 1 { return Err(()); } let _tmp3 = (&_tmp0.fields()[0]).value().to_sequence().map_err(|_| ())?; 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::try_from(_tmp4.clone())?; _tmp2.push(_tmp5);} Ok(CompoundPattern::Tuple {patterns: _tmp2}) } -fn _parse_compound_pattern_tuple_prefix(value: &preserves::value::IOValue) -> std::result::Result { +fn _parse_compound_pattern_tuple_prefix(value: &_Any) -> std::result::Result { let _tmp0 = value.value().to_record(None).map_err(|_| ())?; if _tmp0.label() != &*LIT11 { return Err(()); } let _tmp1 = (); if _tmp0.fields().len() - 0 < 2 { return Err(()); } let _tmp3 = (&_tmp0.fields()[0]).value().to_sequence().map_err(|_| ())?; 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::try_from(_tmp4.clone())?; _tmp2.push(_tmp5);} + let _tmp6 = NamedSimplePattern::try_from((&_tmp0.fields()[1]).clone())?; Ok(CompoundPattern::TuplePrefix {fixed: _tmp2, variable: std::boxed::Box::new(_tmp6)}) } -fn _parse_compound_pattern_dict(value: &preserves::value::IOValue) -> std::result::Result { +fn _parse_compound_pattern_dict(value: &_Any) -> std::result::Result { let _tmp0 = value.value().to_record(None).map_err(|_| ())?; if _tmp0.label() != &*LIT12 { return Err(()); } let _tmp1 = (); if _tmp0.fields().len() - 0 < 1 { return Err(()); } - let _tmp2 = DictionaryEntries::try_from((&_tmp0.fields()[0]))?; + let _tmp2 = DictionaryEntries::try_from((&_tmp0.fields()[0]).clone())?; Ok(CompoundPattern::Dict {entries: std::boxed::Box::new(_tmp2)}) } -impl std::convert::TryFrom<&preserves::value::IOValue> for CompoundPattern { +impl std::convert::TryFrom<_Any> for CompoundPattern { type Error = (); - fn try_from(value: &preserves::value::IOValue) -> std::result::Result { + fn try_from(value: _Any) -> std::result::Result { + let value = &value; if let Ok(r) = _parse_compound_pattern_rec(value) { return Ok(r); } if let Ok(r) = _parse_compound_pattern_tuple(value) { return Ok(r); } if let Ok(r) = _parse_compound_pattern_tuple_prefix(value) { return Ok(r); } @@ -279,13 +285,13 @@ impl std::convert::TryFrom<&preserves::value::IOValue> for CompoundPattern { } } -impl std::convert::From<&CompoundPattern> for preserves::value::IOValue { +impl std::convert::From<&CompoundPattern> for _Any { fn from(value: &CompoundPattern) -> Self { match value { CompoundPattern::Rec {label: _tmp0, fields: _tmp1} => { let mut _tmp2 = preserves::value::Record(vec![(&*LIT9).clone()]); - _tmp2.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0.as_ref())); - _tmp2.fields_vec_mut().push(preserves::value::IOValue::from(_tmp1.as_ref())); + _tmp2.fields_vec_mut().push(_Any::from(_tmp0.as_ref())); + _tmp2.fields_vec_mut().push(_Any::from(_tmp1.as_ref())); _tmp2.finish().wrap() }, CompoundPattern::Tuple {patterns: _tmp0} => { @@ -293,7 +299,7 @@ impl std::convert::From<&CompoundPattern> for preserves::value::IOValue { _tmp1.fields_vec_mut().push( { let mut _tmp2 = vec![]; - for _tmp3 in _tmp0 {_tmp2.push(preserves::value::IOValue::from(_tmp3));} + for _tmp3 in _tmp0 {_tmp2.push(_Any::from(_tmp3));} preserves::value::Value::Sequence(_tmp2).wrap() } ); @@ -304,33 +310,33 @@ impl std::convert::From<&CompoundPattern> for preserves::value::IOValue { _tmp2.fields_vec_mut().push( { let mut _tmp3 = vec![]; - for _tmp4 in _tmp0 {_tmp3.push(preserves::value::IOValue::from(_tmp4));} + for _tmp4 in _tmp0 {_tmp3.push(_Any::from(_tmp4));} preserves::value::Value::Sequence(_tmp3).wrap() } ); - _tmp2.fields_vec_mut().push(preserves::value::IOValue::from(_tmp1.as_ref())); + _tmp2.fields_vec_mut().push(_Any::from(_tmp1.as_ref())); _tmp2.finish().wrap() }, CompoundPattern::Dict {entries: _tmp0} => { let mut _tmp1 = preserves::value::Record(vec![(&*LIT12).clone()]); - _tmp1.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0.as_ref())); + _tmp1.fields_vec_mut().push(_Any::from(_tmp0.as_ref())); _tmp1.finish().wrap() }, } } } -fn _parse_definition_or(value: &preserves::value::IOValue) -> std::result::Result { +fn _parse_definition_or(value: &_Any) -> std::result::Result { let _tmp0 = value.value().to_record(None).map_err(|_| ())?; if _tmp0.label() != &*LIT13 { return Err(()); } let _tmp1 = (); if _tmp0.fields().len() - 0 < 1 { return Err(()); } let _tmp2 = (&_tmp0.fields()[0]).value().to_sequence().map_err(|_| ())?; if _tmp2.len() - 0 < 2 { return Err(()); } - let _tmp3 = NamedAlternative::try_from((&_tmp2[0]))?; - let _tmp4 = NamedAlternative::try_from((&_tmp2[1]))?; + let _tmp3 = NamedAlternative::try_from((&_tmp2[0]).clone())?; + let _tmp4 = NamedAlternative::try_from((&_tmp2[1]).clone())?; 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::try_from(_tmp6.clone())?; _tmp5.push(_tmp7);} Ok(Definition::Or { pattern_0: std::boxed::Box::new(_tmp3), pattern_1: std::boxed::Box::new(_tmp4), @@ -338,17 +344,17 @@ fn _parse_definition_or(value: &preserves::value::IOValue) -> std::result::Resul }) } -fn _parse_definition_and(value: &preserves::value::IOValue) -> std::result::Result { +fn _parse_definition_and(value: &_Any) -> std::result::Result { let _tmp0 = value.value().to_record(None).map_err(|_| ())?; if _tmp0.label() != &*LIT14 { return Err(()); } let _tmp1 = (); if _tmp0.fields().len() - 0 < 1 { return Err(()); } let _tmp2 = (&_tmp0.fields()[0]).value().to_sequence().map_err(|_| ())?; if _tmp2.len() - 0 < 2 { return Err(()); } - let _tmp3 = NamedPattern::try_from((&_tmp2[0]))?; - let _tmp4 = NamedPattern::try_from((&_tmp2[1]))?; + let _tmp3 = NamedPattern::try_from((&_tmp2[0]).clone())?; + let _tmp4 = NamedPattern::try_from((&_tmp2[1]).clone())?; 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::try_from(_tmp6.clone())?; _tmp5.push(_tmp7);} Ok(Definition::And { pattern_0: std::boxed::Box::new(_tmp3), pattern_1: std::boxed::Box::new(_tmp4), @@ -356,14 +362,15 @@ fn _parse_definition_and(value: &preserves::value::IOValue) -> std::result::Resu }) } -fn _parse_definition_pattern(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp0 = Pattern::try_from(value)?; +fn _parse_definition_pattern(value: &_Any) -> std::result::Result { + let _tmp0 = Pattern::try_from(value.clone())?; Ok(Definition::Pattern(std::boxed::Box::new(_tmp0))) } -impl std::convert::TryFrom<&preserves::value::IOValue> for Definition { +impl std::convert::TryFrom<_Any> for Definition { type Error = (); - fn try_from(value: &preserves::value::IOValue) -> std::result::Result { + fn try_from(value: _Any) -> std::result::Result { + let value = &value; if let Ok(r) = _parse_definition_or(value) { return Ok(r); } if let Ok(r) = _parse_definition_and(value) { return Ok(r); } if let Ok(r) = _parse_definition_pattern(value) { return Ok(r); } @@ -371,7 +378,7 @@ impl std::convert::TryFrom<&preserves::value::IOValue> for Definition { } } -impl std::convert::From<&Definition> for preserves::value::IOValue { +impl std::convert::From<&Definition> for _Any { fn from(value: &Definition) -> Self { match value { Definition::Or {pattern_0: _tmp0, pattern_1: _tmp1, pattern_n: _tmp2} => { @@ -379,9 +386,9 @@ impl std::convert::From<&Definition> for preserves::value::IOValue { _tmp3.fields_vec_mut().push( { let mut _tmp4 = vec![]; - _tmp4.push(preserves::value::IOValue::from(_tmp0.as_ref())); - _tmp4.push(preserves::value::IOValue::from(_tmp1.as_ref())); - for _tmp5 in _tmp2 {_tmp4.push(preserves::value::IOValue::from(_tmp5));} + _tmp4.push(_Any::from(_tmp0.as_ref())); + _tmp4.push(_Any::from(_tmp1.as_ref())); + for _tmp5 in _tmp2 {_tmp4.push(_Any::from(_tmp5));} preserves::value::Value::Sequence(_tmp4).wrap() } ); @@ -392,94 +399,95 @@ impl std::convert::From<&Definition> for preserves::value::IOValue { _tmp3.fields_vec_mut().push( { let mut _tmp4 = vec![]; - _tmp4.push(preserves::value::IOValue::from(_tmp0.as_ref())); - _tmp4.push(preserves::value::IOValue::from(_tmp1.as_ref())); - for _tmp5 in _tmp2 {_tmp4.push(preserves::value::IOValue::from(_tmp5));} + _tmp4.push(_Any::from(_tmp0.as_ref())); + _tmp4.push(_Any::from(_tmp1.as_ref())); + for _tmp5 in _tmp2 {_tmp4.push(_Any::from(_tmp5));} preserves::value::Value::Sequence(_tmp4).wrap() } ); _tmp3.finish().wrap() }, - Definition::Pattern(_tmp0) => preserves::value::IOValue::from(_tmp0.as_ref()), + Definition::Pattern(_tmp0) => _Any::from(_tmp0.as_ref()), } } } -impl std::convert::TryFrom<&preserves::value::IOValue> for Definitions { +impl std::convert::TryFrom<_Any> for Definitions { type Error = (); - fn try_from(value: &preserves::value::IOValue) -> std::result::Result { + fn try_from(value: _Any) -> std::result::Result { + let value = &value; let mut _tmp0 = preserves::value::Map::new(); for (_tmp1, _tmp2) in value.value().to_dictionary().map_err(|_| ())? { let _tmp3 = _tmp1.value().to_symbol().map_err(|_| ())?; - let _tmp4 = Definition::try_from(_tmp2)?; + let _tmp4 = Definition::try_from(_tmp2.clone())?; _tmp0.insert(_tmp3.clone(), _tmp4); } Ok(Definitions(_tmp0)) } } -impl std::convert::From<&Definitions> for preserves::value::IOValue { +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(), - preserves::value::IOValue::from(_tmp2) - )).collect()).wrap() + preserves::value::Value::Dictionary(_tmp0.iter().map(|(_tmp1, _tmp2)| (preserves::value::Value::symbol(_tmp1).wrap(), _Any::from(_tmp2))).collect()).wrap() } } -impl std::convert::TryFrom<&preserves::value::IOValue> for DictionaryEntries { +impl std::convert::TryFrom<_Any> for DictionaryEntries { type Error = (); - fn try_from(value: &preserves::value::IOValue) -> std::result::Result { + fn try_from(value: _Any) -> std::result::Result { + let value = &value; let mut _tmp0 = preserves::value::Map::new(); for (_tmp1, _tmp2) in value.value().to_dictionary().map_err(|_| ())? { let _tmp3 = _tmp1; - let _tmp4 = NamedSimplePattern::try_from(_tmp2)?; + let _tmp4 = NamedSimplePattern::try_from(_tmp2.clone())?; _tmp0.insert(_tmp3.clone(), _tmp4); } Ok(DictionaryEntries(_tmp0)) } } -impl std::convert::From<&DictionaryEntries> for preserves::value::IOValue { +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(), preserves::value::IOValue::from(_tmp2))).collect()).wrap() + preserves::value::Value::Dictionary(_tmp0.iter().map(|(_tmp1, _tmp2)| (_tmp1.clone(), _Any::from(_tmp2))).collect()).wrap() } } -fn _parse_embedded_type_name_ref(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp0 = Ref::try_from(value)?; +fn _parse_embedded_type_name_ref(value: &_Any) -> std::result::Result { + let _tmp0 = Ref::try_from(value.clone())?; Ok(EmbeddedTypeName::Ref(std::boxed::Box::new(_tmp0))) } -fn _parse_embedded_type_name_false(value: &preserves::value::IOValue) -> std::result::Result { +fn _parse_embedded_type_name_false(value: &_Any) -> std::result::Result { if value != &*LIT15 { return Err(()); } let _tmp0 = (); Ok(EmbeddedTypeName::False) } -impl std::convert::TryFrom<&preserves::value::IOValue> for EmbeddedTypeName { +impl std::convert::TryFrom<_Any> for EmbeddedTypeName { type Error = (); - fn try_from(value: &preserves::value::IOValue) -> std::result::Result { + fn try_from(value: _Any) -> std::result::Result { + let value = &value; if let Ok(r) = _parse_embedded_type_name_ref(value) { return Ok(r); } if let Ok(r) = _parse_embedded_type_name_false(value) { return Ok(r); } Err(()) } } -impl std::convert::From<&EmbeddedTypeName> for preserves::value::IOValue { +impl std::convert::From<&EmbeddedTypeName> for _Any { fn from(value: &EmbeddedTypeName) -> Self { match value { - EmbeddedTypeName::Ref(_tmp0) => preserves::value::IOValue::from(_tmp0.as_ref()), + EmbeddedTypeName::Ref(_tmp0) => _Any::from(_tmp0.as_ref()), EmbeddedTypeName::False => (&*LIT15).clone(), } } } -impl std::convert::TryFrom<&preserves::value::IOValue> for ModulePath { +impl std::convert::TryFrom<_Any> for ModulePath { type Error = (); - fn try_from(value: &preserves::value::IOValue) -> std::result::Result { + fn try_from(value: _Any) -> std::result::Result { + let value = &value; let _tmp1 = value.value().to_sequence().map_err(|_| ())?; let mut _tmp0 = std::vec::Vec::new(); for _tmp2 in &_tmp1[0..] { @@ -490,7 +498,7 @@ impl std::convert::TryFrom<&preserves::value::IOValue> for ModulePath { } } -impl std::convert::From<&ModulePath> for preserves::value::IOValue { +impl std::convert::From<&ModulePath> for _Any { fn from(value: &ModulePath) -> Self { let ModulePath(_tmp0) = value; { @@ -501,177 +509,184 @@ impl std::convert::From<&ModulePath> for preserves::value::IOValue { } } -impl std::convert::TryFrom<&preserves::value::IOValue> for Modules { +impl std::convert::TryFrom<_Any> for Modules { type Error = (); - fn try_from(value: &preserves::value::IOValue) -> std::result::Result { + fn try_from(value: _Any) -> std::result::Result { + let value = &value; let mut _tmp0 = preserves::value::Map::new(); for (_tmp1, _tmp2) in value.value().to_dictionary().map_err(|_| ())? { - let _tmp3 = ModulePath::try_from(_tmp1)?; - let _tmp4 = Schema::try_from(_tmp2)?; + let _tmp3 = ModulePath::try_from(_tmp1.clone())?; + let _tmp4 = Schema::try_from(_tmp2.clone())?; _tmp0.insert(_tmp3, _tmp4); } Ok(Modules(_tmp0)) } } -impl std::convert::From<&Modules> for preserves::value::IOValue { +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)| (preserves::value::IOValue::from(_tmp1), preserves::value::IOValue::from(_tmp2))).collect()).wrap() + preserves::value::Value::Dictionary(_tmp0.iter().map(|(_tmp1, _tmp2)| (_Any::from(_tmp1), _Any::from(_tmp2))).collect()).wrap() } } -impl std::convert::TryFrom<&preserves::value::IOValue> for NamedAlternative { +impl std::convert::TryFrom<_Any> for NamedAlternative { type Error = (); - fn try_from(value: &preserves::value::IOValue) -> std::result::Result { + fn try_from(value: _Any) -> std::result::Result { + let value = &value; let _tmp0 = value.value().to_sequence().map_err(|_| ())?; if _tmp0.len() - 0 < 2 { return Err(()); } let _tmp1 = (&_tmp0[0]).value().to_string().map_err(|_| ())?; - let _tmp2 = Pattern::try_from((&_tmp0[1]))?; + let _tmp2 = Pattern::try_from((&_tmp0[1]).clone())?; Ok(NamedAlternative {variant_label: _tmp1.clone(), pattern: _tmp2}) } } -impl std::convert::From<&NamedAlternative> for preserves::value::IOValue { +impl std::convert::From<&NamedAlternative> for _Any { fn from(value: &NamedAlternative) -> Self { let NamedAlternative {variant_label: _tmp0, pattern: _tmp1} = value; { let mut _tmp2 = vec![]; _tmp2.push(preserves::value::Value::from(_tmp0).wrap()); - _tmp2.push(preserves::value::IOValue::from(_tmp1)); + _tmp2.push(_Any::from(_tmp1)); preserves::value::Value::Sequence(_tmp2).wrap() } } } -fn _parse_named_pattern_named(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp0 = Binding::try_from(value)?; +fn _parse_named_pattern_named(value: &_Any) -> std::result::Result { + let _tmp0 = Binding::try_from(value.clone())?; Ok(NamedPattern::Named(std::boxed::Box::new(_tmp0))) } -fn _parse_named_pattern_anonymous(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp0 = Pattern::try_from(value)?; +fn _parse_named_pattern_anonymous(value: &_Any) -> std::result::Result { + let _tmp0 = Pattern::try_from(value.clone())?; Ok(NamedPattern::Anonymous(std::boxed::Box::new(_tmp0))) } -impl std::convert::TryFrom<&preserves::value::IOValue> for NamedPattern { +impl std::convert::TryFrom<_Any> for NamedPattern { type Error = (); - fn try_from(value: &preserves::value::IOValue) -> std::result::Result { + fn try_from(value: _Any) -> std::result::Result { + let value = &value; if let Ok(r) = _parse_named_pattern_named(value) { return Ok(r); } if let Ok(r) = _parse_named_pattern_anonymous(value) { return Ok(r); } Err(()) } } -impl std::convert::From<&NamedPattern> for preserves::value::IOValue { +impl std::convert::From<&NamedPattern> for _Any { fn from(value: &NamedPattern) -> Self { match value { - NamedPattern::Named(_tmp0) => preserves::value::IOValue::from(_tmp0.as_ref()), - NamedPattern::Anonymous(_tmp0) => preserves::value::IOValue::from(_tmp0.as_ref()), + NamedPattern::Named(_tmp0) => _Any::from(_tmp0.as_ref()), + NamedPattern::Anonymous(_tmp0) => _Any::from(_tmp0.as_ref()), } } } -fn _parse_named_simple_pattern_named(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp0 = Binding::try_from(value)?; +fn _parse_named_simple_pattern_named(value: &_Any) -> std::result::Result { + let _tmp0 = Binding::try_from(value.clone())?; Ok(NamedSimplePattern::Named(std::boxed::Box::new(_tmp0))) } -fn _parse_named_simple_pattern_anonymous(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp0 = SimplePattern::try_from(value)?; +fn _parse_named_simple_pattern_anonymous(value: &_Any) -> std::result::Result { + let _tmp0 = SimplePattern::try_from(value.clone())?; Ok(NamedSimplePattern::Anonymous(std::boxed::Box::new(_tmp0))) } -impl std::convert::TryFrom<&preserves::value::IOValue> for NamedSimplePattern { +impl std::convert::TryFrom<_Any> for NamedSimplePattern { type Error = (); - fn try_from(value: &preserves::value::IOValue) -> std::result::Result { + fn try_from(value: _Any) -> std::result::Result { + let value = &value; if let Ok(r) = _parse_named_simple_pattern_named(value) { return Ok(r); } if let Ok(r) = _parse_named_simple_pattern_anonymous(value) { return Ok(r); } Err(()) } } -impl std::convert::From<&NamedSimplePattern> for preserves::value::IOValue { +impl std::convert::From<&NamedSimplePattern> for _Any { fn from(value: &NamedSimplePattern) -> Self { match value { - NamedSimplePattern::Named(_tmp0) => preserves::value::IOValue::from(_tmp0.as_ref()), - NamedSimplePattern::Anonymous(_tmp0) => preserves::value::IOValue::from(_tmp0.as_ref()), + NamedSimplePattern::Named(_tmp0) => _Any::from(_tmp0.as_ref()), + NamedSimplePattern::Anonymous(_tmp0) => _Any::from(_tmp0.as_ref()), } } } -fn _parse_pattern_simple_pattern(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp0 = SimplePattern::try_from(value)?; +fn _parse_pattern_simple_pattern(value: &_Any) -> std::result::Result { + let _tmp0 = SimplePattern::try_from(value.clone())?; Ok(Pattern::SimplePattern(std::boxed::Box::new(_tmp0))) } -fn _parse_pattern_compound_pattern(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp0 = CompoundPattern::try_from(value)?; +fn _parse_pattern_compound_pattern(value: &_Any) -> std::result::Result { + let _tmp0 = CompoundPattern::try_from(value.clone())?; Ok(Pattern::CompoundPattern(std::boxed::Box::new(_tmp0))) } -impl std::convert::TryFrom<&preserves::value::IOValue> for Pattern { +impl std::convert::TryFrom<_Any> for Pattern { type Error = (); - fn try_from(value: &preserves::value::IOValue) -> std::result::Result { + fn try_from(value: _Any) -> std::result::Result { + let value = &value; if let Ok(r) = _parse_pattern_simple_pattern(value) { return Ok(r); } if let Ok(r) = _parse_pattern_compound_pattern(value) { return Ok(r); } Err(()) } } -impl std::convert::From<&Pattern> for preserves::value::IOValue { +impl std::convert::From<&Pattern> for _Any { fn from(value: &Pattern) -> Self { match value { - Pattern::SimplePattern(_tmp0) => preserves::value::IOValue::from(_tmp0.as_ref()), - Pattern::CompoundPattern(_tmp0) => preserves::value::IOValue::from(_tmp0.as_ref()), + Pattern::SimplePattern(_tmp0) => _Any::from(_tmp0.as_ref()), + Pattern::CompoundPattern(_tmp0) => _Any::from(_tmp0.as_ref()), } } } -impl std::convert::TryFrom<&preserves::value::IOValue> for Ref { +impl std::convert::TryFrom<_Any> for Ref { type Error = (); - fn try_from(value: &preserves::value::IOValue) -> std::result::Result { + fn try_from(value: _Any) -> std::result::Result { + let value = &value; let _tmp0 = value.value().to_record(None).map_err(|_| ())?; if _tmp0.label() != &*LIT16 { return Err(()); } let _tmp1 = (); if _tmp0.fields().len() - 0 < 2 { return Err(()); } - let _tmp2 = ModulePath::try_from((&_tmp0.fields()[0]))?; + let _tmp2 = ModulePath::try_from((&_tmp0.fields()[0]).clone())?; let _tmp3 = (&_tmp0.fields()[1]).value().to_symbol().map_err(|_| ())?; Ok(Ref {module: _tmp2, name: _tmp3.clone()}) } } -impl std::convert::From<&Ref> for preserves::value::IOValue { +impl std::convert::From<&Ref> for _Any { fn from(value: &Ref) -> Self { let Ref {module: _tmp0, name: _tmp1} = value; { let mut _tmp2 = preserves::value::Record(vec![(&*LIT16).clone()]); - _tmp2.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0)); + _tmp2.fields_vec_mut().push(_Any::from(_tmp0)); _tmp2.fields_vec_mut().push(preserves::value::Value::symbol(_tmp1).wrap()); _tmp2.finish().wrap() } } } -impl std::convert::TryFrom<&preserves::value::IOValue> for Schema { +impl std::convert::TryFrom<_Any> for Schema { type Error = (); - fn try_from(value: &preserves::value::IOValue) -> std::result::Result { + fn try_from(value: _Any) -> std::result::Result { + let value = &value; let _tmp0 = value.value().to_record(None).map_err(|_| ())?; if _tmp0.label() != &*LIT17 { return Err(()); } let _tmp1 = (); if _tmp0.fields().len() - 0 < 1 { return Err(()); } let _tmp2 = (&_tmp0.fields()[0]).value().to_dictionary().map_err(|_| ())?; let _tmp3 = _tmp2.get(&*LIT18).ok_or(())?; - let _tmp4 = Definitions::try_from(_tmp3)?; + let _tmp4 = Definitions::try_from(_tmp3.clone())?; let _tmp5 = _tmp2.get(&*LIT19).ok_or(())?; - let _tmp6 = EmbeddedTypeName::try_from(_tmp5)?; + let _tmp6 = EmbeddedTypeName::try_from(_tmp5.clone())?; let _tmp7 = _tmp2.get(&*LIT20).ok_or(())?; - let _tmp8 = Version::try_from(_tmp7)?; + let _tmp8 = Version::try_from(_tmp7.clone())?; Ok(Schema {definitions: _tmp4, embedded_type: _tmp6, version: _tmp8}) } } -impl std::convert::From<&Schema> for preserves::value::IOValue { +impl std::convert::From<&Schema> for _Any { fn from(value: &Schema) -> Self { let Schema {definitions: _tmp0, embedded_type: _tmp1, version: _tmp2} = value; { @@ -679,9 +694,9 @@ impl std::convert::From<&Schema> for preserves::value::IOValue { _tmp3.fields_vec_mut().push( { let mut _tmp4 = preserves::value::Map::new(); - _tmp4.insert((&*LIT18).clone(), preserves::value::IOValue::from(_tmp0)); - _tmp4.insert((&*LIT19).clone(), preserves::value::IOValue::from(_tmp1)); - _tmp4.insert((&*LIT20).clone(), preserves::value::IOValue::from(_tmp2)); + _tmp4.insert((&*LIT18).clone(), _Any::from(_tmp0)); + _tmp4.insert((&*LIT19).clone(), _Any::from(_tmp1)); + _tmp4.insert((&*LIT20).clone(), _Any::from(_tmp2)); preserves::value::Value::Dictionary(_tmp4).wrap() } ); @@ -690,27 +705,27 @@ impl std::convert::From<&Schema> for preserves::value::IOValue { } } -fn _parse_simple_pattern_any(value: &preserves::value::IOValue) -> std::result::Result {if value != &*LIT21 { return Err(()); } let _tmp0 = (); Ok(SimplePattern::Any)} +fn _parse_simple_pattern_any(value: &_Any) -> std::result::Result {if value != &*LIT21 { return Err(()); } let _tmp0 = (); Ok(SimplePattern::Any)} -fn _parse_simple_pattern_atom(value: &preserves::value::IOValue) -> std::result::Result { +fn _parse_simple_pattern_atom(value: &_Any) -> std::result::Result { let _tmp0 = value.value().to_record(None).map_err(|_| ())?; if _tmp0.label() != &*LIT22 { return Err(()); } let _tmp1 = (); if _tmp0.fields().len() - 0 < 1 { return Err(()); } - let _tmp2 = AtomKind::try_from((&_tmp0.fields()[0]))?; + let _tmp2 = AtomKind::try_from((&_tmp0.fields()[0]).clone())?; Ok(SimplePattern::Atom {atom_kind: std::boxed::Box::new(_tmp2)}) } -fn _parse_simple_pattern_embedded(value: &preserves::value::IOValue) -> std::result::Result { +fn _parse_simple_pattern_embedded(value: &_Any) -> std::result::Result { let _tmp0 = value.value().to_record(None).map_err(|_| ())?; if _tmp0.label() != &*LIT23 { return Err(()); } let _tmp1 = (); if _tmp0.fields().len() - 0 < 1 { return Err(()); } - let _tmp2 = SimplePattern::try_from((&_tmp0.fields()[0]))?; + let _tmp2 = SimplePattern::try_from((&_tmp0.fields()[0]).clone())?; Ok(SimplePattern::Embedded {interface: std::boxed::Box::new(_tmp2)}) } -fn _parse_simple_pattern_lit(value: &preserves::value::IOValue) -> std::result::Result { +fn _parse_simple_pattern_lit(value: &_Any) -> std::result::Result { let _tmp0 = value.value().to_record(None).map_err(|_| ())?; if _tmp0.label() != &*LIT24 { return Err(()); } let _tmp1 = (); @@ -719,42 +734,43 @@ fn _parse_simple_pattern_lit(value: &preserves::value::IOValue) -> std::result:: Ok(SimplePattern::Lit {value: _tmp2.clone()}) } -fn _parse_simple_pattern_seqof(value: &preserves::value::IOValue) -> std::result::Result { +fn _parse_simple_pattern_seqof(value: &_Any) -> std::result::Result { let _tmp0 = value.value().to_record(None).map_err(|_| ())?; if _tmp0.label() != &*LIT25 { return Err(()); } let _tmp1 = (); if _tmp0.fields().len() - 0 < 1 { return Err(()); } - let _tmp2 = SimplePattern::try_from((&_tmp0.fields()[0]))?; + let _tmp2 = SimplePattern::try_from((&_tmp0.fields()[0]).clone())?; Ok(SimplePattern::Seqof {pattern: std::boxed::Box::new(_tmp2)}) } -fn _parse_simple_pattern_setof(value: &preserves::value::IOValue) -> std::result::Result { +fn _parse_simple_pattern_setof(value: &_Any) -> std::result::Result { let _tmp0 = value.value().to_record(None).map_err(|_| ())?; if _tmp0.label() != &*LIT26 { return Err(()); } let _tmp1 = (); if _tmp0.fields().len() - 0 < 1 { return Err(()); } - let _tmp2 = SimplePattern::try_from((&_tmp0.fields()[0]))?; + let _tmp2 = SimplePattern::try_from((&_tmp0.fields()[0]).clone())?; Ok(SimplePattern::Setof {pattern: std::boxed::Box::new(_tmp2)}) } -fn _parse_simple_pattern_dictof(value: &preserves::value::IOValue) -> std::result::Result { +fn _parse_simple_pattern_dictof(value: &_Any) -> std::result::Result { let _tmp0 = value.value().to_record(None).map_err(|_| ())?; if _tmp0.label() != &*LIT27 { return Err(()); } let _tmp1 = (); if _tmp0.fields().len() - 0 < 2 { return Err(()); } - let _tmp2 = SimplePattern::try_from((&_tmp0.fields()[0]))?; - let _tmp3 = SimplePattern::try_from((&_tmp0.fields()[1]))?; + let _tmp2 = SimplePattern::try_from((&_tmp0.fields()[0]).clone())?; + let _tmp3 = SimplePattern::try_from((&_tmp0.fields()[1]).clone())?; Ok(SimplePattern::Dictof {key: std::boxed::Box::new(_tmp2), value: std::boxed::Box::new(_tmp3)}) } -fn _parse_simple_pattern_ref(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp0 = Ref::try_from(value)?; +fn _parse_simple_pattern_ref(value: &_Any) -> std::result::Result { + let _tmp0 = Ref::try_from(value.clone())?; Ok(SimplePattern::Ref(std::boxed::Box::new(_tmp0))) } -impl std::convert::TryFrom<&preserves::value::IOValue> for SimplePattern { +impl std::convert::TryFrom<_Any> for SimplePattern { type Error = (); - fn try_from(value: &preserves::value::IOValue) -> std::result::Result { + fn try_from(value: _Any) -> std::result::Result { + let value = &value; if let Ok(r) = _parse_simple_pattern_any(value) { return Ok(r); } if let Ok(r) = _parse_simple_pattern_atom(value) { return Ok(r); } if let Ok(r) = _parse_simple_pattern_embedded(value) { return Ok(r); } @@ -767,18 +783,18 @@ impl std::convert::TryFrom<&preserves::value::IOValue> for SimplePattern { } } -impl std::convert::From<&SimplePattern> for preserves::value::IOValue { +impl std::convert::From<&SimplePattern> for _Any { fn from(value: &SimplePattern) -> Self { match value { SimplePattern::Any => (&*LIT21).clone(), SimplePattern::Atom {atom_kind: _tmp0} => { let mut _tmp1 = preserves::value::Record(vec![(&*LIT22).clone()]); - _tmp1.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0.as_ref())); + _tmp1.fields_vec_mut().push(_Any::from(_tmp0.as_ref())); _tmp1.finish().wrap() }, SimplePattern::Embedded {interface: _tmp0} => { let mut _tmp1 = preserves::value::Record(vec![(&*LIT23).clone()]); - _tmp1.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0.as_ref())); + _tmp1.fields_vec_mut().push(_Any::from(_tmp0.as_ref())); _tmp1.finish().wrap() }, SimplePattern::Lit {value: _tmp0} => { @@ -788,29 +804,34 @@ impl std::convert::From<&SimplePattern> for preserves::value::IOValue { }, SimplePattern::Seqof {pattern: _tmp0} => { let mut _tmp1 = preserves::value::Record(vec![(&*LIT25).clone()]); - _tmp1.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0.as_ref())); + _tmp1.fields_vec_mut().push(_Any::from(_tmp0.as_ref())); _tmp1.finish().wrap() }, SimplePattern::Setof {pattern: _tmp0} => { let mut _tmp1 = preserves::value::Record(vec![(&*LIT26).clone()]); - _tmp1.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0.as_ref())); + _tmp1.fields_vec_mut().push(_Any::from(_tmp0.as_ref())); _tmp1.finish().wrap() }, SimplePattern::Dictof {key: _tmp0, value: _tmp1} => { let mut _tmp2 = preserves::value::Record(vec![(&*LIT27).clone()]); - _tmp2.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0.as_ref())); - _tmp2.fields_vec_mut().push(preserves::value::IOValue::from(_tmp1.as_ref())); + _tmp2.fields_vec_mut().push(_Any::from(_tmp0.as_ref())); + _tmp2.fields_vec_mut().push(_Any::from(_tmp1.as_ref())); _tmp2.finish().wrap() }, - SimplePattern::Ref(_tmp0) => preserves::value::IOValue::from(_tmp0.as_ref()), + SimplePattern::Ref(_tmp0) => _Any::from(_tmp0.as_ref()), } } } -impl std::convert::TryFrom<&preserves::value::IOValue> for Version { +impl std::convert::TryFrom<_Any> for Version { type Error = (); - fn try_from(value: &preserves::value::IOValue) -> std::result::Result {if value != &*LIT28 { return Err(()); } let _tmp0 = (); Ok(Version)} + fn try_from(value: _Any) -> std::result::Result { + let value = &value; + if value != &*LIT28 { return Err(()); } + let _tmp0 = (); + Ok(Version) + } } -impl std::convert::From<&Version> for preserves::value::IOValue {fn from(value: &Version) -> Self {let Version = value; (&*LIT28).clone()}} +impl std::convert::From<&Version> for _Any {fn from(value: &Version) -> Self {let Version = value; (&*LIT28).clone()}} diff --git a/implementations/rust/preserves-schema/src/lib.rs b/implementations/rust/preserves-schema/src/lib.rs index f5fb229..27ef55f 100644 --- a/implementations/rust/preserves-schema/src/lib.rs +++ b/implementations/rust/preserves-schema/src/lib.rs @@ -31,15 +31,16 @@ mod tests { #[test] fn metaschema_parsing() -> Result<(), std::io::Error> { - use preserves::value::{IOValue, Reader}; + use preserves::value::{Reader, NestedValue}; use std::convert::TryFrom; use std::convert::From; + use crate::gen::schema::*; let mut f = std::fs::File::open("../../../schema/schema.bin")?; let mut reader = preserves::value::PackedReader::decode_read(&mut f); - let schema = reader.demand_next(false)?; - let parsed = crate::gen::schema::Schema::try_from(&schema).expect("successful parse"); - assert_eq!(schema, IOValue::from(&parsed)); + let schema = _Any::from_io_value(&reader.demand_next(false)?)?; + let parsed = Schema::try_from(schema.clone()).expect("successful parse"); + assert_eq!(schema, _Any::from(&parsed)); Ok(()) } }