forked from syndicate-lang/preserves
Bootstrap Rust preserves-schema
This commit is contained in:
parent
7546ba29ad
commit
9c4be54be1
|
@ -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)?,
|
||||||
|
},
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -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);
|
||||||
|
|
|
@ -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
|
||||||
|
},
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -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)
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -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, ()> {
|
||||||
|
|
|
@ -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)
|
||||||
|
}
|
||||||
|
|
Loading…
Reference in New Issue