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

Better idioms

This commit is contained in:
Tony Garnock-Jones 2021-06-28 22:38:30 +02:00
parent 9c4be54be1
commit 5c2d12971d
3 changed files with 18 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -60,9 +60,9 @@ fn main() -> Result<(), Error> {
}, },
Err(()) => match Bundle::try_from(&schema) { Err(()) => match Bundle::try_from(&schema) {
Ok(Bundle { modules }) => { Ok(Bundle { modules }) => {
for (k, v) in modules.0 { for (ModulePath(k), v) in modules.0 {
let mut name = prefix.clone(); let mut name = prefix.clone();
name.extend(k.0); name.extend(k);
config.bundle.insert(name, v); config.bundle.insert(name, v);
} }
}, },

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

@ -13,9 +13,8 @@ pub fn gen_definition_parser(m: &mut ModuleContext, n: &str, d: &Definition) {
match d { match d {
Definition::Or { pattern_0, pattern_1, pattern_n } => { Definition::Or { pattern_0, pattern_1, pattern_n } => {
let mut ps: Vec<&NamedAlternative> = pattern_n.iter().collect(); let mut ps = vec![&**pattern_0, &**pattern_1];
ps.insert(0, &**pattern_1); ps.extend(pattern_n);
ps.insert(0, &**pattern_0);
for NamedAlternative { variant_label: name, pattern: pat } in ps { for NamedAlternative { variant_label: name, pattern: pat } in ps {
let fname = seq!["_parse_", names::render_fieldname(n), "_", names::render_fieldname(name)]; let fname = seq!["_parse_", names::render_fieldname(n), "_", names::render_fieldname(name)];
let ctorname = item(name![names::render_constructor(n), names::render_constructor(name)]); let ctorname = item(name![names::render_constructor(n), names::render_constructor(name)]);
@ -34,9 +33,8 @@ pub fn gen_definition_parser(m: &mut ModuleContext, n: &str, d: &Definition) {
body.push(item(seq!["Err(())"])); body.push(item(seq!["Err(())"]));
} }
Definition::And { pattern_0, pattern_1, pattern_n } => { Definition::And { pattern_0, pattern_1, pattern_n } => {
let mut ps: Vec<&NamedPattern> = pattern_n.iter().collect(); let mut ps = vec![&**pattern_0, &**pattern_1];
ps.insert(0, &**pattern_1); ps.extend(pattern_n);
ps.insert(0, &**pattern_0);
for e in ps { for e in ps {
named_pattern_parser(&mut ctxt, e, "value", None, &mut body); named_pattern_parser(&mut ctxt, e, "value", None, &mut body);
} }
@ -117,15 +115,16 @@ fn simple_pattern_parser(
dest dest
}, },
SimplePattern::Atom { atom_kind: k } => { SimplePattern::Atom { atom_kind: k } => {
match &**k { let converter = match &**k {
AtomKind::Boolean => push_let(body, &dest, item(seq![src.to_owned(), ".value().to_boolean().map_err(|_| ())?"])), AtomKind::Boolean => "to_boolean",
AtomKind::Float => push_let(body, &dest, item(seq![src.to_owned(), ".value().to_float().map_err(|_| ())?"])), AtomKind::Float => "to_float",
AtomKind::Double => push_let(body, &dest, item(seq![src.to_owned(), ".value().to_double().map_err(|_| ())?"])), AtomKind::Double => "to_double",
AtomKind::SignedInteger => push_let(body, &dest, item(seq![src.to_owned(), ".value().to_signedinteger().map_err(|_| ())?"])), AtomKind::SignedInteger => "to_signedinteger",
AtomKind::String => push_let(body, &dest, item(seq![src.to_owned(), ".value().to_string().map_err(|_| ())?"])), AtomKind::String => "to_string",
AtomKind::ByteString => push_let(body, &dest, item(seq![src.to_owned(), ".value().to_bytestring().map_err(|_| ())?"])), AtomKind::ByteString => "to_bytestring",
AtomKind::Symbol => push_let(body, &dest, item(seq![src.to_owned(), ".value().to_symbol().map_err(|_| ())?"])), AtomKind::Symbol => "to_symbol",
} };
push_let(body, &dest, item(seq![src.to_owned(), ".value().", converter, "().map_err(|_| ())?"]));
dest dest
}, },
SimplePattern::Embedded { .. } => { SimplePattern::Embedded { .. } => {

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

@ -41,9 +41,8 @@ pub fn definition_type(d: &Definition) -> TDefinition {
TDefinition::Union(entries) TDefinition::Union(entries)
}, },
Definition::And { pattern_0, pattern_1, pattern_n } => { Definition::And { pattern_0, pattern_1, pattern_n } => {
let mut arms: Vec<&NamedPattern> = pattern_n.iter().collect(); let mut arms = vec![&**pattern_0, &**pattern_1];
arms.insert(0, &**pattern_1); arms.extend(pattern_n);
arms.insert(0, &**pattern_0);
TDefinition::Simple(record_type(&arms)) TDefinition::Simple(record_type(&arms))
}, },
Definition::Pattern(p) => TDefinition::Simple(pattern_type(p)), Definition::Pattern(p) => TDefinition::Simple(pattern_type(p)),