rectangle rendering

src/flow/traversible/unbalanced.rs

@@ -158,7 +158,9 @@ impl<'a, T: 'a + Monad, A: 'a> UnbalancedConstructor<'a, T, A> {
 
 #[cfg(test)]
 mod tests {
-    use rand::Rng;
+    use rand::{Rng, SeedableRng};
+
+    use crate::std::tracing::*;
 
     use super::*;
 
@@ -255,4 +257,30 @@ mod tests {
             );
         }
     }
+
+    #[test]
+    fn trace_one_slice() {
+        let ctr: Rc<UnbalancedConstructor<TracedClass, _>> =
+            UnbalancedConstructor::rc(Box::new(|node| TracedClass::pure(node).after_resolution()));
+        // let mut rng = rand::thread_rng();
+        let mut rng = rand::rngs::StdRng::seed_from_u64(426);
+        let big: Vec<i32> = (0..(rng.gen_range(1000..2000))).collect();
+        let key = big[rng.gen_range(0..big.len())];
+        let small: Vec<i32> = big
+            .iter()
+            .filter(|x| **x != key && rng.gen_ratio(4, 5))
+            .map(|x| *x)
+            .collect();
+        let t_small = ctr.from_slice(&mut rng, &small);
+        let t_big = ctr.from_slice(&mut rng, &big);
+        let traced = t_subset_of_t(
+            &DefaultComparator,
+            t_small.clone(),
+            t_big.clone(),
+            None,
+            None,
+        );
+        assert!(traced.a);
+        // panic!("{:?}", traced.render().to_vec());
+    }
 }

src/std/collections/stack.rs

@@ -277,7 +277,7 @@ mod tests {
         let traced = stack.clone().vec();
         assert_eq!(traced.length(), 3);
         assert_eq!(traced.width(), 1);
-        assert_eq!(format!("{}", traced.t), "( ? -> ? -> ? )");
+        assert_eq!(format!("{}", traced.t), "( ? > ? > ? )");
         Ok(())
     }
 
@@ -292,7 +292,7 @@ mod tests {
         let rendered = stack.clone().vec().render();
         assert_eq!(rendered.length(), 3);
         assert_eq!(rendered.width(), 1);
-        assert_eq!(format!("{}", rendered), "( ? -> ? -> ? )");
+        assert_eq!(format!("{}", rendered), "( ? > ? > ? )");
         Ok(())
     }
 }

src/std/tracing/rendered.rs

@@ -81,6 +81,10 @@ impl WithLengthAndWidth<RenderedWide> {
         vec.width = max(vec.width, self.width);
         vec.value.push(self);
     }
+
+    pub fn any(self) -> WithLengthAndWidth<RenderedAny> {
+        self.map(RenderedWide::any)
+    }
 }
 
 impl WithLengthAndWidth<RenderedLong> {
@@ -89,6 +93,28 @@ impl WithLengthAndWidth<RenderedLong> {
         vec.length = max(vec.length, self.length);
         vec.value.push(self);
     }
+
+    pub fn any(self) -> WithLengthAndWidth<RenderedAny> {
+        self.map(RenderedLong::any)
+    }
+}
+
+impl RenderedWide {
+    fn any(self) -> RenderedAny {
+        match self {
+            RenderedWide::Common(common) => RenderedAny::Common(common),
+            RenderedWide::Wide(vec) => RenderedAny::Wide(vec),
+        }
+    }
+}
+
+impl RenderedLong {
+    fn any(self) -> RenderedAny {
+        match self {
+            RenderedLong::Common(common) => RenderedAny::Common(common),
+            RenderedLong::Long(vec) => RenderedAny::Long(vec),
+        }
+    }
 }
 
 impl<A> WithLengthAndWidth<A> {
@@ -161,3 +187,45 @@ impl RenderedCommon {
         }
     }
 }
+
+impl RenderedCommon {
+    fn rectangles(self, vec: &mut Vec<(usize, usize)>, t: usize, c: usize) {
+        match self {
+            RenderedCommon::Empty => {}
+            RenderedCommon::Resolution => vec.push((t, c)),
+            RenderedCommon::Event(_) => {}
+            RenderedCommon::Action { rendered, .. } => rendered.rectangles(vec, t, c),
+        }
+    }
+}
+
+impl WithLengthAndWidth<RenderedAny> {
+    fn rectangles(self, vec: &mut Vec<(usize, usize)>, t: usize, c: usize) {
+        match self.value {
+            RenderedAny::Common(common) => common.rectangles(vec, t, c),
+            RenderedAny::Wide(rendereds) => {
+                let mut c = c;
+                for rendered in rendereds.into_iter().map(|x| x.map(RenderedLong::any)) {
+                    let rw = rendered.width;
+                    rendered.rectangles(vec, t, c);
+                    c += 2 * rw;
+                }
+            }
+            RenderedAny::Long(rendereds) => {
+                let mut t = t;
+                for rendered in rendereds.into_iter().map(|x| x.map(RenderedWide::any)) {
+                    let rl = rendered.length;
+                    let rw = rendered.width;
+                    rendered.rectangles(vec, t, c + (self.width - rw) / 2);
+                    t += rl;
+                }
+            }
+        }
+    }
+
+    pub fn to_vec(self) -> Vec<(usize, usize)> {
+        let mut vec = Vec::new();
+        self.rectangles(&mut vec, 0, 0);
+        vec
+    }
+}

src/std/tracing/rendered_display.rs

@@ -39,7 +39,7 @@ impl Display for RenderVec<&Vec<WithLengthAndWidth<RenderedWide>>> {
         let mut tail = "~";
         for rendered in self.0 {
             f.write_fmt(format_args!("{}{}", delimiter, rendered))?;
-            delimiter = " -> ";
+            delimiter = " > ";
             tail = "";
         }
         f.write_fmt(format_args!("{}", tail))

src/std/tracing/trace.rs

@@ -30,7 +30,7 @@ impl Trace {
     fn fmt_sequential(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Trace::Sequential { first, second } => f.write_fmt(format_args!(
-                "{} -> {}",
+                "{} > {}",
                 SequentialBox(first),
                 SequentialBox(second)
             )),
@@ -66,7 +66,7 @@ impl Display for Trace {
                 f.write_fmt(format_args!("( {} | {} )", ParallelBox(a), ParallelBox(b)))
             }
             Trace::Sequential { first, second } => f.write_fmt(format_args!(
-                "( {} -> {} )",
+                "( {} > {} )",
                 SequentialBox(first),
                 SequentialBox(second)
             )),