From 5c2d12971db3ec690debfa43d4a51dfe7d5860b1 Mon Sep 17 00:00:00 2001
From: Tony Garnock-Jones <tonyg@leastfixedpoint.com>
Date: Mon, 28 Jun 2021 22:38:30 +0200
Subject: [PATCH] Better idioms

---
 .../src/bin/preserves-schema-rs.rs            |  4 +--
 .../preserves-schema/src/compiler/parsers.rs  | 29 +++++++++----------
 .../preserves-schema/src/compiler/types.rs    |  5 ++--
 3 files changed, 18 insertions(+), 20 deletions(-)

diff --git a/implementations/rust/preserves-schema/src/bin/preserves-schema-rs.rs b/implementations/rust/preserves-schema/src/bin/preserves-schema-rs.rs
index a848133..56a394e 100644
--- a/implementations/rust/preserves-schema/src/bin/preserves-schema-rs.rs
+++ b/implementations/rust/preserves-schema/src/bin/preserves-schema-rs.rs
@@ -60,9 +60,9 @@ fn main() -> Result<(), Error> {
             },
             Err(()) => match Bundle::try_from(&schema) {
                 Ok(Bundle { modules }) => {
-                    for (k, v) in modules.0 {
+                    for (ModulePath(k), v) in modules.0 {
                         let mut name = prefix.clone();
-                        name.extend(k.0);
+                        name.extend(k);
                         config.bundle.insert(name, v);
                     }
                 },
diff --git a/implementations/rust/preserves-schema/src/compiler/parsers.rs b/implementations/rust/preserves-schema/src/compiler/parsers.rs
index 2b3705a..f110611 100644
--- a/implementations/rust/preserves-schema/src/compiler/parsers.rs
+++ b/implementations/rust/preserves-schema/src/compiler/parsers.rs
@@ -13,9 +13,8 @@ pub fn gen_definition_parser(m: &mut ModuleContext, n: &str, d: &Definition) {
 
             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);
+                    let mut ps = vec![&**pattern_0, &**pattern_1];
+                    ps.extend(pattern_n);
                     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)]);
@@ -34,9 +33,8 @@ pub fn gen_definition_parser(m: &mut ModuleContext, n: &str, d: &Definition) {
                     body.push(item(seq!["Err(())"]));
                 }
                 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);
+                    let mut ps = vec![&**pattern_0, &**pattern_1];
+                    ps.extend(pattern_n);
                     for e in ps {
                         named_pattern_parser(&mut ctxt, e, "value", None, &mut body);
                     }
@@ -117,15 +115,16 @@ fn simple_pattern_parser(
             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(|_| ())?"])),
-            }
+            let converter = match &**k {
+                AtomKind::Boolean => "to_boolean",
+                AtomKind::Float => "to_float",
+                AtomKind::Double => "to_double",
+                AtomKind::SignedInteger => "to_signedinteger",
+                AtomKind::String => "to_string",
+                AtomKind::ByteString => "to_bytestring",
+                AtomKind::Symbol => "to_symbol",
+            };
+            push_let(body, &dest, item(seq![src.to_owned(), ".value().", converter, "().map_err(|_| ())?"]));
             dest
         },
         SimplePattern::Embedded { .. } => {
diff --git a/implementations/rust/preserves-schema/src/compiler/types.rs b/implementations/rust/preserves-schema/src/compiler/types.rs
index 9fe2661..bf8737f 100644
--- a/implementations/rust/preserves-schema/src/compiler/types.rs
+++ b/implementations/rust/preserves-schema/src/compiler/types.rs
@@ -41,9 +41,8 @@ pub fn definition_type(d: &Definition) -> TDefinition {
             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);
+            let mut arms = vec![&**pattern_0, &**pattern_1];
+            arms.extend(pattern_n);
             TDefinition::Simple(record_type(&arms))
         },
         Definition::Pattern(p) => TDefinition::Simple(pattern_type(p)),