Fix panic when quitting application

crates/fj-host/src/evaluator.rs

@@ -6,7 +6,7 @@ use crate::{Error, Evaluation, Model};
 
 /// Evaluates a model in a background thread
 pub struct Evaluator {
-    trigger_tx: Sender<()>,
+    trigger_tx: Sender<TriggerEvaluation>,
     event_rx: Receiver<ModelEvent>,
 }
 
@@ -16,24 +16,26 @@ impl Evaluator {
         let (event_tx, event_rx) = crossbeam_channel::bounded(0);
         let (trigger_tx, trigger_rx) = crossbeam_channel::bounded(0);
 
-        thread::spawn(move || loop {
-            let () = trigger_rx
-                .recv()
-                .expect("Expected channel to never disconnect");
-
-            let evaluation = match model.evaluate() {
-                Ok(evaluation) => evaluation,
-                Err(err) => {
-                    event_tx
-                        .send(ModelEvent::Error(err))
-                        .expect("Expected channel to never disconnect");
-                    continue;
-                }
-            };
-
-            event_tx
-                .send(ModelEvent::Evaluation(evaluation))
-                .expect("Expected channel to never disconnect");
+        thread::spawn(move || {
+            while let Ok(TriggerEvaluation) = trigger_rx.recv() {
+                let evaluation = match model.evaluate() {
+                    Ok(evaluation) => evaluation,
+                    Err(err) => {
+                        event_tx
+                            .send(ModelEvent::Error(err))
+                            .expect("Expected channel to never disconnect");
+                        continue;
+                    }
+                };
+
+                event_tx
+                    .send(ModelEvent::Evaluation(evaluation))
+                    .expect("Expected channel to never disconnect");
+            }
+
+            // The channel is disconnected, which means this instance of
+            // `Evaluator`, as well as all `Sender`s created from it, have been
+            // dropped. We're done.
         });
 
         Self {
@@ -43,7 +45,7 @@ impl Evaluator {
     }
 
     /// Access a channel for triggering evaluations
-    pub fn trigger(&self) -> Sender<()> {
+    pub fn trigger(&self) -> Sender<TriggerEvaluation> {
         self.trigger_tx.clone()
     }
 
@@ -53,6 +55,9 @@ impl Evaluator {
     }
 }
 
+/// Command received by [`Evaluator`] through its channel
+pub struct TriggerEvaluation;
+
 /// An event emitted by [`Evaluator`]
 pub enum ModelEvent {
     /// The model has been evaluated

crates/fj-host/src/watcher.rs

@@ -2,7 +2,7 @@ use std::{collections::HashSet, ffi::OsStr, path::Path, thread};
 
 use notify::Watcher as _;
 
-use crate::{Error, Evaluator};
+use crate::{evaluator::TriggerEvaluation, Error, Evaluator};
 
 /// Watches a model for changes, reloading it continually
 pub struct Watcher {
@@ -65,7 +65,9 @@ impl Watcher {
                     // application is being shut down.
                     //
                     // Either way, not much we can do about it here.
-                    watch_tx.send(()).expect("Channel is disconnected");
+                    watch_tx
+                        .send(TriggerEvaluation)
+                        .expect("Channel is disconnected");
                 }
             },
         )?;
@@ -82,7 +84,9 @@ impl Watcher {
         // Will panic, if the receiving end has panicked. Not much we can do
         // about that, if it happened.
         thread::spawn(move || {
-            watch_tx_2.send(()).expect("Channel is disconnected")
+            watch_tx_2
+                .send(TriggerEvaluation)
+                .expect("Channel is disconnected")
         });
 
         Ok(Self {