combine functions behind to/from-c/tsv commands

fixes #969, admittedly without a --delimiter alias

moves from_structured_data.rs to from_delimited_data.rs to better
identify its scope and adds to_delimited_data.rs. Now csv and tsv both
use the same code, tsv passes in a fixed '\t' argument where csv passes
in the value of --separator

src/commands.rs

@@ -1,7 +1,8 @@
 #[macro_use]
 pub(crate) mod macros;
 
-mod from_structured_data;
+mod from_delimited_data;
+mod to_delimited_data;
 
 pub(crate) mod append;
 pub(crate) mod args;

src/commands/from_csv.rs

@@ -1,4 +1,4 @@
-use crate::commands::from_structured_data::from_structured_data;
+use crate::commands::from_delimited_data::from_delimited_data;
 use crate::commands::WholeStreamCommand;
 use crate::data::{Primitive, Value};
 use crate::prelude::*;
@@ -52,18 +52,22 @@ fn from_csv(
             tag,
             ..
         }) => {
-            let vec_s: Vec<char> = s.chars().collect();
-            if vec_s.len() != 1 {
-                return Err(ShellError::labeled_error(
-                    "Expected a single separator char from --separator",
-                    "requires a single character string input",
-                    tag,
-                ));
-            };
-            vec_s[0]
+            if s == r"\t" {
+                '\t'
+            } else {
+                let vec_s: Vec<char> = s.chars().collect();
+                if vec_s.len() != 1 {
+                    return Err(ShellError::labeled_error(
+                        "Expected a single separator char from --separator",
+                        "requires a single character string input",
+                        tag,
+                    ));
+                };
+                vec_s[0]
+            }
         }
         _ => ',',
     };
 
-    from_structured_data(headerless, sep, "CSV", runnable_context)
+    from_delimited_data(headerless, sep, "CSV", runnable_context)
 }

src/commands/from_delimited_data.rs

@@ -2,7 +2,7 @@ use crate::data::{Primitive, TaggedDictBuilder, Value};
 use crate::prelude::*;
 use csv::ReaderBuilder;
 
-fn from_stuctured_string_to_value(
+fn from_delimited_string_to_value(
     s: String,
     headerless: bool,
     separator: char,
@@ -37,7 +37,7 @@ fn from_stuctured_string_to_value(
     Ok(Value::Table(rows).tagged(&tag))
 }
 
-pub fn from_structured_data(
+pub fn from_delimited_data(
     headerless: bool,
     sep: char,
     format_name: &'static str,
@@ -70,7 +70,7 @@ pub fn from_structured_data(
             }
         }
 
-        match from_stuctured_string_to_value(concat_string, headerless, sep, name_tag.clone()) {
+        match from_delimited_string_to_value(concat_string, headerless, sep, name_tag.clone()) {
             Ok(x) => match x {
                 Tagged { item: Value::Table(list), .. } => {
                     for l in list {

src/commands/from_ssv.rs

@@ -488,7 +488,7 @@ mod tests {
 
     #[test]
     fn input_is_parsed_correctly_if_either_option_works() {
-        let input =             r#"
+        let input = r#"
                 docker-registry   docker-registry=default                   docker-registry=default   172.30.78.158   5000/TCP
                 kubernetes        component=apiserver,provider=kubernetes   <none>                    172.30.0.2      443/TCP
                 kubernetes-ro     component=apiserver,provider=kubernetes   <none>                    172.30.0.1      80/TCP

src/commands/from_tsv.rs

@@ -1,4 +1,4 @@
-use crate::commands::from_structured_data::from_structured_data;
+use crate::commands::from_delimited_data::from_delimited_data;
 use crate::commands::WholeStreamCommand;
 use crate::prelude::*;
 
@@ -36,5 +36,5 @@ fn from_tsv(
     FromTSVArgs { headerless }: FromTSVArgs,
     runnable_context: RunnableContext,
 ) -> Result<OutputStream, ShellError> {
-    from_structured_data(headerless, '\t', "TSV", runnable_context)
+    from_delimited_data(headerless, '\t', "TSV", runnable_context)
 }

src/commands/to_csv.rs

@@ -1,13 +1,14 @@
+use crate::commands::to_delimited_data::to_delimited_data;
 use crate::commands::WholeStreamCommand;
 use crate::data::{Primitive, Value};
 use crate::prelude::*;
-use csv::WriterBuilder;
 
 pub struct ToCSV;
 
 #[derive(Deserialize)]
 pub struct ToCSVArgs {
     headerless: bool,
+    separator: Option<Tagged<Value>>,
 }
 
 impl WholeStreamCommand for ToCSV {
@@ -35,170 +36,34 @@ impl WholeStreamCommand for ToCSV {
     }
 }
 
-pub fn value_to_csv_value(v: &Tagged<Value>) -> Tagged<Value> {
-    match &v.item {
-        Value::Primitive(Primitive::String(s)) => Value::Primitive(Primitive::String(s.clone())),
-        Value::Primitive(Primitive::Nothing) => Value::Primitive(Primitive::Nothing),
-        Value::Primitive(Primitive::Boolean(b)) => Value::Primitive(Primitive::Boolean(b.clone())),
-        Value::Primitive(Primitive::Decimal(f)) => Value::Primitive(Primitive::Decimal(f.clone())),
-        Value::Primitive(Primitive::Int(i)) => Value::Primitive(Primitive::Int(i.clone())),
-        Value::Primitive(Primitive::Path(x)) => Value::Primitive(Primitive::Path(x.clone())),
-        Value::Primitive(Primitive::Bytes(b)) => Value::Primitive(Primitive::Bytes(b.clone())),
-        Value::Primitive(Primitive::Date(d)) => Value::Primitive(Primitive::Date(d.clone())),
-        Value::Row(o) => Value::Row(o.clone()),
-        Value::Table(l) => Value::Table(l.clone()),
-        Value::Block(_) => Value::Primitive(Primitive::Nothing),
-        _ => Value::Primitive(Primitive::Nothing),
-    }
-    .tagged(v.tag.clone())
-}
-
-fn to_string_helper(v: &Tagged<Value>) -> Result<String, ShellError> {
-    match &v.item {
-        Value::Primitive(Primitive::Date(d)) => Ok(d.to_string()),
-        Value::Primitive(Primitive::Bytes(b)) => Ok(format!("{}", b)),
-        Value::Primitive(Primitive::Boolean(_)) => Ok(v.as_string()?),
-        Value::Primitive(Primitive::Decimal(_)) => Ok(v.as_string()?),
-        Value::Primitive(Primitive::Int(_)) => Ok(v.as_string()?),
-        Value::Primitive(Primitive::Path(_)) => Ok(v.as_string()?),
-        Value::Table(_) => return Ok(String::from("[Table]")),
-        Value::Row(_) => return Ok(String::from("[Row]")),
-        Value::Primitive(Primitive::String(s)) => return Ok(s.to_string()),
-        _ => {
-            return Err(ShellError::labeled_error(
-                "Unexpected value",
-                "",
-                v.tag.clone(),
-            ))
-        }
-    }
-}
-
-fn merge_descriptors(values: &[Tagged<Value>]) -> Vec<String> {
-    let mut ret = vec![];
-    for value in values {
-        for desc in value.data_descriptors() {
-            if !ret.contains(&desc) {
-                ret.push(desc);
-            }
-        }
-    }
-    ret
-}
-
-pub fn to_string(tagged_value: &Tagged<Value>) -> Result<String, ShellError> {
-    let v = &tagged_value.item;
-
-    match v {
-        Value::Row(o) => {
-            let mut wtr = WriterBuilder::new().from_writer(vec![]);
-            let mut fields: VecDeque<String> = VecDeque::new();
-            let mut values: VecDeque<String> = VecDeque::new();
-
-            for (k, v) in o.entries.iter() {
-                fields.push_back(k.clone());
-
-                values.push_back(to_string_helper(&v)?);
-            }
-
-            wtr.write_record(fields).expect("can not write.");
-            wtr.write_record(values).expect("can not write.");
-
-            return Ok(String::from_utf8(wtr.into_inner().map_err(|_| {
-                ShellError::labeled_error(
-                    "Could not convert record",
-                    "original value",
-                    &tagged_value.tag,
-                )
-            })?)
-            .map_err(|_| {
-                ShellError::labeled_error(
-                    "Could not convert record",
-                    "original value",
-                    &tagged_value.tag,
-                )
-            })?);
-        }
-        Value::Table(list) => {
-            let mut wtr = WriterBuilder::new().from_writer(vec![]);
-
-            let merged_descriptors = merge_descriptors(&list);
-            wtr.write_record(&merged_descriptors)
-                .expect("can not write.");
-
-            for l in list {
-                let mut row = vec![];
-                for desc in &merged_descriptors {
-                    match l.item.get_data_by_key(&desc) {
-                        Some(s) => {
-                            row.push(to_string_helper(s)?);
-                        }
-                        None => {
-                            row.push(String::new());
-                        }
-                    }
-                }
-                wtr.write_record(&row).expect("can not write");
-            }
-
-            return Ok(String::from_utf8(wtr.into_inner().map_err(|_| {
-                ShellError::labeled_error(
-                    "Could not convert record",
-                    "original value",
-                    &tagged_value.tag,
-                )
-            })?)
-            .map_err(|_| {
-                ShellError::labeled_error(
-                    "Could not convert record",
-                    "original value",
-                    &tagged_value.tag,
-                )
-            })?);
-        }
-        _ => return to_string_helper(tagged_value),
-    }
-}
-
 fn to_csv(
-    ToCSVArgs { headerless }: ToCSVArgs,
-    RunnableContext { input, name, .. }: RunnableContext,
+    ToCSVArgs {
+        separator,
+        headerless,
+    }: ToCSVArgs,
+    runnable_context: RunnableContext,
 ) -> Result<OutputStream, ShellError> {
-    let name_tag = name;
-    let stream = async_stream! {
-         let input: Vec<Tagged<Value>> = input.values.collect().await;
-
-         let to_process_input = if input.len() > 1 {
-             let tag = input[0].tag.clone();
-             vec![Tagged { item: Value::Table(input), tag } ]
-         } else if input.len() == 1 {
-             input
-         } else {
-             vec![]
-         };
-
-         for value in to_process_input {
-             match to_string(&value_to_csv_value(&value)) {
-                 Ok(x) => {
-                     let converted = if headerless {
-                         x.lines().skip(1).collect()
-                     } else {
-                         x
-                     };
-                     yield ReturnSuccess::value(Value::Primitive(Primitive::String(converted)).tagged(&name_tag))
-                 }
-                 _ => {
-                     yield Err(ShellError::labeled_error_with_secondary(
-                         "Expected a table with CSV-compatible structure.tag() from pipeline",
-                         "requires CSV-compatible input",
-                         &name_tag,
-                         "originates from here".to_string(),
-                         value.tag(),
-                     ))
-                 }
-             }
-         }
+    let sep = match separator {
+        Some(Tagged {
+            item: Value::Primitive(Primitive::String(s)),
+            tag,
+            ..
+        }) => {
+            if s == r"\t" {
+                '\t'
+            } else {
+                let vec_s: Vec<char> = s.chars().collect();
+                if vec_s.len() != 1 {
+                    return Err(ShellError::labeled_error(
+                        "Expected a single separator char from --separator",
+                        "requires a single character string input",
+                        tag,
+                    ));
+                };
+                vec_s[0]
+            }
+        }
+        _ => ',',
     };
-
-    Ok(stream.to_output_stream())
+    to_delimited_data(headerless, sep, "CSV", runnable_context)
 }

src/commands/to_delimited_data.rs

@@ -0,0 +1,188 @@
+use crate::data::{Primitive, Value};
+use crate::prelude::*;
+use csv::WriterBuilder;
+
+fn from_value_to_delimited_string(
+    tagged_value: &Tagged<Value>,
+    separator: char,
+) -> Result<String, ShellError> {
+    let v = &tagged_value.item;
+
+    match v {
+        Value::Row(o) => {
+            let mut wtr = WriterBuilder::new()
+                .delimiter(separator as u8)
+                .from_writer(vec![]);
+            let mut fields: VecDeque<String> = VecDeque::new();
+            let mut values: VecDeque<String> = VecDeque::new();
+
+            for (k, v) in o.entries.iter() {
+                fields.push_back(k.clone());
+
+                values.push_back(to_string_tagged_value(&v)?);
+            }
+
+            wtr.write_record(fields).expect("can not write.");
+            wtr.write_record(values).expect("can not write.");
+
+            return Ok(String::from_utf8(wtr.into_inner().map_err(|_| {
+                ShellError::labeled_error(
+                    "Could not convert record",
+                    "original value",
+                    &tagged_value.tag,
+                )
+            })?)
+            .map_err(|_| {
+                ShellError::labeled_error(
+                    "Could not convert record",
+                    "original value",
+                    &tagged_value.tag,
+                )
+            })?);
+        }
+        Value::Table(list) => {
+            let mut wtr = WriterBuilder::new()
+                .delimiter(separator as u8)
+                .from_writer(vec![]);
+
+            let merged_descriptors = merge_descriptors(&list);
+            wtr.write_record(&merged_descriptors)
+                .expect("can not write.");
+
+            for l in list {
+                let mut row = vec![];
+                for desc in &merged_descriptors {
+                    match l.item.get_data_by_key(&desc) {
+                        Some(s) => {
+                            row.push(to_string_tagged_value(s)?);
+                        }
+                        None => {
+                            row.push(String::new());
+                        }
+                    }
+                }
+                wtr.write_record(&row).expect("can not write");
+            }
+
+            return Ok(String::from_utf8(wtr.into_inner().map_err(|_| {
+                ShellError::labeled_error(
+                    "Could not convert record",
+                    "original value",
+                    &tagged_value.tag,
+                )
+            })?)
+            .map_err(|_| {
+                ShellError::labeled_error(
+                    "Could not convert record",
+                    "original value",
+                    &tagged_value.tag,
+                )
+            })?);
+        }
+        _ => return to_string_tagged_value(tagged_value),
+    }
+}
+
+// NOTE: could this be useful more widely and implemented on Tagged<Value> ?
+pub fn clone_tagged_value(v: &Tagged<Value>) -> Tagged<Value> {
+    match &v.item {
+        Value::Primitive(Primitive::String(s)) => Value::Primitive(Primitive::String(s.clone())),
+        Value::Primitive(Primitive::Nothing) => Value::Primitive(Primitive::Nothing),
+        Value::Primitive(Primitive::Boolean(b)) => Value::Primitive(Primitive::Boolean(b.clone())),
+        Value::Primitive(Primitive::Decimal(f)) => Value::Primitive(Primitive::Decimal(f.clone())),
+        Value::Primitive(Primitive::Int(i)) => Value::Primitive(Primitive::Int(i.clone())),
+        Value::Primitive(Primitive::Path(x)) => Value::Primitive(Primitive::Path(x.clone())),
+        Value::Primitive(Primitive::Bytes(b)) => Value::Primitive(Primitive::Bytes(b.clone())),
+        Value::Primitive(Primitive::Date(d)) => Value::Primitive(Primitive::Date(d.clone())),
+        Value::Row(o) => Value::Row(o.clone()),
+        Value::Table(l) => Value::Table(l.clone()),
+        Value::Block(_) => Value::Primitive(Primitive::Nothing),
+        _ => Value::Primitive(Primitive::Nothing),
+    }
+    .tagged(v.tag.clone())
+}
+
+// NOTE: could this be useful more widely and implemented on Tagged<Value> ?
+fn to_string_tagged_value(v: &Tagged<Value>) -> Result<String, ShellError> {
+    match &v.item {
+        Value::Primitive(Primitive::Date(d)) => Ok(d.to_string()),
+        Value::Primitive(Primitive::Bytes(b)) => {
+            let tmp = format!("{}", b);
+            Ok(tmp)
+        }
+        Value::Primitive(Primitive::Boolean(_)) => Ok(v.as_string()?),
+        Value::Primitive(Primitive::Decimal(_)) => Ok(v.as_string()?),
+        Value::Primitive(Primitive::Int(_)) => Ok(v.as_string()?),
+        Value::Primitive(Primitive::Path(_)) => Ok(v.as_string()?),
+        Value::Table(_) => return Ok(String::from("[Table]")),
+        Value::Row(_) => return Ok(String::from("[Row]")),
+        Value::Primitive(Primitive::String(s)) => return Ok(s.to_string()),
+        _ => {
+            return Err(ShellError::labeled_error(
+                "Unexpected value",
+                "",
+                v.tag.clone(),
+            ))
+        }
+    }
+}
+
+fn merge_descriptors(values: &[Tagged<Value>]) -> Vec<String> {
+    let mut ret = vec![];
+    for value in values {
+        for desc in value.data_descriptors() {
+            if !ret.contains(&desc) {
+                ret.push(desc);
+            }
+        }
+    }
+    ret
+}
+
+pub fn to_delimited_data(
+    headerless: bool,
+    sep: char,
+    format_name: &'static str,
+    RunnableContext { input, name, .. }: RunnableContext,
+) -> Result<OutputStream, ShellError> {
+    let name_tag = name;
+
+    let stream = async_stream! {
+         let input: Vec<Tagged<Value>> = input.values.collect().await;
+
+         let to_process_input = if input.len() > 1 {
+             let tag = input[0].tag.clone();
+             vec![Tagged { item: Value::Table(input), tag } ]
+         } else if input.len() == 1 {
+             input
+         } else {
+             vec![]
+         };
+
+         for value in to_process_input {
+             match from_value_to_delimited_string(&clone_tagged_value(&value), sep) {
+                 Ok(x) => {
+                     let converted = if headerless {
+                         x.lines().skip(1).collect()
+                     } else {
+                         x
+                     };
+                     yield ReturnSuccess::value(Value::Primitive(Primitive::String(converted)).tagged(&name_tag))
+                 }
+                 _ => {
+                     let expected = format!("Expected a table with {}-compatible structure.tag() from pipeline", format_name);
+                     let requires = format!("requires {}-compatible input", format_name);
+                     yield Err(ShellError::labeled_error_with_secondary(
+                         expected,
+                         requires,
+                         &name_tag,
+                         "originates from here".to_string(),
+                         value.tag(),
+                     ))
+                 }
+             }
+         }
+    };
+
+    Ok(stream.to_output_stream())
+}

src/commands/to_tsv.rs

@@ -1,7 +1,6 @@
+use crate::commands::to_delimited_data::to_delimited_data;
 use crate::commands::WholeStreamCommand;
-use crate::data::{Primitive, Value};
 use crate::prelude::*;
-use csv::WriterBuilder;
 
 pub struct ToTSV;
 
@@ -35,172 +34,9 @@ impl WholeStreamCommand for ToTSV {
     }
 }
 
-pub fn value_to_tsv_value(tagged_value: &Tagged<Value>) -> Tagged<Value> {
-    let v = &tagged_value.item;
-
-    match v {
-        Value::Primitive(Primitive::String(s)) => Value::Primitive(Primitive::String(s.clone())),
-        Value::Primitive(Primitive::Nothing) => Value::Primitive(Primitive::Nothing),
-        Value::Primitive(Primitive::Boolean(b)) => Value::Primitive(Primitive::Boolean(b.clone())),
-        Value::Primitive(Primitive::Decimal(f)) => Value::Primitive(Primitive::Decimal(f.clone())),
-        Value::Primitive(Primitive::Int(i)) => Value::Primitive(Primitive::Int(i.clone())),
-        Value::Primitive(Primitive::Path(x)) => Value::Primitive(Primitive::Path(x.clone())),
-        Value::Primitive(Primitive::Bytes(b)) => Value::Primitive(Primitive::Bytes(b.clone())),
-        Value::Primitive(Primitive::Date(d)) => Value::Primitive(Primitive::Date(d.clone())),
-        Value::Row(o) => Value::Row(o.clone()),
-        Value::Table(l) => Value::Table(l.clone()),
-        Value::Block(_) => Value::Primitive(Primitive::Nothing),
-        _ => Value::Primitive(Primitive::Nothing),
-    }
-    .tagged(&tagged_value.tag)
-}
-
-fn to_string_helper(tagged_value: &Tagged<Value>) -> Result<String, ShellError> {
-    let v = &tagged_value.item;
-    match v {
-        Value::Primitive(Primitive::Date(d)) => Ok(d.to_string()),
-        Value::Primitive(Primitive::Bytes(b)) => Ok(format!("{}", b)),
-        Value::Primitive(Primitive::Boolean(_)) => Ok(tagged_value.as_string()?),
-        Value::Primitive(Primitive::Decimal(_)) => Ok(tagged_value.as_string()?),
-        Value::Primitive(Primitive::Int(_)) => Ok(tagged_value.as_string()?),
-        Value::Primitive(Primitive::Path(_)) => Ok(tagged_value.as_string()?),
-        Value::Table(_) => return Ok(String::from("[table]")),
-        Value::Row(_) => return Ok(String::from("[row]")),
-        Value::Primitive(Primitive::String(s)) => return Ok(s.to_string()),
-        _ => {
-            return Err(ShellError::labeled_error(
-                "Unexpected value",
-                "original value",
-                &tagged_value.tag,
-            ))
-        }
-    }
-}
-
-fn merge_descriptors(values: &[Tagged<Value>]) -> Vec<String> {
-    let mut ret = vec![];
-    for value in values {
-        for desc in value.data_descriptors() {
-            if !ret.contains(&desc) {
-                ret.push(desc);
-            }
-        }
-    }
-    ret
-}
-
-pub fn to_string(tagged_value: &Tagged<Value>) -> Result<String, ShellError> {
-    let v = &tagged_value.item;
-
-    match v {
-        Value::Row(o) => {
-            let mut wtr = WriterBuilder::new().delimiter(b'\t').from_writer(vec![]);
-            let mut fields: VecDeque<String> = VecDeque::new();
-            let mut values: VecDeque<String> = VecDeque::new();
-
-            for (k, v) in o.entries.iter() {
-                fields.push_back(k.clone());
-                values.push_back(to_string_helper(&v)?);
-            }
-
-            wtr.write_record(fields).expect("can not write.");
-            wtr.write_record(values).expect("can not write.");
-
-            return Ok(String::from_utf8(wtr.into_inner().map_err(|_| {
-                ShellError::labeled_error(
-                    "Could not convert record",
-                    "original value",
-                    &tagged_value.tag,
-                )
-            })?)
-            .map_err(|_| {
-                ShellError::labeled_error(
-                    "Could not convert record",
-                    "original value",
-                    &tagged_value.tag,
-                )
-            })?);
-        }
-        Value::Table(list) => {
-            let mut wtr = WriterBuilder::new().delimiter(b'\t').from_writer(vec![]);
-
-            let merged_descriptors = merge_descriptors(&list);
-            wtr.write_record(&merged_descriptors)
-                .expect("can not write.");
-
-            for l in list {
-                let mut row = vec![];
-                for desc in &merged_descriptors {
-                    match l.item.get_data_by_key(&desc) {
-                        Some(s) => {
-                            row.push(to_string_helper(s)?);
-                        }
-                        None => {
-                            row.push(String::new());
-                        }
-                    }
-                }
-                wtr.write_record(&row).expect("can not write");
-            }
-
-            return Ok(String::from_utf8(wtr.into_inner().map_err(|_| {
-                ShellError::labeled_error(
-                    "Could not convert record",
-                    "original value",
-                    &tagged_value.tag,
-                )
-            })?)
-            .map_err(|_| {
-                ShellError::labeled_error(
-                    "Could not convert record",
-                    "original value",
-                    &tagged_value.tag,
-                )
-            })?);
-        }
-        _ => return to_string_helper(tagged_value),
-    }
-}
-
 fn to_tsv(
     ToTSVArgs { headerless }: ToTSVArgs,
-    RunnableContext { input, name, .. }: RunnableContext,
+    runnable_context: RunnableContext,
 ) -> Result<OutputStream, ShellError> {
-    let name_tag = name;
-    let stream = async_stream! {
-         let input: Vec<Tagged<Value>> = input.values.collect().await;
-
-         let to_process_input = if input.len() > 1 {
-             let tag = input[0].tag.clone();
-             vec![Tagged { item: Value::Table(input), tag } ]
-         } else if input.len() == 1 {
-             input
-         } else {
-             vec![]
-         };
-
-         for value in to_process_input {
-             match to_string(&value_to_tsv_value(&value)) {
-                 Ok(x) => {
-                     let converted = if headerless {
-                         x.lines().skip(1).collect()
-                     } else {
-                         x
-                     };
-                     yield ReturnSuccess::value(Value::Primitive(Primitive::String(converted)).tagged(&name_tag))
-                 }
-                 _ => {
-                     yield Err(ShellError::labeled_error_with_secondary(
-                         "Expected a table with TSV-compatible structure.tag() from pipeline",
-                         "requires TSV-compatible input",
-                         &name_tag,
-                         "originates from here".to_string(),
-                         value.tag(),
-                     ))
-                 }
-             }
-         }
-    };
-
-    Ok(stream.to_output_stream())
+    to_delimited_data(headerless, '\t', "TSV", runnable_context)
 }