diff --git a/src/format/table.rs b/src/format/table.rs
index a59e1adaf..3ed5937b4 100644
--- a/src/format/table.rs
+++ b/src/format/table.rs
@@ -23,11 +23,20 @@ enum TableMode {
 
 impl TableView {
     fn merge_descriptors(values: &[Tagged<Value>]) -> Vec<String> {
-        let mut ret = vec![];
+        let mut ret: Vec<String> = vec![];
+        let value_column = "<value>".to_string();
         for value in values {
-            for desc in value.data_descriptors() {
-                if !ret.contains(&desc) {
-                    ret.push(desc);
+            let descs = value.data_descriptors();
+
+            if descs.len() == 0 {
+                if !ret.contains(&value_column) {
+                    ret.push("<value>".to_string());
+                }
+            } else {
+                for desc in value.data_descriptors() {
+                    if !ret.contains(&desc) {
+                        ret.push(desc);
+                    }
                 }
             }
         }
@@ -48,23 +57,59 @@ impl TableView {
         let mut entries = vec![];
 
         for (idx, value) in values.iter().enumerate() {
-            let mut row: Vec<(String, &'static str)> = match value {
-                Tagged {
-                    item: Value::Row(..),
-                    ..
-                } => headers
-                    .iter()
-                    .enumerate()
-                    .map(|(i, d)| {
-                        let data = value.get_data(d);
-                        return (
-                            data.borrow().format_leaf(Some(&headers[i])),
-                            data.borrow().style_leaf(),
-                        );
-                    })
-                    .collect(),
-                x => vec![(x.format_leaf(None), x.style_leaf())],
-            };
+            // let mut row: Vec<(String, &'static str)> = match value {
+            //     Tagged {
+            //         item: Value::Row(..),
+            //         ..
+            //     } => headers
+            //         .iter()
+            //         .enumerate()
+            //         .map(|(i, d)| {
+            //             let data = value.get_data(d);
+            //             return (
+            //                 data.borrow().format_leaf(Some(&headers[i])),
+            //                 data.borrow().style_leaf(),
+            //             );
+            //         })
+            //         .collect(),
+            //     x => vec![(x.format_leaf(None), x.style_leaf())],
+            // };
+
+            let mut row: Vec<(String, &'static str)> = headers
+                .iter()
+                .enumerate()
+                .map(|(i, d)| {
+                    if d == "<value>" {
+                        match value {
+                            Tagged {
+                                item: Value::Row(..),
+                                ..
+                            } => (
+                                Value::nothing().format_leaf(None),
+                                Value::nothing().style_leaf(),
+                            ),
+                            _ => (value.format_leaf(None), value.style_leaf()),
+                        }
+                    } else {
+                        match value {
+                            Tagged {
+                                item: Value::Row(..),
+                                ..
+                            } => {
+                                let data = value.get_data(d);
+                                (
+                                    data.borrow().format_leaf(Some(&headers[i])),
+                                    data.borrow().style_leaf(),
+                                )
+                            }
+                            _ => (
+                                Value::nothing().format_leaf(None),
+                                Value::nothing().style_leaf(),
+                            ),
+                        }
+                    }
+                })
+                .collect();
 
             if values.len() > 1 {
                 // Indices are black, bold, right-aligned:
diff --git a/src/plugins/str.rs b/src/plugins/str.rs
index cab9c6a96..7fb694d3a 100644
--- a/src/plugins/str.rs
+++ b/src/plugins/str.rs
@@ -41,9 +41,13 @@ impl Str {
                 if start > input.len() - 1 {
                     Value::string("")
                 } else {
-                    // Index operator isn't perfect:
-                    // https://users.rust-lang.org/t/how-to-get-a-substring-of-a-string/1351
-                    Value::string(&input[start..end])
+                    Value::string(
+                        &input
+                            .chars()
+                            .skip(start)
+                            .take(end - start)
+                            .collect::<String>(),
+                    )
                 }
             }
             Some(Action::ToInteger) => match input.trim() {