a test that now *runs*... but fails

Author: tim-at-topos

packages/catlog/src/dbl/discrete_tabulator/model.rs

@@ -74,6 +74,21 @@ pub enum TabEdge {
     },
 }
 
+impl TabEdge {
+    /// Extracts a basic object or nothing.
+    pub fn basic(self) -> Option<QualifiedName> {
+        match self {
+            TabEdge::Basic(id) => Some(id),
+            _ => None,
+        }
+    }
+
+    /// Unwraps a basic object, or panics.
+    pub fn unwrap_basic(self) -> QualifiedName {
+        self.basic().expect("Morphism should be a basic Morphism")
+    }
+}
+
 /// Morphism in a model of a discrete tabulator theory.
 pub type TabMor = Path<TabOb, TabEdge>;
 

packages/catlog/src/stdlib/analyses/signed_links_to_signed_cat.rs

@@ -1,8 +1,10 @@
 //! Migration for going from categories with signed links to signed categories
 //  (e.g. from signed stock-flow diagrams to causal loop diagrams)
+//
+// Note that this migration expects a DiscreteTabModel whose underlying theory
+// is th_category_signed_links, otherwise it will panic
 
-use crate::dbl::discrete_tabulator::theory::TabMorType;
-use crate::dbl::discrete_tabulator::theory::TabObType;
+use crate::dbl::discrete_tabulator::theory::{TabMorType, TabObType};
 use std::rc::Rc;
 
 use crate::dbl::discrete::model::DiscreteDblModel;
@@ -44,58 +46,73 @@ pub fn span_migrate(model: DiscreteTabModel) -> DiscreteDblModel {
     let neg_link_type = TabMorType::Basic(name("NegativeLink"));
 
     // Create an object for each stock (a "stock-object")
-    for s in model.ob_generators() {
-        migrated_model.add_ob(s.clone(), name("Object"));
+    for stock in model.ob_generators() {
+        migrated_model.add_ob(stock.clone(), name("Object"));
     }
 
     // Create a span for each flow
-    for f in model.mor_generators_with_type(&flow_type) {
+    for flow in model.mor_generators_with_type(&flow_type) {
         // An object for each flow (a "flow-object")
-        migrated_model.add_ob(f.clone(), name("Object"));
+        migrated_model.add_ob(flow.clone(), name("Object"));
         // A negative link from the flow object to the flow-source object
         migrated_model.add_mor(
-            format!("{}_in", f).as_str().into(),
-            f.clone(),
-            model.mor_generator_dom(&f).unwrap_basic(),
+            format!("{}_in", flow).as_str().into(),
+            flow.clone(),
+            model.mor_generator_dom(&flow).unwrap_basic(),
             name("Negative").into(),
         );
         // A positive link from the flow object to the flow-target object
         migrated_model.add_mor(
-            format!("{}_out", f).as_str().into(),
-            f.clone(),
-            model.mor_generator_cod(&f).unwrap_basic(),
+            format!("{}_out", flow).as_str().into(),
+            flow.clone(),
+            model.mor_generator_cod(&flow).unwrap_basic(),
             Path::Id(name("Object")),
         );
     }
 
     // Create a positive arrow for each positive link
     for pl in model.mor_generators_with_type(&pos_link_type) {
+        // We know, by design, that the codomain of a morphism generator of type
+        // pos_link_type will be of type TabOb::Tabulated and furthermore will
+        // contain (in its box) a path (TabMor) consisting of a *single* TabEdge
+        // which will *furthermore* itself be of type TabEdge::Basic
+        let pl_cod = model
+            .mor_generator_cod(&pl)
+            .unwrap_tabulated()
+            .only()
+            .expect("Morphism should be a singleton path of type TabEdge")
+            .unwrap_basic();
         migrated_model.add_mor(
             pl.clone(),
             model.mor_generator_dom(&pl).unwrap_basic(),
-            model.mor_generator_cod(&pl).unwrap_basic(),
+            pl_cod,
             Path::Id(name("Object")),
         );
     }
     // Create a negative arrow for each negative link
     for nl in model.mor_generators_with_type(&neg_link_type) {
+        let nl_cod = model
+            .mor_generator_cod(&nl)
+            .unwrap_tabulated()
+            .only()
+            .expect("Morphism should be a singleton path of type TabEdge")
+            .unwrap_basic();
         migrated_model.add_mor(
             nl.clone(),
             model.mor_generator_dom(&nl).unwrap_basic(),
-            model.mor_generator_cod(&nl).unwrap_basic(),
+            nl_cod,
             name("Negative").into(),
         );
     }
 
     migrated_model
 }
 
-// TO-DO: add test !
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::dbl::model::MutDblModel;
-    use crate::stdlib::{negative_backward_link};
+    use crate::stdlib::negative_backward_link;
     use std::rc::Rc;
 
     #[test]
@@ -115,7 +132,6 @@ mod tests {
         cld_model.add_mor(name("link"), name("y"), name("f"), name("Negative").into());
 
         // Test the putative migration against the correct one
-        // TO-DO: I don't think you can use assert_eq!() on models?
         assert_eq!(span_migrate(sf_model), cld_model);
     }
 }