Merge branch 'main' of https://github.com/nushell/engine-q into port_first_command

crates/nu-command/src/core_commands/echo.rs

@@ -0,0 +1,66 @@
+use nu_engine::CallExt;
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{
+    Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value, ValueStream,
+};
+
+#[derive(Clone)]
+pub struct Echo;
+
+impl Command for Echo {
+    fn name(&self) -> &str {
+        "echo"
+    }
+
+    fn usage(&self) -> &str {
+        "Echo the arguments back to the user."
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("echo").rest("rest", SyntaxShape::Any, "the values to echo")
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        call.rest(engine_state, stack, 0).map(|to_be_echoed| {
+            PipelineData::Stream(ValueStream::from_stream(
+                to_be_echoed.into_iter(),
+                engine_state.ctrlc.clone(),
+            ))
+        })
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Put a hello message in the pipeline",
+                example: "echo 'hello'",
+                result: Some(Value::List {
+                    vals: vec![Value::test_string("hello")],
+                    span: Span::new(0, 0),
+                }),
+            },
+            Example {
+                description: "Print the value of the special '$nu' variable",
+                example: "echo $nu",
+                result: None,
+            },
+        ]
+    }
+}
+
+#[cfg(test)]
+mod test {
+    #[test]
+    fn test_examples() {
+        use super::Echo;
+        use crate::test_examples;
+        test_examples(Echo {})
+    }
+}

crates/nu-command/src/core_commands/mod.rs

@@ -1,6 +1,7 @@
 mod alias;
 mod def;
 mod do_;
+mod echo;
 mod export_def;
 mod for_;
 mod help;
@@ -8,12 +9,15 @@ mod hide;
 mod if_;
 mod let_;
 mod module;
+mod register;
+mod run_plugin;
 mod source;
 mod use_;
 
 pub use alias::Alias;
 pub use def::Def;
 pub use do_::Do;
+pub use echo::Echo;
 pub use export_def::ExportDef;
 pub use for_::For;
 pub use help::Help;
@@ -21,5 +25,7 @@ pub use hide::Hide;
 pub use if_::If;
 pub use let_::Let;
 pub use module::Module;
+pub use register::Register;
+pub use run_plugin::RunPlugin;
 pub use source::Source;
 pub use use_::Use;

crates/nu-command/src/core_commands/register.rs

@@ -0,0 +1,34 @@
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{PipelineData, Signature, SyntaxShape};
+
+#[derive(Clone)]
+pub struct Register;
+
+impl Command for Register {
+    fn name(&self) -> &str {
+        "register"
+    }
+
+    fn usage(&self) -> &str {
+        "Register a plugin"
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build("register").required(
+            "plugin",
+            SyntaxShape::Filepath,
+            "location of bin for plugin",
+        )
+    }
+
+    fn run(
+        &self,
+        _engine_state: &EngineState,
+        _stack: &mut Stack,
+        _call: &Call,
+        _input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        Ok(PipelineData::new())
+    }
+}

crates/nu-command/src/core_commands/run_plugin.rs

@@ -0,0 +1,30 @@
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{PipelineData, Signature};
+
+#[derive(Clone)]
+pub struct RunPlugin;
+
+impl Command for RunPlugin {
+    fn name(&self) -> &str {
+        "run_plugin"
+    }
+
+    fn usage(&self) -> &str {
+        "test for plugin encoding"
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build("run_plugin")
+    }
+
+    fn run(
+        &self,
+        _context: &EngineState,
+        _stack: &mut Stack,
+        _call: &Call,
+        _input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        Ok(PipelineData::new())
+    }
+}

crates/nu-command/src/core_commands/use_.rs

@@ -15,7 +15,7 @@ impl Command for Use {
     }
 
     fn signature(&self) -> nu_protocol::Signature {
-        Signature::build("use").required("pattern", SyntaxShape::String, "import pattern")
+        Signature::build("use").rest("pattern", SyntaxShape::String, "import pattern parts")
     }
 
     fn run(

crates/nu-command/src/date/command.rs

@@ -0,0 +1,47 @@
+use nu_engine::get_full_help;
+use nu_protocol::{
+    ast::Call,
+    engine::{Command, EngineState, Stack},
+    IntoPipelineData, PipelineData, ShellError, Signature, Value,
+};
+
+#[derive(Clone)]
+pub struct Date;
+
+impl Command for Date {
+    fn name(&self) -> &str {
+        "date"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("date")
+    }
+
+    fn usage(&self) -> &str {
+        "date"
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        date(engine_state, stack, call)
+    }
+}
+
+fn date(
+    engine_state: &EngineState,
+    _stack: &mut Stack,
+    call: &Call,
+) -> Result<PipelineData, ShellError> {
+    let head = call.head;
+
+    Ok(Value::String {
+        val: get_full_help(&Date.signature(), &Date.examples(), engine_state),
+        span: head,
+    }
+    .into_pipeline_data())
+}

crates/nu-command/src/date/format.rs

@@ -0,0 +1,116 @@
+use chrono::Local;
+use nu_engine::CallExt;
+use nu_protocol::{
+    ast::Call,
+    engine::{Command, EngineState, Stack},
+    Example, PipelineData, Signature, Span, Spanned, SyntaxShape, Value,
+};
+
+use super::utils::{parse_date_from_string, unsupported_input_error};
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "date format"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("date format").required(
+            "format string",
+            SyntaxShape::String,
+            "the desired date format",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Format a given date using the given format string."
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        let head = call.head;
+        let formatter: Spanned<String> = call.req(engine_state, stack, 0)?;
+        input.map(
+            move |value| format_helper(value, &formatter, head),
+            engine_state.ctrlc.clone(),
+        )
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Format a given date using the given format string.",
+                example: "date format '%Y-%m-%d'",
+                result: Some(Value::String {
+                    val: Local::now().format("%Y-%m-%d").to_string(),
+                    span: Span::unknown(),
+                }),
+            },
+            Example {
+                description: "Format a given date using the given format string.",
+                example: r#"date format "%Y-%m-%d %H:%M:%S""#,
+                result: Some(Value::String {
+                    val: Local::now().format("%Y-%m-%d %H:%M:%S").to_string(),
+                    span: Span::unknown(),
+                }),
+            },
+            Example {
+                description: "Format a given date using the given format string.",
+                example: r#""2021-10-22 20:00:12 +01:00" | date format "%Y-%m-%d""#,
+                result: Some(Value::String {
+                    val: "2021-10-22".into(),
+                    span: Span::unknown(),
+                }),
+            },
+        ]
+    }
+}
+
+fn format_helper(value: Value, formatter: &Spanned<String>, span: Span) -> Value {
+    match value {
+        Value::Date { val, span: _ } => Value::String {
+            val: val.format(formatter.item.as_str()).to_string(),
+            span,
+        },
+        Value::String { val, span: _ } => {
+            let dt = parse_date_from_string(val);
+            match dt {
+                Ok(x) => Value::String {
+                    val: x.format(formatter.item.as_str()).to_string(),
+                    span,
+                },
+                Err(e) => e,
+            }
+        }
+        Value::Nothing { span: _ } => {
+            let dt = Local::now();
+            Value::String {
+                val: dt
+                    .with_timezone(dt.offset())
+                    .format(formatter.item.as_str())
+                    .to_string(),
+                span,
+            }
+        }
+        _ => unsupported_input_error(),
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

crates/nu-command/src/date/humanize.rs

@@ -0,0 +1,99 @@
+use crate::date::utils::parse_date_from_string;
+use chrono::{DateTime, FixedOffset, Local};
+use chrono_humanize::HumanTime;
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{Example, PipelineData, ShellError, Signature, Span, Value};
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "date humanize"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("date humanize")
+    }
+
+    fn usage(&self) -> &str {
+        "Print a 'humanized' format for the date, relative to now."
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        let head = call.head;
+        input.map(move |value| helper(value, head), engine_state.ctrlc.clone())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Print a 'humanized' format for the date, relative to now.",
+                example: "date humanize",
+                result: Some(Value::String {
+                    val: "now".to_string(),
+                    span: Span::unknown(),
+                }),
+            },
+            Example {
+                description: "Print a 'humanized' format for the date, relative to now.",
+                example: r#""2021-10-22 20:00:12 +01:00" | date humanize"#,
+                result: None,
+            },
+        ]
+    }
+}
+
+fn helper(value: Value, head: Span) -> Value {
+    match value {
+        Value::Nothing { span: _ } => {
+            let dt = Local::now();
+            Value::String {
+                val: humanize_date(dt.with_timezone(dt.offset())),
+                span: head,
+            }
+        }
+        Value::String { val, span: _ } => {
+            let dt = parse_date_from_string(val);
+            match dt {
+                Ok(x) => Value::String {
+                    val: humanize_date(x),
+                    span: head,
+                },
+                Err(e) => e,
+            }
+        }
+        Value::Date { val, span: _ } => Value::String {
+            val: humanize_date(val),
+            span: head,
+        },
+        _ => Value::Error {
+            error: ShellError::UnsupportedInput(
+                String::from("Date cannot be parsed / date format is not supported"),
+                Span::unknown(),
+            ),
+        },
+    }
+}
+
+fn humanize_date(dt: DateTime<FixedOffset>) -> String {
+    HumanTime::from(dt).to_string()
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

crates/nu-command/src/date/list_timezone.rs

@@ -0,0 +1,44 @@
+use chrono_tz::TZ_VARIANTS;
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{IntoInterruptiblePipelineData, PipelineData, Signature, Value};
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "date list-timezone"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("date list-timezone")
+    }
+
+    fn usage(&self) -> &str {
+        "List supported time zones."
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        let span = call.head;
+
+        Ok(TZ_VARIANTS
+            .iter()
+            .map(move |x| {
+                let cols = vec!["timezone".into()];
+                let vals = vec![Value::String {
+                    val: x.name().to_string(),
+                    span,
+                }];
+                Value::Record { cols, vals, span }
+            })
+            .into_iter()
+            .into_pipeline_data(engine_state.ctrlc.clone()))
+    }
+}

crates/nu-command/src/date/mod.rs

@@ -0,0 +1,17 @@
+mod command;
+mod format;
+mod humanize;
+mod list_timezone;
+mod now;
+mod parser;
+mod to_table;
+mod to_timezone;
+mod utils;
+
+pub use command::Date;
+pub use format::SubCommand as DateFormat;
+pub use humanize::SubCommand as DateHumanize;
+pub use list_timezone::SubCommand as DateListTimezones;
+pub use now::SubCommand as DateNow;
+pub use to_table::SubCommand as DateToTable;
+pub use to_timezone::SubCommand as DateToTimezone;

crates/nu-command/src/date/now.rs

@@ -0,0 +1,36 @@
+use chrono::Local;
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{IntoPipelineData, PipelineData, Signature, Value};
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "date now"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("date now")
+    }
+
+    fn usage(&self) -> &str {
+        "Get the current date."
+    }
+
+    fn run(
+        &self,
+        _engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        let head = call.head;
+        let dt = Local::now();
+        Ok(Value::Date {
+            val: dt.with_timezone(dt.offset()),
+            span: head,
+        }
+        .into_pipeline_data())
+    }
+}

crates/nu-command/src/date/parser.rs

@@ -0,0 +1,107 @@
+// Modified from chrono::format::scan
+
+use chrono::{DateTime, FixedOffset, Local, Offset, TimeZone};
+use chrono_tz::Tz;
+use titlecase::titlecase;
+
+#[derive(Debug, Clone, PartialEq, Eq, Copy)]
+pub enum ParseErrorKind {
+    /// Given field is out of permitted range.
+    OutOfRange,
+
+    /// The input string has some invalid character sequence for given formatting items.
+    Invalid,
+
+    /// The input string has been prematurely ended.
+    TooShort,
+}
+
+pub fn datetime_in_timezone(
+    dt: &DateTime<FixedOffset>,
+    s: &str,
+) -> Result<DateTime<FixedOffset>, ParseErrorKind> {
+    match timezone_offset_internal(s, true, true) {
+        Ok(offset) => match FixedOffset::east_opt(offset) {
+            Some(offset) => Ok(dt.with_timezone(&offset)),
+            None => Err(ParseErrorKind::OutOfRange),
+        },
+        Err(ParseErrorKind::Invalid) => {
+            if s.to_lowercase() == "local" {
+                Ok(dt.with_timezone(Local::now().offset()))
+            } else {
+                let tz: Tz = parse_timezone_internal(s)?;
+                let offset = tz.offset_from_utc_datetime(&dt.naive_utc()).fix();
+                Ok(dt.with_timezone(&offset))
+            }
+        }
+        Err(e) => Err(e),
+    }
+}
+
+fn parse_timezone_internal(s: &str) -> Result<Tz, ParseErrorKind> {
+    if let Ok(tz) = s.parse() {
+        Ok(tz)
+    } else if let Ok(tz) = titlecase(s).parse() {
+        Ok(tz)
+    } else if let Ok(tz) = s.to_uppercase().parse() {
+        Ok(tz)
+    } else {
+        Err(ParseErrorKind::Invalid)
+    }
+}
+
+fn timezone_offset_internal(
+    mut s: &str,
+    consume_colon: bool,
+    allow_missing_minutes: bool,
+) -> Result<i32, ParseErrorKind> {
+    fn digits(s: &str) -> Result<(u8, u8), ParseErrorKind> {
+        let b = s.as_bytes();
+        if b.len() < 2 {
+            Err(ParseErrorKind::TooShort)
+        } else {
+            Ok((b[0], b[1]))
+        }
+    }
+    let negative = match s.as_bytes().first() {
+        Some(&b'+') => false,
+        Some(&b'-') => true,
+        Some(_) => return Err(ParseErrorKind::Invalid),
+        None => return Err(ParseErrorKind::TooShort),
+    };
+    s = &s[1..];
+
+    // hours (00--99)
+    let hours = match digits(s)? {
+        (h1 @ b'0'..=b'9', h2 @ b'0'..=b'9') => i32::from((h1 - b'0') * 10 + (h2 - b'0')),
+        _ => return Err(ParseErrorKind::Invalid),
+    };
+    s = &s[2..];
+
+    // colons (and possibly other separators)
+    if consume_colon {
+        s = s.trim_start_matches(|c: char| c == ':' || c.is_whitespace());
+    }
+
+    // minutes (00--59)
+    // if the next two items are digits then we have to add minutes
+    let minutes = if let Ok(ds) = digits(s) {
+        match ds {
+            (m1 @ b'0'..=b'5', m2 @ b'0'..=b'9') => i32::from((m1 - b'0') * 10 + (m2 - b'0')),
+            (b'6'..=b'9', b'0'..=b'9') => return Err(ParseErrorKind::OutOfRange),
+            _ => return Err(ParseErrorKind::Invalid),
+        }
+    } else if allow_missing_minutes {
+        0
+    } else {
+        return Err(ParseErrorKind::TooShort);
+    };
+    match s.len() {
+        len if len >= 2 => &s[2..],
+        len if len == 0 => s,
+        _ => return Err(ParseErrorKind::TooShort),
+    };
+
+    let seconds = hours * 3600 + minutes * 60;
+    Ok(if negative { -seconds } else { seconds })
+}

crates/nu-command/src/date/to_table.rs

@@ -0,0 +1,163 @@
+use crate::date::utils::{parse_date_from_string, unsupported_input_error};
+use chrono::{DateTime, Datelike, FixedOffset, Local, Timelike};
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{Example, PipelineData, Signature, Span, Value};
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "date to-table"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("date to-table")
+    }
+
+    fn usage(&self) -> &str {
+        "Print the date in a structured table."
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        let head = call.head;
+        input.map(move |value| helper(value, head), engine_state.ctrlc.clone())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Print the date in a structured table.",
+                example: "date to-table",
+                result: None,
+            },
+            Example {
+                description: "Print the date in a structured table.",
+                example: "date now | date to-table",
+                result: None,
+            },
+            Example {
+                description: "Print the date in a structured table.",
+                example: " '2020-04-12 22:10:57 +0200' | date to-table",
+                result: {
+                    let span = Span::unknown();
+                    let cols = vec![
+                        "year".into(),
+                        "month".into(),
+                        "day".into(),
+                        "hour".into(),
+                        "minute".into(),
+                        "second".into(),
+                        "timezone".into(),
+                    ];
+                    let vals = vec![
+                        Value::Int { val: 2020, span },
+                        Value::Int { val: 4, span },
+                        Value::Int { val: 12, span },
+                        Value::Int { val: 22, span },
+                        Value::Int { val: 10, span },
+                        Value::Int { val: 57, span },
+                        Value::String {
+                            val: "+02:00".to_string(),
+                            span,
+                        },
+                    ];
+                    Some(Value::List {
+                        vals: vec![Value::Record { cols, vals, span }],
+                        span,
+                    })
+                },
+            },
+        ]
+    }
+}
+
+fn parse_date_into_table(date: Result<DateTime<FixedOffset>, Value>, head: Span) -> Value {
+    let cols = vec![
+        "year".into(),
+        "month".into(),
+        "day".into(),
+        "hour".into(),
+        "minute".into(),
+        "second".into(),
+        "timezone".into(),
+    ];
+    match date {
+        Ok(x) => {
+            let vals = vec![
+                Value::Int {
+                    val: x.year() as i64,
+                    span: head,
+                },
+                Value::Int {
+                    val: x.month() as i64,
+                    span: head,
+                },
+                Value::Int {
+                    val: x.day() as i64,
+                    span: head,
+                },
+                Value::Int {
+                    val: x.hour() as i64,
+                    span: head,
+                },
+                Value::Int {
+                    val: x.minute() as i64,
+                    span: head,
+                },
+                Value::Int {
+                    val: x.second() as i64,
+                    span: head,
+                },
+                Value::String {
+                    val: x.offset().to_string(),
+                    span: head,
+                },
+            ];
+            Value::List {
+                vals: vec![Value::Record {
+                    cols,
+                    vals,
+                    span: head,
+                }],
+                span: head,
+            }
+        }
+        Err(e) => e,
+    }
+}
+
+fn helper(val: Value, head: Span) -> Value {
+    match val {
+        Value::String { val, span: _ } => {
+            let date = parse_date_from_string(val);
+            parse_date_into_table(date, head)
+        }
+        Value::Nothing { span: _ } => {
+            let now = Local::now();
+            let n = now.with_timezone(now.offset());
+            parse_date_into_table(Ok(n), head)
+        }
+        Value::Date { val, span: _ } => parse_date_into_table(Ok(val), head),
+        _ => unsupported_input_error(),
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

crates/nu-command/src/date/to_timezone.rs

@@ -0,0 +1,129 @@
+use super::parser::datetime_in_timezone;
+use crate::date::utils::{parse_date_from_string, unsupported_input_error};
+use chrono::{DateTime, Local};
+use nu_engine::CallExt;
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{
+    Example, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape, Value,
+};
+
+use chrono::{FixedOffset, TimeZone};
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "date to-timezone"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("date to-timezone").required(
+            "time zone",
+            SyntaxShape::String,
+            "time zone description",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Convert a date to a given time zone."
+    }
+
+    fn extra_usage(&self) -> &str {
+        "Use 'date list-timezone' to list all supported time zones."
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        let head = call.head;
+        let timezone: Spanned<String> = call.req(engine_state, stack, 0)?;
+
+        //Ok(PipelineData::new())
+        input.map(
+            move |value| helper(value, head, &timezone),
+            engine_state.ctrlc.clone(),
+        )
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Get the current date in UTC+05:00",
+                example: "date now | date to-timezone +0500",
+                result: None,
+            },
+            Example {
+                description: "Get the current local date",
+                example: "date now | date to-timezone local",
+                result: None,
+            },
+            Example {
+                description: "Get the current date in Hawaii",
+                example: "date now | date to-timezone US/Hawaii",
+                result: None,
+            },
+            Example {
+                description: "Get the current date in Hawaii",
+                example: r#""2020-10-10 10:00:00 +02:00" | date to-timezone "+0500""#,
+                // result: None
+                // The following should be the result of the test, but it fails. Cannot figure it out why.
+                result: {
+                    let dt = FixedOffset::east(5 * 3600)
+                        .ymd(2020, 10, 10)
+                        .and_hms(13, 00, 00);
+
+                    Some(Value::Date {
+                        val: dt,
+                        span: Span::unknown(),
+                    })
+                },
+            },
+        ]
+    }
+}
+
+fn helper(value: Value, head: Span, timezone: &Spanned<String>) -> Value {
+    match value {
+        Value::Date { val, span: _ } => _to_timezone(val, timezone, head),
+        Value::String { val, span: _ } => {
+            let time = parse_date_from_string(val);
+            match time {
+                Ok(dt) => _to_timezone(dt, timezone, head),
+                Err(e) => e,
+            }
+        }
+
+        Value::Nothing { span: _ } => {
+            let dt = Local::now();
+            _to_timezone(dt.with_timezone(dt.offset()), timezone, head)
+        }
+        _ => unsupported_input_error(),
+    }
+}
+
+fn _to_timezone(dt: DateTime<FixedOffset>, timezone: &Spanned<String>, span: Span) -> Value {
+    match datetime_in_timezone(&dt, timezone.item.as_str()) {
+        Ok(dt) => Value::Date { val: dt, span },
+        Err(_) => Value::Error {
+            error: ShellError::UnsupportedInput(String::from("invalid time zone"), Span::unknown()),
+        },
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

crates/nu-command/src/date/utils.rs

@@ -0,0 +1,43 @@
+use chrono::{DateTime, FixedOffset};
+use nu_protocol::{ShellError, Span, Value};
+
+pub fn unsupported_input_error() -> Value {
+    Value::Error {
+        error: ShellError::UnsupportedInput(
+            String::from(
+                "Only dates with timezones are supported. The following formats are allowed \n 
+            * %Y-%m-%d %H:%M:%S %z -- 2020-04-12 22:10:57 +02:00 \n 
+            * %Y-%m-%d %H:%M:%S%.6f %z -- 2020-04-12 22:10:57.213231 +02:00 \n 
+            * rfc3339 -- 2020-04-12T22:10:57+02:00 \n 
+            * rfc2822 -- Tue, 1 Jul 2003 10:52:37 +0200",
+            ),
+            Span::unknown(),
+        ),
+    }
+}
+
+pub fn parse_date_from_string(input: String) -> Result<DateTime<FixedOffset>, Value> {
+    let datetime = DateTime::parse_from_str(&input, "%Y-%m-%d %H:%M:%S %z"); // "2020-04-12 22:10:57 +02:00";
+    match datetime {
+        Ok(x) => Ok(x),
+        Err(_) => {
+            let datetime = DateTime::parse_from_str(&input, "%Y-%m-%d %H:%M:%S%.6f %z"); // "2020-04-12 22:10:57.213231 +02:00";
+            match datetime {
+                Ok(x) => Ok(x),
+                Err(_) => {
+                    let datetime = DateTime::parse_from_rfc3339(&input); // "2020-04-12T22:10:57+02:00";
+                    match datetime {
+                        Ok(x) => Ok(x),
+                        Err(_) => {
+                            let datetime = DateTime::parse_from_rfc2822(&input); // "Tue, 1 Jul 2003 10:52:37 +0200";
+                            match datetime {
+                                Ok(x) => Ok(x),
+                                Err(_) => Err(unsupported_input_error()),
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

crates/nu-command/src/default_context.rs

@@ -27,9 +27,17 @@ pub fn create_default_context() -> EngineState {
             BuildString,
             Cd,
             Cp,
+            Date,
+            DateFormat,
+            DateHumanize,
+            DateListTimezones,
+            DateNow,
+            DateToTable,
+            DateToTimezone,
             Def,
             Do,
             Each,
+            Echo,
             ExportDef,
             External,
             First,
@@ -54,13 +62,21 @@ pub fn create_default_context() -> EngineState {
             Math,
             MathAbs,
             MathAvg,
+            MathMax,
+            MathMin,
+            MathProduct,
+            MathRound,
+            MathSqrt,
+            MathSum,
             Mkdir,
             Module,
             Mv,
             ParEach,
             Ps,
+            Register,
             Range,
             Rm,
+            RunPlugin,
             Select,
             Size,
             Split,
@@ -74,7 +90,8 @@ pub fn create_default_context() -> EngineState {
             Touch,
             Use,
             Where,
-            Wrap
+            Wrap,
+            Zip
         );
 
         // This is a WIP proof of concept
@@ -82,16 +99,6 @@ pub fn create_default_context() -> EngineState {
 
         let sig = Signature::build("exit");
         working_set.add_decl(sig.predeclare());
-        let sig = Signature::build("vars");
-        working_set.add_decl(sig.predeclare());
-        let sig = Signature::build("decls");
-        working_set.add_decl(sig.predeclare());
-        let sig = Signature::build("blocks");
-        working_set.add_decl(sig.predeclare());
-        let sig = Signature::build("stack");
-        working_set.add_decl(sig.predeclare());
-        let sig = Signature::build("contents");
-        working_set.add_decl(sig.predeclare());
 
         working_set.render()
     };

crates/nu-command/src/example_test.rs

@@ -7,7 +7,7 @@ use nu_protocol::{
 
 use crate::To;
 
-use super::{From, Into, Math, Split};
+use super::{Date, From, Into, Math, Split};
 
 pub fn test_examples(cmd: impl Command + 'static) {
     let examples = cmd.examples();
@@ -22,6 +22,7 @@ pub fn test_examples(cmd: impl Command + 'static) {
         working_set.add_decl(Box::new(Into));
         working_set.add_decl(Box::new(Split));
         working_set.add_decl(Box::new(Math));
+        working_set.add_decl(Box::new(Date));
 
         // Adding the command that is being tested to the working set
         working_set.add_decl(Box::new(cmd));

crates/nu-command/src/filters/each.rs

@@ -73,40 +73,9 @@ impl Command for Each {
         let span = call.head;
 
         match input {
-            PipelineData::Value(Value::Range { val, .. }) => Ok(val
-                .into_range_iter()?
-                .enumerate()
-                .map(move |(idx, x)| {
-                    if let Some(var) = block.signature.get_positional(0) {
-                        if let Some(var_id) = &var.var_id {
-                            if numbered {
-                                stack.add_var(
-                                    *var_id,
-                                    Value::Record {
-                                        cols: vec!["index".into(), "item".into()],
-                                        vals: vec![
-                                            Value::Int {
-                                                val: idx as i64,
-                                                span,
-                                            },
-                                            x,
-                                        ],
-                                        span,
-                                    },
-                                );
-                            } else {
-                                stack.add_var(*var_id, x);
-                            }
-                        }
-                    }
-
-                    match eval_block(&engine_state, &mut stack, &block, PipelineData::new()) {
-                        Ok(v) => v.into_value(),
-                        Err(error) => Value::Error { error },
-                    }
-                })
-                .into_pipeline_data(ctrlc)),
-            PipelineData::Value(Value::List { vals: val, .. }) => Ok(val
+            PipelineData::Value(Value::Range { .. })
+            | PipelineData::Value(Value::List { .. })
+            | PipelineData::Stream { .. } => Ok(input
                 .into_iter()
                 .enumerate()
                 .map(move |(idx, x)| {
@@ -139,38 +108,6 @@ impl Command for Each {
                     }
                 })
                 .into_pipeline_data(ctrlc)),
-            PipelineData::Stream(stream) => Ok(stream
-                .enumerate()
-                .map(move |(idx, x)| {
-                    if let Some(var) = block.signature.get_positional(0) {
-                        if let Some(var_id) = &var.var_id {
-                            if numbered {
-                                stack.add_var(
-                                    *var_id,
-                                    Value::Record {
-                                        cols: vec!["index".into(), "item".into()],
-                                        vals: vec![
-                                            Value::Int {
-                                                val: idx as i64,
-                                                span,
-                                            },
-                                            x,
-                                        ],
-                                        span,
-                                    },
-                                );
-                            } else {
-                                stack.add_var(*var_id, x);
-                            }
-                        }
-                    }
-
-                    match eval_block(&engine_state, &mut stack, &block, PipelineData::new()) {
-                        Ok(v) => v.into_value(),
-                        Err(error) => Value::Error { error },
-                    }
-                })
-                .into_pipeline_data(ctrlc)),
             PipelineData::Value(Value::Record { cols, vals, .. }) => {
                 let mut output_cols = vec![];
                 let mut output_vals = vec![];

crates/nu-command/src/filters/mod.rs

@@ -9,6 +9,7 @@ mod range;
 mod select;
 mod where_;
 mod wrap;
+mod zip;
 
 pub use each::Each;
 pub use first::First;
@@ -21,3 +22,4 @@ pub use range::Range;
 pub use select::Select;
 pub use where_::Where;
 pub use wrap::Wrap;
+pub use zip::Zip;

crates/nu-command/src/filters/zip.rs

@@ -0,0 +1,65 @@
+use nu_engine::CallExt;
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{
+    Example, IntoInterruptiblePipelineData, IntoPipelineData, PipelineData, Signature, SyntaxShape,
+    Value,
+};
+
+#[derive(Clone)]
+pub struct Zip;
+
+impl Command for Zip {
+    fn name(&self) -> &str {
+        "zip"
+    }
+
+    fn usage(&self) -> &str {
+        "Combine a stream with the input"
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build("zip").required("other", SyntaxShape::Any, "the other input")
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            example: "1..3 | zip 4..6",
+            description: "Zip multiple streams and get one of the results",
+            result: None,
+        }]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        let other: Value = call.req(engine_state, stack, 0)?;
+        let head = call.head;
+        let ctrlc = engine_state.ctrlc.clone();
+
+        Ok(input
+            .into_iter()
+            .zip(other.into_pipeline_data().into_iter())
+            .map(move |(x, y)| Value::List {
+                vals: vec![x, y],
+                span: head,
+            })
+            .into_pipeline_data(ctrlc))
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(Zip {})
+    }
+}

crates/nu-command/src/lib.rs

@@ -1,5 +1,6 @@
 mod conversions;
 mod core_commands;
+mod date;
 mod default_context;
 mod env;
 mod example_test;
@@ -14,6 +15,7 @@ mod viewers;
 
 pub use conversions::*;
 pub use core_commands::*;
+pub use date::*;
 pub use default_context::*;
 pub use env::*;
 pub use example_test::test_examples;

crates/nu-command/src/math/avg.rs

@@ -50,6 +50,7 @@ pub fn average(values: &[Value], head: &Span) -> Result<Value, ShellError> {
             span: Span::unknown(),
         },
         values.to_vec(),
+        *head,
     )?;
     match total {
         Value::Filesize { val, span } => Ok(Value::Filesize {

crates/nu-command/src/math/max.rs

@@ -0,0 +1,57 @@
+use crate::math::reducers::{reducer_for, Reduce};
+use crate::math::utils::run_with_function;
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{Example, PipelineData, ShellError, Signature, Span, Value};
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "math max"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("math max")
+    }
+
+    fn usage(&self) -> &str {
+        "Finds the maximum within a list of numbers or tables"
+    }
+
+    fn run(
+        &self,
+        _engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        run_with_function(call, input, maximum)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Find the maximum of list of numbers",
+            example: "[-50 100 25] | math max",
+            result: Some(Value::test_int(100)),
+        }]
+    }
+}
+
+pub fn maximum(values: &[Value], head: &Span) -> Result<Value, ShellError> {
+    let max_func = reducer_for(Reduce::Maximum);
+    max_func(Value::nothing(), values.to_vec(), *head)
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

crates/nu-command/src/math/min.rs

@@ -0,0 +1,57 @@
+use crate::math::reducers::{reducer_for, Reduce};
+use crate::math::utils::run_with_function;
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{Example, PipelineData, ShellError, Signature, Span, Value};
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "math min"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("math min")
+    }
+
+    fn usage(&self) -> &str {
+        "Finds the minimum within a list of numbers or tables"
+    }
+
+    fn run(
+        &self,
+        _engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        run_with_function(call, input, minimum)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Get the minimum of a list of numbers",
+            example: "[-50 100 25] | math min",
+            result: Some(Value::test_int(-50)),
+        }]
+    }
+}
+
+pub fn minimum(values: &[Value], head: &Span) -> Result<Value, ShellError> {
+    let min_func = reducer_for(Reduce::Minimum);
+    min_func(Value::nothing(), values.to_vec(), *head)
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

crates/nu-command/src/math/mod.rs

@@ -1,9 +1,21 @@
 mod abs;
 mod avg;
 pub mod command;
+mod max;
+mod min;
+mod product;
 mod reducers;
+mod round;
+mod sqrt;
+mod sum;
 mod utils;
 
 pub use abs::SubCommand as MathAbs;
 pub use avg::SubCommand as MathAvg;
 pub use command::MathCommand as Math;
+pub use max::SubCommand as MathMax;
+pub use min::SubCommand as MathMin;
+pub use product::SubCommand as MathProduct;
+pub use round::SubCommand as MathRound;
+pub use sqrt::SubCommand as MathSqrt;
+pub use sum::SubCommand as MathSum;

crates/nu-command/src/math/product.rs

@@ -0,0 +1,58 @@
+use crate::math::reducers::{reducer_for, Reduce};
+use crate::math::utils::run_with_function;
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{Example, PipelineData, ShellError, Signature, Span, Value};
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "math product"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("math product")
+    }
+
+    fn usage(&self) -> &str {
+        "Finds the product of a list of numbers or tables"
+    }
+
+    fn run(
+        &self,
+        _engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        run_with_function(call, input, product)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Get the product of a list of numbers",
+            example: "[2 3 3 4] | math product",
+            result: Some(Value::test_int(72)),
+        }]
+    }
+}
+
+/// Calculate product of given values
+pub fn product(values: &[Value], head: &Span) -> Result<Value, ShellError> {
+    let product_func = reducer_for(Reduce::Product);
+    product_func(Value::nothing(), values.to_vec(), *head)
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

crates/nu-command/src/math/reducers.rs

@@ -1,19 +1,75 @@
 use nu_protocol::{ShellError, Span, Value};
+use std::cmp::Ordering;
 
 #[allow(dead_code)]
 pub enum Reduce {
     Summation,
+    Product,
+    Minimum,
+    Maximum,
 }
 
-pub fn reducer_for(
-    command: Reduce,
-) -> Box<dyn Fn(Value, Vec<Value>) -> Result<Value, ShellError> + Send + Sync + 'static> {
+pub type ReducerFunction =
+    Box<dyn Fn(Value, Vec<Value>, Span) -> Result<Value, ShellError> + Send + Sync + 'static>;
+
+pub fn reducer_for(command: Reduce) -> ReducerFunction {
     match command {
-        Reduce::Summation => Box::new(|_, values| sum(values)),
+        Reduce::Summation => Box::new(|_, values, head| sum(values, head)),
+        Reduce::Product => Box::new(|_, values, head| product(values, head)),
+        Reduce::Minimum => Box::new(|_, values, head| min(values, head)),
+        Reduce::Maximum => Box::new(|_, values, head| max(values, head)),
     }
 }
 
-pub fn sum(data: Vec<Value>) -> Result<Value, ShellError> {
+pub fn max(data: Vec<Value>, head: Span) -> Result<Value, ShellError> {
+    let mut biggest = data
+        .first()
+        .ok_or_else(|| ShellError::UnsupportedInput("Empty input".to_string(), Span::unknown()))?
+        .clone();
+
+    for value in &data {
+        if let Some(result) = value.partial_cmp(&biggest) {
+            if result == Ordering::Greater {
+                biggest = value.clone();
+            }
+        } else {
+            return Err(ShellError::OperatorMismatch {
+                op_span: head,
+                lhs_ty: biggest.get_type(),
+                lhs_span: biggest.span()?,
+                rhs_ty: value.get_type(),
+                rhs_span: value.span()?,
+            });
+        }
+    }
+    Ok(biggest)
+}
+
+pub fn min(data: Vec<Value>, head: Span) -> Result<Value, ShellError> {
+    let mut smallest = data
+        .first()
+        .ok_or_else(|| ShellError::UnsupportedInput("Empty input".to_string(), Span::unknown()))?
+        .clone();
+
+    for value in &data {
+        if let Some(result) = value.partial_cmp(&smallest) {
+            if result == Ordering::Less {
+                smallest = value.clone();
+            }
+        } else {
+            return Err(ShellError::OperatorMismatch {
+                op_span: head,
+                lhs_ty: smallest.get_type(),
+                lhs_span: smallest.span()?,
+                rhs_ty: value.get_type(),
+                rhs_span: value.span()?,
+            });
+        }
+    }
+    Ok(smallest)
+}
+
+pub fn sum(data: Vec<Value>, head: Span) -> Result<Value, ShellError> {
     let initial_value = data.get(0);
 
     let mut acc = match initial_value {
@@ -42,7 +98,7 @@ pub fn sum(data: Vec<Value>) -> Result<Value, ShellError> {
             | Value::Float { .. }
             | Value::Filesize { .. }
             | Value::Duration { .. } => {
-                let new_value = acc.add(acc.span().unwrap_or_else(|_| Span::unknown()), value);
+                let new_value = acc.add(head, value);
                 if new_value.is_err() {
                     return new_value;
                 }
@@ -58,3 +114,39 @@ pub fn sum(data: Vec<Value>) -> Result<Value, ShellError> {
     }
     Ok(acc)
 }
+
+pub fn product(data: Vec<Value>, head: Span) -> Result<Value, ShellError> {
+    let initial_value = data.get(0);
+
+    let mut acc = match initial_value {
+        Some(Value::Int { span, .. }) | Some(Value::Float { span, .. }) => Ok(Value::Int {
+            val: 1,
+            span: *span,
+        }),
+        None => Err(ShellError::UnsupportedInput(
+            "Empty input".to_string(),
+            Span::unknown(),
+        )),
+        _ => Ok(Value::nothing()),
+    }?;
+
+    for value in &data {
+        match value {
+            Value::Int { .. } | Value::Float { .. } => {
+                let new_value = acc.mul(head, value);
+                if new_value.is_err() {
+                    return new_value;
+                }
+                acc = new_value.expect("This should never trigger")
+            }
+            other => {
+                return Err(ShellError::UnsupportedInput(
+                    "Attempted to compute the product of a value that cannot be multiplied"
+                        .to_string(),
+                    other.span().unwrap_or_else(|_| Span::unknown()),
+                ));
+            }
+        }
+    }
+    Ok(acc)
+}

crates/nu-command/src/math/round.rs

@@ -0,0 +1,110 @@
+use nu_engine::CallExt;
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value};
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "math round"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("math round").named(
+            "precision",
+            SyntaxShape::Number,
+            "digits of precision",
+            Some('p'),
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Applies the round function to a list of numbers"
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        let precision_param: Option<i64> = call.get_flag(engine_state, stack, "precision")?;
+        let head = call.head;
+        input.map(
+            move |value| operate(value, head, precision_param),
+            engine_state.ctrlc.clone(),
+        )
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Apply the round function to a list of numbers",
+                example: "[1.5 2.3 -3.1] | math round",
+                result: Some(Value::List {
+                    vals: vec![Value::test_int(2), Value::test_int(2), Value::test_int(-3)],
+                    span: Span::unknown(),
+                }),
+            },
+            Example {
+                description: "Apply the round function with precision specified",
+                example: "[1.555 2.333 -3.111] | math round -p 2",
+                result: Some(Value::List {
+                    vals: vec![
+                        Value::Float {
+                            val: 1.56,
+                            span: Span::unknown(),
+                        },
+                        Value::Float {
+                            val: 2.33,
+                            span: Span::unknown(),
+                        },
+                        Value::Float {
+                            val: -3.11,
+                            span: Span::unknown(),
+                        },
+                    ],
+                    span: Span::unknown(),
+                }),
+            },
+        ]
+    }
+}
+
+fn operate(value: Value, head: Span, precision: Option<i64>) -> Value {
+    match value {
+        Value::Float { val, span } => match precision {
+            Some(precision_number) => Value::Float {
+                val: ((val * ((10_f64).powf(precision_number as f64))).round()
+                    / (10_f64).powf(precision_number as f64)),
+                span,
+            },
+            None => Value::Int {
+                val: val.round() as i64,
+                span,
+            },
+        },
+        Value::Int { .. } => value,
+        other => Value::Error {
+            error: ShellError::UnsupportedInput(
+                String::from("Only numerical values are supported"),
+                other.span().unwrap_or(head),
+            ),
+        },
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

crates/nu-command/src/math/sqrt.rs

@@ -0,0 +1,91 @@
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{Example, PipelineData, ShellError, Signature, Span, Value};
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "math sqrt"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("math sqrt")
+    }
+
+    fn usage(&self) -> &str {
+        "Applies the square root function to a list of numbers"
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        let head = call.head;
+        input.map(
+            move |value| operate(value, head),
+            engine_state.ctrlc.clone(),
+        )
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Apply the square root function to a list of numbers",
+            example: "[9 16] | math sqrt",
+            result: Some(Value::List {
+                vals: vec![Value::test_int(3), Value::test_int(4)],
+                span: Span::unknown(),
+            }),
+        }]
+    }
+}
+
+fn operate(value: Value, head: Span) -> Value {
+    match value {
+        Value::Int { val, span } => {
+            let squared = (val as f64).sqrt();
+            if squared.is_nan() {
+                return error_negative_sqrt(span);
+            }
+            Value::Float { val: squared, span }
+        }
+        Value::Float { val, span } => {
+            let squared = val.sqrt();
+            if squared.is_nan() {
+                return error_negative_sqrt(span);
+            }
+            Value::Float { val: squared, span }
+        }
+        other => Value::Error {
+            error: ShellError::UnsupportedInput(
+                String::from("Only numerical values are supported"),
+                other.span().unwrap_or(head),
+            ),
+        },
+    }
+}
+
+fn error_negative_sqrt(span: Span) -> Value {
+    Value::Error {
+        error: ShellError::UnsupportedInput(
+            String::from("Can't square root a negative number"),
+            span,
+        ),
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

crates/nu-command/src/math/sum.rs

@@ -0,0 +1,64 @@
+use crate::math::reducers::{reducer_for, Reduce};
+use crate::math::utils::run_with_function;
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{Example, PipelineData, ShellError, Signature, Span, Value};
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "math sum"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("math sum")
+    }
+
+    fn usage(&self) -> &str {
+        "Finds the sum of a list of numbers or tables"
+    }
+
+    fn run(
+        &self,
+        _engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        run_with_function(call, input, summation)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Sum a list of numbers",
+                example: "[1 2 3] | math sum",
+                result: Some(Value::test_int(6)),
+            },
+            Example {
+                description: "Get the disk usage for the current directory",
+                example: "ls | get size | math sum",
+                result: None,
+            },
+        ]
+    }
+}
+
+pub fn summation(values: &[Value], head: &Span) -> Result<Value, ShellError> {
+    let sum_func = reducer_for(Reduce::Summation);
+    sum_func(Value::nothing(), values.to_vec(), *head)
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(SubCommand {})
+    }
+}