Format

Author: joefreeman

quiver-compiler/src/compiler/pattern.rs

@@ -459,7 +459,9 @@ fn check_match_tuple_match(
         .lookup_type(&type_id)
         .ok_or(Error::TypeNotInRegistry { type_id })?;
 
-    if tuple.name.as_ref() != tuple_info.name.as_ref() || tuple.fields.len() != tuple_info.fields.len() {
+    if tuple.name.as_ref() != tuple_info.name.as_ref()
+        || tuple.fields.len() != tuple_info.fields.len()
+    {
         return Ok(None);
     }
 

quiver-compiler/src/compiler/typing.rs

@@ -105,7 +105,8 @@ impl TypeContext {
                 }
 
                 // Register the tuple type with the is_partial flag
-                let type_id = program.register_type_with_partial(tuple.name, fields, tuple.is_partial);
+                let type_id =
+                    program.register_type_with_partial(tuple.name, fields, tuple.is_partial);
 
                 // Return Type::Partial for partial types, Type::Tuple for concrete types
                 if tuple.is_partial {

quiver-compiler/src/parser.rs

@@ -301,7 +301,8 @@ fn partial_type(input: &str) -> IResult<&str, Type> {
                 ),
                 |tuple_type: &TupleType| {
                     // Empty partial types are allowed, or at least one field must be named
-                    tuple_type.fields.is_empty() || tuple_type.fields.iter().any(|f| f.name.is_some())
+                    tuple_type.fields.is_empty()
+                        || tuple_type.fields.iter().any(|f| f.name.is_some())
                 },
             ),
         )),
@@ -420,7 +421,7 @@ fn function_type(input: &str) -> IResult<&str, Type> {
 
 fn function_input_type(input: &str) -> IResult<&str, Type> {
     alt((
-        partial_type,  // Must come before grouping parentheses
+        partial_type, // Must come before grouping parentheses
         delimited(pair(char('('), ws0), type_definition, pair(ws0, char(')'))),
         tuple_type,
         primitive_type,
@@ -431,7 +432,7 @@ fn function_input_type(input: &str) -> IResult<&str, Type> {
 
 fn function_output_type(input: &str) -> IResult<&str, Type> {
     alt((
-        partial_type,  // Must come before grouping parentheses
+        partial_type, // Must come before grouping parentheses
         delimited(pair(char('('), ws0), type_definition, pair(ws0, char(')'))),
         tuple_type,
         primitive_type,
@@ -443,7 +444,7 @@ fn function_output_type(input: &str) -> IResult<&str, Type> {
 fn base_type(input: &str) -> IResult<&str, Type> {
     alt((
         tuple_type,
-        partial_type,  // Must come before grouping parentheses to have priority
+        partial_type, // Must come before grouping parentheses to have priority
         primitive_type,
         type_cycle,
         process_type,
@@ -533,13 +534,10 @@ fn tuple_field(input: &str) -> IResult<&str, TupleField> {
             },
         ),
         // Spread with identifier: ...identifier
-        map(
-            preceded(tag("..."), identifier),
-            |id| TupleField {
-                name: None,
-                value: FieldValue::Spread(Some(id)),
-            },
-        ),
+        map(preceded(tag("..."), identifier), |id| TupleField {
+            name: None,
+            value: FieldValue::Spread(Some(id)),
+        }),
         // Spread chained value: ...
         map(tag("..."), |_| TupleField {
             name: None,

quiver-core/src/executor.rs

@@ -610,7 +610,10 @@ impl Executor {
                 // Use Type::is_compatible for structural checking
                 let actual_type = Type::Tuple(*actual_type_id);
                 // Check if type_id refers to a partial type
-                let expected_type = if self.lookup_type(&type_id).is_some_and(|info| info.is_partial) {
+                let expected_type = if self
+                    .lookup_type(&type_id)
+                    .is_some_and(|info| info.is_partial)
+                {
                     Type::Partial(type_id)
                 } else {
                     Type::Tuple(type_id)

quiver-core/src/format.rs

@@ -54,7 +54,8 @@ pub fn format_type(program: &crate::program::Program, type_def: &Type) -> String
         Type::Tuple(type_id) | Type::Partial(type_id) => {
             let is_partial = matches!(type_def, Type::Partial(_));
             if let Some(type_info) = program.lookup_type(type_id) {
-                let field_strs: Vec<String> = type_info.fields
+                let field_strs: Vec<String> = type_info
+                    .fields
                     .iter()
                     .map(|(field_name, field_type)| {
                         if let Some(field_name) = field_name {
@@ -71,7 +72,13 @@ pub fn format_type(program: &crate::program::Program, type_def: &Type) -> String
                     if field_strs.is_empty() {
                         type_name.to_string()
                     } else {
-                        format!("{}{}{}{}", type_name, bracket.0, field_strs.join(", "), bracket.1)
+                        format!(
+                            "{}{}{}{}",
+                            type_name,
+                            bracket.0,
+                            field_strs.join(", "),
+                            bracket.1
+                        )
                     }
                 } else {
                     format!("{}{}{}", bracket.0, field_strs.join(", "), bracket.1)