Add commas after match arms wrapped in blocks

app-proto/src/assembly.rs

@@ -717,14 +717,14 @@ impl Assembly {
                 
                 // save the tangent space
                 self.tangent.set_silent(tangent);
-            }
+            },
             Err(message) => {
                 // report the realization status. the `Err(message)` we're
                 // setting the status to has a different type than the
                 // `Err(message)` we received from the match: we're changing the
                 // `Ok` type from `Realization` to `()`
                 self.realization_status.set(Err(message))
-            }
+            },
         }
     }
     
@@ -804,10 +804,10 @@ impl Assembly {
                         // restore its normalization
                         *rep += motion_proj.column(column_index);
                         elt.project_to_normalized(rep);
-                    }
+                    },
                     None => {
                         console_log!("No velocity to unpack for fresh element \"{}\"", elt.id())
-                    }
+                    },
                 };
             });
         }

app-proto/src/components/display.rs

@@ -910,17 +910,17 @@ pub fn Display() -> View {
                                 if depth < best_depth {
                                     clicked = Some((elt, depth))
                                 }
-                            }
+                            },
                             None => clicked = Some((elt, depth)),
-                        }
-                        None => ()
+                        },
+                        None => (),
                     };
                 }
                 
                 // if we clicked something, select it
                 match clicked {
                     Some((elt, _)) => state.select(&elt, event.shift_key()),
-                    None => state.selection.update(|sel| sel.clear())
+                    None => state.selection.update(|sel| sel.clear()),
                 };
             },
         )

app-proto/src/components/outline.rs

@@ -67,8 +67,8 @@ fn RegulatorInput(regulator: Rc<dyn Regulator>) -> View {
                         Ok(set_pt) => {
                             set_point.set(set_pt);
                             true
-                        }
-                        Err(_) => false
+                        },
+                        Err(_) => false,
                     }
                 )
             },
@@ -162,19 +162,19 @@ fn ElementOutlineItem(element: Rc<dyn Element>) -> View {
                                 "Enter" => {
                                     state.select(&element_for_handler, event.shift_key());
                                     event.prevent_default();
-                                }
+                                },
                                 "ArrowRight" if regulated.get() => {
                                     let _ = details_node
                                         .get()
                                         .unchecked_into::<web_sys::Element>()
                                         .set_attribute("open", "");
-                                }
+                                },
                                 "ArrowLeft" => {
                                     let _ = details_node
                                         .get()
                                         .unchecked_into::<web_sys::Element>()
                                         .remove_attribute("open");
-                                }
+                                },
                                 _ => (),
                             }
                         }

app-proto/src/engine.rs

@@ -474,7 +474,7 @@ pub fn realize_gram(
             None => return Realization {
                 result: Err("Cholesky decomposition failed".to_string()),
                 history,
-            }
+            },
         };
         let base_step_stacked = hess_cholesky.solve(&neg_grad_stacked);
         let base_step = base_step_stacked.reshape_generic(Dyn(element_dim), Dyn(assembly_dim));