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 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<String>) -> Vec<PathBuf> {
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)?,
},
}
}

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

@ -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<String>;
pub type Schema = IOValue;
#[derive(Debug)]
pub struct CompilerConfig {
pub bundle: Map<ModulePath, Schema>,
@ -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);

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

@ -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<Item>, name: &str, expr: Item) {
fn simple_pattern_parser(
ctxt: &mut FunctionContext,
p: &IOValue,
p: &SimplePattern,
src: &str,
sequence_base: Option<usize>,
body: &mut Vec<Item>,
) -> Option<String> {
) -> 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<String> = 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<Item>,
) {
@ -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<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(
ctxt: &mut FunctionContext,
p: &IOValue,
p: &Pattern,
src: &str,
sequence_base: Option<usize>,
body: &mut Vec<Item>,
) -> Option<String> {
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
},
}
}

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

@ -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<TDefinition, Error> {
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<TSimple, Error> {
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<IOValue>) -> Result<TSimple, Error> {
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<IOValue>, mut fs: Vec<(String, TField)>) ->
Result<Vec<(String, TField)>, 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<Vec<(String, TField)>, 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<Option<TField>, 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<u8>".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<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)]
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<Self, Self::Error> {
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<Self, Self::Error> {
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<CompoundPattern, ()> {
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<CompoundPattern, ()> {
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<CompoundPattern, ()> {
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<CompoundPattern, ()> {
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<Definition, ()> {
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<Definition, ()> {
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<Self, Self::Error> {
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<Self, Self::Error> {
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<Self, Self::Error> {
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<SimplePattern, ()> {if value != &*LIT21 { return Err(()); } let _tmp0 = (); Ok(SimplePattern::Any)}
fn _parse_simple_pattern_atom(value: &preserves::value::IOValue) -> std::result::Result<SimplePattern, ()> {
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<SimplePattern, ()> {
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<SimplePattern, ()> {
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<SimplePattern, ()> {
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<SimplePattern, ()> {
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<SimplePattern, ()> {
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<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 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)
}