Make to_markup more flexible

numbat-cli/src/main.rs

@@ -480,6 +480,7 @@ impl Cli {
                     statements.last(),
                     &registry,
                     interactive || pretty_print,
+                    interactive || pretty_print,
                 );
                 print!("{}", ansi_format(&result_markup, false));
 

numbat-wasm/src/lib.rs

@@ -127,6 +127,7 @@ impl Numbat {
                     statements.last(),
                     &self.ctx.dimension_registry().clone(),
                     true,
+                    true,
                 );
                 output.push_str(&self.format(&result_markup, enable_indentation));
 

numbat/src/help.rs

@@ -29,7 +29,12 @@ fn evaluate_example(context: &mut Context, input: &str) -> m::Markup {
             .fold(m::empty(), |accumulated_mk, single_line| {
                 accumulated_mk + m::nl() + m::whitespace("  ") + single_line.clone() + m::nl()
             })
-            + interpreter_result.to_markup(statements.last(), context.dimension_registry(), true);
+            + interpreter_result.to_markup(
+                statements.last(),
+                context.dimension_registry(),
+                true,
+                true,
+            );
 
     markup
 }

numbat/src/interpreter.rs

@@ -61,29 +61,34 @@ impl InterpreterResult {
         &self,
         evaluated_statement: Option<&Statement>,
         registry: &DimensionRegistry,
-        pretty: bool,
+        with_type_info: bool,
+        with_equal_sign: bool,
     ) -> Markup {
         match self {
             Self::Value(value) => {
-                let leader = m::whitespace("    ") + m::operator("=") + m::space();
-
-                let type_markup = evaluated_statement
-                    .and_then(Statement::as_expression)
-                    .and_then(|e| {
-                        if e.get_type() == Type::scalar() {
-                            None
-                        } else {
-                            let ty = e.get_type().to_readable_type(registry);
-                            Some(m::dimmed("    [") + ty + m::dimmed("]"))
-                        }
-                    })
-                    .unwrap_or_else(m::empty);
-
-                if pretty {
-                    leader + value.pretty_print() + type_markup + m::nl()
+                let leader = if with_equal_sign {
+                    m::whitespace("    ") + m::operator("=") + m::space()
                 } else {
-                    value.pretty_print() + m::nl()
-                }
+                    m::empty()
+                };
+
+                let type_markup = if with_type_info {
+                    evaluated_statement
+                        .and_then(Statement::as_expression)
+                        .and_then(|e| {
+                            if e.get_type() == Type::scalar() {
+                                None
+                            } else {
+                                let ty = e.get_type().to_readable_type(registry);
+                                Some(m::dimmed("    [") + ty + m::dimmed("]"))
+                            }
+                        })
+                        .unwrap_or_else(m::empty)
+                } else {
+                    m::empty()
+                };
+
+                leader + value.pretty_print() + type_markup + m::nl()
             }
             Self::Continue => m::empty(),
         }
@@ -104,6 +109,13 @@ impl InterpreterResult {
     pub fn is_continue(&self) -> bool {
         matches!(self, Self::Continue)
     }
+
+    pub fn value_as_string(&self) -> Option<String> {
+        match self {
+            Self::Continue => None,
+            Self::Value(value) => Some(value.to_string()),
+        }
+    }
 }
 
 pub type Result<T> = std::result::Result<T, RuntimeError>;

numbat/src/lib.rs

@@ -388,7 +388,7 @@ impl Context {
             }
 
             if let Ok((_, results)) = self.interpret(keyword, CodeSource::Internal) {
-                help += m::nl() + results.to_markup(None, self.dimension_registry(), true);
+                help += m::nl() + results.to_markup(None, self.dimension_registry(), true, true);
             }
 
             return help;