minor cleanup

1 files changed, 33 insertions, 37 deletions

diff --git a/src/checker.rs b/src/checker.rs
index 5f01a7d..d45a5a4 100644
--- a/src/checker.rs
+++ b/src/checker.rs
@@ -2,7 +2,7 @@ use crate::ast::*;
 use tracing::{debug, instrument};
 
 use derive_more::Display;
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 use std::fmt;
 use std::iter::zip;
 
@@ -236,12 +236,36 @@ impl CheckState {
         Ok(())
     }
 
-    #[instrument(skip(self), level = "debug")]
+    #[instrument(skip(self), level = "debug", fields(%set))]
     fn check_set(&self, set: &Set) -> Result<Set, CheckError> {
         match set {
             Set::BuiltIn(_) => Ok(set.clone()),
-            Set::Record(fields) => self.check_record(fields),
-            Set::Variant(fields) => self.check_variant(fields),
+            Set::Record(fields) => {
+                let fields = fields
+                    .iter()
+                    .map(|RecordField { name, set }| {
+                        let set = self.check_set(set)?;
+                        Ok(RecordField {
+                            name: name.clone(),
+                            set,
+                        })
+                    })
+                    .collect::<Result<Vec<_>, _>>()?;
+                Ok(Set::Record(fields))
+            }
+            Set::Variant(fields) => {
+                let fields = fields
+                    .iter()
+                    .map(|VariantField { name, set }| {
+                        let set = self.check_set(set)?;
+                        Ok(VariantField {
+                            name: name.clone(),
+                            set,
+                        })
+                    })
+                    .collect::<Result<Vec<_>, _>>()?;
+                Ok(Set::Variant(fields))
+            }
             Set::ClaimedSet(_) => Err(CheckError::Unimplemented("instances as sets".to_string())),
             Set::Var(v) => {
                 if let Some(deref) = self.wf_sets.get(v) {
@@ -253,36 +277,6 @@ impl CheckState {
         }
     }
 
-    #[instrument(skip(self), level = "debug")]
-    fn check_record(&self, fields: &Vec<RecordField>) -> Result<Set, CheckError> {
-        let fields = fields
-            .iter()
-            .map(|RecordField { name, set }| {
-                let set = self.check_set(set)?;
-                Ok(RecordField {
-                    name: name.clone(),
-                    set,
-                })
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-        Ok(Set::Record(fields))
-    }
-
-    #[instrument(skip(self), level = "debug")]
-    fn check_variant(&self, fields: &Vec<VariantField>) -> Result<Set, CheckError> {
-        let fields = fields
-            .iter()
-            .map(|VariantField { name, set }| {
-                let set = self.check_set(set)?;
-                Ok(VariantField {
-                    name: name.clone(),
-                    set,
-                })
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-        Ok(Set::Variant(fields))
-    }
-
     fn _check_literal_set_helper(&self, claimed: &Set, should_be: Set) -> Result<(), CheckError> {
         if !self.set_equal(claimed, &should_be) {
             Err(CheckError::WrongSetForElement(claimed.clone(), should_be))
@@ -291,7 +285,7 @@ impl CheckState {
         }
     }
 
-    #[instrument(skip(self), level = "debug")]
+    #[instrument(skip(self), level = "debug", fields(%element, %set))]
     fn check_element(&self, element: &Element, set: &Set) -> Result<Element, CheckError> {
         match element {
             Element::Literal(lit) => {
@@ -383,8 +377,10 @@ impl CheckState {
                 // resign?
                 Ok(Element::Record(assignations))
             }
-            Element::Project(_, _) => Err(CheckError::Unimplemented("element project".to_string())),
-            Element::Inject(_, _) => Err(CheckError::Unimplemented("element inject".to_string())),
+            Element::Project { .. } => {
+                Err(CheckError::Unimplemented("element project".to_string()))
+            }
+            Element::Inject { .. } => Err(CheckError::Unimplemented("element inject".to_string())),
             Element::App(_, _) => Err(CheckError::Unimplemented("element app".to_string())),
             Element::Case { .. } => Err(CheckError::Unimplemented("element case".to_string())),
         }