diff --git a/implementations/rust/preserves-schema/src/bin/preserves-schema-rs.rs b/implementations/rust/preserves-schema/src/bin/preserves-schema-rs.rs index 0b8b979..a848133 100644 --- a/implementations/rust/preserves-schema/src/bin/preserves-schema-rs.rs +++ b/implementations/rust/preserves-schema/src/bin/preserves-schema-rs.rs @@ -1,11 +1,15 @@ -use std::path::PathBuf; -use std::fs::File; -use preserves::value::packed::PackedReader; -use preserves::value::{NestedValue, Reader}; -use structopt::StructOpt; use glob::glob; +use preserves::value::packed::PackedReader; +use preserves::value::Reader; +use std::convert::TryFrom; +use std::fs::File; +use std::io::Error; +use std::io::ErrorKind; +use std::path::PathBuf; +use structopt::StructOpt; use preserves_schema::compiler::{CompilerConfig, compile}; +use preserves_schema::metaschema::*; #[derive(Clone, StructOpt, Debug)] struct CommandLine { @@ -35,7 +39,7 @@ fn inputs(globs: &Vec) -> Vec { result } -fn main() -> Result<(), std::io::Error> { +fn main() -> Result<(), Error> { let args = CommandLine::from_args(); let prefix = match &args.prefix { @@ -49,16 +53,21 @@ fn main() -> Result<(), std::io::Error> { let mut f = File::open(&i)?; let mut reader = PackedReader::decode_read(&mut f); let schema = reader.demand_next(false)?; - if let Some(s) = schema.value().as_simple_record("schema", Some(1)) { - config.bundle.insert(prefix.clone(), s[0].clone()); - } else if let Some(b) = schema.value().as_simple_record("bundle", Some(1)) { - for (k, v) in b[0].value().to_dictionary()? { - let mut name = prefix.clone(); - for p in k.value().to_sequence()? { - name.push(p.value().to_string()?.to_owned()); - } - config.bundle.insert(name, v.clone()); - } + match Schema::try_from(&schema) { + Ok(s) => { + config.bundle.insert(prefix.clone(), s); + () + }, + Err(()) => match Bundle::try_from(&schema) { + Ok(Bundle { modules }) => { + for (k, v) in modules.0 { + let mut name = prefix.clone(); + name.extend(k.0); + config.bundle.insert(name, v); + } + }, + Err(()) => return Err(ErrorKind::InvalidData)?, + }, } } diff --git a/implementations/rust/preserves-schema/src/compiler/mod.rs b/implementations/rust/preserves-schema/src/compiler/mod.rs index 697450e..abde3f9 100644 --- a/implementations/rust/preserves-schema/src/compiler/mod.rs +++ b/implementations/rust/preserves-schema/src/compiler/mod.rs @@ -4,14 +4,13 @@ pub mod context; pub mod parsers; use std::path::PathBuf; -use preserves::value::{Map, IOValue, NestedValue, Value}; +use preserves::value::Map; use crate::syntax::block::constructors::*; +use crate::metaschema::*; pub type ModulePath = Vec; -pub type Schema = IOValue; - #[derive(Debug)] pub struct CompilerConfig { pub bundle: Map, @@ -38,15 +37,9 @@ pub fn compile(config: &CompilerConfig) -> Result<(), std::io::Error> { // TODO: embedded type - let definitions = v.value().to_dictionary()?.get(&Value::symbol("definitions").wrap()) - .unwrap().value().to_dictionary()?; - - for (n, d) in definitions.iter() { - m.define_type(item(types::render_definition_type( - n.value().to_symbol()?, - &types::definition_type(d)?))); - - parsers::gen_definition_parser(&mut m, n.value().to_symbol()?, &d); + for (n, d) in &v.definitions.0 { + m.define_type(item(types::render_definition_type(n, &types::definition_type(d)))); + parsers::gen_definition_parser(&mut m, n, d); } //--------------------------------------------------------------------------- @@ -54,14 +47,14 @@ pub fn compile(config: &CompilerConfig) -> Result<(), std::io::Error> { println!("#![allow(unused_parens)]"); println!(); println!("use std::convert::TryFrom;"); - println!("use preserves::value::{{NestedValue, Reader}};"); + println!("use preserves::value::NestedValue;"); println!("use lazy_static::lazy_static;"); println!(); println!("lazy_static! {{"); for (value, name) in m.literals { let bs = preserves::value::PackedWriter::encode(&value).unwrap(); - println!(" pub static ref {}: preserves::value::IOValue = /* {:?} */ preserves::value::PackedReader::decode_bytes(&vec!{:?}).demand_next(false).unwrap();", + println!(" pub static ref {}: preserves::value::IOValue = /* {:?} */ preserves::value::packed::from_bytes(&vec!{:?}).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 70bef41..2b3705a 100644 --- a/implementations/rust/preserves-schema/src/compiler/parsers.rs +++ b/implementations/rust/preserves-schema/src/compiler/parsers.rs @@ -1,45 +1,52 @@ use crate::*; use crate::syntax::block::Item; use crate::syntax::block::constructors::*; -use preserves::value::{IOValue, NestedValue}; use super::names; use super::types::*; +use crate::metaschema::*; use super::context::{ModuleContext, FunctionContext}; -pub fn gen_definition_parser(m: &mut ModuleContext, n: &str, d: &IOValue) { +pub fn gen_definition_parser(m: &mut ModuleContext, n: &str, d: &Definition) { m.define_function( |mut ctxt| { let mut body = Vec::new(); - if let Some(fs) = d.value().as_simple_record("or", Some(1)) { - for e in fs[0].value().to_sequence().unwrap() { - let e = e.value().to_sequence().unwrap(); - let name = e[0].value().to_string().unwrap(); - let pat = &e[1]; - 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( - |mut ctxt| { - let mut body = Vec::new(); - let dest = pattern_parser(&mut ctxt, pat, "value", None, &mut body); - let dest = dest.as_ref().map(String::as_str); - construct(&ctxt, ctorname, false, &TDefinition::Simple(simple_type(pat).unwrap()), dest, &mut body); - item(seq!["fn ", fname.clone(), "(value: &preserves::value::IOValue) -> ", - "std::result::Result<", names::render_constructor(n), ", ()> ", - block(body)]) - }); - body.push(item(seq!["if let Ok(r) = ", fname, "(value) { return Ok(r); }"])); + match d { + Definition::Or { pattern_0, pattern_1, pattern_n } => { + let mut ps: Vec<&NamedAlternative> = pattern_n.iter().collect(); + ps.insert(0, &**pattern_1); + ps.insert(0, &**pattern_0); + for NamedAlternative { variant_label: name, pattern: pat } in ps { + 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( + |mut ctxt| { + let mut body = Vec::new(); + let dest = pattern_parser(&mut ctxt, pat, "value", None, &mut body); + let dest = dest.as_ref().map(String::as_str); + construct(&ctxt, ctorname, false, &TDefinition::Simple(pattern_type(pat)), dest, &mut body); + item(seq!["fn ", fname.clone(), "(value: &preserves::value::IOValue) -> ", + "std::result::Result<", names::render_constructor(n), ", ()> ", + block(body)]) + }); + body.push(item(seq!["if let Ok(r) = ", fname, "(value) { return Ok(r); }"])); + } + body.push(item(seq!["Err(())"])); } - body.push(item(seq!["Err(())"])); - } else if let Some(fs) = d.value().as_simple_record("and", Some(1)) { - for e in fs[0].value().to_sequence().unwrap() { - pattern_parser(&mut ctxt, e, "value", None, &mut body); + Definition::And { pattern_0, pattern_1, pattern_n } => { + let mut ps: Vec<&NamedPattern> = pattern_n.iter().collect(); + ps.insert(0, &**pattern_1); + ps.insert(0, &**pattern_0); + for e in ps { + named_pattern_parser(&mut ctxt, e, "value", None, &mut body); + } + construct(&ctxt, item(names::render_constructor(n)), true, &definition_type(d), None, &mut body); + } + Definition::Pattern(p) => { + let dest = pattern_parser(&mut ctxt, p, "value", None, &mut body); + let dest = dest.as_ref().map(String::as_str); + construct(&ctxt, item(names::render_constructor(n)), true, &definition_type(d), dest, &mut body); } - construct(&ctxt, item(names::render_constructor(n)), true, &definition_type(d).unwrap(), None, &mut body); - } else { - let dest = pattern_parser(&mut ctxt, d, "value", None, &mut body); - let dest = dest.as_ref().map(String::as_str); - construct(&ctxt, item(names::render_constructor(n)), true, &definition_type(d).unwrap(), dest, &mut body); } item(seq!["impl std::convert::TryFrom", anglebrackets!["&preserves::value::IOValue"], " for ", @@ -98,87 +105,90 @@ fn push_let_mut(body: &mut Vec, name: &str, expr: Item) { fn simple_pattern_parser( ctxt: &mut FunctionContext, - p: &IOValue, + p: &SimplePattern, src: &str, sequence_base: Option, body: &mut Vec, -) -> Option { +) -> String { let dest = ctxt.gentempname(); - if p.value().as_symbol() == Some(&"any".to_owned()) { - push_let(body, &dest, item(src.to_owned())); - Some(dest) - } else if let Some(fs) = p.value().as_simple_record("atom", Some(1)) { - match fs[0].value().as_symbol().unwrap().as_str() { - "Boolean" => push_let(body, &dest, item(seq![src.to_owned(), ".value().to_boolean().map_err(|_| ())?"])), - "Float" => push_let(body, &dest, item(seq![src.to_owned(), ".value().to_float().map_err(|_| ())?"])), - "Double" => push_let(body, &dest, item(seq![src.to_owned(), ".value().to_double().map_err(|_| ())?"])), - "SignedInteger" => push_let(body, &dest, item(seq![src.to_owned(), ".value().to_signedinteger().map_err(|_| ())?"])), - "String" => push_let(body, &dest, item(seq![src.to_owned(), ".value().to_string().map_err(|_| ())?"])), - "ByteString" => push_let(body, &dest, item(seq![src.to_owned(), ".value().to_bytestring().map_err(|_| ())?"])), - "Symbol" => push_let(body, &dest, item(seq![src.to_owned(), ".value().to_symbol().map_err(|_| ())?"])), - _ => panic!("Unexpected AtomKind"), - } - Some(dest) - } else if let Some(_) = p.value().as_simple_record("embedded", Some(1)) { - push_let(body, &dest, item(seq![src.to_owned(), ".value().to_embedded().map_err(|_| ())?"])); - Some(dest) - } else if let Some(fs) = p.value().as_simple_record("lit", Some(1)) { - body.push(item(seq!["if ", src.to_owned(), " != ", ctxt.m.define_literal(&fs[0]), - " { return Err(()); }"])); - push_let(body, &dest, item("()")); - Some(dest) - } else if let Some(fs) = p.value().as_simple_record("seqof", Some(1)) { - let (src, n) = sequenceify(ctxt, src, sequence_base, body); - let tmp = ctxt.gentempname(); - let mut inner = Vec::new(); - let item_dest = simple_pattern_parser(ctxt, &fs[0], &tmp, None, &mut inner); - inner.push(item(seq![ - dest.to_owned(), ".push(", - store_wrap(true, &field_type(&fs[0]).unwrap().unwrap(), &item_dest.unwrap()), ");"])); - push_let_mut(body, &dest, item("std::vec::Vec::new()")); - body.push(item(seq!["for ", tmp.to_owned(), - " in &", src.to_owned(), brackets![seq![n.to_string() , ".."]], - " ", block(inner)])); - Some(dest) - } else if let Some(fs) = p.value().as_simple_record("setof", Some(1)) { - let tmp = ctxt.gentempname(); - let mut inner = Vec::new(); - let item_dest = simple_pattern_parser(ctxt, &fs[0], &tmp, None, &mut inner); - inner.push(item(seq![ - dest.to_owned(), ".insert(", - store_wrap(true, &field_type(&fs[0]).unwrap().unwrap(), &item_dest.unwrap()), ");"])); - push_let_mut(body, &dest, item("preserves::value::Set::new()")); - body.push(item(seq!["for ", tmp.to_owned(), - " in ", src.to_owned(), ".value().to_set().map_err(|_| ())?", - " ", block(inner)])); - Some(dest) - } else if let Some(fs) = p.value().as_simple_record("dictof", Some(2)) { - let tmp_key = ctxt.gentempname(); - let tmp_value = ctxt.gentempname(); - let mut inner = Vec::new(); - let key_dest = simple_pattern_parser(ctxt, &fs[0], &tmp_key, None, &mut inner); - let value_dest = simple_pattern_parser(ctxt, &fs[1], &tmp_value, None, &mut inner); - inner.push(item(seq![ - dest.to_owned(), ".insert(", - store_wrap(true, &field_type(&fs[0]).unwrap().unwrap(), &key_dest.unwrap()), ", ", - store_wrap(true, &field_type(&fs[1]).unwrap().unwrap(), &value_dest.unwrap()), ");"])); - push_let_mut(body, &dest, item("preserves::value::Map::new()")); - body.push(item(seq!["for (", tmp_key.to_owned(), ", ", tmp_value.to_owned(), ")", - " in ", src.to_owned(), ".value().to_dictionary().map_err(|_| ())?", - " ", block(inner)])); - Some(dest) - } else if let Some(fs) = p.value().as_simple_record("ref", Some(2)) { - let mut n: Vec = fs[0].value().to_sequence().unwrap() - .iter().map(|s| s.value().to_symbol().unwrap().to_owned()).collect(); - use convert_case::{Case, Casing}; - n.push(fs[1].value().to_symbol().unwrap().to_case(Case::UpperCamel)); - let tf = name![names::render_ref(n), "try_from"]; - push_let(body, &dest, item(seq![tf, - parens![src.to_owned()], - "?"])); - Some(dest) - } else { - None + match p { + SimplePattern::Any => { + push_let(body, &dest, item(src.to_owned())); + dest + }, + SimplePattern::Atom { atom_kind: k } => { + match &**k { + AtomKind::Boolean => push_let(body, &dest, item(seq![src.to_owned(), ".value().to_boolean().map_err(|_| ())?"])), + AtomKind::Float => push_let(body, &dest, item(seq![src.to_owned(), ".value().to_float().map_err(|_| ())?"])), + AtomKind::Double => push_let(body, &dest, item(seq![src.to_owned(), ".value().to_double().map_err(|_| ())?"])), + AtomKind::SignedInteger => push_let(body, &dest, item(seq![src.to_owned(), ".value().to_signedinteger().map_err(|_| ())?"])), + AtomKind::String => push_let(body, &dest, item(seq![src.to_owned(), ".value().to_string().map_err(|_| ())?"])), + AtomKind::ByteString => push_let(body, &dest, item(seq![src.to_owned(), ".value().to_bytestring().map_err(|_| ())?"])), + AtomKind::Symbol => push_let(body, &dest, item(seq![src.to_owned(), ".value().to_symbol().map_err(|_| ())?"])), + } + dest + }, + SimplePattern::Embedded { .. } => { + push_let(body, &dest, item(seq![src.to_owned(), ".value().to_embedded().map_err(|_| ())?"])); + dest + }, + SimplePattern::Lit { value } => { + body.push(item(seq!["if ", src.to_owned(), " != ", ctxt.m.define_literal(value), + " { return Err(()); }"])); + push_let(body, &dest, item("()")); + dest + }, + SimplePattern::Seqof { pattern } => { + let (src, n) = sequenceify(ctxt, src, sequence_base, body); + let tmp = ctxt.gentempname(); + let mut inner = Vec::new(); + let item_dest = simple_pattern_parser(ctxt, pattern, &tmp, None, &mut inner); + inner.push(item(seq![dest.to_owned(), ".push(", + store_wrap(true, &field_type(pattern), &item_dest), ");"])); + push_let_mut(body, &dest, item("std::vec::Vec::new()")); + body.push(item(seq!["for ", tmp.to_owned(), + " in &", src.to_owned(), brackets![seq![n.to_string() , ".."]], + " ", block(inner)])); + dest + }, + SimplePattern::Setof { pattern } => { + let tmp = ctxt.gentempname(); + let mut inner = Vec::new(); + let item_dest = simple_pattern_parser(ctxt, pattern, &tmp, None, &mut inner); + inner.push(item(seq![dest.to_owned(), ".insert(", + store_wrap(true, &field_type(pattern), &item_dest), ");"])); + push_let_mut(body, &dest, item("preserves::value::Set::new()")); + body.push(item(seq!["for ", tmp.to_owned(), + " in ", src.to_owned(), ".value().to_set().map_err(|_| ())?", + " ", block(inner)])); + dest + }, + SimplePattern::Dictof { key, value } => { + let tmp_key = ctxt.gentempname(); + let tmp_value = ctxt.gentempname(); + let mut inner = Vec::new(); + let key_dest = simple_pattern_parser(ctxt, key, &tmp_key, None, &mut inner); + let value_dest = simple_pattern_parser(ctxt, value, &tmp_value, None, &mut inner); + inner.push(item(seq![ + dest.to_owned(), ".insert(", + store_wrap(true, &field_type(key), &key_dest), ", ", + store_wrap(true, &field_type(value), &value_dest), ");"])); + push_let_mut(body, &dest, item("preserves::value::Map::new()")); + body.push(item(seq!["for (", tmp_key.to_owned(), ", ", tmp_value.to_owned(), ")", + " in ", src.to_owned(), ".value().to_dictionary().map_err(|_| ())?", + " ", block(inner)])); + dest + }, + SimplePattern::Ref(r) => { + let Ref { module: ModulePath(module), name } = &**r; + let mut mp = module.clone(); + mp.push(name.to_owned()); + let tf = name![names::render_ref(mp), "try_from"]; + push_let(body, &dest, item(seq![tf, + parens![src.to_owned()], + "?"])); + dest + }, } } @@ -201,7 +211,7 @@ fn sequenceify( fn fixed_sequence_parser( ctxt: &mut FunctionContext, base: usize, - ps: &[IOValue], + ps: &[NamedPattern], src: &str, body: &mut Vec, ) { @@ -209,64 +219,71 @@ fn fixed_sequence_parser( body.push(item(seq!["if ", src.to_owned(), ".len() - ", base.to_string(), " < ", ps.len().to_string(), " { return Err(()); }"])); for p in ps { - pattern_parser(ctxt, p, &format!("(&{}[{}])", src, i), None, body); + named_pattern_parser(ctxt, p, &format!("(&{}[{}])", src, i), None, body); i += 1; } } +fn named_pattern_parser( + ctxt: &mut FunctionContext, + p: &NamedPattern, + src: &str, + sequence_base: Option, + body: &mut Vec, +) { + match p { + NamedPattern::Anonymous(p) => { + pattern_parser(ctxt, p, src, sequence_base, body); + }, + NamedPattern::Named(b) => { + let Binding { name, pattern} = &**b; + let dest = simple_pattern_parser(ctxt, pattern, src, sequence_base, body); + let capture_ty = field_type(pattern); + ctxt.capture(names::render_fieldname(name), capture_ty, dest); + } + } +} + fn pattern_parser( ctxt: &mut FunctionContext, - p: &IOValue, + p: &Pattern, src: &str, sequence_base: Option, body: &mut Vec, ) -> Option { - match simple_pattern_parser(ctxt, p, src, sequence_base, body) { - Some(dest) => Some(dest), - None => { - // Compound - let r = p.value().as_record(None).unwrap(); - match r.label().value().as_symbol().unwrap().as_ref() { - "named" => { - let dest = simple_pattern_parser(ctxt, &r.fields()[1], src, sequence_base, body).unwrap(); - let capture_ty = field_type(&r.fields()[1]).unwrap().unwrap(); - ctxt.capture(names::render_fieldname(r.fields()[0].value().as_symbol().unwrap()), - capture_ty, - dest.to_owned()); - Some(dest) - } - "rec" => { + match p { + Pattern::SimplePattern(s) => + Some(simple_pattern_parser(ctxt, s, src, sequence_base, body)), + Pattern::CompoundPattern(c) => { + match &**c { + CompoundPattern::Rec { label, fields } => { let rtmp = ctxt.gentempname(); push_let(body, &rtmp, item(seq![src.to_owned(), ".value().to_record(None).map_err(|_| ())?"])); - pattern_parser(ctxt, &r.fields()[0], &format!("{}.label()", rtmp), None, body); - pattern_parser(ctxt, &r.fields()[1], &format!("{}.fields()", rtmp), Some(0), body); - None - } - "tuple" => { + named_pattern_parser(ctxt, &**label, &format!("{}.label()", rtmp), None, body); + named_pattern_parser(ctxt, &**fields, &format!("{}.fields()", rtmp), Some(0), body); + }, + CompoundPattern::Tuple { patterns } => { let (src, n) = sequenceify(ctxt, src, sequence_base, body); - fixed_sequence_parser(ctxt, n, r.fields()[0].value().to_sequence().unwrap(), &src, body); - None - } - "tuplePrefix" => { + fixed_sequence_parser(ctxt, n, patterns, &src, body); + }, + CompoundPattern::TuplePrefix { fixed, variable } => { let (src, n) = sequenceify(ctxt, src, sequence_base, body); - let fixed = r.fields()[0].value().to_sequence().unwrap(); fixed_sequence_parser(ctxt, n, fixed, &src, body); - pattern_parser(ctxt, &r.fields()[1], &src, Some(n + fixed.len()), body) - } - "dict" => { + named_pattern_parser(ctxt, &promote(&**variable), &src, Some(n + fixed.len()), body); + }, + CompoundPattern::Dict { entries } => { let dtmp = ctxt.gentempname(); push_let(body, &dtmp, item(seq![src.to_owned(), ".value().to_dictionary().map_err(|_| ())?"])); - for (key_lit, value_pat) in r.fields()[0].value().to_dictionary().unwrap() { + for (key_lit, value_pat) in entries.0.iter() { let vtmp = ctxt.gentempname(); push_let(body, &vtmp, item(seq![ dtmp.to_owned(), ".get", parens![ctxt.m.define_literal(key_lit)], ".ok_or(())?"])); - pattern_parser(ctxt, value_pat, &vtmp, None, body); + named_pattern_parser(ctxt, &promote(value_pat), &vtmp, None, body); } - None } - _ => panic!("Unexpected compound"), } - } + None + }, } } diff --git a/implementations/rust/preserves-schema/src/compiler/types.rs b/implementations/rust/preserves-schema/src/compiler/types.rs index 08ecf0b..9fe2661 100644 --- a/implementations/rust/preserves-schema/src/compiler/types.rs +++ b/implementations/rust/preserves-schema/src/compiler/types.rs @@ -1,11 +1,9 @@ use crate::*; use crate::syntax::block::Emittable; use crate::syntax::block::constructors::*; +use crate::metaschema::*; use super::names; -use preserves::value::{IOValue, NestedValue}; -use preserves::error::Error; - #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone)] pub enum TDefinition { Union(Vec<(String, TSimple)>), @@ -31,104 +29,113 @@ pub enum TField { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone)] pub struct TRecord(pub Vec<(String, TField)>); -pub fn definition_type(d: &IOValue) -> Result { - if let Some(fs) = d.value().as_simple_record("or", Some(1)) { - let mut entries = Vec::new(); - for e in fs[0].value().to_sequence()?.iter() { - let e = e.value().to_sequence()?; - entries.push((e[0].value().to_string()?.to_owned(), simple_type(&e[1])?)); - } - Ok(TDefinition::Union(entries)) - } else if let Some(fs) = d.value().as_simple_record("and", Some(1)) { - Ok(TDefinition::Simple(record_type(fs[0].value().to_sequence()?)?)) - } else { - Ok(TDefinition::Simple(simple_type(d)?)) +pub fn definition_type(d: &Definition) -> TDefinition { + match d { + Definition::Or { pattern_0, pattern_1, pattern_n } => { + let mut entries = Vec::new(); + entries.push((pattern_0.variant_label.to_owned(), pattern_type(&pattern_0.pattern))); + entries.push((pattern_1.variant_label.to_owned(), pattern_type(&pattern_1.pattern))); + for e in pattern_n { + entries.push((e.variant_label.to_owned(), pattern_type(&e.pattern))); + } + TDefinition::Union(entries) + }, + Definition::And { pattern_0, pattern_1, pattern_n } => { + let mut arms: Vec<&NamedPattern> = pattern_n.iter().collect(); + arms.insert(0, &**pattern_1); + arms.insert(0, &**pattern_0); + TDefinition::Simple(record_type(&arms)) + }, + Definition::Pattern(p) => TDefinition::Simple(pattern_type(p)), } } -pub fn simple_type(p: &IOValue) -> Result { - if let Some(t) = field_type(p)? { - Ok(TSimple::Field(t)) - } else { - record_type(&vec![p.clone()]) +pub fn pattern_type(p: &Pattern) -> TSimple { + match p { + Pattern::SimplePattern(p) => + TSimple::Field(field_type(p)), + Pattern::CompoundPattern(_) => + record_type(&vec![&NamedPattern::Anonymous(Box::new(p.clone()))]), } } -pub fn record_type(ps: &Vec) -> Result { - let fs = gather_fields(ps, Vec::new())?; +pub fn record_type(ps: &Vec<&NamedPattern>) -> TSimple { + let fs = gather_fields(ps, Vec::new()); if fs.is_empty() { - Ok(TSimple::Field(TField::Unit)) + TSimple::Field(TField::Unit) } else { - Ok(TSimple::Record(TRecord(fs))) + TSimple::Record(TRecord(fs)) } } -pub fn gather_fields(ps: &Vec, mut fs: Vec<(String, TField)>) -> - Result, Error> +pub fn gather_fields(ps: &Vec<&NamedPattern>, mut fs: Vec<(String, TField)>) -> Vec<(String, TField)> { for p in ps.iter() { - fs = gather_field(p, fs)?; + fs = gather_field(p, fs); } - Ok(fs) + fs } -pub fn gather_field(p: &IOValue, mut fs: Vec<(String, TField)>) -> - Result, Error> -{ - if let Some(n) = p.value().as_simple_record("named", Some(2)) { - let name = n[0].value().to_symbol()?; - fs.push((name.to_owned(), field_type(&n[1])?.unwrap())); - Ok(fs) - } else if let Some(label_and_fields) = p.value().as_simple_record("rec", Some(2)) { - Ok(gather_field(&label_and_fields[1], gather_field(&label_and_fields[0], fs)?)?) - } else if let Some(tfs) = p.value().as_simple_record("tuple", Some(1)) { - Ok(gather_fields(tfs[0].value().to_sequence()?, fs)?) - } else if let Some(tfs) = p.value().as_simple_record("tuplePrefix", Some(2)) { - Ok(gather_field(&tfs[1], gather_fields(tfs[0].value().to_sequence()?, fs)?)?) - } else if let Some(dfs) = p.value().as_simple_record("dict", Some(1)) { - let es = dfs[0].value().to_dictionary()?; - for (_k, p) in es.iter() { - fs = gather_field(p, fs)?; +pub fn gather_field(p: &NamedPattern, mut fs: Vec<(String, TField)>) -> Vec<(String, TField)> { + match p { + NamedPattern::Named(b) => { + let Binding { name, pattern } = &**b; + fs.push((name.to_owned(), field_type(pattern))); + fs + }, + NamedPattern::Anonymous(p) => match &**p { + Pattern::SimplePattern(_) => + fs, + Pattern::CompoundPattern(c) => match &**c { + CompoundPattern::Rec { label, fields } => + gather_field(&*fields, gather_field(&*label, fs)), + CompoundPattern::Tuple { patterns } => + gather_fields(&patterns.iter().collect(), fs), + CompoundPattern::TuplePrefix { fixed, variable } => + gather_field(&promote(&**variable), gather_fields(&fixed.iter().collect(), fs)), + CompoundPattern::Dict { entries } => { + for (_k, p) in &entries.0 { + fs = gather_field(&promote(&p), fs); + } + fs + } + } } - Ok(fs) - } else { - Ok(fs) } } -pub fn field_type(p: &IOValue) -> Result, Error> { - if p.value().as_symbol() == Some(&"any".to_owned()) { - Ok(Some(TField::Base("preserves::value::IOValue".to_owned()))) - } else if let Some(fs) = p.value().as_simple_record("atom", Some(1)) { - match fs[0].value().as_symbol().unwrap().as_str() { - "Boolean" => Ok(Some(TField::Base("bool".to_owned()))), - "Float" => Ok(Some(TField::Base("f32".to_owned()))), - "Double" => Ok(Some(TField::Base("f64".to_owned()))), - "SignedInteger" => Ok(Some(TField::Base("preserves::value::signed_integer::SignedInteger".to_owned()))), - "String" => Ok(Some(TField::Base("std::string::String".to_owned()))), - "ByteString" => Ok(Some(TField::Base("std::vec::Vec".to_owned()))), - "Symbol" => Ok(Some(TField::Base("std::string::String".to_owned()))), - _ => Err(Error::Message("Unexpected AtomKind".to_owned())), +pub fn promote(p: &NamedSimplePattern) -> NamedPattern { + match p { + NamedSimplePattern::Anonymous(p) => NamedPattern::Anonymous(Box::new(Pattern::SimplePattern(p.clone()))), + NamedSimplePattern::Named(n) => NamedPattern::Named(n.clone()), + } +} + +pub fn field_type(p: &SimplePattern) -> TField { + match p { + SimplePattern::Any => TField::Base("preserves::value::IOValue".to_owned()), + SimplePattern::Atom { atom_kind: k } => + match **k { + AtomKind::Boolean => TField::Base("bool".to_owned()), + AtomKind::Float => TField::Base("f32".to_owned()), + AtomKind::Double => TField::Base("f64".to_owned()), + AtomKind::SignedInteger => TField::Base("preserves::value::signed_integer::SignedInteger".to_owned()), + AtomKind::String => TField::Base("std::string::String".to_owned()), + AtomKind::ByteString => TField::Base("std::vec::Vec".to_owned()), + AtomKind::Symbol => TField::Base("std::string::String".to_owned()), + }, + SimplePattern::Embedded { .. } => TField::Base("_ptr".to_owned()), + SimplePattern::Lit { .. } => TField::Unit, + SimplePattern::Seqof { pattern: t } => TField::Array(Box::new(field_type(t))), + SimplePattern::Setof { pattern: t } => TField::Set(Box::new(field_type(t))), + SimplePattern::Dictof { key: k, value: v } => + TField::Map(Box::new(field_type(k)), Box::new(field_type(v))), + SimplePattern::Ref(r) => { + let Ref { module: ModulePath(mp), name: n } = &**r; + let mut pieces = mp.clone(); + pieces.push(n.to_owned()); + TField::Ref(pieces) } - } else if let Some(_) = p.value().as_simple_record("embedded", Some(1)) { - Ok(Some(TField::Base("_ptr".to_owned()))) - } else if let Some(_) = p.value().as_simple_record("lit", Some(1)) { - Ok(Some(TField::Unit)) - } else if let Some(fs) = p.value().as_simple_record("seqof", Some(1)) { - Ok(Some(TField::Array(Box::new(field_type(&fs[0])?.unwrap())))) - } else if let Some(fs) = p.value().as_simple_record("setof", Some(1)) { - Ok(Some(TField::Set(Box::new(field_type(&fs[0])?.unwrap())))) - } else if let Some(fs) = p.value().as_simple_record("dictof", Some(2)) { - Ok(Some(TField::Map(Box::new(field_type(&fs[0])?.unwrap()), - Box::new(field_type(&fs[1])?.unwrap())))) - } else if let Some(fs) = p.value().as_simple_record("ref", Some(2)) { - let mut pieces = fs[0].value().to_sequence()?.iter() - .map(|v| v.value().to_symbol().map(String::to_owned)) - .collect::,_>>()?; - pieces.push(fs[1].value().to_symbol()?.to_owned()); - Ok(Some(TField::Ref(pieces))) - } else { - Ok(None) } } diff --git a/implementations/rust/preserves-schema/src/metaschema.rs b/implementations/rust/preserves-schema/src/metaschema.rs index daef17b..4ffa4f5 100644 --- a/implementations/rust/preserves-schema/src/metaschema.rs +++ b/implementations/rust/preserves-schema/src/metaschema.rs @@ -1,39 +1,39 @@ #![allow(unused_parens)] use std::convert::TryFrom; -use preserves::value::{NestedValue, Reader}; +use preserves::value::NestedValue; use lazy_static::lazy_static; lazy_static! { - pub static ref LIT15: preserves::value::IOValue = /* #f */ preserves::value::PackedReader::decode_bytes(&vec![128]).demand_next(false).unwrap(); - pub static ref LIT28: preserves::value::IOValue = /* 1 */ preserves::value::PackedReader::decode_bytes(&vec![145]).demand_next(false).unwrap(); - pub static ref LIT0: preserves::value::IOValue = /* Boolean */ preserves::value::PackedReader::decode_bytes(&vec![179, 7, 66, 111, 111, 108, 101, 97, 110]).demand_next(false).unwrap(); - pub static ref LIT5: preserves::value::IOValue = /* ByteString */ preserves::value::PackedReader::decode_bytes(&vec![179, 10, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103]).demand_next(false).unwrap(); - pub static ref LIT2: preserves::value::IOValue = /* Double */ preserves::value::PackedReader::decode_bytes(&vec![179, 6, 68, 111, 117, 98, 108, 101]).demand_next(false).unwrap(); - pub static ref LIT1: preserves::value::IOValue = /* Float */ preserves::value::PackedReader::decode_bytes(&vec![179, 5, 70, 108, 111, 97, 116]).demand_next(false).unwrap(); - pub static ref LIT3: preserves::value::IOValue = /* SignedInteger */ preserves::value::PackedReader::decode_bytes(&vec![179, 13, 83, 105, 103, 110, 101, 100, 73, 110, 116, 101, 103, 101, 114]).demand_next(false).unwrap(); - pub static ref LIT4: preserves::value::IOValue = /* String */ preserves::value::PackedReader::decode_bytes(&vec![179, 6, 83, 116, 114, 105, 110, 103]).demand_next(false).unwrap(); - pub static ref LIT6: preserves::value::IOValue = /* Symbol */ preserves::value::PackedReader::decode_bytes(&vec![179, 6, 83, 121, 109, 98, 111, 108]).demand_next(false).unwrap(); - pub static ref LIT14: preserves::value::IOValue = /* and */ preserves::value::PackedReader::decode_bytes(&vec![179, 3, 97, 110, 100]).demand_next(false).unwrap(); - pub static ref LIT21: preserves::value::IOValue = /* any */ preserves::value::PackedReader::decode_bytes(&vec![179, 3, 97, 110, 121]).demand_next(false).unwrap(); - pub static ref LIT22: preserves::value::IOValue = /* atom */ preserves::value::PackedReader::decode_bytes(&vec![179, 4, 97, 116, 111, 109]).demand_next(false).unwrap(); - pub static ref LIT8: preserves::value::IOValue = /* bundle */ preserves::value::PackedReader::decode_bytes(&vec![179, 6, 98, 117, 110, 100, 108, 101]).demand_next(false).unwrap(); - pub static ref LIT18: preserves::value::IOValue = /* definitions */ preserves::value::PackedReader::decode_bytes(&vec![179, 11, 100, 101, 102, 105, 110, 105, 116, 105, 111, 110, 115]).demand_next(false).unwrap(); - pub static ref LIT12: preserves::value::IOValue = /* dict */ preserves::value::PackedReader::decode_bytes(&vec![179, 4, 100, 105, 99, 116]).demand_next(false).unwrap(); - pub static ref LIT27: preserves::value::IOValue = /* dictof */ preserves::value::PackedReader::decode_bytes(&vec![179, 6, 100, 105, 99, 116, 111, 102]).demand_next(false).unwrap(); - pub static ref LIT23: preserves::value::IOValue = /* embedded */ preserves::value::PackedReader::decode_bytes(&vec![179, 8, 101, 109, 98, 101, 100, 100, 101, 100]).demand_next(false).unwrap(); - pub static ref LIT19: preserves::value::IOValue = /* embeddedType */ preserves::value::PackedReader::decode_bytes(&vec![179, 12, 101, 109, 98, 101, 100, 100, 101, 100, 84, 121, 112, 101]).demand_next(false).unwrap(); - pub static ref LIT24: preserves::value::IOValue = /* lit */ preserves::value::PackedReader::decode_bytes(&vec![179, 3, 108, 105, 116]).demand_next(false).unwrap(); - pub static ref LIT7: preserves::value::IOValue = /* named */ preserves::value::PackedReader::decode_bytes(&vec![179, 5, 110, 97, 109, 101, 100]).demand_next(false).unwrap(); - pub static ref LIT13: preserves::value::IOValue = /* or */ preserves::value::PackedReader::decode_bytes(&vec![179, 2, 111, 114]).demand_next(false).unwrap(); - pub static ref LIT9: preserves::value::IOValue = /* rec */ preserves::value::PackedReader::decode_bytes(&vec![179, 3, 114, 101, 99]).demand_next(false).unwrap(); - pub static ref LIT16: preserves::value::IOValue = /* ref */ preserves::value::PackedReader::decode_bytes(&vec![179, 3, 114, 101, 102]).demand_next(false).unwrap(); - pub static ref LIT17: preserves::value::IOValue = /* schema */ preserves::value::PackedReader::decode_bytes(&vec![179, 6, 115, 99, 104, 101, 109, 97]).demand_next(false).unwrap(); - pub static ref LIT25: preserves::value::IOValue = /* seqof */ preserves::value::PackedReader::decode_bytes(&vec![179, 5, 115, 101, 113, 111, 102]).demand_next(false).unwrap(); - pub static ref LIT26: preserves::value::IOValue = /* setof */ preserves::value::PackedReader::decode_bytes(&vec![179, 5, 115, 101, 116, 111, 102]).demand_next(false).unwrap(); - pub static ref LIT10: preserves::value::IOValue = /* tuple */ preserves::value::PackedReader::decode_bytes(&vec![179, 5, 116, 117, 112, 108, 101]).demand_next(false).unwrap(); - pub static ref LIT11: preserves::value::IOValue = /* tuplePrefix */ preserves::value::PackedReader::decode_bytes(&vec![179, 11, 116, 117, 112, 108, 101, 80, 114, 101, 102, 105, 120]).demand_next(false).unwrap(); - pub static ref LIT20: preserves::value::IOValue = /* version */ preserves::value::PackedReader::decode_bytes(&vec![179, 7, 118, 101, 114, 115, 105, 111, 110]).demand_next(false).unwrap(); + 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(); } #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone)] @@ -165,68 +165,68 @@ impl std::convert::TryFrom<&preserves::value::IOValue> for AtomKind { impl std::convert::TryFrom<&preserves::value::IOValue> for Binding { type Error = (); fn try_from(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp1 = value.value().to_record(None).map_err(|_| ())?; - if _tmp1.label() != &*LIT7 { return Err(()); } - let _tmp2 = (); - if _tmp1.fields().len() - 0 < 2 { return Err(()); } - let _tmp5 = (&_tmp1.fields()[0]).value().to_symbol().map_err(|_| ())?; - let _tmp7 = SimplePattern::try_from((&_tmp1.fields()[1]))?; - Ok(Binding {name: _tmp5.clone(), pattern: _tmp7}) + 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]))?; + Ok(Binding {name: _tmp2.clone(), pattern: _tmp3}) } } impl std::convert::TryFrom<&preserves::value::IOValue> for Bundle { type Error = (); fn try_from(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp1 = value.value().to_record(None).map_err(|_| ())?; - if _tmp1.label() != &*LIT8 { return Err(()); } - let _tmp2 = (); - if _tmp1.fields().len() - 0 < 1 { return Err(()); } - let _tmp5 = Modules::try_from((&_tmp1.fields()[0]))?; - Ok(Bundle {modules: _tmp5}) + 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]))?; + Ok(Bundle {modules: _tmp2}) } } fn _parse_compound_pattern_rec(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp1 = value.value().to_record(None).map_err(|_| ())?; - if _tmp1.label() != &*LIT9 { return Err(()); } - let _tmp2 = (); - if _tmp1.fields().len() - 0 < 2 { return Err(()); } - let _tmp5 = NamedPattern::try_from((&_tmp1.fields()[0]))?; - let _tmp7 = NamedPattern::try_from((&_tmp1.fields()[1]))?; - Ok(CompoundPattern::Rec {label: std::boxed::Box::new(_tmp5), fields: std::boxed::Box::new(_tmp7)}) + 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]))?; + 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 { - let _tmp1 = value.value().to_record(None).map_err(|_| ())?; - if _tmp1.label() != &*LIT10 { return Err(()); } - let _tmp2 = (); - if _tmp1.fields().len() - 0 < 1 { return Err(()); } - let _tmp6 = (&_tmp1.fields()[0]).value().to_sequence().map_err(|_| ())?; - let mut _tmp5 = std::vec::Vec::new(); - for _tmp7 in &_tmp6[0..] {let _tmp8 = NamedPattern::try_from(_tmp7)?; _tmp5.push(_tmp8);} - Ok(CompoundPattern::Tuple {patterns: _tmp5}) + 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);} + Ok(CompoundPattern::Tuple {patterns: _tmp2}) } fn _parse_compound_pattern_tuple_prefix(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp1 = value.value().to_record(None).map_err(|_| ())?; - if _tmp1.label() != &*LIT11 { return Err(()); } - let _tmp2 = (); - if _tmp1.fields().len() - 0 < 2 { return Err(()); } - let _tmp6 = (&_tmp1.fields()[0]).value().to_sequence().map_err(|_| ())?; - let mut _tmp5 = std::vec::Vec::new(); - for _tmp7 in &_tmp6[0..] {let _tmp8 = NamedPattern::try_from(_tmp7)?; _tmp5.push(_tmp8);} - let _tmp10 = NamedSimplePattern::try_from((&_tmp1.fields()[1]))?; - Ok(CompoundPattern::TuplePrefix {fixed: _tmp5, variable: std::boxed::Box::new(_tmp10)}) + 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]))?; + Ok(CompoundPattern::TuplePrefix {fixed: _tmp2, variable: std::boxed::Box::new(_tmp6)}) } fn _parse_compound_pattern_dict(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp1 = value.value().to_record(None).map_err(|_| ())?; - if _tmp1.label() != &*LIT12 { return Err(()); } - let _tmp2 = (); - if _tmp1.fields().len() - 0 < 1 { return Err(()); } - let _tmp5 = DictionaryEntries::try_from((&_tmp1.fields()[0]))?; - Ok(CompoundPattern::Dict {entries: std::boxed::Box::new(_tmp5)}) + 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]))?; + Ok(CompoundPattern::Dict {entries: std::boxed::Box::new(_tmp2)}) } impl std::convert::TryFrom<&preserves::value::IOValue> for CompoundPattern { @@ -241,38 +241,38 @@ impl std::convert::TryFrom<&preserves::value::IOValue> for CompoundPattern { } fn _parse_definition_or(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp1 = value.value().to_record(None).map_err(|_| ())?; - if _tmp1.label() != &*LIT13 { return Err(()); } - let _tmp2 = (); - if _tmp1.fields().len() - 0 < 1 { return Err(()); } - let _tmp5 = (&_tmp1.fields()[0]).value().to_sequence().map_err(|_| ())?; - if _tmp5.len() - 0 < 2 { return Err(()); } - let _tmp7 = NamedAlternative::try_from((&_tmp5[0]))?; - let _tmp9 = NamedAlternative::try_from((&_tmp5[1]))?; - let mut _tmp11 = std::vec::Vec::new(); - for _tmp12 in &_tmp5[2..] {let _tmp13 = NamedAlternative::try_from(_tmp12)?; _tmp11.push(_tmp13);} + 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 mut _tmp5 = std::vec::Vec::new(); + for _tmp6 in &_tmp2[2..] {let _tmp7 = NamedAlternative::try_from(_tmp6)?; _tmp5.push(_tmp7);} Ok(Definition::Or { - pattern_0: std::boxed::Box::new(_tmp7), - pattern_1: std::boxed::Box::new(_tmp9), - pattern_n: _tmp11 + pattern_0: std::boxed::Box::new(_tmp3), + pattern_1: std::boxed::Box::new(_tmp4), + pattern_n: _tmp5 }) } fn _parse_definition_and(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp1 = value.value().to_record(None).map_err(|_| ())?; - if _tmp1.label() != &*LIT14 { return Err(()); } - let _tmp2 = (); - if _tmp1.fields().len() - 0 < 1 { return Err(()); } - let _tmp5 = (&_tmp1.fields()[0]).value().to_sequence().map_err(|_| ())?; - if _tmp5.len() - 0 < 2 { return Err(()); } - let _tmp7 = NamedPattern::try_from((&_tmp5[0]))?; - let _tmp9 = NamedPattern::try_from((&_tmp5[1]))?; - let mut _tmp11 = std::vec::Vec::new(); - for _tmp12 in &_tmp5[2..] {let _tmp13 = NamedPattern::try_from(_tmp12)?; _tmp11.push(_tmp13);} + 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 mut _tmp5 = std::vec::Vec::new(); + for _tmp6 in &_tmp2[2..] {let _tmp7 = NamedPattern::try_from(_tmp6)?; _tmp5.push(_tmp7);} Ok(Definition::And { - pattern_0: std::boxed::Box::new(_tmp7), - pattern_1: std::boxed::Box::new(_tmp9), - pattern_n: _tmp11 + pattern_0: std::boxed::Box::new(_tmp3), + pattern_1: std::boxed::Box::new(_tmp4), + pattern_n: _tmp5 }) } @@ -366,11 +366,11 @@ impl std::convert::TryFrom<&preserves::value::IOValue> for Modules { impl std::convert::TryFrom<&preserves::value::IOValue> for NamedAlternative { type Error = (); fn try_from(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp1 = value.value().to_sequence().map_err(|_| ())?; - if _tmp1.len() - 0 < 2 { return Err(()); } - let _tmp3 = (&_tmp1[0]).value().to_string().map_err(|_| ())?; - let _tmp5 = Pattern::try_from((&_tmp1[1]))?; - Ok(NamedAlternative {variant_label: _tmp3.clone(), pattern: _tmp5}) + 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]))?; + Ok(NamedAlternative {variant_label: _tmp1.clone(), pattern: _tmp2}) } } @@ -434,89 +434,89 @@ impl std::convert::TryFrom<&preserves::value::IOValue> for Pattern { impl std::convert::TryFrom<&preserves::value::IOValue> for Ref { type Error = (); fn try_from(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp1 = value.value().to_record(None).map_err(|_| ())?; - if _tmp1.label() != &*LIT16 { return Err(()); } - let _tmp2 = (); - if _tmp1.fields().len() - 0 < 2 { return Err(()); } - let _tmp5 = ModulePath::try_from((&_tmp1.fields()[0]))?; - let _tmp7 = (&_tmp1.fields()[1]).value().to_symbol().map_err(|_| ())?; - Ok(Ref {module: _tmp5, name: _tmp7.clone()}) + 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 _tmp3 = (&_tmp0.fields()[1]).value().to_symbol().map_err(|_| ())?; + Ok(Ref {module: _tmp2, name: _tmp3.clone()}) } } impl std::convert::TryFrom<&preserves::value::IOValue> for Schema { type Error = (); fn try_from(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp1 = value.value().to_record(None).map_err(|_| ())?; - if _tmp1.label() != &*LIT17 { return Err(()); } - let _tmp2 = (); - if _tmp1.fields().len() - 0 < 1 { return Err(()); } - let _tmp5 = (&_tmp1.fields()[0]).value().to_dictionary().map_err(|_| ())?; - let _tmp6 = _tmp5.get(&*LIT18).ok_or(())?; - let _tmp8 = Definitions::try_from(_tmp6)?; - let _tmp9 = _tmp5.get(&*LIT19).ok_or(())?; - let _tmp11 = EmbeddedTypeName::try_from(_tmp9)?; - let _tmp12 = _tmp5.get(&*LIT20).ok_or(())?; - let _tmp14 = Version::try_from(_tmp12)?; - Ok(Schema {definitions: _tmp8, embedded_type: _tmp11, version: _tmp14}) + 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 _tmp5 = _tmp2.get(&*LIT19).ok_or(())?; + let _tmp6 = EmbeddedTypeName::try_from(_tmp5)?; + let _tmp7 = _tmp2.get(&*LIT20).ok_or(())?; + let _tmp8 = Version::try_from(_tmp7)?; + Ok(Schema {definitions: _tmp4, embedded_type: _tmp6, version: _tmp8}) } } 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_atom(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp1 = value.value().to_record(None).map_err(|_| ())?; - if _tmp1.label() != &*LIT22 { return Err(()); } - let _tmp2 = (); - if _tmp1.fields().len() - 0 < 1 { return Err(()); } - let _tmp5 = AtomKind::try_from((&_tmp1.fields()[0]))?; - Ok(SimplePattern::Atom {atom_kind: std::boxed::Box::new(_tmp5)}) + 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]))?; + Ok(SimplePattern::Atom {atom_kind: std::boxed::Box::new(_tmp2)}) } fn _parse_simple_pattern_embedded(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp1 = value.value().to_record(None).map_err(|_| ())?; - if _tmp1.label() != &*LIT23 { return Err(()); } - let _tmp2 = (); - if _tmp1.fields().len() - 0 < 1 { return Err(()); } - let _tmp5 = SimplePattern::try_from((&_tmp1.fields()[0]))?; - Ok(SimplePattern::Embedded {interface: std::boxed::Box::new(_tmp5)}) + 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]))?; + Ok(SimplePattern::Embedded {interface: std::boxed::Box::new(_tmp2)}) } fn _parse_simple_pattern_lit(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp1 = value.value().to_record(None).map_err(|_| ())?; - if _tmp1.label() != &*LIT24 { return Err(()); } - let _tmp2 = (); - if _tmp1.fields().len() - 0 < 1 { return Err(()); } - let _tmp5 = (&_tmp1.fields()[0]); - Ok(SimplePattern::Lit {value: _tmp5.clone()}) + let _tmp0 = value.value().to_record(None).map_err(|_| ())?; + if _tmp0.label() != &*LIT24 { return Err(()); } + let _tmp1 = (); + if _tmp0.fields().len() - 0 < 1 { return Err(()); } + let _tmp2 = (&_tmp0.fields()[0]); + Ok(SimplePattern::Lit {value: _tmp2.clone()}) } fn _parse_simple_pattern_seqof(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp1 = value.value().to_record(None).map_err(|_| ())?; - if _tmp1.label() != &*LIT25 { return Err(()); } - let _tmp2 = (); - if _tmp1.fields().len() - 0 < 1 { return Err(()); } - let _tmp5 = SimplePattern::try_from((&_tmp1.fields()[0]))?; - Ok(SimplePattern::Seqof {pattern: std::boxed::Box::new(_tmp5)}) + 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]))?; + Ok(SimplePattern::Seqof {pattern: std::boxed::Box::new(_tmp2)}) } fn _parse_simple_pattern_setof(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp1 = value.value().to_record(None).map_err(|_| ())?; - if _tmp1.label() != &*LIT26 { return Err(()); } - let _tmp2 = (); - if _tmp1.fields().len() - 0 < 1 { return Err(()); } - let _tmp5 = SimplePattern::try_from((&_tmp1.fields()[0]))?; - Ok(SimplePattern::Setof {pattern: std::boxed::Box::new(_tmp5)}) + 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]))?; + Ok(SimplePattern::Setof {pattern: std::boxed::Box::new(_tmp2)}) } fn _parse_simple_pattern_dictof(value: &preserves::value::IOValue) -> std::result::Result { - let _tmp1 = value.value().to_record(None).map_err(|_| ())?; - if _tmp1.label() != &*LIT27 { return Err(()); } - let _tmp2 = (); - if _tmp1.fields().len() - 0 < 2 { return Err(()); } - let _tmp5 = SimplePattern::try_from((&_tmp1.fields()[0]))?; - let _tmp7 = SimplePattern::try_from((&_tmp1.fields()[1]))?; - Ok(SimplePattern::Dictof {key: std::boxed::Box::new(_tmp5), value: std::boxed::Box::new(_tmp7)}) + 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]))?; + 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 { diff --git a/implementations/rust/preserves/src/value/packed/mod.rs b/implementations/rust/preserves/src/value/packed/mod.rs index bc98591..71b2b66 100644 --- a/implementations/rust/preserves/src/value/packed/mod.rs +++ b/implementations/rust/preserves/src/value/packed/mod.rs @@ -4,3 +4,14 @@ pub mod writer; pub use reader::PackedReader; pub use writer::PackedWriter; + +use super::{Reader, IOValue}; +use super::reader::IOResult; + +pub fn from_bytes(bs: &[u8]) -> IOResult { + PackedReader::decode_bytes(bs).demand_next(false) +} + +pub fn annotated_from_bytes(bs: &[u8]) -> IOResult { + PackedReader::decode_bytes(bs).demand_next(true) +}