syndicate-lang
/
preserves
mirror of https://gitlab.com/preserves/preserves.git
1
0
Fork 1
Code Releases Activity

Bootstrap Rust preserves-schema

This commit is contained in:
Tony Garnock-Jones 2021-06-28 22:25:41 +02:00
parent 7546ba29ad
commit 9c4be54be1
6 changed files with 449 additions and 412 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
implementations/rust/preserves-schema/src/bin/preserves-schema-rs.rs
View File

@ -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 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::compiler::{CompilerConfig, compile};
use preserves_schema::metaschema::*;
#[derive(Clone, StructOpt, Debug)] #[derive(Clone, StructOpt, Debug)]
struct CommandLine { struct CommandLine {
@ -35,7 +39,7 @@ fn inputs(globs: &Vec<String>) -> Vec<PathBuf> {
result result
} }
fn main() -> Result<(), std::io::Error> { fn main() -> Result<(), Error> {
let args = CommandLine::from_args(); let args = CommandLine::from_args();
let prefix = match &args.prefix { let prefix = match &args.prefix {
@ -49,16 +53,21 @@ fn main() -> Result<(), std::io::Error> {
let mut f = File::open(&i)?; let mut f = File::open(&i)?;
let mut reader = PackedReader::decode_read(&mut f); let mut reader = PackedReader::decode_read(&mut f);
let schema = reader.demand_next(false)?; let schema = reader.demand_next(false)?;
if let Some(s) = schema.value().as_simple_record("schema", Some(1)) { match Schema::try_from(&schema) {
config.bundle.insert(prefix.clone(), s[0].clone()); Ok(s) => {
} else if let Some(b) = schema.value().as_simple_record("bundle", Some(1)) { config.bundle.insert(prefix.clone(), s);
for (k, v) in b[0].value().to_dictionary()? { ()
let mut name = prefix.clone(); },
for p in k.value().to_sequence()? { Err(()) => match Bundle::try_from(&schema) {
name.push(p.value().to_string()?.to_owned()); Ok(Bundle { modules }) => {
} for (k, v) in modules.0 {
config.bundle.insert(name, v.clone()); let mut name = prefix.clone();
} name.extend(k.0);
config.bundle.insert(name, v);
}
},
Err(()) => return Err(ErrorKind::InvalidData)?,
},
} }
} }

21
implementations/rust/preserves-schema/src/compiler/mod.rs
View File

@ -4,14 +4,13 @@ pub mod context;
pub mod parsers; pub mod parsers;
use std::path::PathBuf; use std::path::PathBuf;
use preserves::value::{Map, IOValue, NestedValue, Value}; use preserves::value::Map;
use crate::syntax::block::constructors::*; use crate::syntax::block::constructors::*;
use crate::metaschema::*;
pub type ModulePath = Vec<String>; pub type ModulePath = Vec<String>;
pub type Schema = IOValue;
#[derive(Debug)] #[derive(Debug)]
pub struct CompilerConfig { pub struct CompilerConfig {
pub bundle: Map<ModulePath, Schema>, pub bundle: Map<ModulePath, Schema>,
@ -38,15 +37,9 @@ pub fn compile(config: &CompilerConfig) -> Result<(), std::io::Error> {
// TODO: embedded type // TODO: embedded type
let definitions = v.value().to_dictionary()?.get(&Value::symbol("definitions").wrap()) for (n, d) in &v.definitions.0 {
.unwrap().value().to_dictionary()?; m.define_type(item(types::render_definition_type(n, &types::definition_type(d))));
parsers::gen_definition_parser(&mut m, n, d);
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);
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
@ -54,14 +47,14 @@ pub fn compile(config: &CompilerConfig) -> Result<(), std::io::Error> {
println!("#![allow(unused_parens)]"); println!("#![allow(unused_parens)]");
println!(); println!();
println!("use std::convert::TryFrom;"); println!("use std::convert::TryFrom;");
println!("use preserves::value::{{NestedValue, Reader}};"); println!("use preserves::value::NestedValue;");
println!("use lazy_static::lazy_static;"); println!("use lazy_static::lazy_static;");
println!(); println!();
println!("lazy_static! {{"); println!("lazy_static! {{");
for (value, name) in m.literals { for (value, name) in m.literals {
let bs = preserves::value::PackedWriter::encode(&value).unwrap(); 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, name,
value, value,
bs); bs);

301
implementations/rust/preserves-schema/src/compiler/parsers.rs
View File

@ -1,45 +1,52 @@
use crate::*; use crate::*;
use crate::syntax::block::Item; use crate::syntax::block::Item;
use crate::syntax::block::constructors::*; use crate::syntax::block::constructors::*;
use preserves::value::{IOValue, NestedValue};
use super::names; use super::names;
use super::types::*; use super::types::*;
use crate::metaschema::*;
use super::context::{ModuleContext, FunctionContext}; 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( m.define_function(
|mut ctxt| { |mut ctxt| {
let mut body = Vec::new(); let mut body = Vec::new();
if let Some(fs) = d.value().as_simple_record("or", Some(1)) { match d {
for e in fs[0].value().to_sequence().unwrap() { Definition::Or { pattern_0, pattern_1, pattern_n } => {
let e = e.value().to_sequence().unwrap(); let mut ps: Vec<&NamedAlternative> = pattern_n.iter().collect();
let name = e[0].value().to_string().unwrap(); ps.insert(0, &**pattern_1);
let pat = &e[1]; ps.insert(0, &**pattern_0);
let fname = seq!["_parse_", names::render_fieldname(n), "_", names::render_fieldname(name)]; for NamedAlternative { variant_label: name, pattern: pat } in ps {
let ctorname = item(name![names::render_constructor(n), names::render_constructor(name)]); let fname = seq!["_parse_", names::render_fieldname(n), "_", names::render_fieldname(name)];
ctxt.m.define_function( let ctorname = item(name![names::render_constructor(n), names::render_constructor(name)]);
|mut ctxt| { ctxt.m.define_function(
let mut body = Vec::new(); |mut ctxt| {
let dest = pattern_parser(&mut ctxt, pat, "value", None, &mut body); let mut body = Vec::new();
let dest = dest.as_ref().map(String::as_str); let dest = pattern_parser(&mut ctxt, pat, "value", None, &mut body);
construct(&ctxt, ctorname, false, &TDefinition::Simple(simple_type(pat).unwrap()), dest, &mut body); let dest = dest.as_ref().map(String::as_str);
item(seq!["fn ", fname.clone(), "(value: &preserves::value::IOValue) -> ", construct(&ctxt, ctorname, false, &TDefinition::Simple(pattern_type(pat)), dest, &mut body);
"std::result::Result<", names::render_constructor(n), ", ()> ", item(seq!["fn ", fname.clone(), "(value: &preserves::value::IOValue) -> ",
block(body)]) "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!["if let Ok(r) = ", fname, "(value) { return Ok(r); }"]));
}
body.push(item(seq!["Err(())"]));
} }
body.push(item(seq!["Err(())"])); Definition::And { pattern_0, pattern_1, pattern_n } => {
} else if let Some(fs) = d.value().as_simple_record("and", Some(1)) { let mut ps: Vec<&NamedPattern> = pattern_n.iter().collect();
for e in fs[0].value().to_sequence().unwrap() { ps.insert(0, &**pattern_1);
pattern_parser(&mut ctxt, e, "value", None, &mut body); 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 ", item(seq!["impl std::convert::TryFrom", anglebrackets!["&preserves::value::IOValue"], " for ",
@ -98,87 +105,90 @@ fn push_let_mut(body: &mut Vec<Item>, name: &str, expr: Item) {
fn simple_pattern_parser( fn simple_pattern_parser(
ctxt: &mut FunctionContext, ctxt: &mut FunctionContext,
p: &IOValue, p: &SimplePattern,
src: &str, src: &str,
sequence_base: Option<usize>, sequence_base: Option<usize>,
body: &mut Vec<Item>, body: &mut Vec<Item>,
) -> Option<String> { ) -> String {
let dest = ctxt.gentempname(); let dest = ctxt.gentempname();
if p.value().as_symbol() == Some(&"any".to_owned()) { match p {
push_let(body, &dest, item(src.to_owned())); SimplePattern::Any => {
Some(dest) push_let(body, &dest, item(src.to_owned()));
} else if let Some(fs) = p.value().as_simple_record("atom", Some(1)) { dest
match fs[0].value().as_symbol().unwrap().as_str() { },
"Boolean" => push_let(body, &dest, item(seq![src.to_owned(), ".value().to_boolean().map_err(|_| ())?"])), SimplePattern::Atom { atom_kind: k } => {
"Float" => push_let(body, &dest, item(seq![src.to_owned(), ".value().to_float().map_err(|_| ())?"])), match &**k {
"Double" => push_let(body, &dest, item(seq![src.to_owned(), ".value().to_double().map_err(|_| ())?"])), AtomKind::Boolean => push_let(body, &dest, item(seq![src.to_owned(), ".value().to_boolean().map_err(|_| ())?"])),
"SignedInteger" => push_let(body, &dest, item(seq![src.to_owned(), ".value().to_signedinteger().map_err(|_| ())?"])), AtomKind::Float => push_let(body, &dest, item(seq![src.to_owned(), ".value().to_float().map_err(|_| ())?"])),
"String" => push_let(body, &dest, item(seq![src.to_owned(), ".value().to_string().map_err(|_| ())?"])), AtomKind::Double => push_let(body, &dest, item(seq![src.to_owned(), ".value().to_double().map_err(|_| ())?"])),
"ByteString" => push_let(body, &dest, item(seq![src.to_owned(), ".value().to_bytestring().map_err(|_| ())?"])), AtomKind::SignedInteger => push_let(body, &dest, item(seq![src.to_owned(), ".value().to_signedinteger().map_err(|_| ())?"])),
"Symbol" => push_let(body, &dest, item(seq![src.to_owned(), ".value().to_symbol().map_err(|_| ())?"])), AtomKind::String => push_let(body, &dest, item(seq![src.to_owned(), ".value().to_string().map_err(|_| ())?"])),
_ => panic!("Unexpected AtomKind"), 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(|_| ())?"])),
Some(dest) }
} else if let Some(_) = p.value().as_simple_record("embedded", Some(1)) { dest
push_let(body, &dest, item(seq![src.to_owned(), ".value().to_embedded().map_err(|_| ())?"])); },
Some(dest) SimplePattern::Embedded { .. } => {
} else if let Some(fs) = p.value().as_simple_record("lit", Some(1)) { push_let(body, &dest, item(seq![src.to_owned(), ".value().to_embedded().map_err(|_| ())?"]));
body.push(item(seq!["if ", src.to_owned(), " != ", ctxt.m.define_literal(&fs[0]), dest
" { return Err(()); }"])); },
push_let(body, &dest, item("()")); SimplePattern::Lit { value } => {
Some(dest) body.push(item(seq!["if ", src.to_owned(), " != ", ctxt.m.define_literal(value),
} else if let Some(fs) = p.value().as_simple_record("seqof", Some(1)) { " { return Err(()); }"]));
let (src, n) = sequenceify(ctxt, src, sequence_base, body); push_let(body, &dest, item("()"));
let tmp = ctxt.gentempname(); dest
let mut inner = Vec::new(); },
let item_dest = simple_pattern_parser(ctxt, &fs[0], &tmp, None, &mut inner); SimplePattern::Seqof { pattern } => {
inner.push(item(seq![ let (src, n) = sequenceify(ctxt, src, sequence_base, body);
dest.to_owned(), ".push(", let tmp = ctxt.gentempname();
store_wrap(true, &field_type(&fs[0]).unwrap().unwrap(), &item_dest.unwrap()), ");"])); let mut inner = Vec::new();
push_let_mut(body, &dest, item("std::vec::Vec::new()")); let item_dest = simple_pattern_parser(ctxt, pattern, &tmp, None, &mut inner);
body.push(item(seq!["for ", tmp.to_owned(), inner.push(item(seq![dest.to_owned(), ".push(",
" in &", src.to_owned(), brackets![seq![n.to_string() , ".."]], store_wrap(true, &field_type(pattern), &item_dest), ");"]));
" ", block(inner)])); push_let_mut(body, &dest, item("std::vec::Vec::new()"));
Some(dest) body.push(item(seq!["for ", tmp.to_owned(),
} else if let Some(fs) = p.value().as_simple_record("setof", Some(1)) { " in &", src.to_owned(), brackets![seq![n.to_string() , ".."]],
let tmp = ctxt.gentempname(); " ", block(inner)]));
let mut inner = Vec::new(); dest
let item_dest = simple_pattern_parser(ctxt, &fs[0], &tmp, None, &mut inner); },
inner.push(item(seq![ SimplePattern::Setof { pattern } => {
dest.to_owned(), ".insert(", let tmp = ctxt.gentempname();
store_wrap(true, &field_type(&fs[0]).unwrap().unwrap(), &item_dest.unwrap()), ");"])); let mut inner = Vec::new();
push_let_mut(body, &dest, item("preserves::value::Set::new()")); let item_dest = simple_pattern_parser(ctxt, pattern, &tmp, None, &mut inner);
body.push(item(seq!["for ", tmp.to_owned(), inner.push(item(seq![dest.to_owned(), ".insert(",
" in ", src.to_owned(), ".value().to_set().map_err(|_| ())?", store_wrap(true, &field_type(pattern), &item_dest), ");"]));
" ", block(inner)])); push_let_mut(body, &dest, item("preserves::value::Set::new()"));
Some(dest) body.push(item(seq!["for ", tmp.to_owned(),
} else if let Some(fs) = p.value().as_simple_record("dictof", Some(2)) { " in ", src.to_owned(), ".value().to_set().map_err(|_| ())?",
let tmp_key = ctxt.gentempname(); " ", block(inner)]));
let tmp_value = ctxt.gentempname(); dest
let mut inner = Vec::new(); },
let key_dest = simple_pattern_parser(ctxt, &fs[0], &tmp_key, None, &mut inner); SimplePattern::Dictof { key, value } => {
let value_dest = simple_pattern_parser(ctxt, &fs[1], &tmp_value, None, &mut inner); let tmp_key = ctxt.gentempname();
inner.push(item(seq![ let tmp_value = ctxt.gentempname();
dest.to_owned(), ".insert(", let mut inner = Vec::new();
store_wrap(true, &field_type(&fs[0]).unwrap().unwrap(), &key_dest.unwrap()), ", ", let key_dest = simple_pattern_parser(ctxt, key, &tmp_key, None, &mut inner);
store_wrap(true, &field_type(&fs[1]).unwrap().unwrap(), &value_dest.unwrap()), ");"])); let value_dest = simple_pattern_parser(ctxt, value, &tmp_value, None, &mut inner);
push_let_mut(body, &dest, item("preserves::value::Map::new()")); inner.push(item(seq![
body.push(item(seq!["for (", tmp_key.to_owned(), ", ", tmp_value.to_owned(), ")", dest.to_owned(), ".insert(",
" in ", src.to_owned(), ".value().to_dictionary().map_err(|_| ())?", store_wrap(true, &field_type(key), &key_dest), ", ",
" ", block(inner)])); store_wrap(true, &field_type(value), &value_dest), ");"]));
Some(dest) push_let_mut(body, &dest, item("preserves::value::Map::new()"));
} else if let Some(fs) = p.value().as_simple_record("ref", Some(2)) { body.push(item(seq!["for (", tmp_key.to_owned(), ", ", tmp_value.to_owned(), ")",
let mut n: Vec<String> = fs[0].value().to_sequence().unwrap() " in ", src.to_owned(), ".value().to_dictionary().map_err(|_| ())?",
.iter().map(|s| s.value().to_symbol().unwrap().to_owned()).collect(); " ", block(inner)]));
use convert_case::{Case, Casing}; dest
n.push(fs[1].value().to_symbol().unwrap().to_case(Case::UpperCamel)); },
let tf = name![names::render_ref(n), "try_from"]; SimplePattern::Ref(r) => {
push_let(body, &dest, item(seq![tf, let Ref { module: ModulePath(module), name } = &**r;
parens![src.to_owned()], let mut mp = module.clone();
"?"])); mp.push(name.to_owned());
Some(dest) let tf = name![names::render_ref(mp), "try_from"];
} else { push_let(body, &dest, item(seq![tf,
None parens![src.to_owned()],
"?"]));
dest
},
} }
} }
@ -201,7 +211,7 @@ fn sequenceify(
fn fixed_sequence_parser( fn fixed_sequence_parser(
ctxt: &mut FunctionContext, ctxt: &mut FunctionContext,
base: usize, base: usize,
ps: &[IOValue], ps: &[NamedPattern],
src: &str, src: &str,
body: &mut Vec<Item>, body: &mut Vec<Item>,
) { ) {
@ -209,64 +219,71 @@ fn fixed_sequence_parser(
body.push(item(seq!["if ", src.to_owned(), ".len() - ", base.to_string(), " < ", body.push(item(seq!["if ", src.to_owned(), ".len() - ", base.to_string(), " < ",
ps.len().to_string(), " { return Err(()); }"])); ps.len().to_string(), " { return Err(()); }"]));
for p in ps { 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; i += 1;
} }
} }
fn named_pattern_parser(
ctxt: &mut FunctionContext,
p: &NamedPattern,
src: &str,
sequence_base: Option<usize>,
body: &mut Vec<Item>,
) {
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( fn pattern_parser(
ctxt: &mut FunctionContext, ctxt: &mut FunctionContext,
p: &IOValue, p: &Pattern,
src: &str, src: &str,
sequence_base: Option<usize>, sequence_base: Option<usize>,
body: &mut Vec<Item>, body: &mut Vec<Item>,
) -> Option<String> { ) -> Option<String> {
match simple_pattern_parser(ctxt, p, src, sequence_base, body) { match p {
Some(dest) => Some(dest), Pattern::SimplePattern(s) =>
None => { Some(simple_pattern_parser(ctxt, s, src, sequence_base, body)),
// Compound Pattern::CompoundPattern(c) => {
let r = p.value().as_record(None).unwrap(); match &**c {
match r.label().value().as_symbol().unwrap().as_ref() { CompoundPattern::Rec { label, fields } => {
"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" => {
let rtmp = ctxt.gentempname(); let rtmp = ctxt.gentempname();
push_let(body, &rtmp, item(seq![src.to_owned(), ".value().to_record(None).map_err(|_| ())?"])); push_let(body, &rtmp, item(seq![src.to_owned(), ".value().to_record(None).map_err(|_| ())?"]));
pattern_parser(ctxt, &r.fields()[0], &format!("{}.label()", rtmp), None, body); named_pattern_parser(ctxt, &**label, &format!("{}.label()", rtmp), None, body);
pattern_parser(ctxt, &r.fields()[1], &format!("{}.fields()", rtmp), Some(0), body); named_pattern_parser(ctxt, &**fields, &format!("{}.fields()", rtmp), Some(0), body);
None },
} CompoundPattern::Tuple { patterns } => {
"tuple" => {
let (src, n) = sequenceify(ctxt, src, sequence_base, body); let (src, n) = sequenceify(ctxt, src, sequence_base, body);
fixed_sequence_parser(ctxt, n, r.fields()[0].value().to_sequence().unwrap(), &src, body); fixed_sequence_parser(ctxt, n, patterns, &src, body);
None },
} CompoundPattern::TuplePrefix { fixed, variable } => {
"tuplePrefix" => {
let (src, n) = sequenceify(ctxt, src, sequence_base, body); 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); fixed_sequence_parser(ctxt, n, fixed, &src, body);
pattern_parser(ctxt, &r.fields()[1], &src, Some(n + fixed.len()), body) named_pattern_parser(ctxt, &promote(&**variable), &src, Some(n + fixed.len()), body);
} },
"dict" => { CompoundPattern::Dict { entries } => {
let dtmp = ctxt.gentempname(); let dtmp = ctxt.gentempname();
push_let(body, &dtmp, item(seq![src.to_owned(), ".value().to_dictionary().map_err(|_| ())?"])); push_let(body, &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(); let vtmp = ctxt.gentempname();
push_let(body, &vtmp, item(seq![ push_let(body, &vtmp, item(seq![
dtmp.to_owned(), ".get", parens![ctxt.m.define_literal(key_lit)], dtmp.to_owned(), ".get", parens![ctxt.m.define_literal(key_lit)],
".ok_or(())?"])); ".ok_or(())?"]));
pattern_parser(ctxt, value_pat, &vtmp, None, body); named_pattern_parser(ctxt, &promote(value_pat), &vtmp, None, body);
} }
None
} }
_ => panic!("Unexpected compound"),
} }
} None
},
} }
} }

167
implementations/rust/preserves-schema/src/compiler/types.rs
View File

@ -1,11 +1,9 @@
use crate::*; use crate::*;
use crate::syntax::block::Emittable; use crate::syntax::block::Emittable;
use crate::syntax::block::constructors::*; use crate::syntax::block::constructors::*;
use crate::metaschema::*;
use super::names; use super::names;
use preserves::value::{IOValue, NestedValue};
use preserves::error::Error;
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone)] #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone)]
pub enum TDefinition { pub enum TDefinition {
Union(Vec<(String, TSimple)>), Union(Vec<(String, TSimple)>),
@ -31,104 +29,113 @@ pub enum TField {
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone)] #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone)]
pub struct TRecord(pub Vec<(String, TField)>); pub struct TRecord(pub Vec<(String, TField)>);
pub fn definition_type(d: &IOValue) -> Result<TDefinition, Error> { pub fn definition_type(d: &Definition) -> TDefinition {
if let Some(fs) = d.value().as_simple_record("or", Some(1)) { match d {
let mut entries = Vec::new(); Definition::Or { pattern_0, pattern_1, pattern_n } => {
for e in fs[0].value().to_sequence()?.iter() { let mut entries = Vec::new();
let e = e.value().to_sequence()?; entries.push((pattern_0.variant_label.to_owned(), pattern_type(&pattern_0.pattern)));
entries.push((e[0].value().to_string()?.to_owned(), simple_type(&e[1])?)); entries.push((pattern_1.variant_label.to_owned(), pattern_type(&pattern_1.pattern)));
} for e in pattern_n {
Ok(TDefinition::Union(entries)) entries.push((e.variant_label.to_owned(), pattern_type(&e.pattern)));
} else if let Some(fs) = d.value().as_simple_record("and", Some(1)) { }
Ok(TDefinition::Simple(record_type(fs[0].value().to_sequence()?)?)) TDefinition::Union(entries)
} else { },
Ok(TDefinition::Simple(simple_type(d)?)) 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<TSimple, Error> { pub fn pattern_type(p: &Pattern) -> TSimple {
if let Some(t) = field_type(p)? { match p {
Ok(TSimple::Field(t)) Pattern::SimplePattern(p) =>
} else { TSimple::Field(field_type(p)),
record_type(&vec![p.clone()]) Pattern::CompoundPattern(_) =>
record_type(&vec![&NamedPattern::Anonymous(Box::new(p.clone()))]),
} }
} }
pub fn record_type(ps: &Vec<IOValue>) -> Result<TSimple, Error> { pub fn record_type(ps: &Vec<&NamedPattern>) -> TSimple {
let fs = gather_fields(ps, Vec::new())?; let fs = gather_fields(ps, Vec::new());
if fs.is_empty() { if fs.is_empty() {
Ok(TSimple::Field(TField::Unit)) TSimple::Field(TField::Unit)
} else { } else {
Ok(TSimple::Record(TRecord(fs))) TSimple::Record(TRecord(fs))
} }
} }
pub fn gather_fields(ps: &Vec<IOValue>, mut fs: Vec<(String, TField)>) -> pub fn gather_fields(ps: &Vec<&NamedPattern>, mut fs: Vec<(String, TField)>) -> Vec<(String, TField)>
Result<Vec<(String, TField)>, Error>
{ {
for p in ps.iter() { 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)>) -> pub fn gather_field(p: &NamedPattern, mut fs: Vec<(String, TField)>) -> Vec<(String, TField)> {
Result<Vec<(String, TField)>, Error> match p {
{ NamedPattern::Named(b) => {
if let Some(n) = p.value().as_simple_record("named", Some(2)) { let Binding { name, pattern } = &**b;
let name = n[0].value().to_symbol()?; fs.push((name.to_owned(), field_type(pattern)));
fs.push((name.to_owned(), field_type(&n[1])?.unwrap())); fs
Ok(fs) },
} else if let Some(label_and_fields) = p.value().as_simple_record("rec", Some(2)) { NamedPattern::Anonymous(p) => match &**p {
Ok(gather_field(&label_and_fields[1], gather_field(&label_and_fields[0], fs)?)?) Pattern::SimplePattern(_) =>
} else if let Some(tfs) = p.value().as_simple_record("tuple", Some(1)) { fs,
Ok(gather_fields(tfs[0].value().to_sequence()?, fs)?) Pattern::CompoundPattern(c) => match &**c {
} else if let Some(tfs) = p.value().as_simple_record("tuplePrefix", Some(2)) { CompoundPattern::Rec { label, fields } =>
Ok(gather_field(&tfs[1], gather_fields(tfs[0].value().to_sequence()?, fs)?)?) gather_field(&*fields, gather_field(&*label, fs)),
} else if let Some(dfs) = p.value().as_simple_record("dict", Some(1)) { CompoundPattern::Tuple { patterns } =>
let es = dfs[0].value().to_dictionary()?; gather_fields(&patterns.iter().collect(), fs),
for (_k, p) in es.iter() { CompoundPattern::TuplePrefix { fixed, variable } =>
fs = gather_field(p, fs)?; 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<Option<TField>, Error> { pub fn promote(p: &NamedSimplePattern) -> NamedPattern {
if p.value().as_symbol() == Some(&"any".to_owned()) { match p {
Ok(Some(TField::Base("preserves::value::IOValue".to_owned()))) NamedSimplePattern::Anonymous(p) => NamedPattern::Anonymous(Box::new(Pattern::SimplePattern(p.clone()))),
} else if let Some(fs) = p.value().as_simple_record("atom", Some(1)) { NamedSimplePattern::Named(n) => NamedPattern::Named(n.clone()),
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()))), pub fn field_type(p: &SimplePattern) -> TField {
"SignedInteger" => Ok(Some(TField::Base("preserves::value::signed_integer::SignedInteger".to_owned()))), match p {
"String" => Ok(Some(TField::Base("std::string::String".to_owned()))), SimplePattern::Any => TField::Base("preserves::value::IOValue".to_owned()),
"ByteString" => Ok(Some(TField::Base("std::vec::Vec<u8>".to_owned()))), SimplePattern::Atom { atom_kind: k } =>
"Symbol" => Ok(Some(TField::Base("std::string::String".to_owned()))), match **k {
_ => Err(Error::Message("Unexpected AtomKind".to_owned())), 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<u8>".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::<Result<Vec<String>,_>>()?;
pieces.push(fs[1].value().to_symbol()?.to_owned());
Ok(Some(TField::Ref(pieces)))
} else {
Ok(None)
} }
} }

320
implementations/rust/preserves-schema/src/metaschema.rs
View File

@ -1,39 +1,39 @@
#![allow(unused_parens)] #![allow(unused_parens)]
use std::convert::TryFrom; use std::convert::TryFrom;
use preserves::value::{NestedValue, Reader}; use preserves::value::NestedValue;
use lazy_static::lazy_static; use lazy_static::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 LIT15: preserves::value::IOValue = /* #f */ preserves::value::packed::from_bytes(&vec![128]).unwrap();
pub static ref LIT28: preserves::value::IOValue = /* 1 */ preserves::value::PackedReader::decode_bytes(&vec![145]).demand_next(false).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::PackedReader::decode_bytes(&vec![179, 7, 66, 111, 111, 108, 101, 97, 110]).demand_next(false).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::PackedReader::decode_bytes(&vec![179, 10, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103]).demand_next(false).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::PackedReader::decode_bytes(&vec![179, 6, 68, 111, 117, 98, 108, 101]).demand_next(false).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::PackedReader::decode_bytes(&vec![179, 5, 70, 108, 111, 97, 116]).demand_next(false).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::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 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::PackedReader::decode_bytes(&vec![179, 6, 83, 116, 114, 105, 110, 103]).demand_next(false).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::PackedReader::decode_bytes(&vec![179, 6, 83, 121, 109, 98, 111, 108]).demand_next(false).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::PackedReader::decode_bytes(&vec![179, 3, 97, 110, 100]).demand_next(false).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::PackedReader::decode_bytes(&vec![179, 3, 97, 110, 121]).demand_next(false).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::PackedReader::decode_bytes(&vec![179, 4, 97, 116, 111, 109]).demand_next(false).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::PackedReader::decode_bytes(&vec![179, 6, 98, 117, 110, 100, 108, 101]).demand_next(false).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::PackedReader::decode_bytes(&vec![179, 11, 100, 101, 102, 105, 110, 105, 116, 105, 111, 110, 115]).demand_next(false).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::PackedReader::decode_bytes(&vec![179, 4, 100, 105, 99, 116]).demand_next(false).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::PackedReader::decode_bytes(&vec![179, 6, 100, 105, 99, 116, 111, 102]).demand_next(false).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::PackedReader::decode_bytes(&vec![179, 8, 101, 109, 98, 101, 100, 100, 101, 100]).demand_next(false).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::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 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::PackedReader::decode_bytes(&vec![179, 3, 108, 105, 116]).demand_next(false).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::PackedReader::decode_bytes(&vec![179, 5, 110, 97, 109, 101, 100]).demand_next(false).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::PackedReader::decode_bytes(&vec![179, 2, 111, 114]).demand_next(false).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::PackedReader::decode_bytes(&vec![179, 3, 114, 101, 99]).demand_next(false).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::PackedReader::decode_bytes(&vec![179, 3, 114, 101, 102]).demand_next(false).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::PackedReader::decode_bytes(&vec![179, 6, 115, 99, 104, 101, 109, 97]).demand_next(false).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::PackedReader::decode_bytes(&vec![179, 5, 115, 101, 113, 111, 102]).demand_next(false).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::PackedReader::decode_bytes(&vec![179, 5, 115, 101, 116, 111, 102]).demand_next(false).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::PackedReader::decode_bytes(&vec![179, 5, 116, 117, 112, 108, 101]).demand_next(false).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::PackedReader::decode_bytes(&vec![179, 11, 116, 117, 112, 108, 101, 80, 114, 101, 102, 105, 120]).demand_next(false).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::PackedReader::decode_bytes(&vec![179, 7, 118, 101, 114, 115, 105, 111, 110]).demand_next(false).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)] #[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 { impl std::convert::TryFrom<&preserves::value::IOValue> for Binding {
type Error = (); type Error = ();
fn try_from(value: &preserves::value::IOValue) -> std::result::Result<Self, Self::Error> { fn try_from(value: &preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
let _tmp1 = value.value().to_record(None).map_err(|_| ())?; let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
if _tmp1.label() != &*LIT7 { return Err(()); } if _tmp0.label() != &*LIT7 { return Err(()); }
let _tmp2 = (); let _tmp1 = ();
if _tmp1.fields().len() - 0 < 2 { return Err(()); } if _tmp0.fields().len() - 0 < 2 { return Err(()); }
let _tmp5 = (&_tmp1.fields()[0]).value().to_symbol().map_err(|_| ())?; let _tmp2 = (&_tmp0.fields()[0]).value().to_symbol().map_err(|_| ())?;
let _tmp7 = SimplePattern::try_from((&_tmp1.fields()[1]))?; let _tmp3 = SimplePattern::try_from((&_tmp0.fields()[1]))?;
Ok(Binding {name: _tmp5.clone(), pattern: _tmp7}) Ok(Binding {name: _tmp2.clone(), pattern: _tmp3})
} }
} }
impl std::convert::TryFrom<&preserves::value::IOValue> for Bundle { impl std::convert::TryFrom<&preserves::value::IOValue> for Bundle {
type Error = (); type Error = ();
fn try_from(value: &preserves::value::IOValue) -> std::result::Result<Self, Self::Error> { fn try_from(value: &preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
let _tmp1 = value.value().to_record(None).map_err(|_| ())?; let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
if _tmp1.label() != &*LIT8 { return Err(()); } if _tmp0.label() != &*LIT8 { return Err(()); }
let _tmp2 = (); let _tmp1 = ();
if _tmp1.fields().len() - 0 < 1 { return Err(()); } if _tmp0.fields().len() - 0 < 1 { return Err(()); }
let _tmp5 = Modules::try_from((&_tmp1.fields()[0]))?; let _tmp2 = Modules::try_from((&_tmp0.fields()[0]))?;
Ok(Bundle {modules: _tmp5}) Ok(Bundle {modules: _tmp2})
} }
} }
fn _parse_compound_pattern_rec(value: &preserves::value::IOValue) -> std::result::Result<CompoundPattern, ()> { fn _parse_compound_pattern_rec(value: &preserves::value::IOValue) -> std::result::Result<CompoundPattern, ()> {
let _tmp1 = value.value().to_record(None).map_err(|_| ())?; let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
if _tmp1.label() != &*LIT9 { return Err(()); } if _tmp0.label() != &*LIT9 { return Err(()); }
let _tmp2 = (); let _tmp1 = ();
if _tmp1.fields().len() - 0 < 2 { return Err(()); } if _tmp0.fields().len() - 0 < 2 { return Err(()); }
let _tmp5 = NamedPattern::try_from((&_tmp1.fields()[0]))?; let _tmp2 = NamedPattern::try_from((&_tmp0.fields()[0]))?;
let _tmp7 = NamedPattern::try_from((&_tmp1.fields()[1]))?; let _tmp3 = NamedPattern::try_from((&_tmp0.fields()[1]))?;
Ok(CompoundPattern::Rec {label: std::boxed::Box::new(_tmp5), fields: std::boxed::Box::new(_tmp7)}) 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<CompoundPattern, ()> { fn _parse_compound_pattern_tuple(value: &preserves::value::IOValue) -> std::result::Result<CompoundPattern, ()> {
let _tmp1 = value.value().to_record(None).map_err(|_| ())?; let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
if _tmp1.label() != &*LIT10 { return Err(()); } if _tmp0.label() != &*LIT10 { return Err(()); }
let _tmp2 = (); let _tmp1 = ();
if _tmp1.fields().len() - 0 < 1 { return Err(()); } if _tmp0.fields().len() - 0 < 1 { return Err(()); }
let _tmp6 = (&_tmp1.fields()[0]).value().to_sequence().map_err(|_| ())?; let _tmp3 = (&_tmp0.fields()[0]).value().to_sequence().map_err(|_| ())?;
let mut _tmp5 = std::vec::Vec::new(); let mut _tmp2 = std::vec::Vec::new();
for _tmp7 in &_tmp6[0..] {let _tmp8 = NamedPattern::try_from(_tmp7)?; _tmp5.push(_tmp8);} for _tmp4 in &_tmp3[0..] {let _tmp5 = NamedPattern::try_from(_tmp4)?; _tmp2.push(_tmp5);}
Ok(CompoundPattern::Tuple {patterns: _tmp5}) Ok(CompoundPattern::Tuple {patterns: _tmp2})
} }
fn _parse_compound_pattern_tuple_prefix(value: &preserves::value::IOValue) -> std::result::Result<CompoundPattern, ()> { fn _parse_compound_pattern_tuple_prefix(value: &preserves::value::IOValue) -> std::result::Result<CompoundPattern, ()> {
let _tmp1 = value.value().to_record(None).map_err(|_| ())?; let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
if _tmp1.label() != &*LIT11 { return Err(()); } if _tmp0.label() != &*LIT11 { return Err(()); }
let _tmp2 = (); let _tmp1 = ();
if _tmp1.fields().len() - 0 < 2 { return Err(()); } if _tmp0.fields().len() - 0 < 2 { return Err(()); }
let _tmp6 = (&_tmp1.fields()[0]).value().to_sequence().map_err(|_| ())?; let _tmp3 = (&_tmp0.fields()[0]).value().to_sequence().map_err(|_| ())?;
let mut _tmp5 = std::vec::Vec::new(); let mut _tmp2 = std::vec::Vec::new();
for _tmp7 in &_tmp6[0..] {let _tmp8 = NamedPattern::try_from(_tmp7)?; _tmp5.push(_tmp8);} for _tmp4 in &_tmp3[0..] {let _tmp5 = NamedPattern::try_from(_tmp4)?; _tmp2.push(_tmp5);}
let _tmp10 = NamedSimplePattern::try_from((&_tmp1.fields()[1]))?; let _tmp6 = NamedSimplePattern::try_from((&_tmp0.fields()[1]))?;
Ok(CompoundPattern::TuplePrefix {fixed: _tmp5, variable: std::boxed::Box::new(_tmp10)}) Ok(CompoundPattern::TuplePrefix {fixed: _tmp2, variable: std::boxed::Box::new(_tmp6)})
} }
fn _parse_compound_pattern_dict(value: &preserves::value::IOValue) -> std::result::Result<CompoundPattern, ()> { fn _parse_compound_pattern_dict(value: &preserves::value::IOValue) -> std::result::Result<CompoundPattern, ()> {
let _tmp1 = value.value().to_record(None).map_err(|_| ())?; let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
if _tmp1.label() != &*LIT12 { return Err(()); } if _tmp0.label() != &*LIT12 { return Err(()); }
let _tmp2 = (); let _tmp1 = ();
if _tmp1.fields().len() - 0 < 1 { return Err(()); } if _tmp0.fields().len() - 0 < 1 { return Err(()); }
let _tmp5 = DictionaryEntries::try_from((&_tmp1.fields()[0]))?; let _tmp2 = DictionaryEntries::try_from((&_tmp0.fields()[0]))?;
Ok(CompoundPattern::Dict {entries: std::boxed::Box::new(_tmp5)}) Ok(CompoundPattern::Dict {entries: std::boxed::Box::new(_tmp2)})
} }
impl std::convert::TryFrom<&preserves::value::IOValue> for CompoundPattern { 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<Definition, ()> { fn _parse_definition_or(value: &preserves::value::IOValue) -> std::result::Result<Definition, ()> {
let _tmp1 = value.value().to_record(None).map_err(|_| ())?; let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
if _tmp1.label() != &*LIT13 { return Err(()); } if _tmp0.label() != &*LIT13 { return Err(()); }
let _tmp2 = (); let _tmp1 = ();
if _tmp1.fields().len() - 0 < 1 { return Err(()); } if _tmp0.fields().len() - 0 < 1 { return Err(()); }
let _tmp5 = (&_tmp1.fields()[0]).value().to_sequence().map_err(|_| ())?; let _tmp2 = (&_tmp0.fields()[0]).value().to_sequence().map_err(|_| ())?;
if _tmp5.len() - 0 < 2 { return Err(()); } if _tmp2.len() - 0 < 2 { return Err(()); }
let _tmp7 = NamedAlternative::try_from((&_tmp5[0]))?; let _tmp3 = NamedAlternative::try_from((&_tmp2[0]))?;
let _tmp9 = NamedAlternative::try_from((&_tmp5[1]))?; let _tmp4 = NamedAlternative::try_from((&_tmp2[1]))?;
let mut _tmp11 = std::vec::Vec::new(); let mut _tmp5 = std::vec::Vec::new();
for _tmp12 in &_tmp5[2..] {let _tmp13 = NamedAlternative::try_from(_tmp12)?; _tmp11.push(_tmp13);} for _tmp6 in &_tmp2[2..] {let _tmp7 = NamedAlternative::try_from(_tmp6)?; _tmp5.push(_tmp7);}
Ok(Definition::Or { Ok(Definition::Or {
pattern_0: std::boxed::Box::new(_tmp7), pattern_0: std::boxed::Box::new(_tmp3),
pattern_1: std::boxed::Box::new(_tmp9), pattern_1: std::boxed::Box::new(_tmp4),
pattern_n: _tmp11 pattern_n: _tmp5
}) })
} }
fn _parse_definition_and(value: &preserves::value::IOValue) -> std::result::Result<Definition, ()> { fn _parse_definition_and(value: &preserves::value::IOValue) -> std::result::Result<Definition, ()> {
let _tmp1 = value.value().to_record(None).map_err(|_| ())?; let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
if _tmp1.label() != &*LIT14 { return Err(()); } if _tmp0.label() != &*LIT14 { return Err(()); }
let _tmp2 = (); let _tmp1 = ();
if _tmp1.fields().len() - 0 < 1 { return Err(()); } if _tmp0.fields().len() - 0 < 1 { return Err(()); }
let _tmp5 = (&_tmp1.fields()[0]).value().to_sequence().map_err(|_| ())?; let _tmp2 = (&_tmp0.fields()[0]).value().to_sequence().map_err(|_| ())?;
if _tmp5.len() - 0 < 2 { return Err(()); } if _tmp2.len() - 0 < 2 { return Err(()); }
let _tmp7 = NamedPattern::try_from((&_tmp5[0]))?; let _tmp3 = NamedPattern::try_from((&_tmp2[0]))?;
let _tmp9 = NamedPattern::try_from((&_tmp5[1]))?; let _tmp4 = NamedPattern::try_from((&_tmp2[1]))?;
let mut _tmp11 = std::vec::Vec::new(); let mut _tmp5 = std::vec::Vec::new();
for _tmp12 in &_tmp5[2..] {let _tmp13 = NamedPattern::try_from(_tmp12)?; _tmp11.push(_tmp13);} for _tmp6 in &_tmp2[2..] {let _tmp7 = NamedPattern::try_from(_tmp6)?; _tmp5.push(_tmp7);}
Ok(Definition::And { Ok(Definition::And {
pattern_0: std::boxed::Box::new(_tmp7), pattern_0: std::boxed::Box::new(_tmp3),
pattern_1: std::boxed::Box::new(_tmp9), pattern_1: std::boxed::Box::new(_tmp4),
pattern_n: _tmp11 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 { impl std::convert::TryFrom<&preserves::value::IOValue> for NamedAlternative {
type Error = (); type Error = ();
fn try_from(value: &preserves::value::IOValue) -> std::result::Result<Self, Self::Error> { fn try_from(value: &preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
let _tmp1 = value.value().to_sequence().map_err(|_| ())?; let _tmp0 = value.value().to_sequence().map_err(|_| ())?;
if _tmp1.len() - 0 < 2 { return Err(()); } if _tmp0.len() - 0 < 2 { return Err(()); }
let _tmp3 = (&_tmp1[0]).value().to_string().map_err(|_| ())?; let _tmp1 = (&_tmp0[0]).value().to_string().map_err(|_| ())?;
let _tmp5 = Pattern::try_from((&_tmp1[1]))?; let _tmp2 = Pattern::try_from((&_tmp0[1]))?;
Ok(NamedAlternative {variant_label: _tmp3.clone(), pattern: _tmp5}) 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 { impl std::convert::TryFrom<&preserves::value::IOValue> for Ref {
type Error = (); type Error = ();
fn try_from(value: &preserves::value::IOValue) -> std::result::Result<Self, Self::Error> { fn try_from(value: &preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
let _tmp1 = value.value().to_record(None).map_err(|_| ())?; let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
if _tmp1.label() != &*LIT16 { return Err(()); } if _tmp0.label() != &*LIT16 { return Err(()); }
let _tmp2 = (); let _tmp1 = ();
if _tmp1.fields().len() - 0 < 2 { return Err(()); } if _tmp0.fields().len() - 0 < 2 { return Err(()); }
let _tmp5 = ModulePath::try_from((&_tmp1.fields()[0]))?; let _tmp2 = ModulePath::try_from((&_tmp0.fields()[0]))?;
let _tmp7 = (&_tmp1.fields()[1]).value().to_symbol().map_err(|_| ())?; let _tmp3 = (&_tmp0.fields()[1]).value().to_symbol().map_err(|_| ())?;
Ok(Ref {module: _tmp5, name: _tmp7.clone()}) Ok(Ref {module: _tmp2, name: _tmp3.clone()})
} }
} }
impl std::convert::TryFrom<&preserves::value::IOValue> for Schema { impl std::convert::TryFrom<&preserves::value::IOValue> for Schema {
type Error = (); type Error = ();
fn try_from(value: &preserves::value::IOValue) -> std::result::Result<Self, Self::Error> { fn try_from(value: &preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
let _tmp1 = value.value().to_record(None).map_err(|_| ())?; let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
if _tmp1.label() != &*LIT17 { return Err(()); } if _tmp0.label() != &*LIT17 { return Err(()); }
let _tmp2 = (); let _tmp1 = ();
if _tmp1.fields().len() - 0 < 1 { return Err(()); } if _tmp0.fields().len() - 0 < 1 { return Err(()); }
let _tmp5 = (&_tmp1.fields()[0]).value().to_dictionary().map_err(|_| ())?; let _tmp2 = (&_tmp0.fields()[0]).value().to_dictionary().map_err(|_| ())?;
let _tmp6 = _tmp5.get(&*LIT18).ok_or(())?; let _tmp3 = _tmp2.get(&*LIT18).ok_or(())?;
let _tmp8 = Definitions::try_from(_tmp6)?; let _tmp4 = Definitions::try_from(_tmp3)?;
let _tmp9 = _tmp5.get(&*LIT19).ok_or(())?; let _tmp5 = _tmp2.get(&*LIT19).ok_or(())?;
let _tmp11 = EmbeddedTypeName::try_from(_tmp9)?; let _tmp6 = EmbeddedTypeName::try_from(_tmp5)?;
let _tmp12 = _tmp5.get(&*LIT20).ok_or(())?; let _tmp7 = _tmp2.get(&*LIT20).ok_or(())?;
let _tmp14 = Version::try_from(_tmp12)?; let _tmp8 = Version::try_from(_tmp7)?;
Ok(Schema {definitions: _tmp8, embedded_type: _tmp11, version: _tmp14}) Ok(Schema {definitions: _tmp4, embedded_type: _tmp6, version: _tmp8})
} }
} }
fn _parse_simple_pattern_any(value: &preserves::value::IOValue) -> std::result::Result<SimplePattern, ()> {if value != &*LIT21 { return Err(()); } let _tmp0 = (); Ok(SimplePattern::Any)} fn _parse_simple_pattern_any(value: &preserves::value::IOValue) -> std::result::Result<SimplePattern, ()> {if value != &*LIT21 { return Err(()); } let _tmp0 = (); Ok(SimplePattern::Any)}
fn _parse_simple_pattern_atom(value: &preserves::value::IOValue) -> std::result::Result<SimplePattern, ()> { fn _parse_simple_pattern_atom(value: &preserves::value::IOValue) -> std::result::Result<SimplePattern, ()> {
let _tmp1 = value.value().to_record(None).map_err(|_| ())?; let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
if _tmp1.label() != &*LIT22 { return Err(()); } if _tmp0.label() != &*LIT22 { return Err(()); }
let _tmp2 = (); let _tmp1 = ();
if _tmp1.fields().len() - 0 < 1 { return Err(()); } if _tmp0.fields().len() - 0 < 1 { return Err(()); }
let _tmp5 = AtomKind::try_from((&_tmp1.fields()[0]))?; let _tmp2 = AtomKind::try_from((&_tmp0.fields()[0]))?;
Ok(SimplePattern::Atom {atom_kind: std::boxed::Box::new(_tmp5)}) Ok(SimplePattern::Atom {atom_kind: std::boxed::Box::new(_tmp2)})
} }
fn _parse_simple_pattern_embedded(value: &preserves::value::IOValue) -> std::result::Result<SimplePattern, ()> { fn _parse_simple_pattern_embedded(value: &preserves::value::IOValue) -> std::result::Result<SimplePattern, ()> {
let _tmp1 = value.value().to_record(None).map_err(|_| ())?; let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
if _tmp1.label() != &*LIT23 { return Err(()); } if _tmp0.label() != &*LIT23 { return Err(()); }
let _tmp2 = (); let _tmp1 = ();
if _tmp1.fields().len() - 0 < 1 { return Err(()); } if _tmp0.fields().len() - 0 < 1 { return Err(()); }
let _tmp5 = SimplePattern::try_from((&_tmp1.fields()[0]))?; let _tmp2 = SimplePattern::try_from((&_tmp0.fields()[0]))?;
Ok(SimplePattern::Embedded {interface: std::boxed::Box::new(_tmp5)}) Ok(SimplePattern::Embedded {interface: std::boxed::Box::new(_tmp2)})
} }
fn _parse_simple_pattern_lit(value: &preserves::value::IOValue) -> std::result::Result<SimplePattern, ()> { fn _parse_simple_pattern_lit(value: &preserves::value::IOValue) -> std::result::Result<SimplePattern, ()> {
let _tmp1 = value.value().to_record(None).map_err(|_| ())?; let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
if _tmp1.label() != &*LIT24 { return Err(()); } if _tmp0.label() != &*LIT24 { return Err(()); }
let _tmp2 = (); let _tmp1 = ();
if _tmp1.fields().len() - 0 < 1 { return Err(()); } if _tmp0.fields().len() - 0 < 1 { return Err(()); }
let _tmp5 = (&_tmp1.fields()[0]); let _tmp2 = (&_tmp0.fields()[0]);
Ok(SimplePattern::Lit {value: _tmp5.clone()}) Ok(SimplePattern::Lit {value: _tmp2.clone()})
} }
fn _parse_simple_pattern_seqof(value: &preserves::value::IOValue) -> std::result::Result<SimplePattern, ()> { fn _parse_simple_pattern_seqof(value: &preserves::value::IOValue) -> std::result::Result<SimplePattern, ()> {
let _tmp1 = value.value().to_record(None).map_err(|_| ())?; let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
if _tmp1.label() != &*LIT25 { return Err(()); } if _tmp0.label() != &*LIT25 { return Err(()); }
let _tmp2 = (); let _tmp1 = ();
if _tmp1.fields().len() - 0 < 1 { return Err(()); } if _tmp0.fields().len() - 0 < 1 { return Err(()); }
let _tmp5 = SimplePattern::try_from((&_tmp1.fields()[0]))?; let _tmp2 = SimplePattern::try_from((&_tmp0.fields()[0]))?;
Ok(SimplePattern::Seqof {pattern: std::boxed::Box::new(_tmp5)}) Ok(SimplePattern::Seqof {pattern: std::boxed::Box::new(_tmp2)})
} }
fn _parse_simple_pattern_setof(value: &preserves::value::IOValue) -> std::result::Result<SimplePattern, ()> { fn _parse_simple_pattern_setof(value: &preserves::value::IOValue) -> std::result::Result<SimplePattern, ()> {
let _tmp1 = value.value().to_record(None).map_err(|_| ())?; let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
if _tmp1.label() != &*LIT26 { return Err(()); } if _tmp0.label() != &*LIT26 { return Err(()); }
let _tmp2 = (); let _tmp1 = ();
if _tmp1.fields().len() - 0 < 1 { return Err(()); } if _tmp0.fields().len() - 0 < 1 { return Err(()); }
let _tmp5 = SimplePattern::try_from((&_tmp1.fields()[0]))?; let _tmp2 = SimplePattern::try_from((&_tmp0.fields()[0]))?;
Ok(SimplePattern::Setof {pattern: std::boxed::Box::new(_tmp5)}) Ok(SimplePattern::Setof {pattern: std::boxed::Box::new(_tmp2)})
} }
fn _parse_simple_pattern_dictof(value: &preserves::value::IOValue) -> std::result::Result<SimplePattern, ()> { fn _parse_simple_pattern_dictof(value: &preserves::value::IOValue) -> std::result::Result<SimplePattern, ()> {
let _tmp1 = value.value().to_record(None).map_err(|_| ())?; let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
if _tmp1.label() != &*LIT27 { return Err(()); } if _tmp0.label() != &*LIT27 { return Err(()); }
let _tmp2 = (); let _tmp1 = ();
if _tmp1.fields().len() - 0 < 2 { return Err(()); } if _tmp0.fields().len() - 0 < 2 { return Err(()); }
let _tmp5 = SimplePattern::try_from((&_tmp1.fields()[0]))?; let _tmp2 = SimplePattern::try_from((&_tmp0.fields()[0]))?;
let _tmp7 = SimplePattern::try_from((&_tmp1.fields()[1]))?; let _tmp3 = SimplePattern::try_from((&_tmp0.fields()[1]))?;
Ok(SimplePattern::Dictof {key: std::boxed::Box::new(_tmp5), value: std::boxed::Box::new(_tmp7)}) 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<SimplePattern, ()> { fn _parse_simple_pattern_ref(value: &preserves::value::IOValue) -> std::result::Result<SimplePattern, ()> {

11
implementations/rust/preserves/src/value/packed/mod.rs
View File

@ -4,3 +4,14 @@ pub mod writer;
pub use reader::PackedReader; pub use reader::PackedReader;
pub use writer::PackedWriter; pub use writer::PackedWriter;
use super::{Reader, IOValue};
use super::reader::IOResult;
pub fn from_bytes(bs: &[u8]) -> IOResult<IOValue> {
PackedReader::decode_bytes(bs).demand_next(false)
}
pub fn annotated_from_bytes(bs: &[u8]) -> IOResult<IOValue> {
PackedReader::decode_bytes(bs).demand_next(true)
}